static dbus_bool_t
__ni_objectmodel_team_link_watch_from_dict(ni_team_link_watch_t *lw, const ni_dbus_variant_t *dict,
DBusError *error, const ni_dbus_property_t *property)
{
const char *string;
dbus_bool_t bvalue;
uint32_t value;
if (!lw || !dict || !error)
return FALSE;
switch(lw->type) {
case NI_TEAM_LINK_WATCH_ETHTOOL:
if (ni_dbus_dict_get_uint32(dict, "delay_up", &value))
lw->ethtool.delay_up = value;
if (ni_dbus_dict_get_uint32(dict, "delay_down", &value))
lw->ethtool.delay_down = value;
break;
case NI_TEAM_LINK_WATCH_ARP_PING:
if (ni_dbus_dict_get_string(dict, "source_host", &string))
ni_string_dup(&lw->arp.source_host, string);
if (ni_dbus_dict_get_string(dict, "target_host", &string))
ni_string_dup(&lw->arp.target_host, string);
if (ni_dbus_dict_get_uint32(dict, "interval", &value))
lw->arp.interval = value;
if (ni_dbus_dict_get_uint32(dict, "init_wait", &value))
lw->arp.init_wait = value;
if (ni_dbus_dict_get_bool(dict, "validate_active", &bvalue))
lw->arp.validate_active = bvalue;
if (ni_dbus_dict_get_bool(dict, "validate_inactive", &bvalue))
lw->arp.validate_inactive = bvalue;
if (ni_dbus_dict_get_bool(dict, "send_always", &bvalue))
lw->arp.send_always = bvalue;
if (ni_dbus_dict_get_uint32(dict, "missed_max", &value))
lw->arp.missed_max = value;
break;
case NI_TEAM_LINK_WATCH_NSNA_PING:
if (ni_dbus_dict_get_string(dict, "target_host", &string))
ni_string_dup(&lw->nsna.target_host, string);
if (ni_dbus_dict_get_uint32(dict, "interval", &value))
lw->nsna.interval = value;
if (ni_dbus_dict_get_uint32(dict, "init_wait", &value))
lw->nsna.init_wait = value;
if (ni_dbus_dict_get_uint32(dict, "missed_max", &value))
lw->nsna.missed_max = value;
break;
case NI_TEAM_LINK_WATCH_TIPC:
if (ni_dbus_dict_get_string(dict, "bearer", &string))
ni_string_dup(&lw->tipc.bearer, string);
break;
default:
return FALSE;
}
return TRUE;
}
static dbus_bool_t
__ni_objectmodel_ovs_bridge_set_vlan(ni_dbus_object_t *object, const ni_dbus_property_t *property,
const ni_dbus_variant_t *argument, DBusError *error)
{
ni_ovs_bridge_t *ovsbr;
const char *parent = NULL;
uint16_t tag = 0;
if (!ni_dbus_variant_is_dict(argument))
return FALSE;
if (!(ovsbr = __ni_objectmodel_ovs_bridge_write_handle(object, error)))
return FALSE;
ni_dbus_dict_get_string(argument, "parent", &parent);
ni_dbus_dict_get_uint16(argument, "tag", &tag);
if (!ni_string_empty(parent) && tag < 0x0fff) {
ovsbr->config.vlan.tag = tag;
ni_netdev_ref_set_ifname(&ovsbr->config.vlan.parent, parent);
} else {
ovsbr->config.vlan.tag = 0;
ni_netdev_ref_destroy(&ovsbr->config.vlan.parent);
}
return TRUE;
}
static dbus_bool_t
__ni_objectmodel_bridge_port_from_dict(ni_bridge_port_t *port, const ni_dbus_variant_t *dict,
DBusError *error,
int config_only)
{
const char *string;
uint32_t value;
if (dict->array.len == 0)
return TRUE;
/* FIXME: should expect object path here and map that to an ifindex */
if (ni_dbus_dict_get_string(dict, "device", &string) && !ni_string_empty(string))
ni_string_dup(&port->ifname, string);
else
return FALSE;
if (ni_dbus_dict_get_uint32(dict, "priority", &value))
port->priority = value;
if (ni_dbus_dict_get_uint32(dict, "path-cost", &value))
port->path_cost = value;
/* FIXME: Really? I don't think so... */
if (ni_dbus_dict_get_uint32(dict, "state", &value))
port->status.state = value;
if (ni_dbus_dict_get_uint32(dict, "port-id", &value))
port->status.port_id = value;
if (ni_dbus_dict_get_uint32(dict, "port-no", &value))
port->status.port_no = value;
return TRUE;
}
static dbus_bool_t
ni_objectmodel_ethtool_link_adv_unknown_from_dict(const ni_dbus_variant_t *dict,
ni_bitfield_t *bitfield)
{
const char *hexstr = NULL;
if (!ni_dbus_dict_get_string(dict, "unknown", &hexstr))
return FALSE;
return ni_bitfield_parse(bitfield, hexstr, 0);
}
/* extern */ dbus_bool_t
__ni_objectmodel_set_ovs_bridge_port_config(ni_ovs_bridge_port_config_t *pconf, const ni_dbus_variant_t *dict, DBusError *error)
{
const char *string;
if (!pconf || !dict)
return FALSE;
if (ni_dbus_dict_get_string(dict, "bridge", &string) && !ni_string_empty(string))
ni_netdev_ref_set_ifname(&pconf->bridge, string);
return TRUE;
}
/*
* Wickedd is sending us a signal indicating internal device state change.
* We want to wait for this signal and when it is >= device-up return TRUE.
* After timeout we fail...
*/
void
ni_state_change_signal_handler(ni_dbus_connection_t *conn, ni_dbus_message_t *msg, void *user_data)
{
const char *signal_name = dbus_message_get_member(msg);
const char *object_path = dbus_message_get_path(msg);
ni_dbus_variant_t argv = NI_DBUS_VARIANT_INIT;
ni_ifworker_array_t *ifworkers = user_data;
ni_fsm_state_t cur_state, target_state;
const char *ifname;
unsigned int i;
if (ni_string_empty(object_path))
return;
/* Deserialize dbus message */
if (ni_dbus_message_get_args_variants(msg, &argv, 1) < 0 ||
!ni_dbus_variant_is_dict(&argv)) {
ni_error("Unable to retrieve dict from signal %s, object_path=%s",
signal_name, object_path);
return;
}
if (!ni_dbus_dict_get_uint32(&argv, "current-state", &cur_state) ||
!ni_dbus_dict_get_uint32(&argv, "target-state", &target_state) ||
!ni_dbus_dict_get_string(&argv, "ifname", &ifname)) {
ni_error("Unable to retrieve dict's values from signal %s, object_path=%s",
signal_name, object_path);
return;
}
ni_debug_application("received signal %s; object_path=%s; target_state=%s, state_name=%s",
signal_name, object_path, ni_ifworker_state_name(target_state),
ni_ifworker_state_name(cur_state));
for (i = 0; i < ifworkers->count; ++i) {
ni_ifworker_t *w = ifworkers->data[i];
if (cur_state != NI_FSM_STATE_NONE && cur_state != target_state)
continue;
if (!ni_string_eq(w->name, ifname))
continue;
ni_warn("%s: Device %s", ifname, cur_state == target_state ? "succeeded" : "failed");
ni_ifworker_array_remove_with_children(ifworkers, w);
}
ni_dbus_variant_destroy(&argv);
}
static dbus_bool_t
ni_objectmodel_ethtool_set_priv_flags(ni_dbus_object_t *object,
const ni_dbus_property_t *property,
const ni_dbus_variant_t *argument,
DBusError *error)
{
const ni_dbus_variant_t *dict;
ni_ethtool_t *ethtool;
unsigned int i, len;
dbus_bool_t enabled;
ni_stringbuf_t buf;
const char *name;
if (!ni_dbus_variant_is_dict_array(argument))
return FALSE;
if (!(ethtool = ni_objectmodel_ethtool_write_handle(object, error)))
return FALSE;
ni_ethtool_priv_flags_free(ethtool->priv_flags);
if (!(ethtool->priv_flags = ni_ethtool_priv_flags_new()))
return FALSE;
if ((len = argument->array.len) > 32)
len = 32;
ni_stringbuf_init(&buf);
for (i = 0; i < argument->array.len; ++i) {
dict = &argument->variant_array_value[i];
if (!ni_dbus_variant_is_dict(dict))
continue;
if (!ni_dbus_dict_get_string(dict, "name", &name) ||
!ni_dbus_dict_get_bool(dict, "enabled", &enabled))
continue;
ni_stringbuf_put(&buf, name, ni_string_len(name));
ni_stringbuf_trim_head(&buf, " \t\n");
ni_stringbuf_trim_tail(&buf, " \t\n");
if (ni_string_empty(buf.string))
continue;
if (ni_string_array_append(ðtool->priv_flags->names, buf.string) == 0) {
if (enabled)
ethtool->priv_flags->bitmap |= NI_BIT(i);
}
ni_stringbuf_destroy(&buf);
}
return TRUE;
}
static dbus_bool_t
ni_objectmodel_ppp_set_mode(ni_dbus_object_t *object, const ni_dbus_property_t *property,
const ni_dbus_variant_t *argument, DBusError *error)
{
ni_dbus_variant_t *dict;
const char *mode;
ni_ppp_t *ppp;
if (!(ppp = ni_objectmodel_ppp_handle(object, TRUE, error)))
return FALSE;
if (!ni_dbus_struct_get_string(argument, 0, &mode)) {
dbus_set_error(error, DBUS_ERROR_INVALID_ARGS,
"bad value for property %s; missed subtype", property->name);
return FALSE;
}
if (!ni_ppp_mode_name_to_type(mode, &ppp->mode.type)) {
dbus_set_error(error, DBUS_ERROR_INVALID_ARGS,
"bad value for property %s; unsupported subtype %s", property->name, mode);
return FALSE;
}
if (!(dict = ni_dbus_struct_get(argument, 1))) {
dbus_set_error(error, DBUS_ERROR_INVALID_ARGS, "missed ppp mode member dict");
return FALSE;
}
if (!ni_dbus_variant_is_dict(dict)) {
dbus_set_error(error, DBUS_ERROR_INVALID_ARGS, "ppp mode member is not a dict");
return FALSE;
}
ni_ppp_mode_init(&ppp->mode, ppp->mode.type);
switch (ppp->mode.type) {
case NI_PPP_MODE_PPPOE: {
ni_ppp_mode_pppoe_t *pppoe = &ppp->mode.pppoe;
const char *string;
if (ni_dbus_dict_get_string(dict, "device", &string))
ni_netdev_ref_set_ifname(&pppoe->device, string);
}
break;
default:
return FALSE;
}
return TRUE;
}
static dbus_bool_t
ni_objectmodel_ethtool_set_driver_info(ni_dbus_object_t *object,
const ni_dbus_property_t *property,
const ni_dbus_variant_t *argument,
DBusError *error)
{
ni_ethtool_driver_info_t *info;
ni_ethtool_t *ethtool;
const char *str;
if (!ni_dbus_variant_is_dict(argument))
return FALSE;
if (!(ethtool = ni_objectmodel_ethtool_write_handle(object, error)))
return FALSE;
ni_ethtool_driver_info_free(ethtool->driver_info);
if (!(ethtool->driver_info = ni_ethtool_driver_info_new()))
return FALSE;
info = ethtool->driver_info;
if (ni_dbus_dict_get_string(argument, "driver", &str))
ni_string_dup(&info->driver, str);
if (ni_dbus_dict_get_string(argument, "version", &str))
ni_string_dup(&info->version, str);
if (ni_dbus_dict_get_string(argument, "bus-info", &str))
ni_string_dup(&info->bus_info, str);
if (ni_dbus_dict_get_string(argument, "firmware-version", &str))
ni_string_dup(&info->fw_version, str);
if (ni_dbus_dict_get_string(argument, "expansion-rom-version", &str))
ni_string_dup(&info->erom_version, str);
ni_dbus_dict_get_uint32(argument, "supports", &info->supports.bitmap);
return TRUE;
}
static dbus_bool_t
ni_objectmodel_ppp_config_set_auth(ni_dbus_object_t *object, const ni_dbus_property_t *property,
const ni_dbus_variant_t *argument, DBusError *error)
{
ni_ppp_config_t *conf;
const char *string;
if (!ni_dbus_variant_is_dict(argument))
return FALSE;
if (!(conf = ni_objectmodel_get_ppp_config(object, TRUE, error)))
return FALSE;
if (ni_dbus_dict_get_string(argument, "hostname", &string))
ni_string_dup(&conf->auth.hostname, string);
if (ni_dbus_dict_get_string(argument, "username", &string))
ni_string_dup(&conf->auth.username, string);
if (ni_dbus_dict_get_string(argument, "password", &string))
ni_string_dup(&conf->auth.password, string);
return TRUE;
}
static dbus_bool_t
__ni_objectmodel_ovs_bridge_port_from_dict(ni_ovs_bridge_port_t *port, const ni_dbus_variant_t *dict, DBusError *error)
{
const char *string;
(void)error;
if (!port || !dict)
return FALSE;
if (!ni_dbus_variant_is_dict(dict))
return FALSE;
if (!ni_dbus_dict_get_string(dict, "device", &string) || ni_string_empty(string))
return FALSE;
ni_netdev_ref_set_ifname(&port->device, string);
return TRUE;
}
static dbus_bool_t
__ni_objectmodel_team_port_from_dict(ni_team_port_t *port, const ni_dbus_variant_t *dict, DBusError *error)
{
const char *string;
(void)error;
if (!port || !dict)
return FALSE;
if (dict->array.len == 0)
return TRUE;
if (ni_dbus_dict_get_string(dict, "device", &string) && !ni_string_empty(string))
ni_netdev_ref_set_ifname(&port->device, string);
else
return FALSE;
ni_team_port_config_init(&port->config);
return __ni_objectmodel_set_team_port_config(&port->config, dict, error);
}
static dbus_bool_t
ni_objectmodel_ethtool_feature_from_dict(const ni_dbus_variant_t *dict,
ni_ethtool_features_t *features)
{
ni_ethtool_feature_value_t value;
dbus_bool_t enabled;
const char *name;
if (!ni_dbus_dict_get_string(dict, "name", &name))
return FALSE;
if (!ni_dbus_dict_get_bool(dict, "enabled", &enabled))
return FALSE;
value = enabled ? NI_ETHTOOL_FEATURE_ON : NI_ETHTOOL_FEATURE_OFF;
if (ni_dbus_dict_get_bool(dict, "fixed", &enabled) && enabled)
value |= NI_ETHTOOL_FEATURE_FIXED;
else
if (ni_dbus_dict_get_bool(dict, "requested", &enabled) && enabled)
value |= NI_ETHTOOL_FEATURE_REQUESTED;
return !!ni_ethtool_features_set(features, name, value);
}
static dbus_bool_t
__ni_objectmodel_bonding_set_slaves(ni_dbus_object_t *object,
const ni_dbus_property_t *property,
const ni_dbus_variant_t *result,
DBusError *error)
{
ni_bonding_t *bond;
ni_dbus_variant_t *var;
unsigned int i;
if (!(bond = __ni_objectmodel_bonding_write_handle(object, error)))
return FALSE;
if (!ni_dbus_variant_is_dict_array(result)) {
dbus_set_error(error, DBUS_ERROR_INVALID_ARGS,
"%s.%s property - expected dict array",
object->path, property->name);
return FALSE;
}
ni_string_free(&bond->primary_slave);
ni_string_free(&bond->active_slave);
ni_string_array_destroy(&bond->slave_names);
for (i = 0, var = result->variant_array_value; i < result->array.len; ++i, ++var) {
dbus_bool_t is_primary = FALSE;
dbus_bool_t is_active = FALSE;
const char *slave_name;
if (!ni_dbus_dict_get_string(var, "device", &slave_name)) {
dbus_set_error(error, DBUS_ERROR_INVALID_ARGS,
"%s.%s property - missing device attribute",
object->path, property->name);
return FALSE;
}
if (ni_string_array_index(&bond->slave_names, slave_name) != -1) {
dbus_set_error(error, DBUS_ERROR_INVALID_ARGS,
"%s.%s property - duplicate slave devices",
object->path, property->name);
return FALSE;
}
if (ni_dbus_dict_get_bool(var, "primary", &is_primary) && is_primary) {
if (bond->primary_slave) {
dbus_set_error(error, DBUS_ERROR_INVALID_ARGS,
"%s.%s property - duplicate primary device",
object->path, property->name);
return FALSE;
}
ni_string_dup(&bond->primary_slave, slave_name);
}
if (ni_dbus_dict_get_bool(var, "active", &is_active) && is_active) {
if (bond->active_slave) {
dbus_set_error(error, DBUS_ERROR_INVALID_ARGS,
"%s.%s property - duplicate active device",
object->path, property->name);
return FALSE;
}
ni_string_dup(&bond->active_slave, slave_name);
}
ni_string_array_append(&bond->slave_names, slave_name);
}
return TRUE;
}
