ospf_xif.cc

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

	return;
    }
    cb->dispatch(e, &networks, &netmasks);
}

bool
XrlOspfV0p1Client::send_add_or_configure_host(
	const char*	the_tgt, 
	const IPv4&	network, 
	const IPv4&	netmask, 
	const uint32_t&	area_id, 
	const uint32_t&	cost, 
	const AddOrConfigureHostCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/add_or_configure_host");
    x.args().add("network", network);
    x.args().add("netmask", netmask);
    x.args().add("area_id", area_id);
    x.args().add("cost", cost);
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_add_or_configure_host, cb));
}


/* Unmarshall add_or_configure_host */
void
XrlOspfV0p1Client::unmarshall_add_or_configure_host(
	const XrlError&	e, 
	XrlArgs*	a, 
	AddOrConfigureHostCB		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_host(
	const char*	the_tgt, 
	const IPv4&	network, 
	const IPv4&	netmask, 
	const uint32_t&	area_id, 
	const DeleteHostCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/delete_host");
    x.args().add("network", network);
    x.args().add("netmask", netmask);
    x.args().add("area_id", area_id);
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_delete_host, cb));
}


/* Unmarshall delete_host */
void
XrlOspfV0p1Client::unmarshall_delete_host(
	const XrlError&	e, 
	XrlArgs*	a, 
	DeleteHostCB		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_host(
	const char*	the_tgt, 
	const IPv4&	network, 
	const IPv4&	netmask, 
	const uint32_t&	area_id, 
	const QueryHostCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/query_host");
    x.args().add("network", network);
    x.args().add("netmask", netmask);
    x.args().add("area_id", area_id);
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_query_host, cb));
}


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

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


/* Unmarshall list_hosts */
void
XrlOspfV0p1Client::unmarshall_list_hosts(
	const XrlError&	e, 
	XrlArgs*	a, 
	ListHostsCB		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);
	return;
    }
    cb->dispatch(e, &networks, &netmasks);
}

bool
XrlOspfV0p1Client::send_add_vlink(
	const char*	the_tgt, 
	const uint32_t&	transit_area, 
	const uint32_t&	neighbor_id, 
	const AddVlinkCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/add_vlink");
    x.args().add("transit_area", transit_area);
    x.args().add("neighbor_id", neighbor_id);
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_add_vlink, cb));
}


/* Unmarshall add_vlink */
void
XrlOspfV0p1Client::unmarshall_add_vlink(
	const XrlError&	e, 
	XrlArgs*	a, 
	AddVlinkCB		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_vlink(
	const char*	the_tgt, 
	const uint32_t&	transit_area, 
	const uint32_t&	neighbor_id, 
	const DeleteVlinkCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/delete_vlink");
    x.args().add("transit_area", transit_area);
    x.args().add("neighbor_id", neighbor_id);
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_delete_vlink, cb));
}


/* Unmarshall delete_vlink */
void
XrlOspfV0p1Client::unmarshall_delete_vlink(
	const XrlError&	e, 
	XrlArgs*	a, 
	DeleteVlinkCB		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_vlink_set_transmit_delay(
	const char*	the_tgt, 
	const uint32_t&	transit_area, 
	const uint32_t&	neighbor_id, 
	const uint32_t&	delay_secs, 
	const VlinkSetTransmitDelayCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/vlink_set_transmit_delay");
    x.args().add("transit_area", transit_area);
    x.args().add("neighbor_id", neighbor_id);
    x.args().add("delay_secs", delay_secs);
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_vlink_set_transmit_delay, cb));
}


/* Unmarshall vlink_set_transmit_delay */
void
XrlOspfV0p1Client::unmarshall_vlink_set_transmit_delay(
	const XrlError&	e, 
	XrlArgs*	a, 
	VlinkSetTransmitDelayCB		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_vlink_get_transmit_delay(
	const char*	the_tgt, 
	const uint32_t&	transit_area, 
	const uint32_t&	neighbor_id, 
	const VlinkGetTransmitDelayCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/vlink_get_transmit_delay");
    x.args().add("transit_area", transit_area);
    x.args().add("neighbor_id", neighbor_id);
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_vlink_get_transmit_delay, cb));
}


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

