fea_ifmgr_xif.cc

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

    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
XrlIfmgrV0p1Client::send_set_prefix6(
	const char*	the_tgt, 
	const uint32_t&	tid, 
	const string&	ifname, 
	const string&	vif, 
	const IPv6&	address, 
	const uint32_t&	prefix_len, 
	const SetPrefix6CB&	cb
)
{
    Xrl x(the_tgt, "ifmgr/0.1/set_prefix6");
    x.args().add("tid", tid);
    x.args().add("ifname", ifname);
    x.args().add("vif", vif);
    x.args().add("address", address);
    x.args().add("prefix_len", prefix_len);
    return _sender->send(x, callback(this, &XrlIfmgrV0p1Client::unmarshall_set_prefix6, cb));
}


/* Unmarshall set_prefix6 */
void
XrlIfmgrV0p1Client::unmarshall_set_prefix6(
	const XrlError&	e, 
	XrlArgs*	a, 
	SetPrefix6CB		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
XrlIfmgrV0p1Client::send_set_endpoint6(
	const char*	the_tgt, 
	const uint32_t&	tid, 
	const string&	ifname, 
	const string&	vif, 
	const IPv6&	address, 
	const IPv6&	endpoint, 
	const SetEndpoint6CB&	cb
)
{
    Xrl x(the_tgt, "ifmgr/0.1/set_endpoint6");
    x.args().add("tid", tid);
    x.args().add("ifname", ifname);
    x.args().add("vif", vif);
    x.args().add("address", address);
    x.args().add("endpoint", endpoint);
    return _sender->send(x, callback(this, &XrlIfmgrV0p1Client::unmarshall_set_endpoint6, cb));
}


/* Unmarshall set_endpoint6 */
void
XrlIfmgrV0p1Client::unmarshall_set_endpoint6(
	const XrlError&	e, 
	XrlArgs*	a, 
	SetEndpoint6CB		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
XrlIfmgrV0p1Client::send_register_client(
	const char*	the_tgt, 
	const string&	clientname, 
	const RegisterClientCB&	cb
)
{
    Xrl x(the_tgt, "ifmgr/0.1/register_client");
    x.args().add("clientname", clientname);
    return _sender->send(x, callback(this, &XrlIfmgrV0p1Client::unmarshall_register_client, cb));
}


/* Unmarshall register_client */
void
XrlIfmgrV0p1Client::unmarshall_register_client(
	const XrlError&	e, 
	XrlArgs*	a, 
	RegisterClientCB		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
XrlIfmgrV0p1Client::send_unregister_client(
	const char*	the_tgt, 
	const string&	clientname, 
	const UnregisterClientCB&	cb
)
{
    Xrl x(the_tgt, "ifmgr/0.1/unregister_client");
    x.args().add("clientname", clientname);
    return _sender->send(x, callback(this, &XrlIfmgrV0p1Client::unmarshall_unregister_client, cb));
}


/* Unmarshall unregister_client */
void
XrlIfmgrV0p1Client::unmarshall_unregister_client(
	const XrlError&	e, 
	XrlArgs*	a, 
	UnregisterClientCB		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
XrlIfmgrV0p1Client::send_get_system_interface_names(
	const char*	the_tgt, 
	const GetSystemInterfaceNamesCB&	cb
)
{
    Xrl x(the_tgt, "ifmgr/0.1/get_system_interface_names");
    return _sender->send(x, callback(this, &XrlIfmgrV0p1Client::unmarshall_get_system_interface_names, cb));
}


/* Unmarshall get_system_interface_names */
void
XrlIfmgrV0p1Client::unmarshall_get_system_interface_names(
	const XrlError&	e, 
	XrlArgs*	a, 
	GetSystemInterfaceNamesCB		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 ifnames;
    try {
	a->get("ifnames", ifnames);
    } catch (const XrlArgs::XrlAtomNotFound&) {
	XLOG_ERROR("Atom not found");
	cb->dispatch(XrlError::BAD_ARGS(), 0);
	return;
    }
    cb->dispatch(e, &ifnames);
}

bool
XrlIfmgrV0p1Client::send_get_system_vif_names(
	const char*	the_tgt, 
	const string&	ifname, 
	const GetSystemVifNamesCB&	cb
)
{
    Xrl x(the_tgt, "ifmgr/0.1/get_system_vif_names");
    x.args().add("ifname", ifname);
    return _sender->send(x, callback(this, &XrlIfmgrV0p1Client::unmarshall_get_system_vif_names, cb));
}


/* Unmarshall get_system_vif_names */
void
XrlIfmgrV0p1Client::unmarshall_get_system_vif_names(
	const XrlError&	e, 
	XrlArgs*	a, 
	GetSystemVifNamesCB		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 vifs;
    try {
	a->get("vifs", vifs);
    } catch (const XrlArgs::XrlAtomNotFound&) {
	XLOG_ERROR("Atom not found");
	cb->dispatch(XrlError::BAD_ARGS(), 0);
	return;
    }
    cb->dispatch(e, &vifs);
}

bool
XrlIfmgrV0p1Client::send_get_system_vif_flags(
	const char*	the_tgt, 
	const string&	ifname, 
	const string&	vif, 
	const GetSystemVifFlagsCB&	cb
)
{
    Xrl x(the_tgt, "ifmgr/0.1/get_system_vif_flags");
    x.args().add("ifname", ifname);
    x.args().add("vif", vif);
    return _sender->send(x, callback(this, &XrlIfmgrV0p1Client::unmarshall_get_system_vif_flags, cb));
}


/* Unmarshall get_system_vif_flags */
void
XrlIfmgrV0p1Client::unmarshall_get_system_vif_flags(
	const XrlError&	e, 
	XrlArgs*	a, 
	GetSystemVifFlagsCB		cb
)
{
    if (e != XrlError::OKAY()) {
	cb->dispatch(e, 0, 0, 0, 0, 0);
	return;
    } else if (a && a->size() != 5) {
	XLOG_ERROR("Wrong number of arguments (%u != 5)", (uint32_t)a->size());
	cb->dispatch(XrlError::BAD_ARGS(), 0, 0, 0, 0, 0);
	return;
    }
    bool enabled;
    bool broadcast;
    bool loopback;
    bool point_to_point;
    bool multicast;
    try {
	a->get("enabled", enabled);
	a->get("broadcast", broadcast);
	a->get("loopback", loopback);
	a->get("point_to_point", point_to_point);
	a->get("multicast", multicast);
    } catch (const XrlArgs::XrlAtomNotFound&) {
	XLOG_ERROR("Atom not found");
	cb->dispatch(XrlError::BAD_ARGS(), 0, 0, 0, 0, 0);
	return;
    }
    cb->dispatch(e, &enabled, &broadcast, &loopback, &point_to_point, &multicast);
}

bool
XrlIfmgrV0p1Client::send_get_system_vif_pif_index(
	const char*	the_tgt, 
	const string&	ifname, 
	const string&	vif, 
	const GetSystemVifPifIndexCB&	cb
)
{
    Xrl x(the_tgt, "ifmgr/0.1/get_system_vif_pif_index");
    x.args().add("ifname", ifname);
    x.args().add("vif", vif);
    return _sender->send(x, callback(this, &XrlIfmgrV0p1Client::unmarshall_get_system_vif_pif_index, cb));
}


/* Unmarshall get_system_vif_pif_index */
void
XrlIfmgrV0p1Client::unmarshall_get_system_vif_pif_index(
	const XrlError&	e, 
	XrlArgs*	a, 
	GetSystemVifPifIndexCB		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 pif_index;
    try {
	a->get("pif_index", pif_index);
    } catch (const XrlArgs::XrlAtomNotFound&) {
	XLOG_ERROR("Atom not found");
	cb->dispatch(XrlError::BAD_ARGS(), 0);
	return;
    }
    cb->dispatch(e, &pif_index);
}

bool
XrlIfmgrV0p1Client::send_get_system_vif_addresses4(
	const char*	the_tgt, 
	const string&	ifname, 
	const string&	vif, 
	const GetSystemVifAddresses4CB&	cb
)
{
    Xrl x(the_tgt, "ifmgr/0.1/get_system_vif_addresses4");
    x.args().add("ifname", ifname);
    x.args().add("vif", vif);
    return _sender->send(x, callback(this, &XrlIfmgrV0p1Client::unmarshall_get_system_vif_addresses4, cb));
}


/* Unmarshall get_system_vif_addresses4 */
void
XrlIfmgrV0p1Client::unmarshall_get_system_vif_addresses4(
	const XrlError&	e, 
	XrlArgs*	a, 
	GetSystemVifAddresses4CB		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 addresses;
    try {
	a->get("addresses", addresses);
    } catch (const XrlArgs::XrlAtomNotFound&) {
	XLOG_ERROR("Atom not found");
	cb->dispatch(XrlError::BAD_ARGS(), 0);
	return;
    }
    cb->dispatch(e, &addresses);
}

bool
XrlIfmgrV0p1Client::send_get_system_address_flags4(
	const char*	the_tgt, 
	const string&	ifname, 
	const string&	vif, 
	const IPv4&	address, 
	const GetSystemAddressFlags4CB&	cb
)
{
    Xrl x(the_tgt, "ifmgr/0.1/get_system_address_flags4");
    x.args().add("ifname", ifname);
    x.args().add("vif", vif);
    x.args().add("address", address);
    return _sender->send(x, callback(this, &XrlIfmgrV0p1Client::unmarshall_get_system_address_flags4, cb));
}


/* Unmarshall get_system_address_flags4 */
void
XrlIfmgrV0p1Client::unmarshall_get_system_address_flags4(
	const XrlError&	e, 
	XrlArgs*	a, 
	GetSystemAddressFlags4CB		cb
)
{
    if (e != XrlError::OKAY()) {
	cb->dispatch(e, 0, 0, 0, 0, 0);
	return;
    } else if (a && a->size() != 5) {
	XLOG_ERROR("Wrong number of arguments (%u != 5)", (uint32_t)a->size());
	cb->dispatch(XrlError::BAD_ARGS(), 0, 0, 0, 0, 0);
	return;
    }
    bool enabled;
    bool broadcast;
    bool loopback;
    bool point_to_point;
    bool multicast;
    try {
	a->get("enabled", enabled);
	a->get("broadcast", broadcast);
	a->get("loopback", loopback);
	a->get("point_to_point", point_to_point);
	a->get("multicast", multicast);
    } catch (const XrlArgs::XrlAtomNotFound&) {
	XLOG_ERROR("Atom not found");
	cb->dispatch(XrlError::BAD_ARGS(), 0, 0, 0, 0, 0);
	return;
    }
    cb->dispatch(e, &enabled, &broadcast, &loopback, &point_to_point, &multicast);
}

bool
XrlIfmgrV0p1Client::send_get_system_vif_addresses6(
	const char*	the_tgt, 
	const string&	ifname, 
	const string&	vif, 
	const GetSystemVifAddresses6CB&	cb
)
{
    Xrl x(the_tgt, "ifmgr/0.1/get_system_vif_addresses6");
    x.args().add("ifname", ifname);
    x.args().add("vif", vif);
    return _sender->send(x, callback(this, &XrlIfmgrV0p1Client::unmarshall_get_system_vif_addresses6, cb));
}


/* Unmarshall get_system_vif_addresses6 */
void
XrlIfmgrV0p1Client::unmarshall_get_system_vif_addresses6(
	const XrlError&	e, 
	XrlArgs*	a, 
	GetSystemVifAddresses6CB		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 addresses;
    try {
	a->get("addresses", addresses);
    } catch (const XrlArgs::XrlAtomNotFound&) {
	XLOG_ERROR("Atom not found");
	cb->dispatch(XrlError::BAD_ARGS(), 0);
	return;
    }
    cb->dispatch(e, &addresses);
}

bool
XrlIfmgrV0p1Client::send_get_system_address_flags6(
	const char*	the_tgt, 
	const string&	ifname, 
	const string&	vif, 
	const IPv6&	address, 
	const GetSystemAddressFlags6CB&	cb
)
{
    Xrl x(the_tgt, "ifmgr/0.1/get_system_address_flags6");
    x.args().add("ifname", ifname);
    x.args().add("vif", vif);
    x.args().add("address", address);
    return _sender->send(x, callback(this, &XrlIfmgrV0p1Client::unmarshall_get_system_address_flags6, cb));
}


/* Unmarshall get_system_address_flags6 */
void
XrlIfmgrV0p1Client::unmarshall_get_system_address_flags6(
	const XrlError&	e, 
	XrlArgs*	a, 
	GetSystemAddressFlags6CB		cb
)
{
    if (e != XrlError::OKAY()) {
	cb->dispatch(e, 0, 0, 0, 0);
	return;
    } else if (a && a->size() != 4) {
	XLOG_ERROR("Wrong number of arguments (%u != 4)", (uint32_t)a->size());
	cb->dispatch(XrlError::BAD_ARGS(), 0, 0, 0, 0);
	return;
    }
    bool enabled;
    bool loopback;
    bool point_to_point;
    bool multicast;
    try {
	a->get("enabled", enabled);
	a->get("loopback", loopback);
	a->get("point_to_point", point_to_point);
	a->get("multicast", multicast);
    } catch (const XrlArgs::XrlAtomNotFound&) {
	XLOG_ERROR("Atom not found");
	cb->dispatch(XrlError::BAD_ARGS(), 0, 0, 0, 0);
	return;
    }
    cb->dispatch(e, &enabled, &loopback, &point_to_point, &multicast);
}

bool
XrlIfmgrV0p1Client::send_get_system_interface_enabled(
	const char*	the_tgt, 
	const string&	ifname, 
	const GetSystemInterfaceEnabledCB&	cb
)
{
    Xrl x(the_tgt, "ifmgr/0.1/get_system_interface_enabled");
    x.args().add("ifname", ifname);
    return _sender->send(x, callback(this, &XrlIfmgrV0p1Client::unmarshall_get_system_interface_enabled, cb));
}