xrl_target_common.hh

RIP 协议实现


// ----------------------------------------------------------------------------
// Utility methods

template <typename A>
pair<Port<A>*, XrlCmdError>
XrlRipCommonTarget<A>::find_port(const string&	ifn,
				 const string&	vifn,
				 const A&	addr)
{
    Port<A>* p = _xpm.find_port(ifn, vifn, addr);
    if (p == 0) {
	string e = c_format("RIP not running on %s/%s/%s",
			    ifn.c_str(), vifn.c_str(), addr.str().c_str());
	return make_pair(p, XrlCmdError::COMMAND_FAILED(e));
    }
    return make_pair(p, XrlCmdError::OKAY());
}


// ----------------------------------------------------------------------------
// Port configuration accessors and modifiers

template <typename A>
XrlCmdError
XrlRipCommonTarget<A>::ripx_0_1_set_rip_address_enabled(const string&	ifn,
							const string&	vifn,
							const A&	addr,
							const bool&	en)
{
    pair<Port<A>*, XrlCmdError> pp = find_port(ifn, vifn, addr);
    if (pp.first == 0)
	return pp.second;

    Port<A>* p = pp.first;
    p->set_enabled(en);
    return XrlCmdError::OKAY();
}

template <typename A>
XrlCmdError
XrlRipCommonTarget<A>::ripx_0_1_rip_address_enabled(const string& ifn,
						    const string& vifn,
						    const A&	  addr,
						    bool&	  en)
{
    pair<Port<A>*, XrlCmdError> pp = find_port(ifn, vifn, addr);
    if (pp.first == 0)
	return pp.second;

    Port<A>* p = pp.first;
    en = p->enabled();

    return XrlCmdError::OKAY();
}

template <typename A>
XrlCmdError
XrlRipCommonTarget<A>::ripx_0_1_set_cost(const string&	ifname,
			       const string&		vifname,
			       const A&			addr,
			       const uint32_t&		cost)
{
    pair<Port<A>*, XrlCmdError> pp = find_port(ifname, vifname, addr);
    if (pp.first == 0)
	return pp.second;

    Port<A>* p = pp.first;

    if (cost > RIP_INFINITY) {
	string e = c_format("Cost must be less that RIP infinity (%u)",
			    XORP_UINT_CAST(RIP_INFINITY));
	return XrlCmdError::COMMAND_FAILED(e);
    }

    p->set_cost(cost);

    return XrlCmdError::OKAY();
}

template <typename A>
XrlCmdError
XrlRipCommonTarget<A>::ripx_0_1_cost(const string&	ifname,
				     const string&	vifname,
				     const A&		addr,
				     uint32_t&		cost)
{
    pair<Port<A>*, XrlCmdError> pp = find_port(ifname, vifname, addr);
    if (pp.first == 0)
	return pp.second;

    Port<A>* p = pp.first;
    cost = p->cost();

    return XrlCmdError::OKAY();
}

template <typename A>
XrlCmdError
XrlRipCommonTarget<A>::ripx_0_1_set_horizon(const string&	ifname,
					    const string&	vifname,
					    const A&		addr,
					    const string&	horizon)
{
    pair<Port<A>*, XrlCmdError> pp = find_port(ifname, vifname, addr);
    if (pp.first == 0)
	return pp.second;

    Port<A>* p = pp.first;

    RipHorizon rh[3] = { NONE, SPLIT, SPLIT_POISON_REVERSE };
    for (uint32_t i = 0; i < 3; ++i) {
	if (string(rip_horizon_name(rh[i])) == horizon) {
	    p->set_horizon(rh[i]);
	    return XrlCmdError::OKAY();
	}
    }
    return XrlCmdError::COMMAND_FAILED(
			c_format("Horizon type \"%s\" not recognized.",
				 horizon.c_str()));
}

template <typename A>
XrlCmdError
XrlRipCommonTarget<A>::ripx_0_1_horizon(const string&	ifname,
					const string&	vifname,
					const A&	addr,
					string&		horizon)
{
    pair<Port<A>*, XrlCmdError> pp = find_port(ifname, vifname, addr);
    if (pp.first == 0)
	return pp.second;

    Port<A>* p = pp.first;
    horizon = rip_horizon_name(p->horizon());
    return XrlCmdError::OKAY();
}

