ospf_xif.cc

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

/* Unmarshall get_max_dds */
void
XrlOspfV0p1Client::unmarshall_get_max_dds(
	const XrlError&	e, 
	XrlArgs*	a, 
	GetMaxDdsCB		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 max_dds;
    try {
	a->get("max_dds", max_dds);
    } catch (const XrlArgs::XrlAtomNotFound&) {
	XLOG_ERROR("Atom not found");
	cb->dispatch(XrlError::BAD_ARGS(), 0);
	return;
    }
    cb->dispatch(e, &max_dds);
}

bool
XrlOspfV0p1Client::send_set_lsa_refresh_rate(
	const char*	the_tgt, 
	const uint32_t&	rate, 
	const SetLsaRefreshRateCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/set_lsa_refresh_rate");
    x.args().add("rate", rate);
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_set_lsa_refresh_rate, cb));
}


/* Unmarshall set_lsa_refresh_rate */
void
XrlOspfV0p1Client::unmarshall_set_lsa_refresh_rate(
	const XrlError&	e, 
	XrlArgs*	a, 
	SetLsaRefreshRateCB		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
XrlOspfV0p1Client::send_get_lsa_refresh_rate(
	const char*	the_tgt, 
	const GetLsaRefreshRateCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/get_lsa_refresh_rate");
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_get_lsa_refresh_rate, cb));
}


/* Unmarshall get_lsa_refresh_rate */
void
XrlOspfV0p1Client::unmarshall_get_lsa_refresh_rate(
	const XrlError&	e, 
	XrlArgs*	a, 
	GetLsaRefreshRateCB		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 rate;
    try {
	a->get("rate", rate);
    } catch (const XrlArgs::XrlAtomNotFound&) {
	XLOG_ERROR("Atom not found");
	cb->dispatch(XrlError::BAD_ARGS(), 0);
	return;
    }
    cb->dispatch(e, &rate);
}

bool
XrlOspfV0p1Client::send_set_p2p_adj_limit(
	const char*	the_tgt, 
	const uint32_t&	max_adj, 
	const SetP2PAdjLimitCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/set_p2p_adj_limit");
    x.args().add("max_adj", max_adj);
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_set_p2p_adj_limit, cb));
}


/* Unmarshall set_p2p_adj_limit */
void
XrlOspfV0p1Client::unmarshall_set_p2p_adj_limit(
	const XrlError&	e, 
	XrlArgs*	a, 
	SetP2PAdjLimitCB		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
XrlOspfV0p1Client::send_get_p2p_adj_limit(
	const char*	the_tgt, 
	const GetP2PAdjLimitCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/get_p2p_adj_limit");
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_get_p2p_adj_limit, cb));
}


/* Unmarshall get_p2p_adj_limit */
void
XrlOspfV0p1Client::unmarshall_get_p2p_adj_limit(
	const XrlError&	e, 
	XrlArgs*	a, 
	GetP2PAdjLimitCB		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 max_adj;
    try {
	a->get("max_adj", max_adj);
    } catch (const XrlArgs::XrlAtomNotFound&) {
	XLOG_ERROR("Atom not found");
	cb->dispatch(XrlError::BAD_ARGS(), 0);
	return;
    }
    cb->dispatch(e, &max_adj);
}

bool
XrlOspfV0p1Client::send_set_random_refresh(
	const char*	the_tgt, 
	const bool&	enabled, 
	const SetRandomRefreshCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/set_random_refresh");
    x.args().add("enabled", enabled);
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_set_random_refresh, cb));
}


/* Unmarshall set_random_refresh */
void
XrlOspfV0p1Client::unmarshall_set_random_refresh(
	const XrlError&	e, 
	XrlArgs*	a, 
	SetRandomRefreshCB		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
XrlOspfV0p1Client::send_get_random_refresh(
	const char*	the_tgt, 
	const GetRandomRefreshCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/get_random_refresh");
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_get_random_refresh, cb));
}


/* Unmarshall get_random_refresh */
void
XrlOspfV0p1Client::unmarshall_get_random_refresh(
	const XrlError&	e, 
	XrlArgs*	a, 
	GetRandomRefreshCB		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;
    }
    bool enabled;
    try {
	a->get("enabled", enabled);
    } catch (const XrlArgs::XrlAtomNotFound&) {
	XLOG_ERROR("Atom not found");
	cb->dispatch(XrlError::BAD_ARGS(), 0);
	return;
    }
    cb->dispatch(e, &enabled);
}

bool
XrlOspfV0p1Client::send_add_or_configure_area(
	const char*	the_tgt, 
	const uint32_t&	area_id, 
	const bool&	is_stub, 
	const uint32_t&	default_cost, 
	const bool&	import_summary_routes, 
	const AddOrConfigureAreaCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/add_or_configure_area");
    x.args().add("area_id", area_id);
    x.args().add("is_stub", is_stub);
    x.args().add("default_cost", default_cost);
    x.args().add("import_summary_routes", import_summary_routes);
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_add_or_configure_area, cb));
}


/* Unmarshall add_or_configure_area */
void
XrlOspfV0p1Client::unmarshall_add_or_configure_area(
	const XrlError&	e, 
	XrlArgs*	a, 
	AddOrConfigureAreaCB		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
XrlOspfV0p1Client::send_delete_area(
	const char*	the_tgt, 
	const uint32_t&	area_id, 
	const DeleteAreaCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/delete_area");
    x.args().add("area_id", area_id);
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_delete_area, cb));
}


