/* * 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; }