route_db.cc

RIP 协议实现

		    // such metric, then remove the "set_cost()" statement
		    // below, and add "return true;" at the end of this block.
		    //
		    r->set_cost(RIP_INFINITY);
		    set_deletion_timer(r);
		    updated = true;
		}    
//		delete_route(r);
	    }
	}
    } else {
	// route from other origin
	if (!accepted) {
	    delete new_route;
	    return false;
	}
	// this is "RIP's decision" -- where one route wins another.
	// Source-match filtering should go here.
	bool should_replace = false;
	do {
	    if (r->cost() > new_route->cost()) {
		should_replace = true;
		break;
	    }
	    if (r->cost() < new_route->cost())
		break;		// XXX: the old route is better

	    //
	    // Same cost routes
	    //

	    if (new_route->cost() == RIP_INFINITY) {
		//
		// XXX: Don't update routes if both the old and the new
		// costs are infinity.
		//
		break;
	    }

	    //
	    // If the existing route is showing signs of timing out, it
	    // may be better to switch to an equally-good alternative route
	    // immediately, rather than waiting for the timeout to happen.
	    // The heuristic is: if the route is at least halfway to the
	    // expiration point, switch to the new route
	    // (see RFC 2453 Section 3.9.2 and RFC 2080 Section 2.4.2).
	    //
	    TimeVal expiry_timeval = TimeVal::ZERO();
	    if (r->origin() != NULL)
		expiry_timeval = TimeVal(r->origin()->expiry_secs(), 0);
	    
	    if (expiry_timeval == TimeVal::ZERO())
		break;		// XXX: the old route would never expire

	    TimeVal remain;
	    if (r->timer().time_remaining(remain) != true)
		break;		// XXX: couldn't get the remaining time
	    if (remain < (expiry_timeval / 2)) {
		should_replace = true;
		break;
	    }
	    break;
	} while (false);
	    
	if (should_replace) {
	    r->set_nexthop(new_route->nexthop());
	    r->set_ifname(new_route->ifname());
	    r->set_vifname(new_route->vifname());
	    r->set_tag(new_route->tag());
	    r->set_cost(new_route->cost());
	    r->set_policytags(new_route->policytags());
	    r->set_origin(o);
	    set_expiry_timer(r);
	    updated = true;

	}    
	delete new_route;
    }
    if (updated) {
	_uq->push_back(r);
    }
    return updated;
}

template <typename A>
void
RouteDB<A>::dump_routes(vector<ConstDBRouteEntry>& routes)
{
    typename RouteContainer::iterator i = _routes.begin();
    while (i != _routes.end()) {
	routes.push_back(i->second);
	++i;
    }
}

template <typename A>
void
RouteDB<A>::flush_routes()
{
    _uq->flush();
    _routes.erase(_routes.begin(), _routes.end());
}

template <typename A>
uint32_t
RouteDB<A>::route_count() const
{
    return _routes.size();
}

template <typename A>
const RouteEntry<A>*
RouteDB<A>::find_route(const IPNet<A>& net) const
{
    typename RouteContainer::const_iterator ri = _routes.find(net);
    if (ri == _routes.end())
	return 0;
    return ri->second.get();
}

template <typename A>
UpdateQueue<A>&
RouteDB<A>::update_queue()
{
    return *_uq;
}

template <typename A>
const UpdateQueue<A>&
RouteDB<A>::update_queue() const
{
    return *_uq;
}

template <typename A>
typename RouteDB<A>::RouteContainer&
RouteDB<A>::routes()
{
    return _routes;
}


// ----------------------------------------------------------------------------
// RouteWalker

template <typename A>
const typename RouteWalker<A>::Net RouteWalker<A>::NO_NET(~A::ZERO(), 0);

template <typename A>
RouteWalker<A>::RouteWalker(RouteDB<A>& rdb)
    : _route_db(rdb), _state(STATE_RUNNING),
      _last_visited(NO_NET),
      _pos(rdb.routes().begin())
{
}

template <typename A>
RouteWalker<A>::~RouteWalker()
{
}

template <typename A>
const typename RouteWalker<A>::Route*
RouteWalker<A>::next_route()
{
    if (state() != STATE_RUNNING) {
	XLOG_ERROR("Calling RouteWalker::next_route() whilst not in "
		   "STATE_RUNNING state.");
	return 0;
    }
    if (++_pos == _route_db.routes().end()) {
	return 0;
    }
    return _pos->second.get();
}

