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; }
/* * Helper functions for getting/setting the port-id and chassis-id attributes. * * * The default-* settings tell LLDP to infer the appropriate value from * the netdevice at runtime */ static inline ni_bool_t try_set_default(const ni_dbus_variant_t *dict, const char *name) { char defnamebuf[64]; snprintf(defnamebuf, sizeof(defnamebuf), "default-%s", name); return ni_dbus_dict_get(dict, defnamebuf) != NULL; }
static dbus_bool_t ni_objectmodel_ethtool_eee_adv_from_dict(const ni_dbus_variant_t *dict, const char *entry, ni_bitfield_t *bitfield) { const ni_dbus_variant_t *array; if (!(array = ni_dbus_dict_get(dict, entry))) return FALSE; return ni_objectmodel_ethtool_link_adv_bitfield_from_array(array, bitfield, ni_ethtool_link_adv_speed_type); }
static dbus_bool_t ni_objectmodel_ethtool_link_adv_fec_modes_from_dict(const ni_dbus_variant_t *dict, ni_bitfield_t *bitfield) { const ni_dbus_variant_t *array; if (!(array = ni_dbus_dict_get(dict, "fec-modes"))) return FALSE; return ni_objectmodel_ethtool_link_adv_bitfield_from_array(array, bitfield, ni_ethtool_link_adv_fec_type); }
static dbus_bool_t __ni_objectmodel_bonding_set_arpmon(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; if (!(bond = __ni_objectmodel_bonding_write_handle(object, error))) return FALSE; bond->monitoring |= NI_BOND_MONITOR_ARP; ni_dbus_dict_get_uint32(result, "interval", &bond->arpmon.interval); ni_dbus_dict_get_uint32(result, "validate", &bond->arpmon.validate); if ((var = ni_dbus_dict_get(result, "targets")) != NULL) { ni_bool_t valid = TRUE; unsigned int i; if (!ni_dbus_variant_is_string_array(var)) { dbus_set_error(error, DBUS_ERROR_INVALID_ARGS, "%s.%s property - expected string array for attribute targets", object->path, property->name); return FALSE; } for (i = 0; i < var->array.len; ++i) { const char *s = var->string_array_value[i]; if (!ni_bonding_is_valid_arp_ip_target(s)) { valid = FALSE; break; } ni_string_array_append(&bond->arpmon.targets, s); } if (!valid) { ni_string_array_destroy(&bond->arpmon.targets); dbus_set_error(error, DBUS_ERROR_INVALID_ARGS, "%s.%s property - invalid arp ip target adddress", object->path, property->name); return FALSE; } } return TRUE; }
static dbus_bool_t ni_objectmodel_ethtool_set_link_settings(ni_dbus_object_t *object, const ni_dbus_property_t *property, const ni_dbus_variant_t *argument, DBusError *error) { ni_ethtool_link_settings_t *link; const ni_dbus_variant_t *adv; uint32_t uv32; int32_t sv32; if (!(link = ni_objectmodel_ethtool_link_settings_write_handle(object, error))) return FALSE; if (ni_dbus_dict_get_int32(argument, "autoneg", &sv32) && ni_tristate_is_set(sv32)) ni_tristate_set(&link->autoneg, sv32); if (ni_dbus_dict_get_uint32(argument, "speed", &uv32) && uv32 <= INT_MAX) link->speed = uv32; if (ni_dbus_dict_get_uint32(argument, "duplex", &uv32) && uv32 < NI_ETHTOOL_DUPLEX_UNKNOWN) link->duplex = uv32; if (ni_dbus_dict_get_uint32(argument, "port", &uv32) && uv32 <= NI_ETHTOOL_PORT_OTHER) link->port = uv32; if (ni_dbus_dict_get_uint32(argument, "mdix", &uv32)) link->tp_mdix = uv32; if (ni_dbus_dict_get_uint32(argument, "mdio", &uv32)) link->mdio_support = uv32; if (ni_dbus_dict_get_uint32(argument, "phy-address", &uv32)) link->phy_address = uv32; if (ni_dbus_dict_get_uint32(argument, "transceiver", &uv32)) link->transceiver = uv32; if ((adv = ni_dbus_dict_get(argument, "advertise"))) { /* config */ ni_objectmodel_ethtool_link_adv_bitfield_from_array(adv, &link->advertising, ni_ethtool_link_adv_type); } else { /* states */ ni_objectmodel_ethtool_link_adv_from_dict(argument, "supported", &link->supported); ni_objectmodel_ethtool_link_adv_from_dict(argument, "advertising", &link->advertising); ni_objectmodel_ethtool_link_adv_from_dict(argument, "lp-advertising", &link->lp_advertising); } return TRUE; }
static dbus_bool_t ni_objectmodel_ethtool_link_adv_from_dict(const ni_dbus_variant_t *dict, const char *name, ni_bitfield_t *bitfield) { const ni_dbus_variant_t *child; if (!dict || !ni_string_empty(name) || !bitfield) return FALSE; if (!(child = ni_dbus_dict_get(dict, name))) return TRUE; ni_objectmodel_ethtool_link_adv_autoneg_from_dict(child, bitfield); ni_objectmodel_ethtool_link_adv_ports_from_dict(child, bitfield); ni_objectmodel_ethtool_link_adv_speed_from_dict(child, bitfield); ni_objectmodel_ethtool_link_adv_pause_from_dict(child, bitfield); ni_objectmodel_ethtool_link_adv_fec_modes_from_dict(child, bitfield); ni_objectmodel_ethtool_link_adv_unknown_from_dict(child, bitfield); return TRUE; }
static dbus_bool_t ni_objectmodel_ethtool_set_eee(ni_dbus_object_t *object, const ni_dbus_property_t *property, const ni_dbus_variant_t *argument, DBusError *error) { const ni_dbus_variant_t *adv; ni_ethtool_t *ethtool; ni_ethtool_eee_t *eee; if (!(ethtool = ni_objectmodel_ethtool_write_handle(object, error))) return FALSE; ni_ethtool_eee_free(ethtool->eee); if (!(ethtool->eee = ni_ethtool_eee_new())) return FALSE; eee = ethtool->eee; ni_dbus_dict_get_int32(argument, "enabled", &eee->status.enabled); ni_dbus_dict_get_int32(argument, "active", &eee->status.active); ni_dbus_dict_get_int32(argument, "tx-lpi", &eee->tx_lpi.enabled); ni_dbus_dict_get_uint32(argument, "tx-timer", &eee->tx_lpi.timer); if ((adv = ni_dbus_dict_get(argument, "advertise"))) { /* config */ ni_objectmodel_ethtool_link_adv_bitfield_from_array(adv, &eee->speed.advertising, ni_ethtool_link_adv_speed_type); } else { /* states */ ni_objectmodel_ethtool_eee_adv_from_dict(argument, "supported", &eee->speed.supported); ni_objectmodel_ethtool_eee_adv_from_dict(argument, "advertising", &eee->speed.advertising); ni_objectmodel_ethtool_eee_adv_from_dict(argument, "lp-advertising", &eee->speed.lp_advertising); } return TRUE; }
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; }