IPPrefix.cpp

/*
** libutil++
** $Id: IPPrefix.cpp 1723 2016-11-03 19:34:33Z 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 1723 2016-11-03 19:34:33Z sella $";

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

using namespace sella::variant;
namespace sn = sella::net;

IPPrefix::IPPrefix() throw () : Nullable(std::make_shared<sn::IPPrefix>()) { }

IPPrefix::IPPrefix(const std::string &value) throw (TypeCastException) : Nullable() {
        if (LIKELY(boost::regex_match(value, IPPrefix::Pattern()))) {
                this->value = std::make_shared<sn::IPPrefix>(value);
        } else {
                THROW(TypeCastException, "unable to cast '%s' to a ipprefix value", value.c_str());
        }
}

IPPrefix::IPPrefix(const sn::IPPrefix &value) throw () : Nullable(std::make_shared<sn::IPPrefix>(value)) { }

IPPrefix::IPPrefix(sn::IPPrefix &&value) throw () : Nullable(std::make_shared<sn::IPPrefix>(std::move(value))) { }

IPPrefix::IPPrefix(const IPPrefix &other) throw () : Nullable() {
        if (LIKELY(this != &other)) {
                if (LIKELY(!other.isNull())) {
                        if (UNLIKELY(isNull())) {
                                this->value = std::make_shared<sn::IPPrefix>(other.get());
                        } else {
                                *std::static_pointer_cast<sn::IPPrefix>(this->value) = *std::static_pointer_cast<sn::IPPrefix>(other.value);
                        }
                } else {
                        this->value.reset();
                }
        }
}

IPPrefix::IPPrefix(IPPrefix &&other) throw () : Nullable() {
        if (LIKELY(!other.isNull())) {
                this->value = std::move(other.value);
        }
}

bool IPPrefix::operator==(const IPPrefix &other) const throw () {
        return (*std::static_pointer_cast<sn::IPPrefix>(this->value) == *std::static_pointer_cast<sn::IPPrefix>(other.value));
}

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

bool IPPrefix::operator>(const IPPrefix &other) const throw () {
        return (*std::static_pointer_cast<sn::IPPrefix>(this->value) > *std::static_pointer_cast<sn::IPPrefix>(other.value));
}

bool IPPrefix::operator<(const IPPrefix &other) const throw () {
        return (*std::static_pointer_cast<sn::IPPrefix>(this->value) < *std::static_pointer_cast<sn::IPPrefix>(other.value));
}

IPPrefix& IPPrefix::operator=(const IPPrefix &other) throw () {
        if (LIKELY(this != &other)) {
                if (LIKELY(!other.isNull())) {
                        if (UNLIKELY(isNull())) {
                                this->value = std::make_shared<sn::IPPrefix>(other.get());
                        } else {
                                *std::static_pointer_cast<sn::IPPrefix>(this->value) = *std::static_pointer_cast<sn::IPPrefix>(other.value);
                        }
                } else {
                        this->value.reset();
                }
        }

        return *this;
}

IPPrefix& IPPrefix::operator=(IPPrefix &&other) throw () {
        if (LIKELY(this != &other)) {
                if (LIKELY(!other.isNull())) {
                        this->value = std::move(other.value);
                }
        }

        return *this;
}

IPPrefix& IPPrefix::operator=(const sella::net::IPPrefix &other) throw () {
        if (UNLIKELY(isNull())) {
                this->value = std::make_shared<sn::IPPrefix>(other);
        } else {
                *std::static_pointer_cast<sn::IPPrefix>(this->value) = other;
        }

        return *this;
}

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

const sn::IPPrefix& IPPrefix::get() const throw (UnsupportedOperatorException) {
        if (UNLIKELY(isNull())) {
                THROW(UnsupportedOperatorException, "unable to take reference of null value");
        }

        return *std::static_pointer_cast<sn::IPPrefix>(this->value);
}

sn::IPPrefix& IPPrefix::get() throw (UnsupportedOperatorException) {
        if (UNLIKELY(isNull())) {
                THROW(UnsupportedOperatorException, "unable to take reference of null value");
        }

        return *std::static_pointer_cast<sn::IPPrefix>(this->value);
}

void IPPrefix::clear() throw() {
        if (UNLIKELY(isNull())) {
                this->value = std::make_shared<sn::IPPrefix>();
        } else {
                this->get().clear();
        }
}

void IPPrefix::msgpack(sella::util::MessagePack &mpack, uint32_t &offset) const throw (TypeCastException) {
        uint32_t c;

        if (UNLIKELY(isNull())) {
                c = mpack.append(offset);
        } else {
                c = mpack.append(offset, std::static_pointer_cast<sella::net::IPPrefix>(this->value)->str());
        }

        offset += c;

        if (UNLIKELY(c == 0)) {
                THROW(TypeCastException, "Failed to append '%s' at offset %d (buffer length: %d)", str(JSON).c_str(), offset, mpack.length());
        }
}

void IPPrefix::msgpackBufferSize(size_t &size) const throw () {
        if (UNLIKELY(isNull())) {
                size += 1;

                return;
        }

        size += 5 + (std::static_pointer_cast<sella::net::IPPrefix>(this->value)->getFamily() == sn::IPAddress::IPv4Family) ? 18 : 43;
}

std::string IPPrefix::str(int type) const throw () {
        if (UNLIKELY(isNull())) {
                return "null";
        }

        return this->get().str();
}

bool IPPrefix::isType(const char *value, size_t size) throw () {
        size_t cidr = 0;

        /* Verify CIDR is present and valid. */
        for (size_t i = size - 4; i < size; i++) {
                if (value[i] == '/' && ::isdigit(value[i + 1]) != 0) {
                        if (::atoi(value + i + 1) > 128) {
                                return false;
                        }

                        cidr = i;
                }
        }

        if (cidr != 0) {
                unsigned char buf[sizeof(struct in6_addr)];
                char tmp[cidr + 1];

                /* Verify as proper IPv4/IPv6 */
                for (size_t i = 0, len = (size > 5) ? 5 : size; i < len; i++) {
                        if (value[i] == '.') { /* Possibly an IPv4 address */
                                strncpy(tmp, value, cidr);
                                tmp[cidr] = 0;

                                return (inet_pton(AF_INET, tmp, buf) == 1);
                        } else if (value[i] == ':') { /* Possibly an IPv6 address */
                                strncpy(tmp, value, cidr);
                                tmp[cidr] = 0;

                                return (inet_pton(AF_INET6, tmp, buf) == 1);
                        }
                }
        }

        return false;
}

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