xrl_target_common.hh

RIP 协议实现

{
    PORT_TIMER_SET_HANDLER(triggered_update_delay, t_secs, 1, 10000,
			   dummy_timer);
}

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

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

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

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

template <typename A>
XrlCmdError
XrlRipCommonTarget<A>::ripx_0_1_interpacket_delay(
						const string&	ifname,
						const string&	vifname,
						const A&	addr,
						uint32_t&	t_msecs
						)
{
    PORT_TIMER_GET_HANDLER(interpacket_delay_ms, t_msecs);
}

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

    Port<A>* p = pp.first;
    status = p->enabled() ? "enabled" : "disabled";

    if (p->enabled()
	&& _xpm.underlying_rip_address_up(ifn, vifn, addr) == false) {
	if (_xpm.underlying_rip_address_exists(ifn, vifn, addr)) {
	    status += " [gated by disabled FEA interface/vif/address]";
	} else {
	    status += " [gated by non-existant FEA interface/vif/address]";
	}
    }

    debug_msg("ripx_0_1_rip_address_status %s/%s/%s -> %s\n",
	      ifn.c_str(), vifn.c_str(), addr.str().c_str(),
	      status.c_str());

    return XrlCmdError::OKAY();
}

template <typename A>
XrlCmdError
XrlRipCommonTarget<A>::ripx_0_1_get_all_addresses(XrlAtomList&	ifnames,
						  XrlAtomList&	vifnames,
						  XrlAtomList&	addrs)
{
    const typename PortManagerBase<A>::PortList & ports = _xpm.const_ports();
    typename PortManagerBase<A>::PortList::const_iterator pci;

    for (pci = ports.begin(); pci != ports.end(); ++pci) {
	const Port<A>*	     	port = *pci;
	const PortIOBase<A>* 	pio  = port->io_handler();
	if (pio == 0) {
	    continue;
	}
	ifnames.append  ( XrlAtom(pio->ifname())   );
	vifnames.append ( XrlAtom(pio->vifname())  );
	addrs.append    ( XrlAtom(pio->address())  );
    }
    return XrlCmdError::OKAY();
}


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

    Port<A>* p = pp.first;
    typename Port<A>::PeerList::const_iterator pi = p->peers().begin();
    while (pi != p->peers().end()) {
	const Peer<A>* peer = *pi;
	peers.append(XrlAtom(peer->address()));
	++pi;
    }
    return XrlCmdError::OKAY();
}

template <typename A>
XrlCmdError
XrlRipCommonTarget<A>::ripx_0_1_get_all_peers(XrlAtomList&	peers,
					      XrlAtomList&	ifnames,
					      XrlAtomList&	vifnames,
					      XrlAtomList&	addrs)
{
    const typename PortManagerBase<A>::PortList & ports = _xpm.const_ports();
    typename PortManagerBase<A>::PortList::const_iterator pci;

    for (pci = ports.begin(); pci != ports.end(); ++pci) {
	const Port<A>* port = *pci;
	const PortIOBase<A>* pio = port->io_handler();
	if (pio == 0) {
	    continue;
	}

	typename Port<A>::PeerList::const_iterator pi;
	for (pi = port->peers().begin(); pi != port->peers().end(); ++pi) {
	    const Peer<A>* peer = *pi;
	    peers.append    ( XrlAtom(peer->address()) );
	    ifnames.append  ( XrlAtom(pio->ifname())   );
	    vifnames.append ( XrlAtom(pio->vifname())  );
	    addrs.append    ( XrlAtom(pio->address())  );
	}
    }
    return XrlCmdError::OKAY();
}

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

    const Port<A>* p = pp.first;
    descriptions.append(XrlAtom("", string("Requests Sent")));
    values.append(XrlAtom(p->counters().table_requests_sent()));

    descriptions.append(XrlAtom("", string("Updates Sent")));
    values.append(XrlAtom(p->counters().unsolicited_updates()));

    descriptions.append(XrlAtom("", string("Triggered Updates Sent")));
    values.append(XrlAtom(p->counters().triggered_updates()));

    descriptions.append(XrlAtom("", string("Non-RIP Updates Sent")));
    values.append(XrlAtom(p->counters().non_rip_updates_sent()));

    descriptions.append(XrlAtom("", string("Total Packets Received")));
    values.append(XrlAtom(p->counters().packets_recv()));

    descriptions.append(XrlAtom("", string("Request Packets Received")));
    values.append(XrlAtom(p->counters().table_requests_recv()));

    descriptions.append(XrlAtom("", string("Update Packets Received")));
    values.append(XrlAtom(p->counters().update_packets_recv()));

    descriptions.append(XrlAtom("", string("Bad Packets Received")));
    values.append(XrlAtom(p->counters().bad_packets()));

    if (A::ip_version() == 4) {
	descriptions.append(XrlAtom("", string("Authentication Failures")));
	values.append(XrlAtom(p->counters().bad_auth_packets()));
    }

    descriptions.append(XrlAtom("", string("Bad Routes Received")));
    values.append(XrlAtom(p->counters().bad_routes()));

    descriptions.append(XrlAtom("", string("Non-RIP Requests Received")));
    values.append(XrlAtom(p->counters().non_rip_requests_recv()));

    return XrlCmdError::OKAY();
}