/* Unmarshall delete_area */
void
XrlOspfV0p1Client::unmarshall_delete_area(
	const XrlError&	e, 
	XrlArgs*	a, 
	DeleteAreaCB		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
XrlOspfV0p1Client::send_query_area(
	const char*	the_tgt, 
	const uint32_t&	area_id, 
	const QueryAreaCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/query_area");
    x.args().add("area_id", area_id);
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_query_area, cb));
}


/* Unmarshall query_area */
void
XrlOspfV0p1Client::unmarshall_query_area(
	const XrlError&	e, 
	XrlArgs*	a, 
	QueryAreaCB		cb
)
{
    if (e != XrlError::OKAY()) {
	cb->dispatch(e, 0, 0, 0);
	return;
    } else if (a && a->size() != 3) {
	XLOG_ERROR("Wrong number of arguments (%u != 3)", (uint32_t)a->size());
	cb->dispatch(XrlError::BAD_ARGS(), 0, 0, 0);
	return;
    }
    bool is_stub;
    uint32_t default_cost;
    bool import_summary_routes;
    try {
	a->get("is_stub", is_stub);
	a->get("default_cost", default_cost);
	a->get("import_summary_routes", import_summary_routes);
    } catch (const XrlArgs::XrlAtomNotFound&) {
	XLOG_ERROR("Atom not found");
	cb->dispatch(XrlError::BAD_ARGS(), 0, 0, 0);
	return;
    }
    cb->dispatch(e, &is_stub, &default_cost, &import_summary_routes);
}

bool
XrlOspfV0p1Client::send_list_area_ids(
	const char*	the_tgt, 
	const ListAreaIdsCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/list_area_ids");
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_list_area_ids, cb));
}


/* Unmarshall list_area_ids */
void
XrlOspfV0p1Client::unmarshall_list_area_ids(
	const XrlError&	e, 
	XrlArgs*	a, 
	ListAreaIdsCB		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;
    }
    XrlAtomList area_ids;
    try {
	a->get("area_ids", area_ids);
    } catch (const XrlArgs::XrlAtomNotFound&) {
	XLOG_ERROR("Atom not found");
	cb->dispatch(XrlError::BAD_ARGS(), 0);
	return;
    }
    cb->dispatch(e, &area_ids);
}

bool
XrlOspfV0p1Client::send_add_or_configure_aggregate(
	const char*	the_tgt, 
	const uint32_t&	area_id, 
	const IPv4&	network, 
	const IPv4&	netmask, 
	const bool&	suppress_advertisement, 
	const AddOrConfigureAggregateCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/add_or_configure_aggregate");
    x.args().add("area_id", area_id);
    x.args().add("network", network);
    x.args().add("netmask", netmask);
    x.args().add("suppress_advertisement", suppress_advertisement);
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_add_or_configure_aggregate, cb));
}


/* Unmarshall add_or_configure_aggregate */
void
XrlOspfV0p1Client::unmarshall_add_or_configure_aggregate(
	const XrlError&	e, 
	XrlArgs*	a, 
	AddOrConfigureAggregateCB		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
XrlOspfV0p1Client::send_delete_aggregate(
	const char*	the_tgt, 
	const uint32_t&	area_id, 
	const IPv4&	network, 
	const IPv4&	netmask, 
	const DeleteAggregateCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/delete_aggregate");
    x.args().add("area_id", area_id);
    x.args().add("network", network);
    x.args().add("netmask", netmask);
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_delete_aggregate, cb));
}


/* Unmarshall delete_aggregate */
void
XrlOspfV0p1Client::unmarshall_delete_aggregate(
	const XrlError&	e, 
	XrlArgs*	a, 
	DeleteAggregateCB		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
XrlOspfV0p1Client::send_query_aggregate(
	const char*	the_tgt, 
	const uint32_t&	area_id, 
	const IPv4&	network, 
	const IPv4&	netmask, 
	const QueryAggregateCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/query_aggregate");
    x.args().add("area_id", area_id);
    x.args().add("network", network);
    x.args().add("netmask", netmask);
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_query_aggregate, cb));
}


/* Unmarshall query_aggregate */
void
XrlOspfV0p1Client::unmarshall_query_aggregate(
	const XrlError&	e, 
	XrlArgs*	a, 
	QueryAggregateCB		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;
    }
    bool suppress_advertisement;
    try {
	a->get("suppress_advertisement", suppress_advertisement);
    } catch (const XrlArgs::XrlAtomNotFound&) {
	XLOG_ERROR("Atom not found");
	cb->dispatch(XrlError::BAD_ARGS(), 0);
	return;
    }
    cb->dispatch(e, &suppress_advertisement);
}

bool
XrlOspfV0p1Client::send_list_aggregates(
	const char*	the_tgt, 
	const uint32_t&	area_id, 
	const ListAggregatesCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/list_aggregates");
    x.args().add("area_id", area_id);
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_list_aggregates, cb));
}


/* Unmarshall list_aggregates */
void
XrlOspfV0p1Client::unmarshall_list_aggregates(
	const XrlError&	e, 
	XrlArgs*	a, 
	ListAggregatesCB		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;
    }
    XrlAtomList networks;
    XrlAtomList netmasks;
    try {
	a->get("networks", networks);
	a->get("netmasks", netmasks);
    } catch (const XrlArgs::XrlAtomNotFound&) {
	XLOG_ERROR("Atom not found");
	cb->dispatch(XrlError::BAD_ARGS(), 0, 0);