/*
* Generic lease properties
*/
static dbus_bool_t
__ni_objectmodel_addrconf_generic_get_lease(const ni_dbus_object_t *object,
ni_addrconf_mode_t mode, unsigned int addrfamily,
ni_dbus_variant_t *dict,
DBusError *error)
{
ni_netdev_t *dev;
const ni_addrconf_lease_t *lease;
if (!(dev = ni_objectmodel_unwrap_netif(object, error)))
return FALSE;
#if 0
NI_TRACE_ENTER_ARGS("dev=%s, af=%s, mode=%s", dev->name,
ni_addrfamily_type_to_name(addrfamily),
ni_addrconf_type_to_name(mode));
#endif
if (!(lease = ni_netdev_get_lease(dev, addrfamily, mode)))
return FALSE;
ni_dbus_dict_add_uint32(dict, "state", lease->state);
if (lease->flags)
ni_dbus_dict_add_uint32(dict, "flags", lease->flags);
if (!ni_uuid_is_null(&lease->uuid))
ni_dbus_dict_add_uuid(dict, "uuid", &lease->uuid);
return TRUE;
}
/*
* get/set ethtool.wake-on-lan
*/
static dbus_bool_t
ni_objectmodel_ethtool_get_wake_on_lan(const ni_dbus_object_t *object,
const ni_dbus_property_t *property,
ni_dbus_variant_t *result,
DBusError *error)
{
const ni_ethtool_wake_on_lan_t *wol;
const ni_ethtool_t *ethtool;
if (!(ethtool = ni_objectmodel_ethtool_read_handle(object, error)))
return FALSE;
if (!(wol = ethtool->wake_on_lan))
return FALSE;
if (wol->support == NI_ETHTOOL_WOL_DEFAULT ||
wol->support == NI_ETHTOOL_WOL_DISABLE)
return FALSE;
ni_dbus_variant_init_dict(result);
ni_dbus_dict_add_uint32(result, "support", wol->support);
if (wol->options != NI_ETHTOOL_WOL_DEFAULT)
ni_dbus_dict_add_uint32(result, "options", wol->options);
/* from config it is VOID, hide sopass from kernel with type ETHER */
if (wol->sopass.len && wol->sopass.type == ARPHRD_VOID &&
wol->sopass.len == ni_link_address_length(ARPHRD_ETHER))
__ni_objectmodel_dict_add_hwaddr(result, "sopass", &wol->sopass);
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;
}
static dbus_bool_t
ni_objectmodel_ethtool_get_eee(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_eee_t *eee;
if (!(ethtool = ni_objectmodel_ethtool_read_handle(object, error)))
return FALSE;
if (!(eee = ethtool->eee))
return FALSE;
if (eee->status.enabled != NI_TRISTATE_DEFAULT)
ni_dbus_dict_add_int32(result, "enabled", eee->status.enabled);
if (eee->status.active != NI_TRISTATE_DEFAULT)
ni_dbus_dict_add_int32(result, "active", eee->status.active);
ni_objectmodel_ethtool_eee_adv_into_dict(result, "supported", &eee->speed.supported);
ni_objectmodel_ethtool_eee_adv_into_dict(result, "advertising", &eee->speed.advertising);
ni_objectmodel_ethtool_eee_adv_into_dict(result, "lp-advertising", &eee->speed.lp_advertising);
if (eee->tx_lpi.enabled != NI_TRISTATE_DEFAULT)
ni_dbus_dict_add_int32(result, "tx-lpi", eee->tx_lpi.enabled);
if (eee->tx_lpi.timer != NI_ETHTOOL_EEE_DEFAULT)
ni_dbus_dict_add_uint32(result, "tx-timer", eee->tx_lpi.timer);
return TRUE;
}
/*
* 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;
}
/*
* Get/set MII monitoring info
*/
static dbus_bool_t
__ni_objectmodel_bonding_get_miimon(const ni_dbus_object_t *object,
const ni_dbus_property_t *property,
ni_dbus_variant_t *result,
DBusError *error)
{
const ni_bonding_t *bond;
if (!(bond = __ni_objectmodel_bonding_read_handle(object, error)))
return FALSE;
if (bond->monitoring != NI_BOND_MONITOR_MII)
return ni_dbus_error_property_not_present(error, object->path, property->name);
ni_dbus_dict_add_uint32(result, "frequency", bond->miimon.frequency);
ni_dbus_dict_add_uint32(result, "updelay", bond->miimon.updelay);
ni_dbus_dict_add_uint32(result, "downdelay", bond->miimon.downdelay);
ni_dbus_dict_add_uint32(result, "carrier-detect", bond->miimon.carrier_detect);
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;
}
/*
* Helper function for team port config as dict
*/
/* extern */ dbus_bool_t
__ni_objectmodel_get_team_port_config(const ni_team_port_config_t *pconf, ni_dbus_variant_t *dict, DBusError *error)
{
(void)error;
if (!pconf || !dict)
return FALSE;
if (pconf->queue_id != -1U)
ni_dbus_dict_add_uint32(dict, "queue_id", pconf->queue_id);
if (pconf->ab.prio)
ni_dbus_dict_add_uint32(dict, "prio", pconf->ab.prio);
if (pconf->ab.sticky)
ni_dbus_dict_add_bool(dict, "sticky", pconf->ab.sticky);
if (pconf->lacp.prio)
ni_dbus_dict_add_uint32(dict, "lacp_prio", pconf->lacp.prio);
if (pconf->lacp.key)
ni_dbus_dict_add_uint32(dict, "lacp_key", pconf->lacp.key);
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_get_link_settings(const ni_dbus_object_t *object,
const ni_dbus_property_t *property,
ni_dbus_variant_t *result,
DBusError *error)
{
const ni_ethtool_link_settings_t *link;
if (!(link = ni_objectmodel_ethtool_link_settings_read_handle(object, error)))
return FALSE;
ni_dbus_variant_init_dict(result);
if (ni_tristate_is_set(link->autoneg))
ni_dbus_dict_add_int32(result, "autoneg", link->autoneg);
if (link->speed != NI_ETHTOOL_SPEED_UNKNOWN)
ni_dbus_dict_add_uint32(result, "speed", link->speed);
if (link->duplex != NI_ETHTOOL_DUPLEX_UNKNOWN)
ni_dbus_dict_add_uint32(result, "duplex", link->duplex);
if (link->port != NI_ETHTOOL_PORT_DEFAULT)
ni_dbus_dict_add_uint32(result, "port", link->port);
if (link->port == NI_ETHTOOL_PORT_TP && link->tp_mdix)
ni_dbus_dict_add_uint32(result, "mdix", link->tp_mdix);
if (link->mdio_support != NI_ETHTOOL_MDI_INVALID)
ni_dbus_dict_add_uint32(result, "mdio", link->mdio_support);
if (link->phy_address != NI_ETHTOOL_PHYAD_UNKNOWN)
ni_dbus_dict_add_uint32(result, "phy-address", link->phy_address);
if (link->transceiver != NI_ETHTOOL_XCVR_UNKNOWN)
ni_dbus_dict_add_uint32(result, "transceiver", link->transceiver);
ni_objectmodel_ethtool_link_adv_into_dict(result, "supported", &link->supported);
ni_objectmodel_ethtool_link_adv_into_dict(result, "advertising", &link->advertising);
ni_objectmodel_ethtool_link_adv_into_dict(result, "lp-advertising", &link->lp_advertising);
return TRUE;
}
/*
* get/set ethtool.coalesce
*/
static dbus_bool_t
ni_objectmodel_ethtool_get_coalesce(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_coalesce_t *coalesce;
if (!(ethtool = ni_objectmodel_ethtool_read_handle(object, error)))
return FALSE;
if (!(coalesce = ethtool->coalesce))
return FALSE;
if (coalesce->adaptive_tx != NI_TRISTATE_DEFAULT)
ni_dbus_dict_add_int32(result, "adaptive-tx", coalesce->adaptive_tx);
if (coalesce->adaptive_rx != NI_TRISTATE_DEFAULT)
ni_dbus_dict_add_int32(result, "adaptive-rx", coalesce->adaptive_rx);
if (coalesce->pkt_rate_low != NI_ETHTOOL_COALESCE_DEFAULT)
ni_dbus_dict_add_uint32(result, "pkt-rate-low", coalesce->pkt_rate_low);
if (coalesce->pkt_rate_high != NI_ETHTOOL_COALESCE_DEFAULT)
ni_dbus_dict_add_uint32(result, "pkt-rate-high", coalesce->pkt_rate_high);
if (coalesce->sample_interval != NI_ETHTOOL_COALESCE_DEFAULT)
ni_dbus_dict_add_uint32(result, "sample-interval", coalesce->sample_interval);
if (coalesce->stats_block_usecs != NI_ETHTOOL_COALESCE_DEFAULT)
ni_dbus_dict_add_uint32(result, "stats-block-usecs", coalesce->stats_block_usecs);
if (coalesce->tx_usecs != NI_ETHTOOL_COALESCE_DEFAULT)
ni_dbus_dict_add_uint32(result, "tx-usecs", coalesce->tx_usecs);
if (coalesce->tx_usecs_irq != NI_ETHTOOL_COALESCE_DEFAULT)
ni_dbus_dict_add_uint32(result, "tx-usecs-irq", coalesce->tx_usecs_irq);
if (coalesce->tx_usecs_low != NI_ETHTOOL_COALESCE_DEFAULT)
ni_dbus_dict_add_uint32(result, "tx-usecs-low", coalesce->tx_usecs_low);
if (coalesce->tx_usecs_high != NI_ETHTOOL_COALESCE_DEFAULT)
ni_dbus_dict_add_uint32(result, "tx-usecs-high", coalesce->tx_usecs_high);
if (coalesce->tx_frames != NI_ETHTOOL_COALESCE_DEFAULT)
ni_dbus_dict_add_uint32(result, "tx-frames", coalesce->tx_frames);
if (coalesce->tx_frames_irq != NI_ETHTOOL_COALESCE_DEFAULT)
ni_dbus_dict_add_uint32(result, "tx-frames-irq", coalesce->tx_frames_irq);
if (coalesce->tx_frames_low != NI_ETHTOOL_COALESCE_DEFAULT)
ni_dbus_dict_add_uint32(result, "tx-frames-low", coalesce->tx_frames_low);
if (coalesce->tx_frames_high != NI_ETHTOOL_COALESCE_DEFAULT)
ni_dbus_dict_add_uint32(result, "tx-frames-high", coalesce->tx_frames_high);
if (coalesce->rx_usecs != NI_ETHTOOL_COALESCE_DEFAULT)
ni_dbus_dict_add_uint32(result, "rx-usecs", coalesce->rx_usecs);
if (coalesce->rx_usecs_irq != NI_ETHTOOL_COALESCE_DEFAULT)
ni_dbus_dict_add_uint32(result, "rx-usecs-irq", coalesce->rx_usecs_irq);
if (coalesce->rx_usecs_low != NI_ETHTOOL_COALESCE_DEFAULT)
ni_dbus_dict_add_uint32(result, "rx-usecs-low", coalesce->rx_usecs_low);
if (coalesce->rx_usecs_high != NI_ETHTOOL_COALESCE_DEFAULT)
ni_dbus_dict_add_uint32(result, "rx-usecs-high", coalesce->rx_usecs_high);
if (coalesce->rx_frames != NI_ETHTOOL_COALESCE_DEFAULT)
ni_dbus_dict_add_uint32(result, "rx-frames", coalesce->rx_frames);
if (coalesce->rx_frames_irq != NI_ETHTOOL_COALESCE_DEFAULT)
ni_dbus_dict_add_uint32(result, "rx-frames-irq", coalesce->rx_frames_irq);
if (coalesce->rx_frames_low != NI_ETHTOOL_COALESCE_DEFAULT)
ni_dbus_dict_add_uint32(result, "rx-frames-low", coalesce->rx_frames_low);
if (coalesce->rx_frames_high != NI_ETHTOOL_COALESCE_DEFAULT)
ni_dbus_dict_add_uint32(result, "rx-frames-high", coalesce->rx_frames_high);
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;
}