template <typename A>
const typename RouteWalker<A>::Route*
RouteWalker<A>::current_route()
{
    if (state() != STATE_RUNNING) {
	XLOG_ERROR("Calling RouteWalker::next_route() whilst not in "
		   "STATE_RUNNING state.");
	return 0;
    }
    if (_pos == _route_db.routes().end()) {
	return 0;
    }
    return _pos->second.get();
}

template <typename A>
void
RouteWalker<A>::pause(uint32_t pause_ms)
{
    if (state() == STATE_PAUSED)
	return;

    _state = STATE_PAUSED;
    if (_pos == _route_db.routes().end()) {
	_last_visited = NO_NET;
	return;
    }

    // Check if route has a deletion timer and if so push it's expiry time
    // back to maximize the chance of the route still being valid when
    // resume is called.  Otherwise we have to do more work to find a good
    // point to resume from.  We're advertising the route at infinity
    // so advertising it once past it's original expiry is no big deal

    XorpTimer t = _pos->second->timer();
    if (t.scheduled() && _pos->second->cost() == RIP_INFINITY) {
	TimeVal next_run;
	_route_db.eventloop().current_time(next_run);
	next_run += TimeVal(0, 1000 * pause_ms * 2); // factor of 2 == slack
	if (t.expiry() <= next_run) {
	    t.schedule_at(next_run);
	    _pos->second->set_timer(t);
	}
    }
    _last_visited = _pos->second->net();
}

template <typename A>
void
RouteWalker<A>::resume()
{
    if (state() != STATE_PAUSED)
	return;

    _state = STATE_RUNNING;
    if (_last_visited == NO_NET) {
	_pos = _route_db.routes().end();
	return;
    }

    _pos = _route_db.routes().find(_last_visited);
    if (_pos == _route_db.routes().end()) {
	// Node got deleted despite our pushing back it's timer (???)
	_pos = _route_db.routes().upper_bound(_last_visited);
    }
}

template <typename A>
void
RouteWalker<A>::reset()
{
    _state = STATE_RUNNING;
    _pos = _route_db.routes().begin();
}

template <typename A>
void
RouteDB<A>::push_routes()
{
    debug_msg("[RIP] Push routes\n");

    //
    // Push the original routes from all peers
    //
    for (typename set<Peer<A>* >::iterator i = _peers.begin();
	 i != _peers.end(); ++i) {
	Peer<A>* peer = *i;
	peer->push_routes();
    }

    // XXX may have got RIB route adds because of delete_route
    // flush is probably not necessary...

    debug_msg("[RIP] Pushing the RIB routes we have\n");
   
    for (typename RouteContainerNoRef::iterator i = _rib_routes.begin();
	i != _rib_routes.end(); ++i) {

	Route* r = (*i).second;

	debug_msg("[RIP] Pushing RIB route %s\n", r->net().str().c_str());
	
	update_route(r->net(), r->nexthop(), r->ifname(), r->vifname(),
		     r->cost(), r->tag(), _rib_origin, r->policytags(), true);
    }
}

template <typename A>
void
RouteDB<A>::add_rib_route(const Net& net, const Addr& nexthop,
			  const string& ifname, const string& vifname,
			  uint32_t cost, uint32_t tag, RouteOrigin* origin,
			  const PolicyTags& policytags)
{
    debug_msg("[RIP] adding RIB route %s\n",net.str().c_str());
  
    _rib_origin = origin;
         
    typename RouteContainerNoRef::iterator i = _rib_routes.find(net);

    if (i != _rib_routes.end()) {
	Route* prev = (*i).second;
	delete prev;
    }

    //
    // XXX: We are cheating here NULL origin so we don't get association.
    //
    RouteOrigin* no_origin = NULL;
    Route* r = new Route(net, nexthop, ifname, vifname, cost, no_origin, tag,
			 policytags);

    _rib_routes[net] = r;
}

template <typename A>
void
RouteDB<A>::delete_rib_route(const Net& net)
{
    debug_msg("[RIP] deleting RIB route %s\n",net.str().c_str());

    typename RouteContainerNoRef::iterator i = _rib_routes.find(net);

    if (i == _rib_routes.end())
	return;			// XXX: nothing to do

    Route* r = (*i).second;

    delete r;

    _rib_routes.erase(i);
}


// ----------------------------------------------------------------------------
// Instantiations

#ifdef INSTANTIATE_IPV4
template class RouteDB<IPv4>;
template class RouteWalker<IPv4>;
#endif

#ifdef INSTANTIATE_IPV6
template class RouteDB<IPv6>;
template class RouteWalker<IPv6>;
#endif