Example #1
0
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;
}
Example #2
0
File: lldp.c Project: mchf/wicked
/*
 * 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;
}
Example #3
0
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);
}
Example #4
0
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);
}
Example #5
0
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;
}
Example #6
0
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;
}
Example #7
0
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;
}
Example #8
0
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;
}
Example #9
0
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;
}