ipv4.hh

// -*- c-basic-offset: 4; tab-width: 8; indent-tabs-mode: t -*-
// vim:set sts=4 ts=8:

// Copyright (c) 2001-2011 XORP, Inc and Others
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License, Version
// 2.1, June 1999 as published by the Free Software Foundation.
// Redistribution and/or modification of this program under the terms of
// any other version of the GNU Lesser General Public License is not
// permitted.
// 
// This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For more details,
// see the GNU Lesser General Public License, Version 2.1, a copy of
// which can be found in the XORP LICENSE.lgpl file.
// 
// XORP, Inc, 2953 Bunker Hill Lane, Suite 204, Santa Clara, CA 95054, USA;
// http://xorp.net


#ifndef __LIBXORP_IPV4_HH__
#define __LIBXORP_IPV4_HH__

#include "libxorp/xorp.h"
#include "libxorp/exceptions.hh"
#include "libxorp/range.hh"
#include "libxorp/utils.hh"


struct in_addr;

class IPv4 {
public:
    typedef in_addr         InAddrType;
    typedef sockaddr_in     SockAddrType;

public:
    IPv4()              { _addr = 0; }

    IPv4(const IPv4& ipv4) : _addr(ipv4._addr) {}

    explicit IPv4(uint32_t value)    { _addr = value; }

    explicit IPv4(const uint8_t *from_uint8);

    IPv4(const in_addr& from_in_addr);

    IPv4(const sockaddr& sa) throw (InvalidFamily);

    IPv4(const sockaddr_storage& ss) throw (InvalidFamily);

    IPv4(const sockaddr_in& sin) throw (InvalidFamily);

    IPv4(const char *from_string) throw (InvalidString);

    size_t copy_out(uint8_t *to_uint8) const;

    size_t copy_out(in_addr& to_in_addr) const;

    size_t copy_out(sockaddr& to_sockaddr) const;

    size_t copy_out(sockaddr_storage& to_sockaddr_storage) const;

    size_t copy_out(sockaddr_in& to_sockaddr_in) const;

    size_t copy_in(const uint8_t *from_uint8);

    size_t copy_in(const in_addr& from_in_addr);

    size_t copy_in(const sockaddr& from_sockaddr) throw (InvalidFamily);

    size_t copy_in(const sockaddr_storage& from_sockaddr_storage)
    throw (InvalidFamily);

    size_t copy_in(const sockaddr_in& from_sockaddr_in) throw (InvalidFamily);

    IPv4 operator~() const { return IPv4(~_addr); }

    IPv4 operator|(const IPv4& other) const {
    return IPv4(_addr | other._addr);
    }

    IPv4 operator&(const IPv4& other) const {
    return IPv4(_addr & other._addr);
    }

    IPv4 operator^(const IPv4& other) const {
    return IPv4(_addr ^ other._addr);
    }

    IPv4 operator<<(uint32_t left_shift) const;

    IPv4 operator>>(uint32_t right_shift) const;

    bool operator<(const IPv4& other) const;

    bool operator==(const IPv4& other) const { return (_addr == other._addr); }

    bool operator!=(const IPv4& other) const { return (_addr != other._addr); }

    bool operator==(const IPv4Range& rhs) const {
    return (_addr >= rhs.low().addr() && _addr <= rhs.high().addr());
    }

    bool operator!=(const IPv4Range& rhs) const {
    return (_addr < rhs.low().addr() || _addr > rhs.high().addr());
    }

    bool operator<(const IPv4Range& rhs) const {
    return (_addr < rhs.low().addr());
    }

    bool operator<=(const IPv4Range& rhs) const {
    return (_addr <= rhs.high().addr());
    }

    bool operator>(const IPv4Range& rhs) const {
    return (_addr > rhs.high().addr());
    }

    bool operator>=(const IPv4Range& rhs) const {
    return (_addr >= rhs.low().addr());
    }

    IPv4& operator--();

    IPv4& operator++();

    string str() const;

    bool is_zero() const        { return (_addr == 0); }

