// SPDX-License-Identifier: LGPL-2.1+

/*

 * Copyright (C) 2018 Red Hat, Inc.

 */

#include "nm-default.h"

#include "nm-core-internal.h"

#include "nm-initrd-generator.h"

#include "systemd/nm-sd-utils-shared.h"

/*****************************************************************************/

#define _NMLOG(level, domain, ...) \

    nm_log ((level), (domain), NULL, NULL, \

            "cmdline-reader: " _NM_UTILS_MACRO_FIRST (__VA_ARGS__) \

            _NM_UTILS_MACRO_REST (__VA_ARGS__))

/*****************************************************************************/

typedef struct {

	GHashTable *hash;

	GPtrArray *array;

	NMConnection *bootdev_connection;   /* connection for bootdev=$ifname */

	NMConnection *default_connection;   /* connection not bound to any ifname */

	char *hostname;

	/* Parameters to be set for all connections */

	gboolean ignore_auto_dns;

	int dhcp_timeout;

	char *dhcp4_vci;

} Reader;

static Reader *

reader_new (void)

{

	Reader *reader;

	reader = g_slice_new (Reader);

	*reader = (Reader) {

		.hash  = g_hash_table_new_full (nm_str_hash, g_str_equal, g_free, g_object_unref),

		.array = g_ptr_array_new (),

	};

	return reader;

}

static GHashTable *

reader_destroy (Reader *reader, gboolean free_hash)

{

	gs_unref_hashtable GHashTable *hash = NULL;

	g_ptr_array_unref (reader->array);

	hash = g_steal_pointer (&reader->hash);

	nm_clear_g_free (&reader->hostname);

	nm_clear_g_free (&reader->dhcp4_vci);

	nm_g_slice_free (reader);

	if (!free_hash)

		return g_steal_pointer (&hash);

	return NULL;

}

static NMConnection *

reader_add_connection (Reader *reader, const char *name, NMConnection *connection_take)

{

	char *name_dup;

	name_dup = g_strdup (name);

	if (g_hash_table_insert (reader->hash, name_dup, connection_take))

		g_ptr_array_add (reader->array, name_dup);

	return connection_take;

}

/* Returns a new connection owned by the reader */

static NMConnection *

reader_create_connection (Reader *reader,

                          const char *basename,

                          const char *id,

                          const char *ifname,

                          const char *mac,

                          const char *type_name,

                          NMConnectionMultiConnect multi_connect)

