io_address.h

Go to the documentation of this file.

// Copyright (C) 2010-2018 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
#ifndef IO_ADDRESS_H
#define IO_ADDRESS_H 1
 
// IMPORTANT NOTE: only very few ASIO headers files can be included in
// this file.  In particular, asio.hpp should never be included here.
// See the description of the namespace below.
#include <unistd.h>             // for some network system calls
#include <stdint.h>             // for uint32_t
#include <boost/asio/ip/address.hpp>
 
#include <functional>
#include <string>
#include <vector>
 
#include <exceptions/exceptions.h>
 
namespace isc {
namespace asiolink {
 
    static constexpr size_t V6ADDRESS_LEN = 16;
 
    static constexpr size_t V4ADDRESS_LEN = 4;
 
    static constexpr size_t V4ADDRESS_TEXT_MAX_LEN = 15u;
 
    static constexpr size_t V6ADDRESS_TEXT_MAX_LEN = 39u;
 
class IOAddress {
public:
 
    IOAddress(const std::string& address_str);
 
    IOAddress(const boost::asio::ip::address& asio_address);
 
    IOAddress(uint32_t v4address);
 
    std::string toText() const;
 
    short getFamily() const;
 
    bool isV4() const {
        return (asio_address_.is_v4());
    }
 
    bool isV4Zero() const {
        return (equals(IPV4_ZERO_ADDRESS()));
    }
 
    bool isV4Bcast() const {
        return (equals(IPV4_BCAST_ADDRESS()));
    }
 
    bool isV6() const {
        return (asio_address_.is_v6());
    }
 
    bool isV6Zero() const {
        return (equals(IPV6_ZERO_ADDRESS()));
    }
 
    bool isV6LinkLocal() const;
 
    bool isV6Multicast() const;
 
    static IOAddress fromBytes(short family, const uint8_t* data);
 
    std::vector<uint8_t> toBytes() const;
 
    bool equals(const IOAddress& other) const {
        return (asio_address_ == other.asio_address_);
    }
 
    bool operator==(const IOAddress& other) const {
        return equals(other);
    }
 
    bool nequals(const IOAddress& other) const {
        return (!equals(other));
    }
 
    bool lessThan(const IOAddress& other) const {
        if (this->getFamily() == other.getFamily()) {
            if (this->getFamily() == AF_INET6) {
                return (this->asio_address_.to_v6() < other.asio_address_.to_v6());
            } else {
                return (this->asio_address_.to_v4() < other.asio_address_.to_v4());
            }
        }
        return (this->getFamily() < other.getFamily());
    }
 
    bool smallerEqual(const IOAddress& other) const {
        if (equals(other)) {
            return (true);
        }
        return (lessThan(other));
    }
 
    bool operator<(const IOAddress& other) const {
        return (lessThan(other));
    }
 
    bool operator<=(const IOAddress& other) const {
        return (smallerEqual(other));
    }
 
    bool operator!=(const IOAddress& other) const {
        return (nequals(other));
    }
 
    static IOAddress subtract(const IOAddress& a, const IOAddress& b);
 
    static IOAddress
    increase(const IOAddress& addr);
 
    uint32_t toUint32() const;
 
 
    static const IOAddress& IPV4_ZERO_ADDRESS() {
        static IOAddress address(0);
        return (address);
    }
 
    static const IOAddress& IPV4_BCAST_ADDRESS() {
        static IOAddress address(0xFFFFFFFF);
        return (address);
    }
 
    static const IOAddress& IPV6_ZERO_ADDRESS() {
        static IOAddress address("::");
        return (address);
    }
 
 
private:
    boost::asio::ip::address asio_address_;
};
 
std::ostream&
operator<<(std::ostream& os, const IOAddress& address);
 
} // namespace asiolink
} // namespace isc
#endif // IO_ADDRESS_H