    bool is_unicast() const;

    bool is_multicast() const;

    bool is_class_a() const;

    bool is_class_b() const;

    bool is_class_c() const;

    bool is_experimental() const;

    bool is_linklocal_unicast() const;

    bool is_interfacelocal_multicast() const;

    bool is_nodelocal_multicast() const { return is_interfacelocal_multicast(); }

    bool is_linklocal_multicast() const;

    bool is_loopback() const;

    static size_t addr_bytelen() {
    x_static_assert(sizeof(IPv4) == sizeof(uint32_t));
    return sizeof(IPv4);
    }

    static uint32_t addr_bitlen() {
    return uint32_t(8 * sizeof(uint8_t) * addr_bytelen());
    }

    static uint32_t ip_multicast_base_address_mask_len() {
#define IP_MULTICAST_BASE_ADDRESS_MASK_LEN_IPV4 4
    return (IP_MULTICAST_BASE_ADDRESS_MASK_LEN_IPV4);
#undef IP_MULTICAST_BASE_ADDRESS_MASK_LEN_IPV4
    }

    static uint32_t ip_class_a_base_address_mask_len() {
#define IP_CLASS_A_BASE_ADDRESS_MASK_LEN_IPV4       1
    return (IP_CLASS_A_BASE_ADDRESS_MASK_LEN_IPV4);
#undef IP_CLASS_A_BASE_ADDRESS_MASK_LEN_IPV4
    }

    static uint32_t ip_class_b_base_address_mask_len() {
#define IP_CLASS_B_BASE_ADDRESS_MASK_LEN_IPV4       2
    return (IP_CLASS_B_BASE_ADDRESS_MASK_LEN_IPV4);
#undef IP_CLASS_B_BASE_ADDRESS_MASK_LEN_IPV4
    }

    static uint32_t ip_class_c_base_address_mask_len() {
#define IP_CLASS_C_BASE_ADDRESS_MASK_LEN_IPV4       3
    return (IP_CLASS_C_BASE_ADDRESS_MASK_LEN_IPV4);
#undef IP_CLASS_C_BASE_ADDRESS_MASK_LEN_IPV4
    }

    static uint32_t ip_experimental_base_address_mask_len() {
#define IP_EXPERIMENTAL_BASE_ADDRESS_MASK_LEN_IPV4  4
    return (IP_EXPERIMENTAL_BASE_ADDRESS_MASK_LEN_IPV4);
#undef IP_EXPERIMENTAL_BASE_ADDRESS_MASK_LEN_IPV4
    }

    static IPv4 make_prefix(uint32_t mask_len) throw (InvalidNetmaskLength);

    IPv4 mask_by_prefix_len(uint32_t mask_len) const
    throw (InvalidNetmaskLength) {
    return (*this) & make_prefix(mask_len);
    }

    uint32_t mask_len() const;

    uint32_t addr() const       { return _addr; }

    void set_addr(uint32_t value)   { _addr = value; }

    enum { AF = AF_INET };

    enum { IPV = 4 };

    static int af() { return AF; }

    static uint32_t ip_version() { return IPV; }

    static const string& ip_version_str();

    uint32_t bits(uint32_t lsb, uint32_t len) const;

    uint32_t bit_count() const;

    uint32_t leading_zero_count() const;

    static const IPv4& ZERO(int af = AF_INET);
    static const IPv4& ANY(int af = AF_INET);
    static const IPv4& ALL_ONES(int af = AF_INET);
    static const IPv4& LOOPBACK(int af = AF_INET);
    static const IPv4& MULTICAST_BASE(int af = AF_INET);
    static const IPv4& MULTICAST_ALL_SYSTEMS(int af = AF_INET);
    static const IPv4& MULTICAST_ALL_ROUTERS(int af = AF_INET);
    static const IPv4& DVMRP_ROUTERS(int af = AF_INET);
    static const IPv4& OSPFIGP_ROUTERS(int af = AF_INET);
    static const IPv4& OSPFIGP_DESIGNATED_ROUTERS(int af = AF_INET);
    static const IPv4& RIP2_ROUTERS(int af = AF_INET);
    static const IPv4& PIM_ROUTERS(int af = AF_INET);
    static const IPv4& SSM_ROUTERS(int af = AF_INET);
    static const IPv4& CLASS_A_BASE(int af = AF_INET);
    static const IPv4& CLASS_B_BASE(int af = AF_INET);
    static const IPv4& CLASS_C_BASE(int af = AF_INET);
    static const IPv4& EXPERIMENTAL_BASE(int af = AF_INET);

