lib/nwamd/llp.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * This file is here for legacy support.
 */

#include <atomic.h>
#include <ctype.h>
#include <errno.h>
#include <limits.h>
#include <libdllink.h>
#include <libscf.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>

#include <libnwam.h>
#include "known_wlans.h"
#include "llp.h"
#include "ncu.h"
#include "util.h"

/*
 * This file formerly contained the routines that manipulate Link Layer
 * Profiles (aka LLPs) and various support functions.  Now only code
 * necessary for parsing the legacy /etc/nwam/llp file on upgrade is included,
 * since this legacy configuration needs to be translated into the User NCP.
 */

#define	OUR_OLD_DHCP_WAIT_TIME_PROP_NAME	"dhcp_wait_time"
#define	OUR_OLD_USE_NET_SVC_PROP_NAME		"use_net_svc"
#define	OUR_OLD_IDLE_TIME_PROP_NAME		"idle_time"

static struct qelem llp_list;

/*
 * Global variable to hold the highest priority.  Need to use the atomic
 * integer arithmetic functions to update it.
 */
static uint32_t llp_highest_pri;

/* Specifies if static address has been configured in /etc/nwam/llp */
static boolean_t static_configured = B_FALSE;

static enum interface_type
find_if_type(const char *name)
{
	uint32_t media;
	enum interface_type type;

	if (name == NULL) {
		nlog(LOG_DEBUG, "find_if_type: no ifname; "
		    "returning IF_UNKNOWN");
		return (IF_UNKNOWN);
	}

	type = IF_WIRED;
	if (dladm_name2info(dld_handle, name, NULL, NULL, NULL, &media) !=
	    DLADM_STATUS_OK) {
		if (strncmp(name, "ip.tun", 6) == 0 ||
		    strncmp(name, "ip6.tun", 7) == 0 ||
		    strncmp(name, "ip.6to4tun", 10) == 0)
			/*
			 * We'll need to update our tunnel detection once
			 * the clearview/tun project is integrated; tunnel
			 * names won't necessarily be ip.tunN.
			 */
			type = IF_TUN;
	} else if (media == DL_WIFI) {
		type = IF_WIRELESS;
	}

	return (type);
}

static void
llp_list_free(void)
{
	llp_t *llp;

	while (llp_list.q_forw != &llp_list) {
		llp = (llp_t *)llp_list.q_forw;
		remque(&llp->llp_links);
		free(llp->llp_ipv6addrstr);
		free(llp->llp_ipv4addrstr);
		free(llp);
	}
}

static void
initialize_llp(void)
{
	llp_list.q_forw = llp_list.q_back = &llp_list;
}

static llp_t *
llp_lookup(const char *link)
{
	llp_t *llp;

	if (link == NULL)
		return (NULL);

	for (llp = (llp_t *)llp_list.q_forw; llp != (llp_t *)&llp_list;
	    llp = (llp_t *)llp->llp_links.q_forw) {
		if (strcmp(link, llp->llp_lname) == 0)
			break;
	}
	if (llp == (llp_t *)&llp_list)
		llp = NULL;
	return (llp);
}

/*
 * Create the named LLP with default settings.  Called only in main thread.
 */
static llp_t *
llp_add(const char *name)
{
	llp_t *llp;

	if ((llp = calloc(1, sizeof (llp_t))) == NULL) {
		nlog(LOG_ERR, "llp_add: cannot allocate LLP: %m");
		return (NULL);
	}

	if (strlcpy(llp->llp_lname, name, sizeof (llp->llp_lname)) >=
	    sizeof (llp->llp_lname)) {
		nlog(LOG_ERR, "llp_add: linkname '%s' too long; ignoring entry",
		    name);
		free(llp);
		return (NULL);
	}

	llp->llp_fileorder = llp->llp_pri =
	    atomic_add_32_nv(&llp_highest_pri, 1);
	llp->llp_ipv4src = IPV4SRC_DHCP;
	llp->llp_type = find_if_type(llp->llp_lname);
	llp->llp_ipv6onlink = B_TRUE;

	/*
	 * should be a no-op, but for now, make sure we only
	 * create llps for wired and wireless interfaces.
	 */
	if (llp->llp_type != IF_WIRED && llp->llp_type != IF_WIRELESS) {
		nlog(LOG_ERR, "llp_add: wrong type of interface for %s", name);
		free(llp);
		return (NULL);
	}
	insque(&llp->llp_links, llp_list.q_back);

	nlog(LOG_DEBUG, "llp_add: "
	    "created llp for link %s, priority %d", llp->llp_lname,
	    llp->llp_pri);
	return (llp);
}

