bgp_xif.cc

来自「BCAST Implementation for NS2」· CC 代码 · 共 1,241 行 · 第 1/2 页

    } else if (a && a->size() != 1) {
	XLOG_ERROR("Wrong number of arguments (%u != 1)", (uint32_t)a->size());
	cb->dispatch(XrlError::BAD_ARGS(), 0);
	return;
    }
    IPv4 peer_id;
    try {
	a->get("peer_id", peer_id);
    } catch (const XrlArgs::XrlAtomNotFound&) {
	XLOG_ERROR("Atom not found");
	cb->dispatch(XrlError::BAD_ARGS(), 0);
	return;
    }
    cb->dispatch(e, &peer_id);
}

bool
XrlBgpV0p2Client::send_get_peer_status(
	const char*	the_tgt, 
	const IPv4&	local_ip, 
	const uint32_t&	local_port, 
	const IPv4&	peer_ip, 
	const uint32_t&	peer_port, 
	const GetPeerStatusCB&	cb
)
{
    Xrl x(the_tgt, "bgp/0.2/get_peer_status");
    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_status, cb));
}


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

bool
XrlBgpV0p2Client::send_get_peer_negotiated_version(
	const char*	the_tgt, 
	const IPv4&	local_ip, 
	const uint32_t&	local_port, 
	const IPv4&	peer_ip, 
	const uint32_t&	peer_port, 
	const GetPeerNegotiatedVersionCB&	cb
)
{
    Xrl x(the_tgt, "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 != 1)", (uint32_t)a->size());
	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*	the_tgt, 
	const IPv4&	local_ip, 
	const uint32_t&	local_port, 
	const IPv4&	peer_ip, 
	const uint32_t&	peer_port, 
	const GetPeerAsCB&	cb
)
{
    Xrl x(the_tgt, "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 != 1)", (uint32_t)a->size());
	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*	the_tgt, 
	const IPv4&	local_ip, 
	const uint32_t&	local_port, 
	const IPv4&	peer_ip, 
	const uint32_t&	peer_port, 
	const GetPeerMsgStatsCB&	cb
)
{
    Xrl x(the_tgt, "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 != 6)", (uint32_t)a->size());
	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*	the_tgt, 
	const IPv4&	local_ip, 
	const uint32_t&	local_port, 
	const IPv4&	peer_ip, 
	const uint32_t&	peer_port, 
	const GetPeerEstablishedStatsCB&	cb
)
{
    Xrl x(the_tgt, "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 != 2)", (uint32_t)a->size());
	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*	the_tgt, 
	const IPv4&	local_ip, 
	const uint32_t&	local_port, 
	const IPv4&	peer_ip, 
	const uint32_t&	peer_port, 
	const GetPeerTimerConfigCB&	cb
)
{
    Xrl x(the_tgt, "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 != 7)", (uint32_t)a->size());
	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*	the_tgt, 
	const string&	name, 
	const RegisterRibCB&	cb
)
{
    Xrl x(the_tgt, "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 != 0)", (uint32_t)a->size());
	cb->dispatch(XrlError::BAD_ARGS());
	return;
    }
    cb->dispatch(e);
}

bool
XrlBgpV0p2Client::send_add_route(
	const char*	the_tgt, 
	const int32_t&	origin, 
	const int32_t&	asnum, 
	const IPv4&	next_hop, 
	const IPv4Net&	nlri, 
	const AddRouteCB&	cb
)
{
    Xrl x(the_tgt, "bgp/0.2/add_route");
    x.args().add("origin", origin);
    x.args().add("asnum", asnum);
    x.args().add("next_hop", next_hop);
    x.args().add("nlri", nlri);
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_add_route, cb));
}


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

bool
XrlBgpV0p2Client::send_delete_route(
	const char*	the_tgt, 
	const IPv4Net&	nlri, 
	const DeleteRouteCB&	cb
)
{
    Xrl x(the_tgt, "bgp/0.2/delete_route");
    x.args().add("nlri", nlri);
    return _sender->send(x, callback(this, &XrlBgpV0p2Client::unmarshall_delete_route, cb));
}


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

bool
XrlBgpV0p2Client::send_get_v4_route_list_start(
	const char*	the_tgt, 
	const GetV4RouteListStartCB&	cb
)
{
    Xrl x(the_tgt, "bgp/0.2/get_v4_route_list_start");
    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 != 1)", (uint32_t)a->size());
	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*	the_tgt, 
	const GetV6RouteListStartCB&	cb
)
{
    Xrl x(the_tgt, "bgp/0.2/get_v6_route_list_start");
    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 != 1)", (uint32_t)a->size());
	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*	the_tgt, 
	const uint32_t&	token, 
	const GetV4RouteListNextCB&	cb
)
{
    Xrl x(the_tgt, "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);
	return;
    } else if (a && a->size() != 12) {
	XLOG_ERROR("Wrong number of arguments (%u != 12)", (uint32_t)a->size());
	cb->dispatch(XrlError::BAD_ARGS(), 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;
    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);
    } 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);
	return;
    }
    cb->dispatch(e, &peer_id, &net, &best_and_origin, &aspath, &nexthop, &med, &localpref, &atomic_agg, &aggregator, &calc_localpref, &attr_unknown, &valid);
}

bool
XrlBgpV0p2Client::send_get_v6_route_list_next(
	const char*	the_tgt, 
	const uint32_t&	token, 
	const GetV6RouteListNextCB&	cb
)
{
    Xrl x(the_tgt, "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);
	return;
    } else if (a && a->size() != 12) {
	XLOG_ERROR("Wrong number of arguments (%u != 12)", (uint32_t)a->size());
	cb->dispatch(XrlError::BAD_ARGS(), 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;
    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);
    } 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);
	return;
    }
    cb->dispatch(e, &peer_id, &net, &best_and_origin, &aspath, &nexthop, &med, &localpref, &atomic_agg, &aggregator, &calc_localpref, &attr_unknown, &valid);
}