ipnet.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

// $XORP: xorp/libxorp/ipnet.hh,v 1.38 2009/01/05 18:30:57 jtc Exp $

#ifndef __LIBXORP_IPNET_HH__
#define __LIBXORP_IPNET_HH__

#include "xorp.h"
#include "exceptions.hh"
#include "c_format.hh"
#include "range.hh"
#include "utils.hh"
#include "ipv4.hh"
#include "ipv6.hh"

template <class A>
class IPNet {
public:
    IPNet() : _prefix_len(0) {}

    IPNet(const A& a, uint8_t prefix_len) throw (InvalidNetmaskLength)
    : _masked_addr(a), _prefix_len(prefix_len)
    {
    if (prefix_len > A::addr_bitlen())
        xorp_throw(InvalidNetmaskLength, prefix_len);
    _masked_addr = a.mask_by_prefix_len(prefix_len);
    }

    IPNet(const char *from_cstring)
    throw (InvalidString, InvalidNetmaskLength)
    {
    initialize_from_string(from_cstring);
    }

    IPNet(const IPNet& n) {
    _masked_addr    = n.masked_addr();
    _prefix_len = n.prefix_len();
    }

    IPNet& operator=(const IPNet& n) {
    _masked_addr    = n.masked_addr();
    _prefix_len = n.prefix_len();
    return *this;
    }

    bool operator==(const IPNet& other) const {
    return ((prefix_len() == other.prefix_len()) &&
        (masked_addr() == other.masked_addr()));
    }

    bool operator<(const IPNet& other) const;

    IPNet& operator--();

    IPNet& operator++();

    bool operator==(const U32Range& range) const {
    return (prefix_len() == range);
    }

    bool operator!=(const U32Range& range) const {
    return (prefix_len() != range);
    }

    bool operator<(const U32Range& range) const {
    return (prefix_len() < range);
    };

    bool operator<=(const U32Range& range) const {
    return (prefix_len() <= range);
    };

    bool operator>(const U32Range& range) const {
    return (prefix_len() > range);
    };

    bool operator>=(const U32Range& range) const {
    return (prefix_len() >= range);
    };

    string str() const;

     bool is_valid() const { return _prefix_len != 0; }

    bool is_overlap(const IPNet& other) const;

    bool contains(const IPNet& other) const;

    bool contains(const A& addr) const {
    return addr.mask_by_prefix_len(_prefix_len) == _masked_addr;
    }

    uint32_t overlap(const IPNet& other) const;

    static int af() { return A::af(); }

    const A& masked_addr() const { return _masked_addr; }

    A& masked_addr_nc() { return _masked_addr; }

    uint8_t prefix_len() const { return _prefix_len; }

    void set_prefix_len(uint8_t v) { _prefix_len = v; }

    A netmask() const { return _masked_addr.make_prefix(_prefix_len); }

    bool is_unicast() const;

    static const IPNet<A> ip_multicast_base_prefix() {
    return IPNet(A::MULTICAST_BASE(),
             A::ip_multicast_base_address_mask_len());
    }

    static const IPNet<A> ip_class_a_base_prefix();

    static const IPNet<A> ip_class_b_base_prefix();

    static const IPNet<A> ip_class_c_base_prefix();

    static const IPNet<A> ip_experimental_base_prefix();

    bool is_multicast() const {
    return (ip_multicast_base_prefix().contains(*this));
    }

    bool is_class_a() const;

    bool is_class_b() const;

    bool is_class_c() const;

    bool is_experimental() const;

    A top_addr() const { return _masked_addr | ~netmask(); }

    static IPNet<A> common_subnet(const IPNet<A> x, const IPNet<A> y) {
    return IPNet<A>(x.masked_addr(), x.overlap(y));
    }

private:
    void initialize_from_string(const char *s)
    throw (InvalidString, InvalidNetmaskLength);

    A       _masked_addr;
    uint8_t _prefix_len;
};

/* ------------------------------------------------------------------------- */
/* Deferred method definitions */