{

	NMConnection *connection;

	NMSetting *setting;

	connection = reader_add_connection (reader,

	                                    basename,

	                                    nm_simple_connection_new ());

	/* Start off assuming dynamic IP configurations. */

	setting = nm_setting_ip4_config_new ();

	nm_connection_add_setting (connection, setting);

	g_object_set (setting,

	              NM_SETTING_IP_CONFIG_METHOD, NM_SETTING_IP4_CONFIG_METHOD_AUTO,

	              NM_SETTING_IP_CONFIG_MAY_FAIL, TRUE,

	              NM_SETTING_IP_CONFIG_IGNORE_AUTO_DNS, reader->ignore_auto_dns,

	              NM_SETTING_IP_CONFIG_DHCP_TIMEOUT, reader->dhcp_timeout,

	              NM_SETTING_IP4_CONFIG_DHCP_VENDOR_CLASS_IDENTIFIER, reader->dhcp4_vci,

	              NULL);

	setting = nm_setting_ip6_config_new ();

	nm_connection_add_setting (connection, setting);

	g_object_set (setting,

	              NM_SETTING_IP_CONFIG_METHOD, NM_SETTING_IP4_CONFIG_METHOD_AUTO,

	              NM_SETTING_IP_CONFIG_MAY_FAIL, TRUE,

	              NM_SETTING_IP6_CONFIG_ADDR_GEN_MODE, (int) NM_SETTING_IP6_CONFIG_ADDR_GEN_MODE_EUI64,

	              NM_SETTING_IP_CONFIG_IGNORE_AUTO_DNS, reader->ignore_auto_dns,

	              NM_SETTING_IP_CONFIG_DHCP_TIMEOUT, reader->dhcp_timeout,

	              NULL);

	setting = nm_setting_connection_new ();

	nm_connection_add_setting (connection, setting);

	g_object_set (setting,

	              NM_SETTING_CONNECTION_ID, id,

	              NM_SETTING_CONNECTION_UUID, nm_utils_uuid_generate_a (),

	              NM_SETTING_CONNECTION_INTERFACE_NAME, ifname,

	              NM_SETTING_CONNECTION_TYPE, type_name,

	              NM_SETTING_CONNECTION_MULTI_CONNECT, multi_connect,

	              NULL);

	if (nm_streq0 (type_name, NM_SETTING_INFINIBAND_SETTING_NAME)) {

		setting = nm_setting_infiniband_new ();

		nm_connection_add_setting (connection, setting);

		g_object_set (setting, NM_SETTING_INFINIBAND_TRANSPORT_MODE, "datagram", NULL);

	}

	if (mac) {

		if (nm_streq0 (type_name, NM_SETTING_INFINIBAND_SETTING_NAME)) {

			setting = (NMSetting *) nm_connection_get_setting_infiniband (connection);

			g_object_set (setting, NM_SETTING_INFINIBAND_MAC_ADDRESS, mac, NULL);

		} else {

			setting = nm_setting_wired_new ();

			nm_connection_add_setting (connection, setting);

			g_object_set (setting, NM_SETTING_WIRED_MAC_ADDRESS, mac, NULL);

		}

	}

	return connection;

}

static NMConnection *

reader_get_default_connection (Reader *reader)

{

	NMConnection *con;

	if (!reader->default_connection) {

		con = reader_create_connection (reader,

		                                "default_connection",

		                                "Wired Connection",

		                                NULL,

		                                NULL,

		                                NM_SETTING_WIRED_SETTING_NAME,

		                                NM_CONNECTION_MULTI_CONNECT_MULTIPLE);

		nm_connection_add_setting (con, nm_setting_wired_new ());

		reader->default_connection = con;

	}

	return reader->default_connection;

}

static NMConnection *

reader_get_connection (Reader *reader,

                       const char *iface_spec,

                       const char *type_name,

                       gboolean create_if_missing)

{

	NMConnection *connection = NULL;

	NMSetting *setting;

	const char *ifname = NULL;

	gs_free char *mac = NULL;

	if (iface_spec) {

		if (nm_utils_is_valid_iface_name (iface_spec, NULL))

			ifname = iface_spec;

		else {

			mac = nm_utils_hwaddr_canonical (iface_spec, -1);

			if (!mac)

				_LOGW (LOGD_CORE, "invalid interface '%s'", iface_spec);

		}

	}

	if (!ifname && !mac) {

		NMConnection *candidate;

		NMSettingConnection *s_con;

		guint i;

		/*

		 * If ifname was not given, we'll match the connection by type.

		 * If the type was not given either, then we're happy with any connection but slaves.

		 * This is so that things like "bond=bond0:eth1,eth2 nameserver=1.3.3.7 end up

		 * slapping the nameserver to the most reasonable connection (bond0).

		 */

		for (i = 0; i < reader->array->len; i++) {

			candidate = g_hash_table_lookup (reader->hash, reader->array->pdata[i]);

			s_con = nm_connection_get_setting_connection (candidate);

			if (   type_name == NULL

			    && nm_setting_connection_get_master (s_con) == NULL) {

				connection = candidate;

				break;

			}

			if (   type_name != NULL

			    && nm_streq (nm_setting_connection_get_connection_type (s_con), type_name)) {

				connection = candidate;

				break;

			}

		}

	} else

		connection = g_hash_table_lookup (reader->hash, (gpointer) ifname ?: mac);

	if (!connection) {

		if (!create_if_missing)

			return NULL;

		if (!type_name) {

			if (   NM_STR_HAS_PREFIX (ifname, "ib")

			    || (mac && nm_utils_hwaddr_valid (mac, INFINIBAND_ALEN)))

				type_name = NM_SETTING_INFINIBAND_SETTING_NAME;

			else

				type_name = NM_SETTING_WIRED_SETTING_NAME;

		}

		connection = reader_create_connection (reader, ifname ?: mac,

		                                       ifname ?: (mac ?: "Wired Connection"),

		                                       ifname, mac, type_name,

		                                       NM_CONNECTION_MULTI_CONNECT_SINGLE);

	}

	setting = (NMSetting *) nm_connection_get_setting_connection (connection);

	if (type_name) {

		g_object_set (setting, NM_SETTING_CONNECTION_TYPE, type_name, NULL);

		if (!nm_connection_get_setting_by_name (connection, type_name)) {

			setting = g_object_new (nm_setting_lookup_type (type_name), NULL);

			nm_connection_add_setting (connection, setting);

		}

	}

	return connection;

}

