bgp_xif.cc

xorp源码hg

    }
    cb->dispatch(e, &peer_state, &admin_status);
}

bool
XrlBgpV0p2Client::send_get_peer_negotiated_version(
	const char*	dst_xrl_target_name,
	const string&	local_ip,
	const uint32_t&	local_port,
	const string&	peer_ip,
	const uint32_t&	peer_port,
	const GetPeerNegotiatedVersionCB&	cb
)
{
    Xrl x(dst_xrl_target_name, "bgp/0.2/get_peer_negotiated_version");
    x.args().add("local_ip", local_ip);
    x.args().add("local_port", local_port);
    x.args().add("peer_ip", peer_ip);
    x.args().add("peer_port", peer_port);
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_get_peer_negotiated_version, cb));
}


/* Unmarshall get_peer_negotiated_version */
void
XrlBgpV0p2Client::unmarshall_get_peer_negotiated_version(
	const XrlError&	e,
	XrlArgs*	a,
	GetPeerNegotiatedVersionCB		cb
)
{
    if (e != XrlError::OKAY()) {
	cb->dispatch(e, 0);
	return;
    } else if (a && a->size() != 1) {
	XLOG_ERROR("Wrong number of arguments (%u != %u)", XORP_UINT_CAST(a->size()), XORP_UINT_CAST(1));
	cb->dispatch(XrlError::BAD_ARGS(), 0);
	return;
    }
    int32_t neg_version;
    try {
	a->get("neg_version", neg_version);
    } catch (const XrlArgs::XrlAtomNotFound&) {
	XLOG_ERROR("Atom not found");
	cb->dispatch(XrlError::BAD_ARGS(), 0);
	return;
    }
    cb->dispatch(e, &neg_version);
}

bool
XrlBgpV0p2Client::send_get_peer_as(
	const char*	dst_xrl_target_name,
	const string&	local_ip,
	const uint32_t&	local_port,
	const string&	peer_ip,
	const uint32_t&	peer_port,
	const GetPeerAsCB&	cb
)
{
    Xrl x(dst_xrl_target_name, "bgp/0.2/get_peer_as");
    x.args().add("local_ip", local_ip);
    x.args().add("local_port", local_port);
    x.args().add("peer_ip", peer_ip);
    x.args().add("peer_port", peer_port);
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_get_peer_as, cb));
}


/* Unmarshall get_peer_as */
void
XrlBgpV0p2Client::unmarshall_get_peer_as(
	const XrlError&	e,
	XrlArgs*	a,
	GetPeerAsCB		cb
)
{
    if (e != XrlError::OKAY()) {
	cb->dispatch(e, 0);
	return;
    } else if (a && a->size() != 1) {
	XLOG_ERROR("Wrong number of arguments (%u != %u)", XORP_UINT_CAST(a->size()), XORP_UINT_CAST(1));
	cb->dispatch(XrlError::BAD_ARGS(), 0);
	return;
    }
    uint32_t peer_as;
    try {
	a->get("peer_as", peer_as);
    } catch (const XrlArgs::XrlAtomNotFound&) {
	XLOG_ERROR("Atom not found");
	cb->dispatch(XrlError::BAD_ARGS(), 0);
	return;
    }
    cb->dispatch(e, &peer_as);
}

bool
XrlBgpV0p2Client::send_get_peer_msg_stats(
	const char*	dst_xrl_target_name,
	const string&	local_ip,
	const uint32_t&	local_port,
	const string&	peer_ip,
	const uint32_t&	peer_port,
	const GetPeerMsgStatsCB&	cb
)
{
    Xrl x(dst_xrl_target_name, "bgp/0.2/get_peer_msg_stats");
    x.args().add("local_ip", local_ip);
    x.args().add("local_port", local_port);
    x.args().add("peer_ip", peer_ip);
    x.args().add("peer_port", peer_port);
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_get_peer_msg_stats, cb));
}