template <class A> bool
IPNet<A>::operator<(const IPNet& other) const
{
#if 1
    /*
     * say x = A/B and y = C/D, then
     *
     *  x < y :
     *
     *      if x.contains(y) // equal is fine
     *          return false
     *      else if y.strictly_contains(x) // equal already taken care of
     *          return true
     *      else
     *          return A < C
     *
     *               |---x---|
     *  x=y          |---y---|
     *  x>y            |-y-|
     *  x<y   |------y-------|
     *  x<y          |-----y---------|
     *  x<y                     |--y-|
     */
    if (masked_addr().af() != other.masked_addr().af())
    return (masked_addr().af() < other.masked_addr().af());

    if (this->contains(other))
    return false;
    else if (other.contains(*this))
    return true;
    else
    return this->masked_addr() < other.masked_addr();

#else   // old code
    const A& maddr_him = other.masked_addr();
    uint8_t his_prefix_len = other.prefix_len();

    //the ordering is important because we want the longest match to
    //be first.  For example, we want the following:
    //  128.16.0.0/24 < 128.16.64.0/24 <  128.16.0.0/16 < 128.17.0.0/24

    if (_prefix_len == his_prefix_len) return _masked_addr < maddr_him;

    // we need to check the case when one subnet is a subset of
    // the other
    if (_prefix_len < his_prefix_len) {
    A test_addr(maddr_him.mask_by_prefix_len(_prefix_len));
    if (_masked_addr == test_addr) {
        //his subnet is a subset of mine, so he goes first.
        return (false);
    }
    } else if (_prefix_len > his_prefix_len) {
    A test_addr(_masked_addr.mask_by_prefix_len(his_prefix_len));
    if (maddr_him == test_addr) {
        //my subnet is a subset of his, so I go first.
        return (true);
    }
    }
    //the subnets don't overlap (or are identical), so just order by address
    if (_masked_addr < maddr_him) {
    return (true);
    }
    return (false);
#endif
}

template <class A> string
IPNet<A>::str() const
{
    return _masked_addr.str() + c_format("/%u", XORP_UINT_CAST(_prefix_len));
}

template <class A> bool
IPNet<A>::is_overlap(const IPNet<A>& other) const
{
    if (masked_addr().af() != other.masked_addr().af())
    return (false);

    if (prefix_len() > other.prefix_len()) {
    // I have smaller prefix size
    IPNet other_masked(masked_addr(), other.prefix_len());
    return (other_masked.masked_addr() == other.masked_addr());
    }
    if (prefix_len() < other.prefix_len()) {
    // I have bigger prefix size
    IPNet other_masked(other.masked_addr(), prefix_len());
    return (other_masked.masked_addr() == masked_addr());
    }
    // Same prefix size
    return (other.masked_addr() == masked_addr());
}

template <class A> bool
IPNet<A>::contains(const IPNet<A>& other) const
{
    if (masked_addr().af() != other.masked_addr().af())
    return (false);

    if (prefix_len() > other.prefix_len()) {
    // I have smaller prefix size, hence I don't contain other.
    return (false);
    }
    if (prefix_len() < other.prefix_len()) {
    // I have bigger prefix size
    IPNet other_masked(other.masked_addr(), prefix_len());
    return (other_masked.masked_addr() == masked_addr());
    }
    // Same prefix size
    return (other.masked_addr() == masked_addr());
}

template <class A> void
IPNet<A>::initialize_from_string(const char *cp)
    throw (InvalidString, InvalidNetmaskLength)
{
    char *slash = strrchr(const_cast<char*>(cp), '/');
    if (slash == 0)
    xorp_throw(InvalidString, "Missing slash");

    if (*(slash + 1) == 0)
    xorp_throw(InvalidString, "Missing prefix length");
    char *n = slash + 1;
    while (*n != 0) {
    if (*n < '0' || *n > '9') {
        xorp_throw(InvalidString, "Bad prefix length");
    }
    n++;
    }
    _prefix_len = atoi(slash + 1);

    string addr = string(cp, slash - cp);

    _masked_addr = A(addr.c_str()).mask_by_prefix_len(_prefix_len);
}

template <class A> IPNet<A>&
IPNet<A>::operator--()
{
    _masked_addr = _masked_addr >> (_masked_addr.addr_bitlen() - _prefix_len);
    --_masked_addr;
    _masked_addr = _masked_addr << (_masked_addr.addr_bitlen() - _prefix_len);
    return (*this);
}

template <class A> IPNet<A>&
IPNet<A>::operator++()
{
    _masked_addr = _masked_addr >> (_masked_addr.addr_bitlen() - _prefix_len);
    ++_masked_addr;
    _masked_addr = _masked_addr << (_masked_addr.addr_bitlen() - _prefix_len);
    return (*this);
}

template <class A>
inline uint32_t
IPNet<A>::overlap(const IPNet<A>& other) const
{
    if (masked_addr().af() != other.masked_addr().af())
    return 0;

    A xor_addr = masked_addr() ^ other.masked_addr();
    uint32_t done = xor_addr.leading_zero_count();

    uint32_t p = (prefix_len() < other.prefix_len()) ?
    prefix_len() : other.prefix_len();
    if (done > p)
    done = p;
    return done;
}

template <class A> uint32_t
overlap(const IPNet<A>& a1, const IPNet<A>& a2)
{
    return a1.overlap(a2);
}

#endif // __LIBXORP_IPNET_HH__