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

/*
** libutil++
** $Id: IPAddress.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: IPAddress.cpp 1243 2014-11-21 01:01:24Z sella $";

#include "IPAddress.h"
#include "AddressException.h"
#include "../util/CommonMacro.h"

#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <net/if.h>
#include <arpa/inet.h>
#include <sys/ioctl.h>
#include <sys/types.h>

#include <limits>
#include <string>

#define HASH_ALGO_INT1

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

using namespace sella::net;

IPAddress::IPAddress(const std::string &text, int family, uint8_t cidr) throw (AddressException) :
        family(family),
        addr(),
        scache(),
        hcache(0)
{
        char    buffer[INET6_ADDRSTRLEN];

        switch (family) {
                case IPv4Family:
                case IPv4Required:
                        if (this->parse(this->family, this->addr.v4, text) == false) {
                                THROW(AddressException, "unable to parse address: '%s' does not represent a valid IPv4 address", text.c_str());
                        }
                        break;

                case IPv4Preferred:
                        if (this->parse(this->family, this->addr.v4, this->addr.v6, text) == false) {
                                THROW(AddressException, "unable to parse address: '%s' does not represent a valid IPv4 or IPv6 address", text.c_str());
                        }
                        break;

                case IPv6Family:
                case IPv6Required:
                        if (this->parse(this->family, this->addr.v6, text) == false) {
                                THROW(AddressException, "unable to parse address: '%s' does not represent a valid IPv6 address", text.c_str());
                        }
                        break;

                case IPv6Preferred:
                        if (this->parse(this->family, this->addr.v6, this->addr.v4, text) == false) {
                                THROW(AddressException, "unable to parse address: '%s' does not represent a valid IPv4 or IPv6 address", text.c_str());
                        }
                        break;

                default:
                        THROW(AddressException, "unable to parse address: unknown family supplied for address '%s'", text.c_str());
        }

        if (inet_ntop(this->family, &(this->addr), buffer, sizeof(buffer)) == NULL) {
                THROW(AddressException, "unable to parse address '%s'", text.c_str());
        }

        if (cidr != 255) {
                applyCIDR(cidr);
        }
}

IPAddress::IPAddress(int family) throw (AddressException) : family(family), hcache(0) {
        char    buffer[INET6_ADDRSTRLEN];

        switch (family) {
                case IPv4Family:
                case IPv4Preferred:
                case IPv4Required:
                        if (this->parse(this->family, this->addr.v4, "0.0.0.0") == false) {
                                THROW(AddressException, "unable to parse address: '%s' does not represent a valid IPv4 address", "0.0.0.0");
                        }
                        break;

                case IPv6Family:
                case IPv6Preferred:
                case IPv6Required:
                        if (this->parse(this->family, this->addr.v6, "::") == false) {
                                THROW(AddressException, "unable to parse address: '%s' does not represent a valid IPv6 address", "::");
                        }
                        break;

                default:
                        THROW(AddressException, "unable to parse address: unknown family supplied for default address");
        }

        if (inet_ntop(this->family, &(this->addr), buffer, sizeof(buffer)) == NULL) {
                THROW(AddressException, "unable to parse default address");
        }
}

IPAddress::IPAddress(const struct sockaddr_storage *ss, uint8_t cidr) throw (AddressException) : hcache(0) {
        char buffer[INET6_ADDRSTRLEN];
        union __sockaddr_union u;

        if (ss == NULL) {
                THROW(AddressException, "passed sockaddr_storage is null");
        }

        u.ss = (struct sockaddr_storage*) ss;
        this->family = u.sa->sa_family;

        if (this->family == AF_INET) {
                this->addr.v4 = u.sa_in->sin_addr;
        } else if (this->family == AF_INET6) {
                this->addr.v6 = u.sa_in6->sin6_addr;
        } else {
                THROW(AddressException, "unknown family '%d'", this->family);
        }

        if (inet_ntop(this->family, &(this->addr), buffer, sizeof(buffer)) == NULL) {
                THROW(AddressException, "unable to convert sockaddr");
        }

        if (cidr != 255) {
                applyCIDR(cidr);
        }
}

IPAddress::IPAddress(const struct sockaddr *sa, uint8_t cidr) throw (AddressException) : hcache(0) {
        char buffer[INET6_ADDRSTRLEN];
        union __sockaddr_union u;

        if (sa == NULL) {
                THROW(AddressException, "passed sockaddr is null");
        }

        u.sa = (struct sockaddr*) sa;
        this->family = sa->sa_family;

        if (this->family == AF_INET) {
                this->addr.v4 = u.sa_in->sin_addr;
        } else if (this->family == AF_INET6) {
                this->addr.v6 = u.sa_in6->sin6_addr;
        } else {
                THROW(AddressException, "unknown family '%d'", this->family);
        }

        if (inet_ntop(this->family, &(this->addr), buffer, sizeof(buffer)) == NULL) {
                THROW(AddressException, "unable to convert sockaddr");
        }

        if (cidr != 255) {
                applyCIDR(cidr);
        }
}

IPAddress::IPAddress(const struct in_addr *in, uint8_t cidr) throw (AddressException) : hcache(0) {
        char buffer[INET6_ADDRSTRLEN];

        if (in == NULL) {
                THROW(AddressException, "passed in_addr is null");
        }

        this->family = AF_INET;
        this->addr.v4 = *in;

        if (inet_ntop(this->family, &(this->addr), buffer, sizeof(buffer)) == NULL) {
                THROW(AddressException, "unable to convert in_addr");
        }

        if (cidr != 255) {
                applyCIDR(cidr);
        }
}

IPAddress::IPAddress(const struct in6_addr *in6, uint8_t cidr) throw (AddressException) {
        char buffer[INET6_ADDRSTRLEN];

        if (in6 == NULL) {
                THROW(AddressException, "passed in6_addr is null");
        }

        this->family = AF_INET6;
        this->addr.v6 = *in6;

        if (inet_ntop(this->family, &(this->addr), buffer, sizeof(buffer)) == NULL) {
                THROW(AddressException, "unable to convert in_addr");
        }

        if (cidr != 255) {
                applyCIDR(cidr);
        }
}

IPAddress::IPAddress(uint32_t address, uint8_t cidr) throw (AddressException) : hcache(0) {
        this->family = AF_INET;
        this->addr.v4.s_addr = htonl(address);

        if (cidr != 255) {
                applyCIDR(cidr);
        }
}

IPAddress::IPAddress(unsigned char address[16], uint8_t cidr) throw (AddressException) : hcache(0) {
        this->family = AF_INET6;
        memcpy(&(this->addr.v6), address, sizeof(addr)); /* May need to htonl() */

        if (cidr != 255) {
                applyCIDR(cidr);
        }
}