template <typename A>
XrlCmdError
XrlRipCommonTarget<A>::ripx_0_1_get_peer_counters(
					const string&	ifn,
					const string&	vifn,
					const A&	addr,
					const A&	peer_addr,
					XrlAtomList&	descriptions,
					XrlAtomList&	values,
					uint32_t&	peer_last_active)
{
    pair<Port<A>*, XrlCmdError> pp = find_port(ifn, vifn, addr);
    if (pp.first == 0)
	return pp.second;

    const Port<A>* port = pp.first;

    typename Port<A>::PeerList::const_iterator pi;
    pi = find_if(port->peers().begin(), port->peers().end(),
		 peer_has_address<A>(peer_addr));

    if (pi == port->peers().end()) {
	return XrlCmdError::COMMAND_FAILED(
		c_format("Peer %s not found on %s/%s/%s",
			 peer_addr.str().c_str(), ifn.c_str(), vifn.c_str(),
			 addr.str().c_str())
		);
    }

    const Peer<A>* const peer = *pi;

    descriptions.append(  XrlAtom("", string("Total Packets Received")) );
    values.append( XrlAtom(peer->counters().packets_recv()) );

    descriptions.append(XrlAtom("", string("Request Packets Received")));
    values.append(XrlAtom(peer->counters().table_requests_recv()));

    descriptions.append(XrlAtom("", string("Update Packets Received")));
    values.append(XrlAtom(peer->counters().update_packets_recv()));

    descriptions.append(XrlAtom("", string("Bad Packets Received")));
    values.append(XrlAtom(peer->counters().bad_packets()));

    if (A::ip_version() == 4) {
	descriptions.append(XrlAtom("", string("Authentication Failures")));
	values.append(XrlAtom(peer->counters().bad_auth_packets()));
    }

    descriptions.append(XrlAtom("", string("Bad Routes Received")));
    values.append(XrlAtom(peer->counters().bad_routes()));

    descriptions.append(XrlAtom("", string("Routes Active")));
    values.append(XrlAtom(peer->route_count()));

    peer_last_active = peer->last_active().secs();

    return XrlCmdError::OKAY();
}

template <typename A>
XrlCmdError
XrlRipCommonTarget<A>::socketx_user_0_1_recv_event(
					const string&		sockid,
					const string&		if_name,
					const string&		vif_name,
					const A&		src_host,
					const uint32_t&		src_port,
					const vector<uint8_t>&	pdata
					)
{
    _xpm.deliver_packet(sockid, if_name, vif_name, src_host, src_port, pdata);
    return XrlCmdError::OKAY();
}