static char *

get_word (char **argument, const char separator)

{

	char *word;

	int nest = 0;

	if (*argument == NULL)

		return NULL;

	if (**argument == '[') {

		nest++;

		(*argument)++;

	}

	word = *argument;

	while (**argument != '\0') {

		if (nest && **argument == ']') {

			**argument = '\0';

			(*argument)++;

			nest--;

			continue;

		}

		if (nest == 0 && **argument == separator) {

			**argument = '\0';

			(*argument)++;

			break;

		}

		(*argument)++;

	}

	return *word ? word : NULL;

}

static void

connection_set (NMConnection *connection, const char *setting_name, const char *property, const char *value)

{

	NMSetting *setting;

	GType setting_type;

	nm_auto_unref_gtypeclass GObjectClass *object_class = NULL;

	GParamSpec *spec;

	setting_type = nm_setting_lookup_type (setting_name);

	object_class = g_type_class_ref (setting_type);

	spec = g_object_class_find_property (object_class, property);

	nm_assert (spec);

	setting = nm_connection_get_setting_by_name (connection, setting_name);

	if (!setting) {

		setting = g_object_new (setting_type, NULL);

		nm_connection_add_setting (connection, setting);

	}

	if (G_IS_PARAM_SPEC_UINT (spec)) {

		guint v;

		v =  _nm_utils_ascii_str_to_int64 (value, 10, 0, G_MAXUINT, 0);

		if (   errno

		    || !nm_g_object_set_property_uint (G_OBJECT (setting), property, v, NULL)) {

			_LOGW (LOGD_CORE,

			       "Could not set property '%s.%s' to '%s'",

			       setting_name, property, value);

		}

	} else if (G_IS_PARAM_SPEC_STRING (spec))

		g_object_set (setting, property, value, NULL);

	else

		_LOGW (LOGD_CORE, "Don't know how to set '%s' of %s", property, setting_name);

}

static void

reader_read_all_connections_from_fw (Reader *reader, const char *sysfs_dir)

{

	gs_unref_hashtable GHashTable *ibft = NULL;

	NMConnection *dt_connection;

	const char *mac;

	GHashTable *nic;

	const char *index;

	GError *error = NULL;

	guint i, length;

	gs_free const char **keys = NULL;

	ibft = nmi_ibft_read (sysfs_dir);

	keys = nm_utils_strdict_get_keys (ibft, TRUE, &length);

	for (i = 0; i < length; i++) {

		gs_unref_object NMConnection *connection = NULL;

		gs_free char *name = NULL;

		mac = keys[i];

		nic = g_hash_table_lookup (ibft, mac);

		connection = nm_simple_connection_new ();

		index = g_hash_table_lookup (nic, "index");

		if (!index) {

			_LOGW (LOGD_CORE, "Ignoring an iBFT entry without an index");

			continue;

		}

		if (!nmi_ibft_update_connection_from_nic (connection, nic, &error)) {

			_LOGW (LOGD_CORE, "Unable to merge iBFT configuration: %s", error->message);

			g_error_free (error);

			continue;

		}

		name = g_strdup_printf ("ibft%s", index);

		reader_add_connection (reader, name, g_steal_pointer (&connection));

	}

	dt_connection = nmi_dt_reader_parse (sysfs_dir);

	if (dt_connection)

		reader_add_connection (reader, "ofw", dt_connection);

}