IPAddress::IPAddress(const IPAddress &other) throw () :
        family(other.family),
        addr(other.addr),
        scache(other.scache),
        hcache(other.hcache)
{ }

IPAddress::IPAddress(const IPAddress &&other) throw () :
        family(other.family),
        addr(other.addr),
        scache(std::move(other.scache)),
        hcache(other.hcache)
{ }

IPAddress::~IPAddress() throw () {
        family = 0;
}

IPAddress & IPAddress::operator=(const IPAddress &other) throw () {
        assert(other.family != 0);

        if (this != &other) {
                this->family = other.family;
                this->addr = other.addr;
                this->scache = other.scache;
                this->hcache = other.hcache;
        }

        return *this;
}

IPAddress & IPAddress::operator=(const IPAddress &&other) throw () {
        assert(other.family != 0);

        if (this != &other) {
                this->family = other.family;
                this->addr = other.addr;
                this->scache = std::move(other.scache);
                this->hcache = other.hcache;
        }

        return *this;
}

bool IPAddress::operator==(const IPAddress &other) const throw () {
        assert(this->family != 0);

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

        if (this->family == AF_INET) {
                return (this->addr.v4.s_addr == other.addr.v4.s_addr);
        } else {
                const uint64_t *a = (const uint64_t*) this->addr.v6.s6_addr;
                const uint64_t *b = (const uint64_t*) other.addr.v6.s6_addr;

                /* Ordered by most likely to be different. */
                return (a[1] == b[1] && a[0] == b[0]);
        }
}

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

bool IPAddress::operator>=(const IPAddress &other) const throw () {
        if (*this == other) {
                return true;
        }

        return (*this > other);
}

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

        return (*this < other);
}