template <typename A>
XrlCmdError
XrlRipCommonTarget<A>::socketx_user_0_1_inbound_connect_event(
					const string&	sockid,
					const A&	src_host,
					const uint32_t&	src_port,
					const string&	new_sockid,
					bool&		accept
					)
{
    debug_msg("socketx_user_0_1_inbound_connect_event %s %s/%u %s\n",
	      sockid.c_str(), src_host.str().c_str(),
	      XORP_UINT_CAST(src_port), new_sockid.c_str());

    UNUSED(sockid);
    UNUSED(src_host);
    UNUSED(src_port);
    UNUSED(new_sockid);

    accept = false;
    return XrlCmdError::COMMAND_FAILED("Inbound connect not requested.");
}

template <typename A>
XrlCmdError
XrlRipCommonTarget<A>::socketx_user_0_1_outgoing_connect_event(
					const string&	sockid
					)
{
    debug_msg("socketx_user_0_1_outgoing_connect_event %s\n",
	      sockid.c_str());

    UNUSED(sockid);
    return XrlCmdError::COMMAND_FAILED("Outgoing connect not requested.");
}

template <typename A>
XrlCmdError
XrlRipCommonTarget<A>::socketx_user_0_1_error_event(
					const string&	sockid,
					const string& 	reason,
					const bool&	fatal
					)
{
    debug_msg("socketx_user_0_1_error_event %s %s %s \n",
	      sockid.c_str(), reason.c_str(),
	      fatal ? "fatal" : "non-fatal");

    UNUSED(sockid);
    UNUSED(reason);
    UNUSED(fatal);

    return XrlCmdError::OKAY();
}

template <typename A>
XrlCmdError
XrlRipCommonTarget<A>::socketx_user_0_1_disconnect_event(
					const string&	sockid
					)
{
    debug_msg("socketx_user_0_1_disconnect_event %s\n",
	      sockid.c_str());

    UNUSED(sockid);

    return XrlCmdError::OKAY();
}


template <typename A>
XrlCmdError
XrlRipCommonTarget<A>::policy_backend_0_1_configure(const uint32_t& filter,
						    const string& conf)
{
    try {
	_rip_system.configure_filter(filter, conf);
    } catch(const PolicyException& e) {
	return XrlCmdError::COMMAND_FAILED("Filter configure failed: " +
					   e.str());
    }
    return XrlCmdError::OKAY();
}

template <typename A>
XrlCmdError
XrlRipCommonTarget<A>::policy_backend_0_1_reset(const uint32_t& filter)
{
    try {
	_rip_system.reset_filter(filter);
    } catch(const PolicyException& e) {
	return XrlCmdError::COMMAND_FAILED("Filter reset failed: " + 
					   e.str());
    }
    return XrlCmdError::OKAY();
}

template <typename A>
XrlCmdError
XrlRipCommonTarget<A>::policy_backend_0_1_push_routes()
{
    _rip_system.push_routes();
    return XrlCmdError::OKAY();
}

template <typename A>
XrlCmdError 
XrlRipCommonTarget<A>::policy_redistx_0_1_add_routex(const IPNet<A>&	net,
						     const bool&	unicast,
						     const bool&	multicast,
						     const A&	        nexthop,
						     const uint32_t&	metric,
						     const XrlAtomList& policytags)
{
    string ifname, vifname;

    UNUSED(multicast);

    if (! unicast)
	return XrlCmdError::OKAY();

    //
    // XXX: The interface and vif name are empty, because the policy
    // mechanism doesn't support setting them (yet).
    //
    _xrm.add_route(net, nexthop, ifname, vifname, metric, 0, policytags);
    return XrlCmdError::OKAY();
}

template <typename A>
XrlCmdError 
XrlRipCommonTarget<A>::policy_redistx_0_1_delete_routex(const IPNet<A>&	net,
							const bool&	unicast,
							const bool&	multicast)
{
    UNUSED(multicast);

    if (! unicast)
	return XrlCmdError::OKAY();

    _xrm.delete_route(net);
    return XrlCmdError::OKAY();
}
#endif // __RIPX_XRL_TARGET_COMMON_HH__