static int
parse_llp_config(void)
{
	static const char STATICSTR[] = "static";
	static const char DHCP[] = "dhcp";
	static const char IPV6[] = "ipv6";
	static const char NOIPV6[] = "noipv6";
	static const char PRIORITY[] = "priority";
	FILE *fp;
	char line[LINE_MAX];
	char *cp, *lasts, *lstr, *srcstr, *addrstr;
	int lnum;
	llp_t *llp;

	initialize_llp();

	fp = fopen(LLPFILE, "r+");
	if (fp == NULL) {
		if (errno == ENOENT)
			return (errno);
		nlog(LOG_ERR, "parse_llp_config: "
		    "open legacy LLP config file: %m");
		return (-1);
	}

	for (lnum = 1; fgets(line, sizeof (line), fp) != NULL; lnum++) {
		if (line[strlen(line) - 1] == '\n')
			line[strlen(line) - 1] = '\0';

		cp = line;
		while (isspace(*cp))
			cp++;

		if (*cp == '#' || *cp == '\0')
			continue;

		nlog(LOG_DEBUG, "parse_llp_config: "
		    "parsing legacy LLP conf file line %d...", lnum);

		if (((lstr = strtok_r(cp, " \t", &lasts)) == NULL) ||
		    ((srcstr = strtok_r(NULL, " \t", &lasts)) == NULL)) {
			nlog(LOG_ERR, "parse_llp_config: line %d: "
			    "not enough tokens; ignoring entry", lnum);
			continue;
		}

		if ((llp = llp_lookup(lstr)) == NULL &&
		    (llp = llp_add(lstr)) == NULL) {
			nlog(LOG_ERR, "parse_llp_config: line %d: "
			    "cannot add entry", lnum);
			continue;
		}

		if (strcasecmp(srcstr, STATICSTR) == 0) {
			if ((addrstr = strtok_r(NULL, " \t", &lasts)) == NULL ||
			    atoi(addrstr) == 0) { /* crude check for number */
				nlog(LOG_ERR, "parse_llp_config: line %d: "
				    "missing ipaddr for static config", lnum);
			} else if ((addrstr = strdup(addrstr)) == NULL) {
				nlog(LOG_ERR, "parse_llp_config: line %d: "
				    "cannot save address", lnum);
			} else {
				free(llp->llp_ipv4addrstr);
				llp->llp_ipv4src = IPV4SRC_STATIC;
				llp->llp_ipv4addrstr = addrstr;
			}

		} else if (strcasecmp(srcstr, DHCP) == 0) {
			llp->llp_ipv4src = IPV4SRC_DHCP;

		} else if (strcasecmp(srcstr, IPV6) == 0) {
			llp->llp_ipv6onlink = B_TRUE;
			if ((addrstr = strtok_r(NULL, " \t", &lasts)) == NULL) {
				(void) 0;
			} else if ((addrstr = strdup(addrstr)) == NULL) {
				nlog(LOG_ERR, "parse_llp_config: line %d: "
				    "cannot save address", lnum);
			} else {
				free(llp->llp_ipv6addrstr);
				llp->llp_ipv6addrstr = addrstr;
			}

		} else if (strcasecmp(srcstr, NOIPV6) == 0) {
			llp->llp_ipv6onlink = B_FALSE;

		} else if (strcasecmp(srcstr, PRIORITY) == 0) {
			if ((addrstr = strtok_r(NULL, " \t", &lasts)) == NULL) {
				nlog(LOG_ERR,
				    "parse_llp_config: line %d: "
				    "missing priority value", lnum);
			} else {
				llp->llp_pri = atoi(addrstr);
			}

		} else {
			nlog(LOG_ERR, "parse_llp_config: line %d: "
			    "unrecognized field '%s'", lnum, srcstr);
		}
	}

	(void) fclose(fp);
	return (0);
}

/*
 * Translate legacy LLP config into the user NCP.
 */