static void

reader_parse_ip (Reader *reader, const char *sysfs_dir, char *argument)

{

	NMConnection *connection;

	NMSettingIPConfig *s_ip4 = NULL, *s_ip6 = NULL;

	gs_unref_hashtable GHashTable *ibft = NULL;

	const char *tmp;

	const char *kind = NULL;

	const char *client_ip = NULL;

	const char *peer = NULL;

	const char *gateway_ip = NULL;

	const char *netmask = NULL;

	const char *client_hostname = NULL;

	const char *iface_spec = NULL;

	const char *mtu = NULL;

	const char *macaddr = NULL;

	int client_ip_family = AF_UNSPEC;

	int client_ip_prefix = -1;

	const char *dns[2] = { 0, };

	int dns_addr_family[2] = { 0, };

	int i;

	GError *error = NULL;

	if (!*argument)

		return;

	tmp = get_word (&argument, ':');

	if (!*argument) {

		/* ip={dhcp|on|any|dhcp6|auto6|ibft} */

		kind = tmp;

	} else {

		client_ip_family = guess_ip_address_family (tmp);

		if (client_ip_family != AF_UNSPEC) {

			/* <client-IP>:[<peer>]:<gateway-IP>:<netmask>:<client_hostname>: */

			client_ip = tmp;

			peer = get_word (&argument, ':');

			gateway_ip = get_word (&argument, ':');

			netmask = get_word (&argument, ':');

			client_hostname = get_word (&argument, ':');

			iface_spec = get_word (&argument, ':');

		} else {

			iface_spec = tmp;

		}

		if (client_hostname && !nm_sd_hostname_is_valid (client_hostname, FALSE))

			client_hostname = NULL;

		if (client_hostname) {

			g_free (reader->hostname);

			reader->hostname = g_strdup (client_hostname);

		}

		/* <ifname>:{none|off|dhcp|on|any|dhcp6|auto6|ibft} */

		kind = get_word (&argument, ':');

		tmp = get_word (&argument, ':');

		dns_addr_family[0] = guess_ip_address_family (tmp);

		if (dns_addr_family[0] != AF_UNSPEC) {

			dns[0] = tmp;

			dns[1] = get_word (&argument, ':');

			dns_addr_family[1] = guess_ip_address_family (dns[1]);

			if (*argument)

				_LOGW (LOGD_CORE, "Ignoring extra: '%s'.", argument);

		} else {

			mtu = tmp;

			macaddr = argument;

		}

	}

	if (   iface_spec == NULL

	    && NM_IN_STRSET (kind, "fw", "ibft")) {

		reader_read_all_connections_from_fw (reader, sysfs_dir);

		return;

	}

	/* Parsing done, construct the NMConnection. */

	if (iface_spec)

		connection = reader_get_connection (reader, iface_spec, NULL, TRUE);

	else

		connection = reader_get_default_connection (reader);

	s_ip4 = nm_connection_get_setting_ip4_config (connection);

	s_ip6 = nm_connection_get_setting_ip6_config (connection);

	if (netmask && *netmask) {

		gboolean is_ipv4 = client_ip_family == AF_INET;

		NMIPAddr addr;

		if (is_ipv4 && nm_utils_parse_inaddr_bin (AF_INET, netmask, NULL, &addr))

			client_ip_prefix = nm_utils_ip4_netmask_to_prefix (addr.addr4);

		else

			client_ip_prefix = _nm_utils_ascii_str_to_int64 (netmask, 10, 0, is_ipv4 ? 32 : 128, -1);

		if (client_ip_prefix == -1)

			_LOGW (LOGD_CORE, "Invalid IP mask: %s", netmask);

	}

	/* Static IP configuration might be present. */

	if (client_ip && *client_ip) {

		NMIPAddress *address = NULL;

		NMIPAddr addr;

		if (nm_utils_parse_inaddr_prefix_bin (client_ip_family, client_ip, NULL, &addr,

		                                      client_ip_prefix == -1 ? &client_ip_prefix : NULL)) {

			if (client_ip_prefix == -1) {

				switch (client_ip_family) {

				case AF_INET:

					client_ip_prefix = _nm_utils_ip4_get_default_prefix (addr.addr4);

					break;

				case AF_INET6:

					client_ip_prefix = 64;

					break;

				}

			}

			address = nm_ip_address_new_binary (client_ip_family, &addr.addr_ptr, client_ip_prefix, &error);

			if (!address) {

				_LOGW (LOGD_CORE, "Invalid address '%s': %s", client_ip, error->message);

				g_clear_error (&error);

			}

		} else {

			_LOGW (LOGD_CORE, "Unrecognized address: %s", client_ip);

		}

		if (address) {

			switch (client_ip_family) {

			case AF_INET:

				g_object_set (s_ip4,

				              NM_SETTING_IP_CONFIG_METHOD, NM_SETTING_IP4_CONFIG_METHOD_MANUAL,

				              NM_SETTING_IP_CONFIG_MAY_FAIL, FALSE,

				              NULL);

				nm_setting_ip_config_add_address (s_ip4, address);

				break;

			case AF_INET6:

				g_object_set (s_ip6,

				              NM_SETTING_IP_CONFIG_METHOD, NM_SETTING_IP4_CONFIG_METHOD_MANUAL,

				              NM_SETTING_IP_CONFIG_MAY_FAIL, FALSE,

				              NULL);

				nm_setting_ip_config_add_address (s_ip6, address);

				break;

			default:

				_LOGW (LOGD_CORE, "Unknown address family: %s", client_ip);

				break;

			}

			nm_ip_address_unref (address);

		}

	}

	/* Dynamic IP configuration configured explicitly. */

	if (NM_IN_STRSET (kind, "none", "off")) {

		if (nm_setting_ip_config_get_num_addresses (s_ip6) == 0) {

			g_object_set (s_ip6,

			              NM_SETTING_IP_CONFIG_METHOD, NM_SETTING_IP6_CONFIG_METHOD_AUTO,

			              NULL);

		}

		if (nm_setting_ip_config_get_num_addresses (s_ip4) == 0) {

			g_object_set (s_ip4,

			              NM_SETTING_IP_CONFIG_METHOD, NM_SETTING_IP4_CONFIG_METHOD_DISABLED,

			              NULL);

		}

	} else if (nm_streq0 (kind, "dhcp")) {

		g_object_set (s_ip4,

		              NM_SETTING_IP_CONFIG_METHOD, NM_SETTING_IP4_CONFIG_METHOD_AUTO,

		              NM_SETTING_IP_CONFIG_MAY_FAIL, FALSE,

		              NULL);

		if (nm_setting_ip_config_get_num_addresses (s_ip6) == 0) {

			g_object_set (s_ip6,

			              NM_SETTING_IP_CONFIG_METHOD, NM_SETTING_IP6_CONFIG_METHOD_AUTO,

			              NULL);

		}

	} else if (NM_IN_STRSET (kind, "auto6", "dhcp6")) {

		g_object_set (s_ip4,

		              NM_SETTING_IP_CONFIG_MAY_FAIL, FALSE,

		              NULL);

		if (nm_setting_ip_config_get_num_addresses (s_ip4) == 0) {

			g_object_set (s_ip4,

			              NM_SETTING_IP_CONFIG_METHOD, NM_SETTING_IP4_CONFIG_METHOD_DISABLED,

			              NULL);

		}

	} else if (nm_streq0 (kind, "ibft")) {

		NMSettingWired *s_wired;

		const char *mac = NULL;

		const char *ifname;

		gs_free char *mac_free = NULL;

		gs_free char *address_path = NULL;

		GHashTable *nic = NULL;

		if (   (s_wired = nm_connection_get_setting_wired (connection))

		    && (mac = nm_setting_wired_get_mac_address (s_wired))) {

			/* got mac from the connection */

		} else if ((ifname = nm_connection_get_interface_name (connection))) {

			/* read it from sysfs */

			address_path = g_build_filename (sysfs_dir, "class", "net", ifname, "address", NULL);

			if (g_file_get_contents (address_path, &mac_free, NULL, &error)) {

				g_strchomp (mac_free);

				mac = mac_free;

			} else {

				_LOGW (LOGD_CORE, "Can't get a MAC address for %s: %s", ifname, error->message);

				g_clear_error (&error);

			}

		}

		if (mac) {

			gs_free char *mac_up = NULL;

			mac_up = g_ascii_strup (mac, -1);

			ibft = nmi_ibft_read (sysfs_dir);

			nic = g_hash_table_lookup (ibft, mac_up);

			if (!nic)

				_LOGW (LOGD_CORE, "No iBFT NIC for %s (%s)", iface_spec, mac_up);

		}

		if (nic) {

			if (!nmi_ibft_update_connection_from_nic (connection, nic, &error)) {

				_LOGW (LOGD_CORE, "Unable to merge iBFT configuration: %s", error->message);

				g_clear_error (&error);

			}

		}

	}

	if (peer && *peer)

		_LOGW (LOGD_CORE, "Ignoring peer: %s (not implemented)\n", peer);

	if (gateway_ip && *gateway_ip) {

		int addr_family = guess_ip_address_family (gateway_ip);

		if (nm_utils_ipaddr_is_valid (addr_family, gateway_ip)) {

			switch (addr_family) {

			case AF_INET:

				g_object_set (s_ip4, NM_SETTING_IP_CONFIG_GATEWAY, gateway_ip, NULL);

				break;

			case AF_INET6:

				g_object_set (s_ip6, NM_SETTING_IP_CONFIG_GATEWAY, gateway_ip, NULL);

				break;

			default:

				_LOGW (LOGD_CORE, "Unknown address family: %s", gateway_ip);

				break;

			}

		} else {

			_LOGW (LOGD_CORE, "Invalid gateway: %s", gateway_ip);

		}

	}

	if (client_hostname && *client_hostname) {

		g_object_set (s_ip4, NM_SETTING_IP_CONFIG_DHCP_HOSTNAME, client_hostname, NULL);

		g_object_set (s_ip6, NM_SETTING_IP_CONFIG_DHCP_HOSTNAME, client_hostname, NULL);

	}

	for (i = 0; i < 2; i++) {

		if (dns_addr_family[i] == AF_UNSPEC)

			break;

		if (nm_utils_ipaddr_is_valid (dns_addr_family[i], dns[i])) {

			switch (dns_addr_family[i]) {

			case AF_INET:

				nm_setting_ip_config_add_dns (s_ip4, dns[i]);

				break;

			case AF_INET6:

				nm_setting_ip_config_add_dns (s_ip6, dns[i]);

				break;

			default:

				_LOGW (LOGD_CORE, "Unknown address family: %s", dns[i]);

				break;

			}

		} else {

			_LOGW (LOGD_CORE, "Invalid name server: %s", dns[i]);

		}

	}

	if (mtu && *mtu)

		connection_set (connection, NM_SETTING_WIRED_SETTING_NAME, NM_SETTING_WIRED_MTU, mtu);

	if (macaddr && *macaddr)

		connection_set (connection, NM_SETTING_WIRED_SETTING_NAME, NM_SETTING_WIRED_CLONED_MAC_ADDRESS, macaddr);

}