bool IPAddress::operator>(const IPAddress &other) const throw () {
        if (this->family < other.family) {
                return false;
        }

        if (this->family == AF_INET) {
                return (ntohl(this->addr.v4.s_addr) > ntohl(other.addr.v4.s_addr));
        } else {
                const uint64_t *a = (const uint64_t*) this->addr.v6.s6_addr;
                const uint64_t *b = (const uint64_t*) other.addr.v6.s6_addr;

                return (ntohll(a[0]) > ntohll(b[0]) || ntohll(a[1]) > ntohll(b[1]));
        }
}

bool IPAddress::operator<(const IPAddress &other) const throw () {
        if (this->family > other.family) {
                return false;
        }

        if (this->family == AF_INET) {
                return (ntohl(this->addr.v4.s_addr) < ntohl(other.addr.v4.s_addr));
        } else {
                const uint64_t *a = (const uint64_t*) this->addr.v6.s6_addr;
                const uint64_t *b = (const uint64_t*) other.addr.v6.s6_addr;

                return (ntohll(a[0]) < ntohll(b[0]) || ntohll(a[1]) < ntohll(b[1]));
        }
}

IPAddress IPAddress::operator&(const IPAddress &other) const throw (AddressException) {
        if (this->family != other.family) {
                THROW(AddressException, "mismatched family not supported");
        }

        IPAddress res(other);

        res.hcache = 0;
        res.scache.clear();

        if (this->family == AF_INET) {
                res.addr.v4.s_addr &= this->addr.v4.s_addr;
        } else {
                uint64_t *a = (uint64_t*) this->addr.v6.s6_addr;
                uint64_t *r = (uint64_t*) res.addr.v6.s6_addr;

                r[0] &= a[0];
                r[1] &= a[1];
        }

        return res;
}

IPAddress IPAddress::operator|(const IPAddress &other) const throw (AddressException) {
        if (this->family != other.family) {
                THROW(AddressException, "mismatched family not supported");
        }

        IPAddress res(other);

        res.hcache = 0;
        res.scache.clear();

        if (this->family == AF_INET) {
                res.addr.v4.s_addr |= this->addr.v4.s_addr;
        } else {
                uint64_t *a = (uint64_t*) this->addr.v6.s6_addr;
                uint64_t *r = (uint64_t*) res.addr.v6.s6_addr;

                r[0] |= a[0];
                r[1] |= a[1];
        }

        return res;
}

IPAddress IPAddress::operator^(const IPAddress &other) const throw (AddressException) {
        if (this->family != other.family) {
                THROW(AddressException, "mismatched family not supported");
        }

        IPAddress res(other);

        res.hcache = 0;
        res.scache.clear();

        if (this->family == AF_INET) {
                res.addr.v4.s_addr ^= this->addr.v4.s_addr;
        } else {
                uint64_t *a = (uint64_t*) this->addr.v6.s6_addr;
                uint64_t *r = (uint64_t*) res.addr.v6.s6_addr;

                r[0] ^= a[0];
                r[1] ^= a[1];
        }

        return res;
}

IPAddress IPAddress::operator~() const throw () {
        IPAddress res(*this);

        res.hcache = 0;
        res.scache.clear();

        if (this->family == AF_INET) {
                res.addr.v4.s_addr = ~(res.addr.v4.s_addr);
        } else {
                uint64_t *r = (uint64_t*) res.addr.v6.s6_addr;

                r[0] = ~r[0];
                r[1] = ~r[1];
        }

        return res;
}

IPAddress& IPAddress::operator+=(uint32_t increment) throw () {
        this->hcache = 0;
        this->scache.clear();

        if (this->family == AF_INET) {
                addr.v4.s_addr = htonl(ntohl(addr.v4.s_addr) + increment);
        } else {
                uint64_t t[2] { 0, 0 };
                uint64_t *a = (uint64_t*) addr.v6.s6_addr;

                t[1] = ntohll(a[1]) + increment;

                if (t[1] < ntohll(a[1]) || t[1] < (uint64_t) increment) { /* Overflow */
                        t[0] = ntohll(a[0]) + t[1] + 1;
                        t[1] = 0;

                        if (t[0] < ntohll(a[0])) { /* Overflow */
                                t[1] = t[0];
                                t[0] = 0;
                        }
                } else {
                        t[0] = ntohll(a[0]);
                }

                a[0] = htonll(t[0]);
                a[1] = htonll(t[1]);
        }

        return *this;
}