/* Unmarshall get_peer_msg_stats */
void
XrlBgpV0p2Client::unmarshall_get_peer_msg_stats(
	const XrlError&	e,
	XrlArgs*	a,
	GetPeerMsgStatsCB		cb
)
{
    if (e != XrlError::OKAY()) {
	cb->dispatch(e, 0, 0, 0, 0, 0, 0);
	return;
    } else if (a && a->size() != 6) {
	XLOG_ERROR("Wrong number of arguments (%u != %u)", XORP_UINT_CAST(a->size()), XORP_UINT_CAST(6));
	cb->dispatch(XrlError::BAD_ARGS(), 0, 0, 0, 0, 0, 0);
	return;
    }
    uint32_t in_updates;
    uint32_t out_updates;
    uint32_t in_msgs;
    uint32_t out_msgs;
    uint32_t last_error;
    uint32_t in_update_elapsed;
    try {
	a->get("in_updates", in_updates);
	a->get("out_updates", out_updates);
	a->get("in_msgs", in_msgs);
	a->get("out_msgs", out_msgs);
	a->get("last_error", last_error);
	a->get("in_update_elapsed", in_update_elapsed);
    } catch (const XrlArgs::XrlAtomNotFound&) {
	XLOG_ERROR("Atom not found");
	cb->dispatch(XrlError::BAD_ARGS(), 0, 0, 0, 0, 0, 0);
	return;
    }
    cb->dispatch(e, &in_updates, &out_updates, &in_msgs, &out_msgs, &last_error, &in_update_elapsed);
}

bool
XrlBgpV0p2Client::send_get_peer_established_stats(
	const char*	dst_xrl_target_name,
	const string&	local_ip,
	const uint32_t&	local_port,
	const string&	peer_ip,
	const uint32_t&	peer_port,
	const GetPeerEstablishedStatsCB&	cb
)
{
    Xrl x(dst_xrl_target_name, "bgp/0.2/get_peer_established_stats");
    x.args().add("local_ip", local_ip);
    x.args().add("local_port", local_port);
    x.args().add("peer_ip", peer_ip);
    x.args().add("peer_port", peer_port);
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_get_peer_established_stats, cb));
}


/* Unmarshall get_peer_established_stats */
void
XrlBgpV0p2Client::unmarshall_get_peer_established_stats(
	const XrlError&	e,
	XrlArgs*	a,
	GetPeerEstablishedStatsCB		cb
)
{
    if (e != XrlError::OKAY()) {
	cb->dispatch(e, 0, 0);
	return;
    } else if (a && a->size() != 2) {
	XLOG_ERROR("Wrong number of arguments (%u != %u)", XORP_UINT_CAST(a->size()), XORP_UINT_CAST(2));
	cb->dispatch(XrlError::BAD_ARGS(), 0, 0);
	return;
    }
    uint32_t transitions;
    uint32_t established_time;
    try {
	a->get("transitions", transitions);
	a->get("established_time", established_time);
    } catch (const XrlArgs::XrlAtomNotFound&) {
	XLOG_ERROR("Atom not found");
	cb->dispatch(XrlError::BAD_ARGS(), 0, 0);
	return;
    }
    cb->dispatch(e, &transitions, &established_time);
}

bool
XrlBgpV0p2Client::send_get_peer_timer_config(
	const char*	dst_xrl_target_name,
	const string&	local_ip,
	const uint32_t&	local_port,
	const string&	peer_ip,
	const uint32_t&	peer_port,
	const GetPeerTimerConfigCB&	cb
)
{
    Xrl x(dst_xrl_target_name, "bgp/0.2/get_peer_timer_config");
    x.args().add("local_ip", local_ip);
    x.args().add("local_port", local_port);
    x.args().add("peer_ip", peer_ip);
    x.args().add("peer_port", peer_port);
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_get_peer_timer_config, cb));
}


/* Unmarshall get_peer_timer_config */
void
XrlBgpV0p2Client::unmarshall_get_peer_timer_config(
	const XrlError&	e,
	XrlArgs*	a,
	GetPeerTimerConfigCB		cb
)
{
    if (e != XrlError::OKAY()) {
	cb->dispatch(e, 0, 0, 0, 0, 0, 0, 0);
	return;
    } else if (a && a->size() != 7) {
	XLOG_ERROR("Wrong number of arguments (%u != %u)", XORP_UINT_CAST(a->size()), XORP_UINT_CAST(7));
	cb->dispatch(XrlError::BAD_ARGS(), 0, 0, 0, 0, 0, 0, 0);
	return;
    }
    uint32_t retry_interval;
    uint32_t hold_time;
    uint32_t keep_alive;
    uint32_t hold_time_conf;
    uint32_t keep_alive_conf;
    uint32_t min_as_orgination_interval;
    uint32_t min_route_adv_interval;
    try {
	a->get("retry_interval", retry_interval);
	a->get("hold_time", hold_time);
	a->get("keep_alive", keep_alive);
	a->get("hold_time_conf", hold_time_conf);
	a->get("keep_alive_conf", keep_alive_conf);
	a->get("min_as_orgination_interval", min_as_orgination_interval);
	a->get("min_route_adv_interval", min_route_adv_interval);
    } catch (const XrlArgs::XrlAtomNotFound&) {
	XLOG_ERROR("Atom not found");
	cb->dispatch(XrlError::BAD_ARGS(), 0, 0, 0, 0, 0, 0, 0);
	return;
    }
    cb->dispatch(e, &retry_interval, &hold_time, &keep_alive, &hold_time_conf, &keep_alive_conf, &min_as_orgination_interval, &min_route_adv_interval);
}