    static const uint32_t ADDR_BITLEN = 32;

    static const uint32_t ADDR_BYTELEN = ADDR_BITLEN / 8;

private:
    uint32_t _addr;     // The address value (in network-order)
};

inline uint32_t
IPv4::bits(uint32_t lsb, uint32_t len) const
{
    uint32_t mask = ~(0xffffffffU << len);

    if (len >= 32)
    mask = 0xffffffffU; // XXX: shifting with >= 32 bits is undefined
    return (ntohl(_addr) >> lsb) & mask;
}

inline uint32_t
IPv4::bit_count() const
{
    // XXX: no need for ntohl()
    return (xorp_bit_count_uint32(_addr));
}

inline uint32_t
IPv4::leading_zero_count() const
{
    return (xorp_leading_zero_count_uint32(ntohl(_addr)));
}

struct IPv4Constants {
    static const IPv4 zero,
    any,
    all_ones,
    loopback,
    multicast_base,
    multicast_all_systems,
    multicast_all_routers,
    dvmrp_routers,
    ospfigp_routers,
    ospfigp_designated_routers,
    rip2_routers,
    pim_routers,
    ssm_routers,
    class_a_base,
    class_b_base,
    class_c_base,
    experimental_base;
};

inline const IPv4& IPv4::ZERO(int) {
    return IPv4Constants::zero;
}

inline const IPv4& IPv4::ANY(int) {
    return IPv4Constants::any;
}

inline const IPv4& IPv4::ALL_ONES(int) {
    return IPv4Constants::all_ones;
}

inline const IPv4& IPv4::LOOPBACK(int) {
    return IPv4Constants::loopback;
}

inline const IPv4& IPv4::MULTICAST_BASE(int) {
    return IPv4Constants::multicast_base;
}

inline const IPv4& IPv4::MULTICAST_ALL_SYSTEMS(int) {
    return IPv4Constants::multicast_all_systems;
}

inline const IPv4& IPv4::MULTICAST_ALL_ROUTERS(int) {
    return IPv4Constants::multicast_all_routers;
}

inline const IPv4& IPv4::DVMRP_ROUTERS(int) {
    return IPv4Constants::dvmrp_routers;
}

inline const IPv4& IPv4::OSPFIGP_ROUTERS(int) {
    return IPv4Constants::ospfigp_routers;
}

inline const IPv4& IPv4::OSPFIGP_DESIGNATED_ROUTERS(int) {
    return IPv4Constants::ospfigp_designated_routers;
}

inline const IPv4& IPv4::RIP2_ROUTERS(int) {
    return IPv4Constants::rip2_routers;
}

inline const IPv4& IPv4::PIM_ROUTERS(int) {
    return IPv4Constants::pim_routers;
}

inline const IPv4& IPv4::SSM_ROUTERS(int) {
    return IPv4Constants::ssm_routers;
}

inline const IPv4& IPv4::CLASS_A_BASE(int) {
    return IPv4Constants::class_a_base;
}

inline const IPv4& IPv4::CLASS_B_BASE(int) {
    return IPv4Constants::class_b_base;
}

inline const IPv4& IPv4::CLASS_C_BASE(int) {
    return IPv4Constants::class_c_base;
}

inline const IPv4& IPv4::EXPERIMENTAL_BASE(int) {
    return IPv4Constants::experimental_base;
}

#endif // __LIBXORP_IPV4_HH__