IPAddress IPAddress::operator+(uint32_t increment) const throw () {
        IPAddress res(*this);

        return (res += increment);
}

IPAddress IPAddress::operator++(int) throw () {
        IPAddress res(*this);
        ++(*this);

        return res;
}

IPAddress& IPAddress::operator++() throw () {
        return (*this += 1);
}

IPAddress& IPAddress::operator-=(uint32_t increment) throw () {
        this->hcache = 0;
        this->scache.clear();

        if (this->family == AF_INET) {
                addr.v4.s_addr = htonl(ntohl(addr.v4.s_addr) - increment);
        } else {
                uint64_t t[2] { 0, 0 };
                uint64_t *a = (uint64_t*) addr.v6.s6_addr;

                t[1] = ntohll(a[1]) - increment;

                if (t[1] > ntohll(a[1]) && t[1] > (uint64_t) increment) { /* Underflow */
                        t[0] = ntohll(a[0]) - (std::numeric_limits<uint64_t>::max() - t[1] + 1);
                        t[1] = std::numeric_limits<uint64_t>::max();

                        if (t[0] > ntohll(a[0])) { /* Overflow */
                                t[1] = t[0];
                                t[0] = std::numeric_limits<uint64_t>::max();
                        }
                } else {
                        t[0] = ntohll(a[0]);
                }

                a[0] = htonll(t[0]);
                a[1] = htonll(t[1]);
        }

        return *this;
}

IPAddress IPAddress::operator-(uint32_t increment) const throw () {
        IPAddress res(*this);

        return (res -= increment);
}

IPAddress IPAddress::operator--(int) throw () {
        IPAddress res(*this);
        --(*this);

        return res;
}

IPAddress& IPAddress::operator--() throw () {
        return (*this -= 1);
}

bool IPAddress::parse(int &family, struct in6_addr &v6, struct in_addr &v4, const std::string &addr) throw () {
        if (this->parse(family, v6, addr) == false) {
                return this->parse(family, v4, addr);
        }
        return true;
}

bool IPAddress::parse(int &family, struct in_addr &v4, struct in6_addr &v6, const std::string &addr) throw () {
        if (this->parse(family, v4, addr) == false) {
                return this->parse(family, v6, addr);
        }
        return true;
}

bool IPAddress::parse(int &family, struct in_addr &v4, const std::string &addr) throw () {
        bool                                             result = false;

        struct ifreq                     interface[256];
        struct sockaddr_in      *sockaddr;
        int                                              s;

        assert(family != 0);

        if (inet_pton(AF_INET, addr.c_str(), &v4) != 1) {
                if ((s = socket(AF_INET, SOCK_DGRAM, 0)) > 1) {
                        strncpy(interface[0].ifr_name, addr.c_str(), IFNAMSIZ);
                        interface[0].ifr_addr.sa_family = AF_INET;

                        if (ioctl(s, SIOCGIFADDR,  interface) == 0) {
                                sockaddr = (struct sockaddr_in *)&(interface[0].ifr_ifru.ifru_addr);
                                memcpy(&v4, &(sockaddr->sin_addr), sizeof(addr));

                                family = AF_INET;
                                result = true;
                        }
                        close(s);
                }
        } else {
                family = AF_INET;
                result = true;
        }
        return result;
}

bool IPAddress::parse(int &famiy, struct in6_addr &v6, const std::string &addr) throw () {
        bool                                             result = false;

        struct ifreq                     interface[256];
        struct sockaddr_in6     *sockaddr;
        int                                              s;

        assert(family != 0);

        if (inet_pton(AF_INET6, addr.c_str(), &v6) != 1) {
                if ((s = socket(AF_INET6, SOCK_DGRAM, 0)) > 1) {
                        strncpy(interface[0].ifr_name, addr.c_str(), IFNAMSIZ);
                        interface[0].ifr_addr.sa_family = AF_INET6;

                        if (ioctl(s, SIOCGIFADDR,  interface) == 0) {
                                sockaddr = (struct sockaddr_in6 *)&(interface[0].ifr_ifru.ifru_addr);
                                memcpy(&v6, &(sockaddr->sin6_addr), sizeof(addr));

                                family = AF_INET6;
                                result = true;
                        }
                        close(s);
                }
        } else {
                family = AF_INET6;
                result = true;
        }
        return result;
}

