route_entry.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/rip/route_entry.hh,v 1.23 2008/10/02 21:58:17 bms Exp $

#ifndef __RIP_ROUTE_ENTRY_HH__
#define __RIP_ROUTE_ENTRY_HH__

#include "libxorp/xorp.h"
#include "libxorp/ipnet.hh"
#include "libxorp/timer.hh"



#include "policy/backend/policytags.hh"

template<typename A> class RouteEntryOrigin;
template<typename A> class RouteEntryRef;

template<typename A>
class RouteEntry :
    public NONCOPYABLE
{
public:
    typedef A Addr;
    typedef IPNet<A> Net;
    typedef RouteEntryOrigin<A> Origin;

public:
    RouteEntry(const Net&  n,
           const Addr& nh,
           const string& ifname,
           const string& vifname,
           uint16_t    cost,
           Origin*&    o,
           uint16_t    tag);

    RouteEntry(const Net&  n,
           const Addr& nh,
           const string& ifname,
           const string& vifname,
           uint16_t    cost,
           Origin*&    o,
           uint16_t    tag,
           const PolicyTags& policytags);
    ~RouteEntry();

    const IPNet<A>& net() const     { return _net; }

    bool set_nexthop(const A& nh);

    const A& nexthop() const        { return _nh; }

    const string& ifname() const    { return _ifname; }

    bool set_ifname(const string& ifname);

    const string& vifname() const   { return _vifname; }

    bool set_vifname(const string& vifname);
    
    bool set_cost(uint16_t cost);

    uint16_t cost() const           { return _cost; }

    bool set_origin(Origin* origin);

    const Origin* origin() const    { return _origin; }

    Origin* origin()            { return _origin; }

    bool set_tag(uint16_t tag);

    uint16_t tag() const        { return _tag; }

    void set_timer(const XorpTimer& t)  { _timer = t; }

    const XorpTimer& timer() const  { return _timer; }

    const PolicyTags& policytags() const    { return _policytags; }

    PolicyTags& policytags()            { return _policytags; }

    bool set_policytags(const PolicyTags& tags);

    bool filtered() const           { return _filtered; }
    void set_filtered(bool v)           { _filtered = v;    }

private:
    friend class RouteEntryRef<A>;
    void ref()              { _ref_cnt++; }
    uint16_t unref()            { return --_ref_cnt; }
    uint16_t ref_cnt() const        { return _ref_cnt; }

protected:
    void dissociate();
    void associate(Origin* o);

protected:
    Net     _net;
    Addr    _nh;
    string  _ifname;
    string  _vifname;
    uint16_t    _cost;
    Origin* _origin;
    uint16_t    _tag;
    uint16_t    _ref_cnt;

    XorpTimer   _timer;
    
    PolicyTags  _policytags;
    bool    _filtered;
};


template <typename A>
class RouteEntryRef {
private:
    RouteEntry<A>* _rt;

protected:
    void release() {
    if (_rt && _rt->unref() == 0) delete _rt;
    }

public:
    RouteEntryRef(RouteEntry<A>* r) : _rt(r)        { _rt->ref(); }

    RouteEntryRef() : _rt(0)                {}

    ~RouteEntryRef()                    { release(); }

    RouteEntryRef(const RouteEntryRef& o) : _rt(o._rt)
    {
    if (_rt) _rt->ref();
    }

    RouteEntryRef& operator=(const RouteEntryRef& o) {
    release();
    _rt = o._rt;
    if (_rt) _rt->ref();
    return *this;
    }

    RouteEntry<A>* get() const { return _rt; }

    RouteEntry<A>* operator->() const { return _rt; }

    bool operator==(const RouteEntryRef& o) const { return _rt == o._rt; }
};


template <typename A>
class RouteEntryOrigin :
    public NONCOPYABLE
{
public:
    typedef RouteEntry<A> Route;
    typedef IPNet<A>      Net;
    struct RouteEntryStore;

public:
    RouteEntryOrigin(bool is_rib_origin);
    virtual ~RouteEntryOrigin();

    bool is_rib_origin() const { return _is_rib_origin; }

    bool associate(Route* r);

    bool dissociate(Route* r);

    Route* find_route(const Net& n) const;

    uint32_t route_count() const;

    void clear();

    void dump_routes(vector<const Route*>& routes) const;

    virtual uint32_t expiry_secs() const = 0;

    virtual uint32_t deletion_secs() const = 0;

protected:
    struct RouteEntryStore* _rtstore;

private:
    bool    _is_rib_origin;     // True if the origin is RIB
};



#endif // __RIP_ROUTE_ENTRY_HH__