mrib_table.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 General Public License, Version 2, June
// 1991 as published by the Free Software Foundation. Redistribution
// and/or modification of this program under the terms of any other
// version of the GNU 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 General Public License, Version 2, a copy of which can be
// found in the XORP LICENSE.gpl file.
// 
// XORP Inc, 2953 Bunker Hill Lane, Suite 204, Santa Clara, CA 95054, USA;
// http://xorp.net

// $XORP: xorp/mrt/mrib_table.hh,v 1.17 2008/10/02 21:57:45 bms Exp $

#ifndef __MRT_MRIB_TABLE_HH__
#define __MRT_MRIB_TABLE_HH__


//
// Multicast Routing Information Base Table header file.
//





#include "libxorp/ipvx.hh"
#include "libxorp/ipvxnet.hh"


//
// Constants definitions
//
enum {
    MRIB_DONT_CREATE = false,
    MRIB_DO_CREATE = true
};

//
// Structures/classes, typedefs and macros
//

class MribTable;
class MribTableIterator;
class MribLookup;
class Mrib;


class Mrib {
public:
    Mrib(int family);

    Mrib(const IPvXNet& dest_prefix);

    Mrib(const Mrib& mrib);
    
    bool operator==(const Mrib& other) const;
    
    const IPvXNet& dest_prefix() const { return (_dest_prefix); }

    void    set_dest_prefix(const IPvXNet& v) { _dest_prefix = v; }
    
    const IPvX& next_hop_router_addr() const { return (_next_hop_router_addr); }
    
    void    set_next_hop_router_addr(const IPvX& v) { _next_hop_router_addr = v; }
    
    uint32_t    next_hop_vif_index() const { return (_next_hop_vif_index); }
    
    void    set_next_hop_vif_index(uint32_t v) { _next_hop_vif_index = v; }
    
    uint32_t    metric_preference() const { return (_metric_preference); }
    
    void    set_metric_preference(uint32_t v) { _metric_preference = v; }

    uint32_t    metric() const { return (_metric); }
    
    void    set_metric(uint32_t v) { _metric = v; }
    
    string str() const;
    
private:
    IPvXNet _dest_prefix;       // The destination prefix address
    IPvX    _next_hop_router_addr;  // The address of the next-hop router
    uint32_t    _next_hop_vif_index;    // The vif index to the next-hop router
    uint32_t    _metric_preference; // The metric preference to the
                    // destination
    uint32_t    _metric;        // The metric to the destination
};

class MribTableIterator {
public:
    MribTableIterator(MribLookup *mrib_lookup) : _mrib_lookup(mrib_lookup) {}
    
    MribTableIterator() {}
    
    MribTableIterator& operator++();

    MribTableIterator operator++(int);
    
    bool operator==(const MribTableIterator& other) const {
    return (_mrib_lookup == other._mrib_lookup);
    }
    
    bool operator!=(const MribTableIterator& other) const {
    return (_mrib_lookup != other._mrib_lookup);
    }
    
    Mrib* operator*() const;
    
private:
    MribLookup *_mrib_lookup;   // The MribLookup entry for this iterator
};

class MribTable {
public:
    MribTable(int family);
    
    ~MribTable();
    
    typedef MribTableIterator   iterator;

    int     family() const { return (_family); }

    void    clear();

    void    remove_all_entries();

    list<Mrib *>& removed_mrib_entries() {
    return (_removed_mrib_entries);
    }

    bool is_preserving_removed_mrib_entries() const {
    return (_is_preserving_removed_mrib_entries);
    }

    void set_is_preserving_removed_mrib_entries(bool v) {
    _is_preserving_removed_mrib_entries = v;
    }

    Mrib    *insert(const Mrib& mrib);
    
    void    remove(const IPvXNet& dest_prefix);
    
    void    remove(const Mrib& mrib);
    
    Mrib    *find(const IPvX& address) const;
    
    Mrib    *find_exact(const IPvXNet& dest_prefix) const;
    
    iterator    begin() const { return (_mrib_lookup_root); }
    
    iterator    end() const { return (NULL); }