void IPAddress::applyCIDR(uint8_t cidr) throw (AddressException) {
        assert(this->family != 0);

        if (this->family == AF_INET) {
                if (cidr > 32) {
                        THROW(AddressException, "IPv4 CIDR %u outside of valid range (0-32)", cidr);
                }

                addr.v4.s_addr = htonl(ntohl(addr.v4.s_addr) >> (32 - cidr) << (32 - cidr));
        } else {
                if (cidr > 128) {
                        THROW(AddressException, "IPv6 CIDR %u outside of valid range (0-128)", cidr);
                }

                for (int i = 15; i > cidr / 8 - 1; i--) {
                        if (i == cidr / 8) {
            addr.v6.s6_addr[i] = addr.v6.s6_addr[i] >> (8 - cidr % 8) << (8 - cidr % 8);
         } else {
            addr.v6.s6_addr[i] = 0;
         }
                }
        }
}

int IPAddress::getFamily(void) const throw () {
        assert(this->family != 0);

        return this->family;
}

const struct in_addr& IPAddress::getIPv4AddressStructure(void) const throw (AddressException) {
        if (this->family != IPv4Family) {
                THROW(AddressException, "instance is not an IPv4 address");
        }
        return this->addr.v4;
}

const struct in6_addr& IPAddress::getIPv6AddressStructure(void) const throw (AddressException) {
        if (this->family != IPv6Family) {
                THROW(AddressException, "instance is not an IPv6 address");
        }
        return this->addr.v6;
}

size_t IPAddress::getAddressStructureSize(void) const throw () {
        assert(this->family != 0);

        return (this->family == IPv4Family) ? sizeof(this->addr.v4) : sizeof(this->addr.v6);
}

const std::string& IPAddress::str(void) const throw (AddressException) {
        char buffer[INET6_ADDRSTRLEN];

        assert(this->family != 0);

        if (scache.empty()) {
                if (inet_ntop(this->family, &(this->addr), buffer, sizeof(buffer)) == NULL) {
                        THROW(AddressException, "inet_ntop failure");
                }

                scache = buffer;
        }

        return scache;
}

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

uint32_t IPAddress::getU32(void) const throw () {
        assert(this->family != 0);

        if (this->family == IPv4Family) {
                return ntohl(this->addr.v4.s_addr);
        }

        const uint32_t *a = (const uint32_t*) this->addr.v6.s6_addr;

        return ntohl(a[0] ^ ~a[1] ^ a[2] ^ ~a[3]);
}

uint32_t IPAddress::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 very good. */
        hcache = getU32();
#else
        #error No hash algo selected.
#endif

        return hcache;
}

bool IPAddress::empty(void) const throw () {
        const uint64_t *a = (const uint64_t*) this->addr.v6.s6_addr;

        return (a[0] == 0 && a[1] == 0);
}

void IPAddress::clear(void) throw () {
        hcache = 0;
        scache.clear();
        family = IPv4Family;
        memset(&addr, 0, sizeof(addr));
}

const IPAddress::shared IPAddress::shared_ptr(const std::string &text, int family, uint8_t cidr) throw (AddressException) {
        return std::make_shared<IPAddress>(text, family, cidr);
}

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

const IPAddress::shared IPAddress::shared_ptr(const struct sockaddr_storage *ss, uint8_t cidr) throw (AddressException) {
        return std::make_shared<IPAddress>(ss, cidr);
}

const IPAddress::shared IPAddress::shared_ptr(const struct sockaddr *sa, uint8_t cidr) throw (AddressException) {
        return std::make_shared<IPAddress>(sa, cidr);
}

const IPAddress::shared IPAddress::shared_ptr(const struct in_addr *in, uint8_t cidr) throw (AddressException) {
        return std::make_shared<IPAddress>(in, cidr);
}

const IPAddress::shared IPAddress::shared_ptr(const struct in6_addr *in6, uint8_t cidr) throw (AddressException) {
        return std::make_shared<IPAddress>(in6, cidr);
}

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

const IPAddress::shared IPAddress::shared_ptr(unsigned char address[16], uint8_t cidr) throw (AddressException) {
        return std::make_shared<IPAddress>(address, cidr);
}

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

---