template <typename A>
XrlCmdError
XrlRipCommonTarget<A>::ripx_0_1_set_passive(const string&	ifname,
					    const string&	vifname,
					    const A&		addr,
					    const bool&		passive)
{
    pair<Port<A>*, XrlCmdError> pp = find_port(ifname, vifname, addr);
    if (pp.first == 0)
	return pp.second;

    Port<A>* p = pp.first;
    p->set_passive(passive);
    return XrlCmdError::OKAY();
}

template <typename A>
XrlCmdError
XrlRipCommonTarget<A>::ripx_0_1_passive(const string&	ifname,
					const string&	vifname,
					const A&	addr,
					bool&		passive)
{
    pair<Port<A>*, XrlCmdError> pp = find_port(ifname, vifname, addr);
    if (pp.first == 0)
	return pp.second;

    Port<A>* p = pp.first;
    passive = p->passive();
    return XrlCmdError::OKAY();
}

template <typename A>
XrlCmdError
XrlRipCommonTarget<A>::ripx_0_1_set_accept_non_rip_requests(
						const string&	ifname,
						const string&	vifname,
						const A&	addr,
						const bool&	accept
						)
{
    pair<Port<A>*, XrlCmdError> pp = find_port(ifname, vifname, addr);
    if (pp.first == 0)
	return pp.second;

    Port<A>* p = pp.first;
    p->set_accept_non_rip_requests(accept);
    return XrlCmdError::OKAY();
}

template <typename A>
XrlCmdError
XrlRipCommonTarget<A>::ripx_0_1_accept_non_rip_requests(
						const string&	ifname,
						const string&	vifname,
						const A&	addr,
						bool&		accept
						)
{
    pair<Port<A>*, XrlCmdError> pp = find_port(ifname, vifname, addr);
    if (pp.first == 0)
	return pp.second;

    Port<A>* p = pp.first;
    accept = p->accept_non_rip_requests();
    return XrlCmdError::OKAY();
}

template <typename A>
XrlCmdError
XrlRipCommonTarget<A>::ripx_0_1_set_accept_default_route(
						const string&	ifname,
						const string&	vifname,
						const A&	addr,
						const bool&	accept
						)
{
    pair<Port<A>*, XrlCmdError> pp = find_port(ifname, vifname, addr);
    if (pp.first == 0)
	return pp.second;

    Port<A>* p = pp.first;
    p->set_accept_default_route(accept);
    return XrlCmdError::OKAY();
}

template <typename A>
XrlCmdError
XrlRipCommonTarget<A>::ripx_0_1_accept_default_route(
						const string&	ifname,
						const string&	vifname,
						const A&	addr,
						bool&		accept
						)
{
    pair<Port<A>*, XrlCmdError> pp = find_port(ifname, vifname, addr);
    if (pp.first == 0)
	return pp.second;

    Port<A>* p = pp.first;
    accept = p->accept_default_route();
    return XrlCmdError::OKAY();
}

template <typename A>
XrlCmdError
XrlRipCommonTarget<A>::ripx_0_1_set_advertise_default_route(
						const string&	ifname,
						const string&	vifname,
						const A&	addr,
						const bool&	advertise
						)
{
    pair<Port<A>*, XrlCmdError> pp = find_port(ifname, vifname, addr);
    if (pp.first == 0)
	return pp.second;

    Port<A>* p = pp.first;
    p->set_advertise_default_route(advertise);
    return XrlCmdError::OKAY();
}

template <typename A>
XrlCmdError
XrlRipCommonTarget<A>::ripx_0_1_advertise_default_route(
						const string&	ifname,
						const string&	vifname,
						const A&	addr,
						bool&		advertise
						)
{
    pair<Port<A>*, XrlCmdError> pp = find_port(ifname, vifname, addr);
    if (pp.first == 0)
	return pp.second;

    Port<A>* p = pp.first;
    advertise = p->advertise_default_route();
    return XrlCmdError::OKAY();
}


// ----------------------------------------------------------------------------
// The following pair of macros are used in setting timer constants on
// RIP ports.