static int
upgrade_llp_config(void)
{
	llp_t *wp;
	nwam_ncp_handle_t user_ncp;
	nwam_ncu_handle_t phys_ncu = NULL, ip_ncu = NULL;
	nwam_error_t err;
	uint64_t uintval;
	char *strval;
	const char *prop;

	switch (parse_llp_config()) {
	case -1:
		return (0);
	case ENOENT:
		return (ENOENT);
	default:
		break;
	}

	err = nwam_ncp_create(NWAM_NCP_NAME_USER, 0, &user_ncp);
	switch (err) {
	case NWAM_SUCCESS:
		break;
	case NWAM_ERROR_BIND:
	case NWAM_ERROR_INTERNAL:
		nlog(LOG_ERR, "upgrade_llp_config: "
		    "could not create User NCP: %s", nwam_strerror(err));
		llp_list_free();
		return (EAGAIN);
	default:
		nlog(LOG_ERR, "upgrade_llp_config: error creating User NCP: %s",
		    nwam_strerror(err));
		llp_list_free();
		return (0);
	}

	nlog(LOG_DEBUG, "upgrade_llp_config: walking llp list");

	for (wp = (llp_t *)llp_list.q_forw; wp != (llp_t *)&llp_list;
	    wp = (llp_t *)wp->llp_links.q_forw) {

		nlog(LOG_DEBUG, "upgrade_llp_config: "
		    "upgrading llp %s", wp->llp_lname);

		if (nwam_ncu_create(user_ncp, wp->llp_lname,
		    NWAM_NCU_TYPE_INTERFACE, NWAM_NCU_CLASS_IP, &ip_ncu)
		    != NWAM_SUCCESS ||
		    nwam_ncu_create(user_ncp, wp->llp_lname, NWAM_NCU_TYPE_LINK,
		    NWAM_NCU_CLASS_PHYS, &phys_ncu) != NWAM_SUCCESS) {
			nlog(LOG_ERR, "upgrade_llp_config: llp %s: "
			    "could not create NCUs: %s", wp->llp_lname,
			    nwam_strerror(err));
			break;
		}

		/* Link NCU properties */
		prop = NWAM_NCU_PROP_ACTIVATION_MODE;
		uintval = NWAM_ACTIVATION_MODE_PRIORITIZED;
		if ((err = nwamd_set_ncu_uint(phys_ncu, &uintval, 1, prop))
		    != NWAM_SUCCESS)
			break;

		prop = NWAM_NCU_PROP_PRIORITY_MODE;
		uintval = NWAM_PRIORITY_MODE_EXCLUSIVE;
		if ((err = nwamd_set_ncu_uint(phys_ncu, &uintval, 1, prop))
		    != NWAM_SUCCESS)
			break;

		prop = NWAM_NCU_PROP_PRIORITY_GROUP;
		uintval = wp->llp_pri;
		if ((err = nwamd_set_ncu_uint(phys_ncu, &uintval, 1, prop))
		    != NWAM_SUCCESS)
			break;

		/* IP NCU properties */
		if (wp->llp_ipv4addrstr != NULL) {
			/* Set v4 address and specify static addrsrc */
			prop = NWAM_NCU_PROP_IPV4_ADDRSRC;
			uintval = NWAM_ADDRSRC_STATIC;
			if ((err = nwamd_set_ncu_uint(ip_ncu, &uintval, 1,
			    prop)) != NWAM_SUCCESS)
				break;

			prop = NWAM_NCU_PROP_IPV4_ADDR;
			strval = wp->llp_ipv4addrstr;
			if ((err = nwamd_set_ncu_string(ip_ncu, &strval, 1,
			    prop)) != NWAM_SUCCESS)
				break;

			static_configured = B_TRUE;
		}

		if (wp->llp_ipv6addrstr != NULL) {
			/* Set v6 address and specify static addrsrc */
			prop = NWAM_NCU_PROP_IPV6_ADDRSRC;
			uintval = NWAM_ADDRSRC_STATIC;
			if ((err = nwamd_set_ncu_uint(ip_ncu, &uintval, 1,
			    prop)) != NWAM_SUCCESS)
				break;

			prop = NWAM_NCU_PROP_IPV6_ADDR;
			strval = wp->llp_ipv6addrstr;
			if ((err = nwamd_set_ncu_string(ip_ncu, &strval, 1,
			    prop)) != NWAM_SUCCESS)
				break;

			static_configured = B_TRUE;
		}

		if (!wp->llp_ipv6onlink) {
			prop = NWAM_NCU_PROP_IP_VERSION;
			uintval = IPV4_VERSION;
			if ((err = nwamd_set_ncu_uint(ip_ncu, &uintval, 1,
			    prop)) != NWAM_SUCCESS)
				break;
		}

		if ((err = nwam_ncu_commit(ip_ncu, 0)) != NWAM_SUCCESS ||
		    (err = nwam_ncu_commit(phys_ncu, 0)) != NWAM_SUCCESS) {
			nlog(LOG_ERR, "upgrade_llp_config: llp %s: "
			    "could not commit NCUs: %s", wp->llp_lname,
			    nwam_strerror(err));
			/* Schedule a retry - root filesystem may be readonly */
			llp_list_free();
			nwam_ncu_free(ip_ncu);
			nwam_ncu_free(phys_ncu);
			(void) nwam_ncp_destroy(user_ncp, 0);
			return (EAGAIN);
		}
	}

	if (err != NWAM_SUCCESS) {
		nlog(LOG_ERR, "upgrade_llp_config: llp %s: "
		    "could not set value for property %s: %s", wp->llp_lname,
		    prop, nwam_strerror(err));
	}
	llp_list_free();
	nwam_ncu_free(ip_ncu);
	nwam_ncu_free(phys_ncu);
	nwam_ncp_free(user_ncp);
	return (0);
}