bool
XrlOspfV0p1Client::send_vlink_set_retransmit_interval(
	const char*	the_tgt, 
	const uint32_t&	transit_area, 
	const uint32_t&	neighbor_id, 
	const uint32_t&	interval_secs, 
	const VlinkSetRetransmitIntervalCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/vlink_set_retransmit_interval");
    x.args().add("transit_area", transit_area);
    x.args().add("neighbor_id", neighbor_id);
    x.args().add("interval_secs", interval_secs);
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_vlink_set_retransmit_interval, cb));
}


/* Unmarshall vlink_set_retransmit_interval */
void
XrlOspfV0p1Client::unmarshall_vlink_set_retransmit_interval(
	const XrlError&	e, 
	XrlArgs*	a, 
	VlinkSetRetransmitIntervalCB		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_vlink_get_retransmit_interval(
	const char*	the_tgt, 
	const uint32_t&	transit_area, 
	const uint32_t&	neighbor_id, 
	const VlinkGetRetransmitIntervalCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/vlink_get_retransmit_interval");
    x.args().add("transit_area", transit_area);
    x.args().add("neighbor_id", neighbor_id);
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_vlink_get_retransmit_interval, cb));
}


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

bool
XrlOspfV0p1Client::send_vlink_set_hello_interval(
	const char*	the_tgt, 
	const uint32_t&	transit_area, 
	const uint32_t&	neighbor_id, 
	const uint32_t&	interval_secs, 
	const VlinkSetHelloIntervalCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/vlink_set_hello_interval");
    x.args().add("transit_area", transit_area);
    x.args().add("neighbor_id", neighbor_id);
    x.args().add("interval_secs", interval_secs);
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_vlink_set_hello_interval, cb));
}


/* Unmarshall vlink_set_hello_interval */
void
XrlOspfV0p1Client::unmarshall_vlink_set_hello_interval(
	const XrlError&	e, 
	XrlArgs*	a, 
	VlinkSetHelloIntervalCB		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_vlink_get_hello_interval(
	const char*	the_tgt, 
	const uint32_t&	transit_area, 
	const uint32_t&	neighbor_id, 
	const VlinkGetHelloIntervalCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/vlink_get_hello_interval");
    x.args().add("transit_area", transit_area);
    x.args().add("neighbor_id", neighbor_id);
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_vlink_get_hello_interval, cb));
}


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

bool
XrlOspfV0p1Client::send_vlink_set_router_dead_interval(
	const char*	the_tgt, 
	const uint32_t&	transit_area, 
	const uint32_t&	neighbor_id, 
	const uint32_t&	interval_secs, 
	const VlinkSetRouterDeadIntervalCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/vlink_set_router_dead_interval");
    x.args().add("transit_area", transit_area);
    x.args().add("neighbor_id", neighbor_id);
    x.args().add("interval_secs", interval_secs);
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_vlink_set_router_dead_interval, cb));
}


/* Unmarshall vlink_set_router_dead_interval */
void
XrlOspfV0p1Client::unmarshall_vlink_set_router_dead_interval(
	const XrlError&	e, 
	XrlArgs*	a, 
	VlinkSetRouterDeadIntervalCB		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_vlink_get_router_dead_interval(
	const char*	the_tgt, 
	const uint32_t&	transit_area, 
	const uint32_t&	neighbor_id, 
	const VlinkGetRouterDeadIntervalCB&	cb
)
{
    Xrl x(the_tgt, "ospf/0.1/vlink_get_router_dead_interval");
    x.args().add("transit_area", transit_area);
    x.args().add("neighbor_id", neighbor_id);
    return _sender->send(x, callback(this, &XrlOspfV0p1Client::unmarshall_vlink_get_router_dead_interval, cb));
}


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