bool
XrlBgpV0p2Client::send_register_rib(
	const char*	dst_xrl_target_name,
	const string&	name,
	const RegisterRibCB&	cb
)
{
    Xrl x(dst_xrl_target_name, "bgp/0.2/register_rib");
    x.args().add("name", name);
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_register_rib, cb));
}


/* Unmarshall register_rib */
void
XrlBgpV0p2Client::unmarshall_register_rib(
	const XrlError&	e,
	XrlArgs*	a,
	RegisterRibCB		cb
)
{
    if (e != XrlError::OKAY()) {
	cb->dispatch(e);
	return;
    } else if (a && a->size() != 0) {
	XLOG_ERROR("Wrong number of arguments (%u != %u)", XORP_UINT_CAST(a->size()), XORP_UINT_CAST(0));
	cb->dispatch(XrlError::BAD_ARGS());
	return;
    }
    cb->dispatch(e);
}

bool
XrlBgpV0p2Client::send_get_v4_route_list_start(
	const char*	dst_xrl_target_name,
	const IPv4Net&	net,
	const bool&	unicast,
	const bool&	multicast,
	const GetV4RouteListStartCB&	cb
)
{
    Xrl x(dst_xrl_target_name, "bgp/0.2/get_v4_route_list_start");
    x.args().add("net", net);
    x.args().add("unicast", unicast);
    x.args().add("multicast", multicast);
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_get_v4_route_list_start, cb));
}


/* Unmarshall get_v4_route_list_start */
void
XrlBgpV0p2Client::unmarshall_get_v4_route_list_start(
	const XrlError&	e,
	XrlArgs*	a,
	GetV4RouteListStartCB		cb
)
{
    if (e != XrlError::OKAY()) {
	cb->dispatch(e, 0);
	return;
    } else if (a && a->size() != 1) {
	XLOG_ERROR("Wrong number of arguments (%u != %u)", XORP_UINT_CAST(a->size()), XORP_UINT_CAST(1));
	cb->dispatch(XrlError::BAD_ARGS(), 0);
	return;
    }
    uint32_t token;
    try {
	a->get("token", token);
    } catch (const XrlArgs::XrlAtomNotFound&) {
	XLOG_ERROR("Atom not found");
	cb->dispatch(XrlError::BAD_ARGS(), 0);
	return;
    }
    cb->dispatch(e, &token);
}

bool
XrlBgpV0p2Client::send_get_v6_route_list_start(
	const char*	dst_xrl_target_name,
	const IPv6Net&	net,
	const bool&	unicast,
	const bool&	multicast,
	const GetV6RouteListStartCB&	cb
)
{
    Xrl x(dst_xrl_target_name, "bgp/0.2/get_v6_route_list_start");
    x.args().add("net", net);
    x.args().add("unicast", unicast);
    x.args().add("multicast", multicast);
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_get_v6_route_list_start, cb));
}


/* Unmarshall get_v6_route_list_start */
void
XrlBgpV0p2Client::unmarshall_get_v6_route_list_start(
	const XrlError&	e,
	XrlArgs*	a,
	GetV6RouteListStartCB		cb
)
{
    if (e != XrlError::OKAY()) {
	cb->dispatch(e, 0);
	return;
    } else if (a && a->size() != 1) {
	XLOG_ERROR("Wrong number of arguments (%u != %u)", XORP_UINT_CAST(a->size()), XORP_UINT_CAST(1));
	cb->dispatch(XrlError::BAD_ARGS(), 0);
	return;
    }
    uint32_t token;
    try {
	a->get("token", token);
    } catch (const XrlArgs::XrlAtomNotFound&) {
	XLOG_ERROR("Atom not found");
	cb->dispatch(XrlError::BAD_ARGS(), 0);
	return;
    }
    cb->dispatch(e, &token);
}

bool
XrlBgpV0p2Client::send_get_v4_route_list_next(
	const char*	dst_xrl_target_name,
	const uint32_t&	token,
	const GetV4RouteListNextCB&	cb
)
{
    Xrl x(dst_xrl_target_name, "bgp/0.2/get_v4_route_list_next");
    x.args().add("token", token);
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_get_v4_route_list_next, cb));
}


