IPAddressPort.cpp

/*
** libutil++
** $Id: IPAddressPort.cpp 1664 2016-04-04 03:57:40Z 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: IPAddressPort.cpp 1664 2016-04-04 03:57:40Z sella $";

#include "IPAddressPort.h"
#include "../util/String.h"

#include <string.h>

#define HASH_ALGO_INT1

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

IPAddressPort::IPAddressPort(const IPAddress &address, const Port &port) throw () :
        hcache(0)
{
        init(address, port);
}

IPAddressPort::IPAddressPort(const IPAddress &address, const TCPPort &port) throw () :
        hcache(0)
{
        init(address, (Port) port);
}

IPAddressPort::IPAddressPort(const IPAddress &address, const UDPPort &port) throw () :
        hcache(0)
{
        init(address, (Port) port);
}

IPAddressPort::IPAddressPort(const IPAddress &address, uint16_t port) throw (PortException) :
        hcache(0)
{
        const Port p(port);

        init(address, p);
}

IPAddressPort::IPAddressPort(const std::string &address, uint16_t port) throw (AddressException, PortException) :
        hcache(0)
{
        std::vector<std::string> matches;

        std::string aaa = address;
        std::string pat = "^\\s*(\\[?([0-9\\.]+)\\]?|\\[([0-9A-Z:]+)\\]):([0-9]+)\\s*$";

        if (String::regex_imatch(aaa, pat, matches)) {
                const IPAddress a((matches.at(3).empty()) ? matches.at(2) : matches.at(3));

                if (port > 0) {
                        const Port p(port);

                        init(a, p);
                } else {
                        const Port p(matches.at(4));

                        init(a, p);
                }
        } else if (String::regex_imatch(address, "^\\s*\\[?([0-9\\.]+|[0-9A-Z:]+)\\]?\\s*$", matches)) {
                const IPAddress a(matches.at(1));
                const Port p(port);

                init(a, p);
        } else {
                const IPAddress a(address);
                const Port p(port);

                init(a, p);
        }
}

IPAddressPort::IPAddressPort(const struct sockaddr_storage *ss) throw (AddressException, PortException) :
        hcache(0)
{
        const IPAddress a(ss);
        const Port p(ss);

        init(a, p);
}

IPAddressPort::IPAddressPort(const struct sockaddr *sa) throw (AddressException, PortException) :
        hcache(0)
{
        const IPAddress a(sa);
        const Port p(sa);

        init(a, p);
}

IPAddressPort::IPAddressPort(const IPAddressPort &other) throw () :
        address(other.address),
        port(other.port),
        u(other.u),
        scache(other.scache),
        hcache(other.hcache)
{ }

IPAddressPort::IPAddressPort(const IPAddressPort &&other) throw () :
        address(std::move(other.address)),
        port(std::move(other.port)),
        u(other.u),
        scache(std::move(other.scache)),
        hcache(other.hcache)
{ }

IPAddressPort::~IPAddressPort() throw () { }

IPAddressPort& IPAddressPort::operator = (const IPAddressPort &other) throw () {
        if (this != &other) {
                this->address = other.address;
                this->port = other.port;
                this->u = other.u;
                this->scache = other.scache;
                this->hcache = other.hcache;
        }

        return *this;
}

IPAddressPort& IPAddressPort::operator = (const IPAddressPort &&other) throw () {
        if (this != &other) {
                this->address = std::move(other.address);
                this->port = std::move(other.port);
                this->u = other.u;
                this->scache = std::move(other.scache);
                this->hcache = other.hcache;
        }

        return *this;
}

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

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

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

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

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

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

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

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

const Port& IPAddressPort::getPort(void) const throw () {
        return this->port;
}

const struct sockaddr_storage& IPAddressPort::getSockaddrStorage(void) const throw () {
        return u.ss;
}

const struct sockaddr& IPAddressPort::getSockaddr(void) const throw () {
        return u.sa;
}

const struct sockaddr_in& IPAddressPort::getSockaddrIn(void) const throw () {
        return u.sa_in;
}

const struct sockaddr_in6& IPAddressPort::getSockaddrIn6(void) const throw () {
        return u.sa_in6;
}

bool IPAddressPort::hasIPAddress(void) const throw () {
        return (!address.empty());
}

bool IPAddressPort::hasPort(void) const throw () {
        return (!port.empty());
}

const std::string& IPAddressPort::str(void) const throw (AddressException) {
        if (scache.empty()) {
                if (this->address.getFamily() == AF_INET) {
                        scache.append(this->address.str()).append(":").append(this->port.str());
                } else {
                        scache.append("[").append(this->address.str()).append("]:").append(this->port.str());
                }
        }

        return scache;
}

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

uint32_t IPAddressPort::getU32(void) const throw () {
        return (address.getU32() ^ port.getU32());
}

uint32_t IPAddressPort::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 IPAddressPort::empty(void) const throw () {
        return (port.empty() && address.empty());
}

const IPAddressPort::shared IPAddressPort::shared_ptr(const IPAddress &address, const Port &port) throw () {
        return std::make_shared<IPAddressPort>(address, port);
}

const IPAddressPort::shared IPAddressPort::shared_ptr(const IPAddress &address, const TCPPort &port) throw () {
        return std::make_shared<IPAddressPort>(address, port);
}

const IPAddressPort::shared IPAddressPort::shared_ptr(const IPAddress &address, const UDPPort &port) throw () {
        return std::make_shared<IPAddressPort>(address, port);
}

const IPAddressPort::shared IPAddressPort::shared_ptr(const IPAddress &address, uint16_t port) throw (PortException) {
        return std::make_shared<IPAddressPort>(address, port);
}

const IPAddressPort::shared IPAddressPort::shared_ptr(const std::string &address, uint16_t port) throw (AddressException, PortException) {
        return std::make_shared<IPAddressPort>(address, port);
}

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

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

void IPAddressPort::init(const IPAddress &address, const Port &port) throw () {
        this->address = address;
        this->port = port;

        memset(&u, 0, sizeof(union __sockaddr_union));

        u.sa.sa_family = address.getFamily();
        if (u.sa.sa_family == AF_INET) {
                memcpy(&(u.sa_in.sin_addr), &(address.getIPv4AddressStructure()), sizeof(struct in_addr));
        } else {
                memcpy(&(u.sa_in6.sin6_addr), &(address.getIPv6AddressStructure()), sizeof(struct in6_addr));
        }
        u.sa_in.sin_port = htons(port.get());
}

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