#define PORT_TIMER_SET_HANDLER(field, t, min_val, max_val, method)	\
do {									\
    pair<Port<A>*, XrlCmdError> pp = find_port(ifname, vifname, addr);	\
    if (pp.first == 0)							\
	return pp.second;						\
    Port<A>* p = pp.first;						\
									\
    if (static_cast<int32_t>(t) < min_val) 				\
	return XrlCmdError::COMMAND_FAILED(c_format(			\
	    "value supplied less than permitted minimum (%u < %u)", 	\
	    XORP_UINT_CAST(t), XORP_UINT_CAST(min_val)));		\
    if (t > max_val) 							\
	return XrlCmdError::COMMAND_FAILED(c_format(			\
	    "value supplied greater than permitted maximum (%u > %u)", 	\
	    XORP_UINT_CAST(t), XORP_UINT_CAST(max_val)));		\
    if (p->constants().set_##field (t) == false)			\
	return XrlCmdError::COMMAND_FAILED(				\
	    "Failed to set value.");					\
    p->reschedule_##method ();						\
    return XrlCmdError::OKAY();						\
} while (0)

#define PORT_TIMER_GET_HANDLER(field, t)				\
do {									\
    pair<Port<A>*, XrlCmdError> pp = find_port(ifname, vifname, addr);	\
    if (pp.first == 0)							\
	return pp.second;						\
    Port<A>* p = pp.first;						\
    t = p->constants(). field ();					\
    return XrlCmdError::OKAY();						\
} while (0)


template <typename A>
XrlCmdError
XrlRipCommonTarget<A>::ripx_0_1_set_route_timeout(
						const string&	ifname,
						const string&	vifname,
						const A&	addr,
						const uint32_t&	t
						)
{
    PORT_TIMER_SET_HANDLER(expiry_secs, t, 10, 10000, dummy_timer);
}

template <typename A>
XrlCmdError
XrlRipCommonTarget<A>::ripx_0_1_route_timeout(
					     const string&	ifname,
					     const string&	vifname,
					     const A&		addr,
					     uint32_t&		t
					     )
{
    PORT_TIMER_GET_HANDLER(expiry_secs, t);
}

template <typename A>
XrlCmdError
XrlRipCommonTarget<A>::ripx_0_1_set_deletion_delay(
						const string&	ifname,
						const string&	vifname,
						const A&	addr,
						const uint32_t&	t
						)
{
    PORT_TIMER_SET_HANDLER(deletion_secs, t, 10, 10000, dummy_timer);
}

template <typename A>
XrlCmdError
XrlRipCommonTarget<A>::ripx_0_1_deletion_delay(
						const string&	ifname,
						const string&	vifname,
						const A&	addr,
						uint32_t&	t
						)
{
    PORT_TIMER_GET_HANDLER(deletion_secs, t);
}

template <typename A>
XrlCmdError
XrlRipCommonTarget<A>::ripx_0_1_set_request_interval(
						const string&	ifname,
						const string&	vifname,
						const A&	addr,
						const uint32_t&	t
						)
{
    PORT_TIMER_SET_HANDLER(table_request_period_secs, t, 0, 10000,
			   request_table_timer);
}

template <typename A>
XrlCmdError
XrlRipCommonTarget<A>::ripx_0_1_request_interval(
						const string&	ifname,
						const string&	vifname,
						const A&	addr,
						uint32_t&	t
						)
{
    PORT_TIMER_GET_HANDLER(table_request_period_secs, t);
}

template <typename A>
XrlCmdError
XrlRipCommonTarget<A>::ripx_0_1_set_update_interval(
						const string&	ifname,
						const string&	vifname,
						const A&	addr,
						const uint32_t& t_secs
						)
{
    PORT_TIMER_SET_HANDLER(update_interval, t_secs, 1, 600, dummy_timer);
}

template <typename A>
XrlCmdError
XrlRipCommonTarget<A>::ripx_0_1_update_interval(const string&	ifname,
						const string&	vifname,
						const A&	addr,
						uint32_t&	t_secs)
{
    PORT_TIMER_GET_HANDLER(update_interval, t_secs);
}

template <typename A>
XrlCmdError
XrlRipCommonTarget<A>::ripx_0_1_set_update_jitter(const string&	ifname,
						  const string&	vifname,
						  const A&	addr,
						  const uint32_t& t_jitter)
{
    PORT_TIMER_SET_HANDLER(update_jitter, t_jitter, 0, 100, dummy_timer);
}

template <typename A>
XrlCmdError
XrlRipCommonTarget<A>::ripx_0_1_update_jitter(const string&	ifname,
					      const string&	vifname,
					      const A&		addr,
					      uint32_t&		t_jitter)
{
    PORT_TIMER_GET_HANDLER(update_jitter, t_jitter);
}

template <typename A>
XrlCmdError
XrlRipCommonTarget<A>::ripx_0_1_set_triggered_update_delay(
						const string&	ifname,
						const string&	vifname,
						const A&	addr,
						const uint32_t&	t_secs)