static void

reader_parse_master (Reader *reader,

                     char *argument,

                     const char *type_name,

                     const char *default_name)

{

	NMConnection *connection;

	NMSettingConnection *s_con;

	gs_free char *master_to_free = NULL;

	const char *master;

	char *slaves;

	const char *slave;

	char *opts;

	char *opt;

	const char *opt_name;

	const char *mtu = NULL;

	master = get_word (&argument, ':');

	if (!master)

		master = master_to_free = g_strdup_printf ("%s0", default_name ?: type_name);

	slaves = get_word (&argument, ':');

	connection = reader_get_connection (reader, master, type_name, TRUE);

	s_con = nm_connection_get_setting_connection (connection);

	master = nm_setting_connection_get_uuid (s_con);

	if (nm_streq (type_name, NM_SETTING_BRIDGE_SETTING_NAME)) {

		NMSettingBridge *s_bridge = nm_connection_get_setting_bridge (connection);

		/* Avoid the forwarding delay */

		g_object_set (s_bridge,

		              NM_SETTING_BRIDGE_STP, FALSE,

		              NULL);

	} else if (nm_streq (type_name, NM_SETTING_BOND_SETTING_NAME)) {

		NMSettingBond *s_bond = nm_connection_get_setting_bond (connection);

		opts = get_word (&argument, ':');

		while (opts && *opts) {

			opt = get_word (&opts, ',');

			opt_name = get_word (&opt, '=');

			nm_setting_bond_add_option (s_bond, opt_name, opt);

		}

		mtu = get_word (&argument, ':');

	}

	do {

		slave = get_word (&slaves, ',');

		if (slave == NULL)

			slave = "eth0";

		connection = reader_get_connection (reader, slave, NULL, TRUE);

		s_con = nm_connection_get_setting_connection (connection);

		g_object_set (s_con,

		              NM_SETTING_CONNECTION_SLAVE_TYPE, type_name,

		              NM_SETTING_CONNECTION_MASTER, master,

		              NULL);

		if (mtu)

			connection_set (connection, NM_SETTING_WIRED_SETTING_NAME, NM_SETTING_WIRED_MTU, mtu);

	} while (slaves && *slaves != '\0');

	if (argument && *argument)

		_LOGW (LOGD_CORE, "Ignoring extra: '%s'.", argument);

}