/* Unmarshall get_v4_route_list_next */
void
XrlBgpV0p2Client::unmarshall_get_v4_route_list_next(
	const XrlError&	e,
	XrlArgs*	a,
	GetV4RouteListNextCB		cb
)
{
    if (e != XrlError::OKAY()) {
	cb->dispatch(e, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
	return;
    } else if (a && a->size() != 14) {
	XLOG_ERROR("Wrong number of arguments (%u != %u)", XORP_UINT_CAST(a->size()), XORP_UINT_CAST(14));
	cb->dispatch(XrlError::BAD_ARGS(), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
	return;
    }
    IPv4 peer_id;
    IPv4Net net;
    uint32_t best_and_origin;
    vector<uint8_t> aspath;
    IPv4 nexthop;
    int32_t med;
    int32_t localpref;
    int32_t atomic_agg;
    vector<uint8_t> aggregator;
    int32_t calc_localpref;
    vector<uint8_t> attr_unknown;
    bool valid;
    bool unicast;
    bool multicast;
    try {
	a->get("peer_id", peer_id);
	a->get("net", net);
	a->get("best_and_origin", best_and_origin);
	a->get("aspath", aspath);
	a->get("nexthop", nexthop);
	a->get("med", med);
	a->get("localpref", localpref);
	a->get("atomic_agg", atomic_agg);
	a->get("aggregator", aggregator);
	a->get("calc_localpref", calc_localpref);
	a->get("attr_unknown", attr_unknown);
	a->get("valid", valid);
	a->get("unicast", unicast);
	a->get("multicast", multicast);
    } catch (const XrlArgs::XrlAtomNotFound&) {
	XLOG_ERROR("Atom not found");
	cb->dispatch(XrlError::BAD_ARGS(), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
	return;
    }
    cb->dispatch(e, &peer_id, &net, &best_and_origin, &aspath, &nexthop, &med, &localpref, &atomic_agg, &aggregator, &calc_localpref, &attr_unknown, &valid, &unicast, &multicast);
}

bool
XrlBgpV0p2Client::send_get_v6_route_list_next(
	const char*	dst_xrl_target_name,
	const uint32_t&	token,
	const GetV6RouteListNextCB&	cb
)
{
    Xrl x(dst_xrl_target_name, "bgp/0.2/get_v6_route_list_next");
    x.args().add("token", token);
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_get_v6_route_list_next, cb));
}


/* Unmarshall get_v6_route_list_next */
void
XrlBgpV0p2Client::unmarshall_get_v6_route_list_next(
	const XrlError&	e,
	XrlArgs*	a,
	GetV6RouteListNextCB		cb
)
{
    if (e != XrlError::OKAY()) {
	cb->dispatch(e, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
	return;
    } else if (a && a->size() != 14) {
	XLOG_ERROR("Wrong number of arguments (%u != %u)", XORP_UINT_CAST(a->size()), XORP_UINT_CAST(14));
	cb->dispatch(XrlError::BAD_ARGS(), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
	return;
    }
    IPv4 peer_id;
    IPv6Net net;
    uint32_t best_and_origin;
    vector<uint8_t> aspath;
    IPv6 nexthop;
    int32_t med;
    int32_t localpref;
    int32_t atomic_agg;
    vector<uint8_t> aggregator;
    int32_t calc_localpref;
    vector<uint8_t> attr_unknown;
    bool valid;
    bool unicast;
    bool multicast;
    try {
	a->get("peer_id", peer_id);
	a->get("net", net);
	a->get("best_and_origin", best_and_origin);
	a->get("aspath", aspath);
	a->get("nexthop", nexthop);
	a->get("med", med);
	a->get("localpref", localpref);
	a->get("atomic_agg", atomic_agg);
	a->get("aggregator", aggregator);
	a->get("calc_localpref", calc_localpref);
	a->get("attr_unknown", attr_unknown);
	a->get("valid", valid);
	a->get("unicast", unicast);
	a->get("multicast", multicast);
    } catch (const XrlArgs::XrlAtomNotFound&) {
	XLOG_ERROR("Atom not found");
	cb->dispatch(XrlError::BAD_ARGS(), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
	return;
    }
    cb->dispatch(e, &peer_id, &net, &best_and_origin, &aspath, &nexthop, &med, &localpref, &atomic_agg, &aggregator, &calc_localpref, &attr_unknown, &valid, &unicast, &multicast);
}