    void update_entry_vif_index(const IPvXNet& dest_prefix,
                uint32_t vif_index);

    //
    // Pending transactions related methods
    //
    void    add_pending_insert(uint32_t tid, const Mrib& mrib);

    void    add_pending_remove(uint32_t tid, const Mrib& mrib);

    void    add_pending_remove_all_entries(uint32_t tid);

    void    commit_pending_transactions(uint32_t tid);
    
    void    abort_pending_transactions(uint32_t tid);
    
    void    abort_all_pending_transactions() {
    _mrib_pending_transactions.clear();
    }
    
    size_t  size()   const  { return (_mrib_size);  }
    
private:
    void remove_mrib_entry(Mrib *mrib);

    MribLookup  *find_prefix_mrib_lookup(const IPvXNet& addr_prefix) const;
    
    void    remove_mrib_lookup(MribLookup *mrib_lookup);
    
    //
    // Private class used to keep track of pending transactions
    //
    class PendingTransaction {
    public:
    PendingTransaction(uint32_t tid, const Mrib& mrib, bool is_insert)
        : _tid(tid),
          _mrib(mrib),
          _is_insert(is_insert),
          _is_remove_all(false)
    {}

#ifdef XORP_USE_USTL
    PendingTransaction(): _mrib(AF_INET) { }
#endif

    PendingTransaction(const MribTable& mrib_table, uint32_t tid)
        : _tid(tid),
          _mrib(Mrib(IPvXNet(IPvX::ZERO(mrib_table.family()), 0))),
          _is_insert(false),
          _is_remove_all(true)
    {}
    uint32_t    tid() const { return (_tid); }
    const Mrib& mrib() const { return (_mrib); }
    bool        is_insert() const { return (_is_insert); }
    bool        is_remove_all() const { return (_is_remove_all); }
    void        update_entry_vif_index(uint32_t vif_index) {
        _mrib.set_next_hop_vif_index(vif_index);
    }
    
    private:
    uint32_t    _tid;       // The transaction ID
    Mrib        _mrib;      // The MRIB to add or remove
    bool        _is_insert; // If true, insert, otherwise remove
    bool        _is_remove_all; // If true, remove all entries
    };
    
    //
    // The private state
    //
    int     _family;        // The address family of this table
    MribLookup  *_mrib_lookup_root; // The root of the MRIB lookup tree
    size_t  _mrib_lookup_size;  // The number of MribLookup entries
    size_t  _mrib_size;     // The number of Mrib entries
    
    //
    // The list of pending transactions
    //
    list<PendingTransaction> _mrib_pending_transactions;

    //
    // A flag to indicate whether the removed Mrib entries are preserved
    // on the _removed_mrib_entries list, or are deleted.
    //
    bool        _is_preserving_removed_mrib_entries;

    //
    // The list of removed Mrib entries that may be still in use.
    //
    list<Mrib *>    _removed_mrib_entries;
};

class MribLookup {
public:
    MribLookup(MribLookup *parent)
    : _parent(parent),
      _left_child(NULL),
      _right_child(NULL),
      _mrib(NULL)
    {}
    
    ~MribLookup() { if (_mrib != NULL) delete _mrib; }
    
    Mrib *mrib() const { return (_mrib); }

    void set_mrib(Mrib *v) { _mrib = v; }

    MribLookup *parent() { return (_parent); }

    void set_parent(MribLookup *v) { _parent = v; }

    MribLookup *left_child() { return (_left_child); }

    void set_left_child(MribLookup *v) { _left_child = v; }

    MribLookup *right_child() { return (_right_child); }

    void set_right_child(MribLookup *v) { _right_child = v; }

    MribLookup *get_next() const;
    
private:
    MribLookup  *_parent;   // The parent in the lookup tree
    MribLookup  *_left_child;   // The left child in the lookup tree
    MribLookup  *_right_child;  // The right child in the lookup tree
    Mrib    *_mrib;     // A pointer to the MRIB info
};

//
// Global variables
//

//
// Global functions prototypes
//

#endif // __MRT_MRIB_TABLE_HH__