/*
 * Upgrade legacy llp and known_wifi_nets files. Note - it is possible that
 * the root filesystem is not writable at this point, so we need to schedule
 * a retry of the upgrade operation in the event that committing the new
 * config fails.
 */
/* ARGSUSED0 */
void
nwamd_handle_upgrade(nwamd_event_t event)
{
	nwamd_event_t upgrade_event;
	uint64_t dhcp_wait_time, idle_time;
	boolean_t use_net_svc;

	switch (upgrade_llp_config()) {
	case -1:
	case ENOENT:
		/* Nothing readable to upgrade */
		break;
	case EAGAIN:
		/*
		 * Schedule retry in NWAMD_READONLY_RETRY_INTERVAL seconds
		 * as root fs may be readonly.
		 *
		 * The upgrade event is of type NCU, but has no associated
		 * object (we use the event type to map to the appropriate
		 * event/method mappings, so to find the NCU upgrade event
		 * method we specify type NCU while not specifying an
		 * object since all NCUs have to be upgraded.
		 */
		upgrade_event = nwamd_event_init(NWAM_EVENT_TYPE_UPGRADE,
		    NWAM_OBJECT_TYPE_NCP, 0, NULL);
		if (upgrade_event == NULL) {
			nlog(LOG_ERR, "nwamd_handle_upgrade: "
			    "could not create retry event to upgrade "
			    "%s configuration", LLPFILE);
			return;
		}
		nwamd_event_enqueue_timed(upgrade_event,
		    NWAMD_READONLY_RETRY_INTERVAL);
		return;
	default:
		break;
	}

	/*
	 * If static_configured is set, then at least one static address is
	 * configured in /etc/nwam/llp.  Enable the User NCP in this case.
	 */
	if (static_configured) {
		nlog(LOG_DEBUG, "nwamd_handle_upgrade: "
		    "static address configured, enabling User NCP");
		(void) pthread_mutex_lock(&active_ncp_mutex);
		(void) strlcpy(active_ncp, NWAM_NCP_NAME_USER,
		    NWAM_MAX_NAME_LEN);
		(void) pthread_mutex_unlock(&active_ncp_mutex);
	}

	/* upgrade /etc/nwam/known_wifi_nets */
	upgrade_known_wifi_nets_config();

	/*
	 * SMF property nwamd/dhcp_wait_time in Phase 0/0.5 has been
	 * replaced by nwamd/ncu_wait_time property.  If the dhcp_wait_time
	 * property exists (which means it has been changed by the user),
	 * set its value to ncu_wait_time and remove the property.
	 */
	if (nwamd_lookup_count_property(OUR_FMRI, OUR_PG,
	    OUR_OLD_DHCP_WAIT_TIME_PROP_NAME, &dhcp_wait_time) == 0) {
		(void) nwamd_set_count_property(OUR_FMRI, OUR_PG,
		    OUR_NCU_WAIT_TIME_PROP_NAME, dhcp_wait_time);
		(void) nwamd_delete_scf_property(OUR_FMRI, OUR_PG,
		    OUR_OLD_DHCP_WAIT_TIME_PROP_NAME);
		nlog(LOG_DEBUG, "nwamd_handle_upgrade: "
		    "converted '%s' to '%s' with value of %lld",
		    OUR_OLD_DHCP_WAIT_TIME_PROP_NAME,
		    OUR_NCU_WAIT_TIME_PROP_NAME, dhcp_wait_time);
	}

	/*
	 * If the user has changed Phase 0/0.5 properties that don't exist in
	 * Phase 1, manifest-import reports a warning; but those properties are
	 * not removed.  nwamd/use_net_svc and nwamd/idle_time are two
	 * properties that don't exist in Phase 1.  If they exist, remove them.
	 */
	if (nwamd_lookup_count_property(OUR_FMRI, OUR_PG,
	    OUR_OLD_IDLE_TIME_PROP_NAME, &idle_time) == 0) {
		(void) nwamd_delete_scf_property(OUR_FMRI, OUR_PG,
		    OUR_OLD_IDLE_TIME_PROP_NAME);
	}
	if (nwamd_lookup_boolean_property(OUR_FMRI, OUR_PG,
	    OUR_OLD_USE_NET_SVC_PROP_NAME, &use_net_svc) == 0) {
		(void) nwamd_delete_scf_property(OUR_FMRI, OUR_PG,
		    OUR_OLD_USE_NET_SVC_PROP_NAME);
	}

	nlog(LOG_DEBUG, "nwamd_handle_upgrade: "
	    "creating version property, setting to 1\n");
	(void) nwamd_set_count_property(OUR_FMRI, OUR_PG,
	    OUR_VERSION_PROP_NAME, 1U);
	(void) smf_refresh_instance(OUR_FMRI);
}