static void

reader_add_routes (Reader *reader, GPtrArray *array)

{

	guint i;

	for (i = 0; i < array->len; i++) {

		NMConnection *connection = NULL;

		const char *net;

		const char *gateway;

		const char *interface;

		int family = AF_UNSPEC;

		NMIPAddr net_addr = { };

		NMIPAddr gateway_addr = { };

		int net_prefix = -1;

		NMIPRoute *route;

		NMSettingIPConfig *s_ip;

		char *argument;

		gs_free_error GError *error = NULL;

		argument = array->pdata[i];

		net = get_word (&argument, ':');

		gateway = get_word (&argument, ':');

		interface = get_word (&argument, ':');

		if (interface)

			connection = reader_get_connection (reader, interface, NULL, TRUE);

		if (!connection)

			connection = reader->bootdev_connection;

		if (!connection)

			connection = reader_get_connection (reader, interface, NULL, FALSE);

		if (!connection)

			connection = reader_get_default_connection (reader);

		if (net && *net) {

			if (!nm_utils_parse_inaddr_prefix_bin (family, net, &family, &net_addr, &net_prefix)) {

				_LOGW (LOGD_CORE, "Unrecognized address: %s", net);

				continue;

			}

		}

		if (gateway && *gateway) {

			if (!nm_utils_parse_inaddr_bin (family, gateway, &family, &gateway_addr)) {

				_LOGW (LOGD_CORE, "Unrecognized address: %s", gateway);

				continue;

			}

		}

		switch (family) {

		case AF_INET:

			s_ip = nm_connection_get_setting_ip4_config (connection);

			if (net_prefix == -1)

				net_prefix = 32;

			break;

		case AF_INET6:

			s_ip = nm_connection_get_setting_ip6_config (connection);

			if (net_prefix == -1)

				net_prefix = 128;

			break;

		default:

			_LOGW (LOGD_CORE, "Unknown address family: %s", net);

			continue;

		}

		route = nm_ip_route_new_binary (family, &net_addr.addr_ptr, net_prefix, &gateway_addr.addr_ptr, -1, &error);

		if (!route) {

			g_warning ("Invalid route '%s via %s': %s\n", net, gateway, error->message);

			continue;

		}

		nm_setting_ip_config_add_route (s_ip, route);

		nm_ip_route_unref (route);

	}

}

