static dbus_bool_t
ni_objectmodel_ppp_config_get_ipv6(const ni_dbus_object_t *object, const ni_dbus_property_t *property,
ni_dbus_variant_t *result, DBusError *error)
{
const ni_ppp_config_t *conf;
ni_dbus_variant_t *ipcp;
if (!(conf = ni_objectmodel_get_ppp_config(object, FALSE, error)))
return FALSE;
ni_dbus_dict_add_bool(result, "enabled", conf->ipv6.enabled);
if (!conf->ipv6.enabled)
return TRUE;
if (ni_sockaddr_is_specified(&conf->ipv6.local_ip)) {
if (!__ni_objectmodel_dict_add_sockaddr(result, "local-ip", &conf->ipv6.local_ip))
return FALSE;
}
if (ni_sockaddr_is_specified(&conf->ipv6.remote_ip)) {
if (!__ni_objectmodel_dict_add_sockaddr(result, "remote-ip", &conf->ipv6.remote_ip))
return FALSE;
}
if (!(ipcp = ni_dbus_dict_add(result, "ipcp")))
return FALSE;
ni_dbus_variant_init_dict(ipcp);
ni_dbus_dict_add_bool(ipcp, "accept-local", conf->ipv6.ipcp.accept_local);
return TRUE;
}
/*
* Property link_watch
*/
static dbus_bool_t
__ni_objectmodel_team_get_link_watch(const ni_dbus_object_t *object, const ni_dbus_property_t *property,
ni_dbus_variant_t *result, DBusError *error)
{
const ni_team_t *team;
unsigned int i;
if (!(team = __ni_objectmodel_team_read_handle(object, error)))
return FALSE;
if (!team->link_watch.count)
return FALSE;
ni_dbus_variant_init_dict(result);
for (i = 0; i < team->link_watch.count; i++) {
ni_team_link_watch_t *lw = team->link_watch.data[i];
ni_dbus_variant_t *entry;
ni_dbus_variant_t *dict;
const char *name;
if (!(name = ni_team_link_watch_type_to_name(lw->type)))
continue;
entry = ni_dbus_dict_add(result, "watch");
ni_dbus_variant_init_struct(entry);
ni_dbus_struct_add_string(entry, name);
dict = ni_dbus_struct_add(entry);
ni_dbus_variant_init_dict(dict);
__ni_objectmodel_team_link_watch_to_dict(lw, dict, error, object, property);
}
return TRUE;
}
void
get_default(ni_dbus_variant_t *dict, const char *name)
{
ni_dbus_variant_t *entry;
entry = ni_dbus_dict_add(dict, name);
ni_dbus_variant_set_byte(entry, 0);
}
/*
* This works a lot like the serialization code in xml-dbus, except we're not defining a
* schema for this.
* Used by the device identification code below.
*/
static void
__ni_call_build_dict(ni_dbus_variant_t *var, const xml_node_t *query)
{
if (query->cdata) {
ni_dbus_variant_set_string(var, query->cdata);
} else if (query->children) {
const xml_node_t *attr;
ni_dbus_variant_init_dict(var);
for (attr = query->children; attr; attr = attr->next)
__ni_call_build_dict(ni_dbus_dict_add(var, attr->name), attr);
} else {
ni_warn("ni_call_identify_device: empty query attribute %s (%s)",
query->name, xml_node_location(query));
}
}
/*
* get/set ethtool.eee
*/
static dbus_bool_t
ni_objectmodel_ethtool_eee_adv_into_dict(ni_dbus_variant_t *dict,
const char *entry, const ni_bitfield_t *bitfield)
{
ni_bitfield_t tmpfield = NI_BITFIELD_INIT;
ni_dbus_variant_t *array;
unsigned int bit, bits;
char *hexstr = NULL;
const char *name;
if (!dict || !ni_bitfield_isset(bitfield))
return FALSE;
if (!(array = ni_dbus_dict_add(dict, entry)))
return FALSE;
ni_dbus_variant_init_string_array(array);
/* known modes by name */
bits = ni_bitfield_bits(bitfield);
for (bit = 0; bit < bits; ++bit) {
if (!ni_bitfield_testbit(bitfield, bit))
continue;
if (!(name = ni_ethtool_link_adv_speed_name(bit)))
ni_bitfield_setbit(&tmpfield, bit);
else
if (!ni_dbus_variant_append_string_array(array, name))
ni_bitfield_setbit(&tmpfield, bit);
}
/* unknown modes as hex */
if (ni_bitfield_isset(&tmpfield)) {
if (ni_bitfield_format(&tmpfield, &hexstr, TRUE) && hexstr)
ni_dbus_variant_append_string_array(array, hexstr);
ni_string_free(&hexstr);
}
ni_bitfield_destroy(&tmpfield);
return TRUE;
}
static dbus_bool_t
ni_objectmodel_ethtool_link_adv_fec_modes_into_dict(ni_dbus_variant_t *dict,
ni_bitfield_t *bitfield)
{
ni_string_array_t tmp = NI_STRING_ARRAY_INIT;
ni_dbus_variant_t *ent;
if (!dict || !ni_bitfield_words(bitfield))
return FALSE;
if (!ni_objectmodel_ethtool_link_adv_bitfield_into_array(&tmp,
bitfield, ni_ethtool_link_adv_fec_name))
return FALSE;
if (!(ent = ni_dbus_dict_add(dict, "fec-modes"))) {
ni_string_array_destroy(&tmp);
return FALSE;
}
ni_dbus_variant_set_string_array(ent, (const char **)tmp.data, tmp.count);
ni_string_array_destroy(&tmp);
return TRUE;
}
/*
* Get/set ARP monitoring info
*/
static dbus_bool_t
__ni_objectmodel_bonding_get_arpmon(const ni_dbus_object_t *object,
const ni_dbus_property_t *property,
ni_dbus_variant_t *result,
DBusError *error)
{
const ni_bonding_t *bond;
ni_dbus_variant_t *var;
if (!(bond = __ni_objectmodel_bonding_read_handle(object, error)))
return FALSE;
if (bond->monitoring != NI_BOND_MONITOR_ARP)
return ni_dbus_error_property_not_present(error, object->path, property->name);
ni_dbus_dict_add_uint32(result, "interval", bond->arpmon.interval);
ni_dbus_dict_add_uint32(result, "validate", bond->arpmon.validate);
var = ni_dbus_dict_add(result, "targets");
ni_dbus_variant_set_string_array(var,
(const char **) bond->arpmon.targets.data,
bond->arpmon.targets.count);
return TRUE;
}
static dbus_bool_t
ni_objectmodel_ethtool_link_adv_into_dict(ni_dbus_variant_t *dict,
const char *name, const ni_bitfield_t *bitfield)
{
ni_bitfield_t tmpfield = NI_BITFIELD_INIT;
ni_dbus_variant_t *child;
if (!dict || ni_string_empty(name) || !ni_bitfield_bits(bitfield))
return FALSE;
if (!(child = ni_dbus_dict_add(dict, name)))
return FALSE;
ni_dbus_variant_init_dict(child);
ni_bitfield_set_data(&tmpfield, ni_bitfield_get_data(bitfield), ni_bitfield_bytes(bitfield));
ni_objectmodel_ethtool_link_adv_autoneg_into_dict(child, &tmpfield);
ni_objectmodel_ethtool_link_adv_ports_into_dict(child, &tmpfield);
ni_objectmodel_ethtool_link_adv_speed_into_dict(child, &tmpfield);
ni_objectmodel_ethtool_link_adv_pause_into_dict(child, &tmpfield);
ni_objectmodel_ethtool_link_adv_fec_modes_into_dict(child, &tmpfield);
ni_objectmodel_ethtool_link_adv_unknown_into_dict(child, &tmpfield);
ni_bitfield_destroy(&tmpfield);
return TRUE;
}
static dbus_bool_t
__ni_objectmodel_team_get_runner(const ni_dbus_object_t *object, const ni_dbus_property_t *property,
ni_dbus_variant_t *result, DBusError *error)
{
ni_dbus_variant_t *dict;
const ni_team_t *team;
const char *name;
if (!(team = __ni_objectmodel_team_read_handle(object, error)))
return FALSE;
if (!team->runner.type)
return ni_dbus_error_property_not_present(error, object->path, property->name);
if (!(name = ni_team_runner_type_to_name(team->runner.type))) {
dbus_set_error(error, DBUS_ERROR_INVALID_ARGS,
"bad property %s; unsupported runner name type %u",
property->name, team->runner.type);
return FALSE;
}
ni_dbus_variant_init_struct(result);
ni_dbus_struct_add_string(result, name);
dict = ni_dbus_struct_add(result);
ni_dbus_variant_init_dict(dict);
switch (team->runner.type) {
case NI_TEAM_RUNNER_ACTIVE_BACKUP: {
const ni_team_runner_active_backup_t *ab = &team->runner.ab;
ni_dbus_dict_add_uint32(dict, "hwaddr_policy", ab->config.hwaddr_policy);
}
break;
case NI_TEAM_RUNNER_LOAD_BALANCE: {
const ni_team_runner_load_balance_t *lb = &team->runner.lb;
ni_dbus_variant_t *txb;
ni_dbus_dict_add_uint32(dict, "tx_hash", lb->config.tx_hash);
txb = ni_dbus_dict_add(dict, "tx_balancer");
ni_dbus_variant_init_dict(txb);
ni_dbus_dict_add_uint32(txb, "name", lb->config.tx_balancer.type);
ni_dbus_dict_add_uint32(txb, "balancing_interval", lb->config.tx_balancer.interval);
}
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: {
const ni_team_runner_lacp_t *lacp = &team->runner.lacp;
ni_dbus_variant_t *txb;
ni_dbus_dict_add_bool(dict, "active", lacp->config.active);
ni_dbus_dict_add_bool(dict, "fast_rate", lacp->config.fast_rate);
ni_dbus_dict_add_uint16(dict, "sys_prio", lacp->config.sys_prio);
ni_dbus_dict_add_uint16(dict, "min_ports", lacp->config.min_ports);
ni_dbus_dict_add_uint32(dict, "select_policy", lacp->config.select_policy);
ni_dbus_dict_add_uint32(dict, "tx_hash", lacp->config.tx_hash);
txb = ni_dbus_dict_add(dict, "tx_balancer");
ni_dbus_variant_init_dict(txb);
ni_dbus_dict_add_uint32(txb, "name", lacp->config.tx_balancer.type);
ni_dbus_dict_add_uint32(txb, "balancing_interval", lacp->config.tx_balancer.interval);
}
break;
default:
return FALSE;
}
return TRUE;
}
