static dbus_bool_t
ni_objectmodel_ppp_config_set_ipv4(ni_dbus_object_t *object, const ni_dbus_property_t *property,
const ni_dbus_variant_t *argument, DBusError *error)
{
const ni_dbus_variant_t *ipcp;
ni_ppp_config_t *conf;
dbus_bool_t b;
if (!ni_dbus_variant_is_dict(argument))
return FALSE;
if (!(conf = ni_objectmodel_get_ppp_config(object, TRUE, error)))
return FALSE;
__ni_objectmodel_dict_get_sockaddr(argument, "local-ip", &conf->ipv4.local_ip);
if (conf->ipv4.local_ip.ss_family != AF_UNSPEC &&
conf->ipv4.local_ip.ss_family != AF_INET)
return FALSE;
__ni_objectmodel_dict_get_sockaddr(argument, "remote-ip", &conf->ipv4.remote_ip);
if (conf->ipv4.remote_ip.ss_family != AF_UNSPEC &&
conf->ipv4.remote_ip.ss_family != AF_INET)
return FALSE;
if (!(ipcp = ni_dbus_dict_get(argument, "ipcp")))
return TRUE;
if (!ni_dbus_variant_is_dict(ipcp))
return FALSE;
if (ni_dbus_dict_get_bool(ipcp, "accept-local", &b))
conf->ipv4.ipcp.accept_local = b;
if (ni_dbus_dict_get_bool(ipcp, "accept-remote", &b))
conf->ipv4.ipcp.accept_remote = b;
return TRUE;
}
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_ppp_config_set_dns(ni_dbus_object_t *object, const ni_dbus_property_t *property,
const ni_dbus_variant_t *argument, DBusError *error)
{
ni_ppp_config_t *conf;
dbus_bool_t b;
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_bool(argument, "usepeerdns", &b))
conf->dns.usepeerdns = b;
__ni_objectmodel_dict_get_sockaddr(argument, "dns1", &conf->dns.dns1);
__ni_objectmodel_dict_get_sockaddr(argument, "dns2", &conf->dns.dns2);
#if 0 /* limitted to IPv4? */
if (conf->dns.dns1.ss_family != AF_UNSPEC && conf->dns.dns1.ss_family != AF_INET)
return FALSE;
if (conf->dns.dns2.ss_family != AF_UNSPEC && conf->dns.dns2.ss_family != AF_INET)
return FALSE;
#endif
return TRUE;
}
/* extern */ dbus_bool_t
__ni_objectmodel_set_team_port_config(ni_team_port_config_t *pconf, const ni_dbus_variant_t *dict, DBusError *error)
{
dbus_bool_t b;
uint32_t u32;
(void)error;
if (!pconf || !dict)
return FALSE;
if (ni_dbus_dict_get_uint32(dict, "queue_id", &u32))
pconf->queue_id = u32;
if (ni_dbus_dict_get_uint32(dict, "prio", &u32))
pconf->ab.prio = u32;
if (ni_dbus_dict_get_bool(dict, "sticky", &b))
pconf->ab.sticky = b;
if (ni_dbus_dict_get_uint32(dict, "lacp_prio", &u32))
pconf->lacp.prio = u32;
if (ni_dbus_dict_get_uint32(dict, "lacp_key", &u32))
pconf->lacp.key = u32;
return TRUE;
}
static dbus_bool_t
ni_objectmodel_ethtool_link_adv_autoneg_from_dict(const ni_dbus_variant_t *dict,
ni_bitfield_t *bitfield)
{
dbus_bool_t bvalue;
if (ni_dbus_dict_get_bool(dict, "autoneg", &bvalue)) {
ni_ethtool_link_adv_set_autoneg(bitfield, bvalue);
return TRUE;
}
return FALSE;
}
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_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;
}
/*
* Forward an addrconf request to a supplicant service, such as DHCP or zeroconf
*
* What we do here is:
*
* - create an addrconf request handle, and register it with the interface
* - assign a uuid
* - assign an event ID
* - forward the request, along with the uuid
* - when we receive a lease event with the matching uuid,
* broadcast a corresponding interface event (with the assigned even ID)
*
* Note, we do not record the contents of the addrconf request, which may be totally
* free-form. We just pass it on to the respective addrconf service.
*/
static dbus_bool_t
ni_objectmodel_addrconf_forward_request(ni_dbus_addrconf_forwarder_t *forwarder,
ni_netdev_t *dev, const ni_dbus_variant_t *dict,
ni_dbus_message_t *reply, DBusError *error)
{
ni_addrconf_lease_t *lease;
ni_uuid_t req_uuid;
dbus_bool_t rv, enabled;
uint32_t flags = 0;
/* Check whether we already have a lease on this interface. */
lease = ni_netdev_get_lease(dev, forwarder->addrfamily, forwarder->addrconf);
/* Generate a uuid and assign an event ID */
ni_uuid_generate(&req_uuid);
/* If the caller tells us to disable this addrconf family, we may need
* to do a release() call. */
if (!ni_dbus_dict_get_bool(dict, "enabled", &enabled) || !enabled)
return ni_objectmodel_addrconf_forward_release(forwarder, dev, NULL, reply, error);
if (!ni_dbus_dict_get_uint32(dict, "flags", &flags))
flags = 0;
if (lease == NULL) {
/* We didn't have a lease for this address family and addrconf protocol yet.
* Create one and track it. */
lease = ni_addrconf_lease_new(forwarder->addrconf, forwarder->addrfamily);
ni_netdev_set_lease(dev, lease);
}
lease->uuid = req_uuid;
lease->state = NI_ADDRCONF_STATE_REQUESTING;
lease->flags = flags;
rv = ni_objectmodel_addrconf_forwarder_call(forwarder, dev, "acquire", &req_uuid, dict, error);
if (rv) {
/* Tell the client to wait for an addressAcquired event with the given uuid */
rv = __ni_objectmodel_return_callback_info(reply, NI_EVENT_ADDRESS_ACQUIRED, &req_uuid, error);
}
return rv;
}
static dbus_bool_t
__ni_objectmodel_team_set_runner(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 *name;
ni_team_t *team;
if (!(team = __ni_objectmodel_team_write_handle(object, error)))
return FALSE;
if (!ni_dbus_struct_get_string(argument, 0, &name)) {
dbus_set_error(error, DBUS_ERROR_INVALID_ARGS,
"bad value for property %s; missed subtype", property->name);
return FALSE;
}
if (!ni_team_runner_name_to_type(name, &team->runner.type)) {
dbus_set_error(error, DBUS_ERROR_INVALID_ARGS,
"bad value for property %s; unsupported subtype %s", property->name, name);
return FALSE;
}
if (!(dict = ni_dbus_struct_get(argument, 1))) {
dbus_set_error(error, DBUS_ERROR_INVALID_ARGS, "missed team runner member dict");
return FALSE;
}
if (!ni_dbus_variant_is_dict(dict)) {
dbus_set_error(error, DBUS_ERROR_INVALID_ARGS, "team runner member is not a dict");
return FALSE;
}
ni_team_runner_init(&team->runner, team->runner.type);
switch (team->runner.type) {
case NI_TEAM_RUNNER_ACTIVE_BACKUP: {
ni_team_runner_active_backup_t *ab = &team->runner.ab;
uint32_t u32;
if (ni_dbus_dict_get_uint32(dict, "hwaddr_policy", &u32))
ab->config.hwaddr_policy = u32;
else
ab->config.hwaddr_policy = NI_TEAM_AB_HWADDR_POLICY_SAME_ALL;
}
break;
case NI_TEAM_RUNNER_LOAD_BALANCE: {
ni_team_runner_load_balance_t *lb = &team->runner.lb;
ni_dbus_variant_t *txb;
uint32_t u32;
if (ni_dbus_dict_get_uint32(dict, "tx_hash", &u32))
lb->config.tx_hash = u32;
else lb->config.tx_hash = NI_TEAM_TX_HASH_NONE;
txb = ni_dbus_dict_get(dict, "tx_balancer");
if (txb) {
if (ni_dbus_dict_get_uint32(txb, "name", &u32) &&
ni_team_tx_balancer_type_to_name(u32))
lb->config.tx_balancer.type = u32;
else lb->config.tx_balancer.type = NI_TEAM_TX_BALANCER_BASIC;
if (ni_dbus_dict_get_uint32(txb, "balancing_interval", &u32))
lb->config.tx_balancer.interval = u32;
else lb->config.tx_balancer.interval = 50;
}
}
break;
case NI_TEAM_RUNNER_ROUND_ROBIN:
break;
case NI_TEAM_RUNNER_BROADCAST:
break;
case NI_TEAM_RUNNER_RANDOM:
break;
case NI_TEAM_RUNNER_LACP: {
ni_team_runner_lacp_t *lacp = &team->runner.lacp;
ni_dbus_variant_t *txb;
dbus_bool_t b;
uint16_t u16;
uint32_t u32;
if (ni_dbus_dict_get_bool(dict, "active", &b))
lacp->config.active = b;
else lacp->config.active = TRUE;
if (ni_dbus_dict_get_uint16(dict, "sys_prio", &u16))
lacp->config.sys_prio = u16;
else lacp->config.sys_prio = 255;
if (ni_dbus_dict_get_bool(dict, "fast_rate", &b))
lacp->config.fast_rate = b;
else lacp->config.fast_rate = FALSE;
if (ni_dbus_dict_get_uint16(dict, "min_ports", &u16) && u16 < 256)
lacp->config.sys_prio = u16;
else lacp->config.sys_prio = 0;
if (ni_dbus_dict_get_uint32(dict, "select_policy", &u32))
lacp->config.select_policy = u32;
else lacp->config.select_policy = NI_TEAM_LACP_SELECT_POLICY_PRIO;
if (ni_dbus_dict_get_uint32(dict, "tx_hash", &u32))
lacp->config.tx_hash = u32;
else lacp->config.tx_hash = NI_TEAM_TX_HASH_NONE;
txb = ni_dbus_dict_get(dict, "tx_balancer");
if (txb) {
if (ni_dbus_dict_get_uint32(txb, "name", &u32) &&
ni_team_tx_balancer_type_to_name(u32))
lacp->config.tx_balancer.type = u32;
else lacp->config.tx_balancer.type = NI_TEAM_TX_BALANCER_BASIC;
if (ni_dbus_dict_get_uint32(txb, "balancing_interval", &u32))
lacp->config.tx_balancer.interval = u32;
else lacp->config.tx_balancer.interval = 50;
}
}
break;
default:
return FALSE;
}
return TRUE;
}
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;
}