static void

reader_parse_vlan (Reader *reader, char *argument)

{

	NMConnection *connection;

	NMSettingVlan *s_vlan;

	const char *vlan;

	const char *phy;

	const char *vlanid;

	vlan = get_word (&argument, ':');

	phy = get_word (&argument, ':');

	for (vlanid = vlan + strlen (vlan); vlanid > vlan; vlanid--) {

		if (!g_ascii_isdigit (*(vlanid - 1)))

			break;

	}

	connection = reader_get_connection (reader, vlan, NM_SETTING_VLAN_SETTING_NAME, TRUE);

	s_vlan = nm_connection_get_setting_vlan (connection);

	g_object_set (s_vlan,

	              NM_SETTING_VLAN_PARENT, phy,

	              NM_SETTING_VLAN_ID, (guint) _nm_utils_ascii_str_to_int64 (vlanid, 10, 0, G_MAXUINT, G_MAXUINT),

	              NULL);

	if (argument && *argument)

		_LOGW (LOGD_CORE, "Ignoring extra: '%s'.", argument);

}

static void

reader_parse_rd_znet (Reader *reader, char *argument, gboolean net_ifnames)

{

	const char *nettype;

	const char *subchannels[4] = { 0, 0, 0, 0 };

	const char *tmp;

	gs_free char *ifname = NULL;

	const char *prefix;

	NMConnection *connection;

	NMSettingWired *s_wired;

	static int count_ctc = 0;

	static int count_eth = 0;

	int index;

	nettype = get_word (&argument, ',');

	subchannels[0] = get_word (&argument, ',');

	subchannels[1] = get_word (&argument, ',');

	if (nm_streq0 (nettype, "ctc")) {

		if (net_ifnames == TRUE) {

			prefix = "sl";

		} else {

			prefix = "ctc";

			index = count_ctc++;

		}

	} else {

		subchannels[2] = get_word (&argument, ',');

		if (net_ifnames == TRUE) {

			prefix = "en";

		} else {

			prefix = "eth";

			index = count_eth++;

		}

	}

	if (net_ifnames == TRUE) {

		const char *bus_id;

		size_t bus_id_len;

		size_t bus_id_start;

		/* The following logic is taken from names_ccw() in systemd/src/udev/udev-builtin-net_id.c */

		bus_id = subchannels[0];

		bus_id_len = strlen (bus_id);

		bus_id_start = strspn (bus_id, ".0");

		bus_id += bus_id_start < bus_id_len ? bus_id_start : bus_id_len - 1;

		ifname = g_strdup_printf ("%sc%s", prefix, bus_id);

	} else {

		ifname = g_strdup_printf ("%s%d", prefix, index);

	}

	connection = reader_get_connection (reader, ifname, NM_SETTING_WIRED_SETTING_NAME, FALSE);

	if (!connection)

		return;

	s_wired = nm_connection_get_setting_wired (connection);

	g_object_set (s_wired,

	              NM_SETTING_WIRED_S390_NETTYPE, nettype,

	              NM_SETTING_WIRED_S390_SUBCHANNELS, &subchannels,

	              NULL);

	while ((tmp = get_word (&argument, ',')) != NULL) {

		char *val;

		val = strchr (tmp, '=');

		if (val) {

			gs_free char *key = NULL;

			key = g_strndup (tmp, val - tmp);

			val[0] = '\0';

			val++;

			nm_setting_wired_add_s390_option (s_wired, key, val);

		}

	}

}

static void

_normalize_conn (gpointer key, gpointer value, gpointer user_data)

{

	NMConnection *connection = value;