/*
* get/set ethtool.driver-info properties
*/
static dbus_bool_t
ni_objectmodel_ethtool_get_driver_info(const ni_dbus_object_t *object,
const ni_dbus_property_t *property,
ni_dbus_variant_t *result,
DBusError *error)
{
const ni_ethtool_t *ethtool;
const ni_ethtool_driver_info_t *info;
if (!(ethtool = ni_objectmodel_ethtool_read_handle(object, error)))
return FALSE;
if (!(info = ethtool->driver_info))
return FALSE;
if (info->driver)
ni_dbus_dict_add_string(result, "driver", info->driver);
if (info->version)
ni_dbus_dict_add_string(result, "version", info->version);
if (info->bus_info)
ni_dbus_dict_add_string(result, "bus-info", info->bus_info);
if (info->fw_version)
ni_dbus_dict_add_string(result, "firmware-version", info->fw_version);
if (info->erom_version)
ni_dbus_dict_add_string(result, "expansion-rom-version", info->erom_version);
if (info->supports.bitmap)
ni_dbus_dict_add_uint32(result, "supports", info->supports.bitmap);
return TRUE;
}
/*
* Helper functions to represent link_watches as a dbus dict
*/
static dbus_bool_t
__ni_objectmodel_team_link_watch_to_dict(const ni_team_link_watch_t *lw, ni_dbus_variant_t *dict,
DBusError *error, const ni_dbus_object_t *object, const ni_dbus_property_t *property)
{
if (!lw || !dict)
return FALSE;
switch(lw->type) {
case NI_TEAM_LINK_WATCH_ETHTOOL:
ni_dbus_dict_add_uint32(dict, "delay_up", lw->ethtool.delay_up);
ni_dbus_dict_add_uint32(dict, "delay_down", lw->ethtool.delay_down);
break;
case NI_TEAM_LINK_WATCH_ARP_PING:
if (lw->arp.source_host)
ni_dbus_dict_add_string(dict, "source_host", lw->arp.source_host);
if (lw->arp.target_host)
ni_dbus_dict_add_string(dict, "target_host", lw->arp.target_host);
if (lw->arp.interval)
ni_dbus_dict_add_uint32(dict, "interval", lw->arp.interval);
if (lw->arp.init_wait)
ni_dbus_dict_add_uint32(dict, "init_wait", lw->arp.init_wait);
if (lw->arp.validate_active)
ni_dbus_dict_add_bool(dict, "validate_active", lw->arp.validate_active);
if (lw->arp.validate_inactive)
ni_dbus_dict_add_bool(dict, "validate_inactive", lw->arp.validate_inactive);
if (lw->arp.send_always)
ni_dbus_dict_add_bool(dict, "send_always", lw->arp.send_always);
if (lw->arp.missed_max > 0)
ni_dbus_dict_add_uint32(dict, "missed_max", lw->arp.missed_max);
break;
case NI_TEAM_LINK_WATCH_NSNA_PING:
if (lw->nsna.target_host)
ni_dbus_dict_add_string(dict, "target_host", lw->nsna.target_host);
if (lw->nsna.interval > 0)
ni_dbus_dict_add_uint32(dict, "interval", lw->nsna.interval);
if (lw->nsna.init_wait > 0)
ni_dbus_dict_add_uint32(dict, "init_wait", lw->nsna.init_wait);
if (lw->nsna.missed_max)
ni_dbus_dict_add_uint32(dict, "missed_max", lw->nsna.missed_max);
break;
case NI_TEAM_LINK_WATCH_TIPC:
if (lw->tipc.bearer)
ni_dbus_dict_add_string(dict, "bearer", lw->tipc.bearer);
break;
default:
return FALSE;
}
return TRUE;
}
static dbus_bool_t
ni_objectmodel_ethtool_link_adv_unknown_into_dict(ni_dbus_variant_t *dict,
ni_bitfield_t *bitfield)
{
char *hexstr = NULL;
unsigned int words;
words = ni_bitfield_words(bitfield);
while (words) {
if (!bitfield->field[words - 1])
words--;
else
break;
}
if (!dict || !words)
return FALSE;
if (!ni_bitfield_format(bitfield, &hexstr, TRUE) || !hexstr)
return FALSE;
if (!ni_dbus_dict_add_string(dict, "unknown", hexstr)) {
ni_string_free(&hexstr);
return FALSE;
}
ni_string_free(&hexstr);
return TRUE;
}
/*
* get/set ethtool.priv-flags
*/
static dbus_bool_t
ni_objectmodel_ethtool_get_priv_flags(const ni_dbus_object_t *object,
const ni_dbus_property_t *property,
ni_dbus_variant_t *result,
DBusError *error)
{
const ni_ethtool_priv_flags_t *priv;
const ni_ethtool_t *ethtool;
ni_dbus_variant_t *dict;
const char *name;
unsigned int i;
if (!(ethtool = ni_objectmodel_ethtool_read_handle(object, error)))
return FALSE;
if (!(priv = ethtool->priv_flags) || !priv->names.count || priv->names.count > 32)
return FALSE;
ni_dbus_dict_array_init(result);
for (i = 0; i < priv->names.count; ++i) {
name = priv->names.data[i];
if (ni_string_empty(name))
continue;
if (!(dict = ni_dbus_dict_array_add(result)))
continue;
ni_dbus_dict_add_string(dict, "name", name);
ni_dbus_dict_add_bool(dict, "enabled", !!(priv->bitmap & NI_BIT(i)));
}
return TRUE;
}
/*
* Helper functions to represent ports as a dbus dict
*/
static dbus_bool_t
__ni_objectmodel_bridge_port_to_dict(const ni_bridge_port_t *port, ni_dbus_variant_t *dict,
const ni_dbus_object_t *object,
int config_only)
{
/*
* Hmm... Resolving the complete tree and ports to devices
* while serializing at client side does not work properly,
* e.g. when the port does not exists yet...
*
* FIXME: should we resolve the object path here?
*/
if (ni_string_empty(port->ifname))
return FALSE;
ni_dbus_dict_add_string(dict, "device", port->ifname);
ni_dbus_dict_add_uint32(dict, "priority", port->priority);
ni_dbus_dict_add_uint32(dict, "path-cost", port->path_cost);
if (config_only)
return TRUE;
ni_dbus_dict_add_uint32(dict, "state", port->status.state);
ni_dbus_dict_add_uint32(dict, "port-id", port->status.port_id);
ni_dbus_dict_add_uint32(dict, "port-no", port->status.port_no);
return TRUE;
}
/*
* Get/set the list of slaves
*/
static dbus_bool_t
__ni_objectmodel_bonding_get_slaves(const ni_dbus_object_t *object,
const ni_dbus_property_t *property,
ni_dbus_variant_t *result,
DBusError *error)
{
const ni_bonding_t *bond;
unsigned int i;
if (!(bond = __ni_objectmodel_bonding_read_handle(object, error)))
return FALSE;
ni_dbus_dict_array_init(result);
for (i = 0; i < bond->slave_names.count; ++i) {
const char *slave_name = bond->slave_names.data[i];
ni_dbus_variant_t *slave;
slave = ni_dbus_dict_array_add(result);
ni_dbus_dict_add_string(slave, "device", slave_name);
if (bond->primary_slave && ni_string_eq(bond->primary_slave, slave_name))
ni_dbus_dict_add_bool(slave, "primary", TRUE);
if (bond->active_slave && ni_string_eq(bond->active_slave, slave_name))
ni_dbus_dict_add_bool(slave, "active", TRUE);
}
return TRUE;
}
void
get_string(ni_dbus_variant_t *dict, const char *name, const char *value)
{
if (strncmp(name, "default-", 8) != 0)
ni_fatal("get_string: bad element name %s (should start with default-", name);
if (value == NULL || *value == '\0')
get_default(dict, name);
else
ni_dbus_dict_add_string(dict, name + 8, value);
}
static dbus_bool_t
ni_objectmodel_ppp_config_get_auth(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;
if (!(conf = ni_objectmodel_get_ppp_config(object, FALSE, error)))
return FALSE;
if (!ni_string_empty(conf->auth.hostname))
ni_dbus_dict_add_string(result, "hostname", conf->auth.hostname);
if (!ni_string_empty(conf->auth.username))
ni_dbus_dict_add_string(result, "username", conf->auth.username);
if (!ni_string_empty(conf->auth.password))
ni_dbus_dict_add_string(result, "password", conf->auth.password);
return TRUE;
}
/*
* Property ports (array)
*/
static dbus_bool_t
__ni_objectmodel_ovs_bridge_port_to_dict(const ni_ovs_bridge_port_t *port, ni_dbus_variant_t *dict, DBusError *error)
{
(void)error;
if (!port || !dict)
return FALSE;
ni_dbus_dict_add_string(dict, "device", port->device.name);
return TRUE;
}
/*
* Helper function for team port device as dict
*/
static dbus_bool_t
__ni_objectmodel_team_port_to_dict(const ni_team_port_t *port, ni_dbus_variant_t *dict, DBusError *error)
{
(void)error;
if (!port || !dict || ni_string_empty(port->device.name))
return FALSE;
ni_dbus_dict_add_string(dict, "device", port->device.name);
return __ni_objectmodel_get_team_port_config(&port->config, dict, error);
}
/*
* OVS Bridge port config helpers
*/
/* extern */ dbus_bool_t
__ni_objectmodel_get_ovs_bridge_port_config(const ni_ovs_bridge_port_config_t *pconf, ni_dbus_variant_t *dict, DBusError *error)
{
(void)error;
if (!pconf || !dict)
return FALSE;
if (!ni_string_empty(pconf->bridge.name))
ni_dbus_dict_add_string(dict, "bridge", pconf->bridge.name);
return TRUE;
}
/*
* get/set ethtool.features (offloads)
*/
static dbus_bool_t
ni_objectmodel_ethtool_feature_into_dict(ni_dbus_variant_t *dict,
const ni_ethtool_feature_t *feature)
{
if (!dict || !feature || ni_string_empty(feature->map.name))
return FALSE;
ni_dbus_dict_add_string(dict, "name", feature->map.name);
ni_dbus_dict_add_bool(dict, "enabled", !!(feature->value & NI_ETHTOOL_FEATURE_ON));
if (feature->value & NI_ETHTOOL_FEATURE_FIXED)
ni_dbus_dict_add_bool(dict, "fixed", TRUE);
else
if (feature->value & NI_ETHTOOL_FEATURE_REQUESTED)
ni_dbus_dict_add_bool(dict, "requested", TRUE);
return TRUE;
}
/*
* OVS Bridge vlan
*/
static dbus_bool_t
__ni_objectmodel_ovs_bridge_get_vlan(const ni_dbus_object_t *object, const ni_dbus_property_t *property,
ni_dbus_variant_t *result, DBusError *error)
{
const ni_ovs_bridge_t *ovsbr;
if (!(ovsbr = __ni_objectmodel_ovs_bridge_read_handle(object, error)))
return ni_dbus_error_property_not_present(error, object->path, property->name);
if (ni_string_empty(ovsbr->config.vlan.parent.name))
return ni_dbus_error_property_not_present(error, object->path, property->name);
ni_dbus_variant_init_dict(result);
ni_dbus_dict_add_string(result, "parent", ovsbr->config.vlan.parent.name);
ni_dbus_dict_add_uint16(result, "tag", ovsbr->config.vlan.tag);
return TRUE;
}
static dbus_bool_t
ni_objectmodel_ppp_get_mode(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_ppp_t *ppp;
const char *mode;
if (!(ppp = ni_objectmodel_ppp_handle(object, FALSE, error)))
return FALSE;
if (NI_PPP_MODE_UNKNOWN == ppp->mode.type)
return ni_dbus_error_property_not_present(error, object->path, property->name);
if (!(mode = ni_ppp_mode_type_to_name(ppp->mode.type))) {
dbus_set_error(error, DBUS_ERROR_INVALID_ARGS,
"bad property %s; unsupported mode type %u",
property->name, ppp->mode.type);
return FALSE;
}
ni_dbus_variant_init_struct(result);
ni_dbus_struct_add_string(result, mode);
dict = ni_dbus_struct_add(result);
ni_dbus_variant_init_dict(dict);
switch (ppp->mode.type) {
case NI_PPP_MODE_PPPOE: {
const ni_ppp_mode_pppoe_t *pppoe = &ppp->mode.pppoe;
if (!ni_string_empty(pppoe->device.name))
ni_dbus_dict_add_string(dict, "device", pppoe->device.name);
}
break;
default:
return FALSE;
}
return TRUE;
}
