lib/nwamd/conditions.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) 2010, Oracle and/or its affiliates. All rights reserved.
 */

#include <arpa/inet.h>
#include <ctype.h>
#include <errno.h>
#include <inet/ip.h>
#include <libdladm.h>
#include <libdllink.h>
#include <libdlwlan.h>
#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <libnwam.h>
#include "conditions.h"
#include "ncu.h"
#include "objects.h"
#include "util.h"

/*
 * conditions.c - contains routines which check state to see if activation
 * conditions for NWAM objects are satisfied and rates activation conditions to
 * help determine which is most specific.
 *
 * If the activation-mode is CONDITIONAL_ANY or CONDITIONAL_ALL, the conditions
 * property is set to a string made up of conditional expressions. Each
 * expression is made up of a condition that can be assigned a boolean value,
 * e.g. "system-domain is sun.com" or "ncu ip:bge0 is-not active". If the
 * activation-mode is CONDITIONAL_ANY, the condition will be satisfied if any
 * one of the conditions is true; if the activation-mode is CONDITIONAL_ALL,
 * the condition is satisfied only if all of the conditions are true.
 */

uint64_t condition_check_interval = CONDITION_CHECK_INTERVAL_DEFAULT;

extern int getdomainname(char *, int);

/* NCP, NCU, ENM and location conditions */
static boolean_t test_condition_ncp(nwam_condition_t condition,
    const char *ncp_name);
static boolean_t test_condition_ncu(nwam_condition_t condition,
    const char *ncu_name);
static boolean_t test_condition_enm(nwam_condition_t condition,
    const char *enm_name);
static boolean_t test_condition_loc(nwam_condition_t condition,
    const char *loc_name);

/* IP address conditions */
static boolean_t test_condition_ip_address(nwam_condition_t condition,
    const char *ip_address);

/* domainname conditions */
static boolean_t test_condition_sys_domain(nwam_condition_t condition,
    const char *domainname);
static boolean_t test_condition_adv_domain(nwam_condition_t condition,
    const char *domainname);

/*  WLAN conditions */
static boolean_t test_condition_wireless_essid(nwam_condition_t condition,
    const char *essid);
static boolean_t test_condition_wireless_bssid(nwam_condition_t condition,
    const char *essid);

struct nwamd_condition_map {
	nwam_condition_object_type_t object_type;
	boolean_t (*condition_func)(nwam_condition_t, const char *);
} condition_map[] =
{
	{ NWAM_CONDITION_OBJECT_TYPE_NCP, test_condition_ncp },
	{ NWAM_CONDITION_OBJECT_TYPE_NCU, test_condition_ncu },
	{ NWAM_CONDITION_OBJECT_TYPE_ENM, test_condition_enm },
	{ NWAM_CONDITION_OBJECT_TYPE_LOC, test_condition_loc },
	{ NWAM_CONDITION_OBJECT_TYPE_IP_ADDRESS, test_condition_ip_address },
	{ NWAM_CONDITION_OBJECT_TYPE_SYS_DOMAIN, test_condition_sys_domain },
	{ NWAM_CONDITION_OBJECT_TYPE_ADV_DOMAIN, test_condition_adv_domain },
	{ NWAM_CONDITION_OBJECT_TYPE_ESSID, test_condition_wireless_essid },
	{ NWAM_CONDITION_OBJECT_TYPE_BSSID, test_condition_wireless_bssid }
};

/*
 * This function takes which kind of conditions (is or is not) we are testing
 * the object against and an object and applies the conditon to the object.
 */
static boolean_t
test_condition_object_state(nwam_condition_t condition,
    nwam_object_type_t object_type, const char *object_name)
{
	nwamd_object_t object;
	nwam_state_t state;

	object = nwamd_object_find(object_type, object_name);
	if (object == NULL)
		return (B_FALSE);

	state = object->nwamd_object_state;
	nwamd_object_release(object);

	switch (condition) {
	case NWAM_CONDITION_IS:
		return (state == NWAM_STATE_ONLINE);
	case NWAM_CONDITION_IS_NOT:
		return (state != NWAM_STATE_ONLINE);
	default:
		return (B_FALSE);
	}
}

static boolean_t
test_condition_ncp(nwam_condition_t condition, const char *name)
{
	boolean_t active;

	(void) pthread_mutex_lock(&active_ncp_mutex);
	active = (strcasecmp(active_ncp, name) == 0);
	(void) pthread_mutex_unlock(&active_ncp_mutex);

	switch (condition) {
	case NWAM_CONDITION_IS:
		return (active);
	case NWAM_CONDITION_IS_NOT:
		return (active != B_TRUE);
	default:
		return (B_FALSE);
	}
}

static boolean_t
test_condition_ncu(nwam_condition_t condition, const char *name)
{
	char *real_name, *ncu_name;
	nwam_ncu_handle_t ncuh;
	nwam_ncu_type_t ncu_type;
	boolean_t rv;

	/* names are case-insensitive, so get real name from libnwam */
	if (nwam_ncu_read(active_ncph, name, NWAM_NCU_TYPE_INTERFACE, 0, &ncuh)
	    == NWAM_SUCCESS) {
		ncu_type = NWAM_NCU_TYPE_INTERFACE;
	} else if (nwam_ncu_read(active_ncph, name, NWAM_NCU_TYPE_LINK, 0,
	    &ncuh) == NWAM_SUCCESS) {
		ncu_type = NWAM_NCU_TYPE_LINK;
	} else {
		return (B_FALSE);
	}
	if (nwam_ncu_get_name(ncuh, &real_name) != NWAM_SUCCESS) {
		nwam_ncu_free(ncuh);
		return (B_FALSE);
	}
	nwam_ncu_free(ncuh);

	/*
	 * Name may be either unqualified or qualified by NCU type
	 * (interface:/link:).  Need to translate unqualified names
	 * to qualified, specifying interface:name if an interface
	 * NCU is present, otherwise link:ncu.
	 */
	if (nwam_ncu_name_to_typed_name(real_name, ncu_type, &ncu_name)
	    != NWAM_SUCCESS) {
		free(real_name);
		return (B_FALSE);
	}
	free(real_name);

	rv = test_condition_object_state(condition, NWAM_OBJECT_TYPE_NCU,
	    ncu_name);
	free(ncu_name);
	return (rv);
}

static boolean_t
test_condition_enm(nwam_condition_t condition, const char *enm_name)
{
	nwam_enm_handle_t enmh;
	char *real_name;
	boolean_t rv;

	/* names are case-insensitive, so get real name from libnwam */
	if (nwam_enm_read(enm_name, 0, &enmh) != NWAM_SUCCESS)
		return (B_FALSE);
	if (nwam_enm_get_name(enmh, &real_name) != NWAM_SUCCESS) {
		nwam_enm_free(enmh);
		return (B_FALSE);
	}
	nwam_enm_free(enmh);

	rv = test_condition_object_state(condition, NWAM_OBJECT_TYPE_ENM,
	    real_name);
	free(real_name);
	return (rv);
}

static boolean_t
test_condition_loc(nwam_condition_t condition, const char *loc_name)
{
	nwam_loc_handle_t loch;
	char *real_name;
	boolean_t rv;

	/* names are case-insensitive, so get real name from libnwam */
	if (nwam_loc_read(loc_name, 0, &loch) != NWAM_SUCCESS)
		return (B_FALSE);
	if (nwam_loc_get_name(loch, &real_name) != NWAM_SUCCESS) {
		nwam_loc_free(loch);
		return (B_FALSE);
	}
	nwam_loc_free(loch);

	rv = test_condition_object_state(condition, NWAM_OBJECT_TYPE_LOC,
	    real_name);
	free(real_name);
	return (rv);
}

static boolean_t
test_condition_domain(nwam_condition_t condition, const char *target_domain,
    const char *found_domain)
{
	int i, len_t, len_f;
	char target[MAXHOSTNAMELEN], found[MAXHOSTNAMELEN];

	len_t = target_domain == NULL ? 0 : strlen(target_domain);
	len_f = found_domain == NULL ? 0 : strlen(found_domain);

	/* convert target_domain and found_domain to lowercase for strstr() */
	for (i = 0; i < len_t; i++)
		target[i] = tolower(target_domain[i]);
	target[len_t] = '\0';

	for (i = 0; i < len_f; i++)
		found[i] = tolower(found_domain[i]);
	found[len_f] = '\0';

	switch (condition) {
	case NWAM_CONDITION_IS:
		return (found_domain != NULL && strcmp(found, target) == 0);
	case NWAM_CONDITION_IS_NOT:
		return (found_domain == NULL || strcmp(found, target) != 0);
	case NWAM_CONDITION_CONTAINS:
		return (found_domain != NULL && strstr(found, target) != NULL);
	case NWAM_CONDITION_DOES_NOT_CONTAIN:
		return (found_domain == NULL || strstr(found, target) == NULL);
	default:
		return (B_FALSE);
	}
}

struct ncu_adv_domains {
	struct ncu_adv_domains *next;
	char *dns_domain;
	char *nis_domain;
};

static int
get_adv_domains(nwamd_object_t obj, void *arg)
{
	nwamd_ncu_t *ncu = (nwamd_ncu_t *)obj->nwamd_object_data;
	struct ncu_adv_domains **headpp = (struct ncu_adv_domains **)arg;
	struct ncu_adv_domains *adp;
	char *dns, *nis;

	if (ncu->ncu_type != NWAM_NCU_TYPE_INTERFACE)
		return (0);

	dns = nwamd_get_dhcpinfo_data("DNSdmain", ncu->ncu_name);
	nis = nwamd_get_dhcpinfo_data("NISdmain", ncu->ncu_name);

	if (dns != NULL || nis != NULL) {
		adp = (struct ncu_adv_domains *)malloc(sizeof (*adp));
		if (adp == NULL)
			return (1);
		adp->dns_domain = dns;
		adp->nis_domain = nis;
		adp->next = *headpp;
		*headpp = adp;
	}

	return (0);
}

static boolean_t
test_condition_sys_domain(nwam_condition_t condition, const char *domainname)
{
	char cur_domainname[MAXHOSTNAMELEN];

	if (getdomainname(cur_domainname, MAXHOSTNAMELEN) != 0)
		return (B_FALSE);

	return (test_condition_domain(condition, domainname, cur_domainname));
}

static boolean_t
test_condition_adv_domain(nwam_condition_t condition, const char *domainname)
{
	struct ncu_adv_domains *adv_domains = NULL;
	struct ncu_adv_domains *adp, *prev;
	boolean_t positive, rtn;

	(void) nwamd_walk_objects(NWAM_OBJECT_TYPE_NCU, get_adv_domains,
	    &adv_domains);

	positive = (condition == NWAM_CONDITION_IS ||
	    condition == NWAM_CONDITION_CONTAINS);

	/*
	 * Walk the advertised domain list.  Our test function tests one
	 * single domain, but we're dealing with a list: if our condition
	 * is positive ('is' or 'contains'), the test function for each
	 * domain results are or'd together; if our condition is negative
	 * ('is-not' or 'does-not-contain'), the test function results must
	 * be and'd.  Thus our short-circuit exit value depends on our
	 * condition: if the test function returns TRUE it implies immediate
	 * success for a positive condition; if it returns FALSE it implies
	 * immediate failure for a negative condition.
	 */
	adp = adv_domains;
	while (adp != NULL) {
		if ((test_condition_domain(condition, domainname,
		    adp->dns_domain) == positive) ||
		    (test_condition_domain(condition, domainname,
		    adp->nis_domain) == positive)) {
			rtn = positive;
			break;
		}
		adp = adp->next;
	}
	if (adp == NULL) {
		/*
		 * We did not short-circuit; we therefore failed if our
		 * condition was positive, and succeeded if our condition
		 * was negative.
		 */
		rtn = !positive;
	}

	/* now free the domain list */
	adp = adv_domains;
	while (adp != NULL) {
		prev = adp;
		adp = prev->next;
		free(prev->dns_domain);
		free(prev->nis_domain);
		free(prev);
	}

	return (rtn);
}

/*
 * Returns true if prefixlen bits of addr1 match prefixlen bits of addr2.
 */
static boolean_t
prefixmatch(uchar_t *addr1, uchar_t *addr2, int prefixlen)
{
	uchar_t mask[IPV6_ABITS/8];
	int i, j = 0;

	if (prefixlen == 0)
		return (B_TRUE);

	while (prefixlen > 0) {
		if (prefixlen >= 8) {
			mask[j++] = 0xFF;
			prefixlen -= 8;
		} else {
			mask[j] |= 1 << (8 - prefixlen);
			prefixlen--;
		}
	}
	/* Ensure at least one byte is tested */
	if (j == 0) j++;

	for (i = 0; i < j; i++) {
		if ((addr1[i] & mask[i]) != (addr2[i] & mask[i]))
			return (B_FALSE);
	}
	return (B_TRUE);
}

/*
 * Given a string representation of an IPv4 or IPv6 address returns the
 * sockaddr representation. Note that 'sockaddr' should point at the correct
 * sockaddr structure for the address family (sockaddr_in for AF_INET or
 * sockaddr_in6 for AF_INET6) or alternatively at a sockaddr_storage
 * structure.
 */
static struct sockaddr_storage *
nwamd_str2sockaddr(sa_family_t af, const char *straddr,
    struct sockaddr_storage *addr)
{
	struct sockaddr_in *sin;
	struct sockaddr_in6 *sin6;
	int err;

	if (af == AF_INET) {
		sin = (struct sockaddr_in *)addr;
		sin->sin_family = AF_INET;
		err = inet_pton(AF_INET, straddr, &sin->sin_addr);
	} else if (af == AF_INET6) {
		sin6 = (struct sockaddr_in6 *)addr;
		sin6->sin6_family = AF_INET6;
		err = inet_pton(AF_INET6, straddr, &sin6->sin6_addr);
	} else {
		errno = EINVAL;
		return (NULL);
	}
	return (err == 1 ? addr : NULL);
}

struct nwamd_ipaddr_condition_walk_arg {
	nwam_condition_t condition;
	struct sockaddr_storage sockaddr;
	int prefixlen;
	boolean_t res;
};

static int
check_ipaddr(sa_family_t family, struct ifaddrs *ifa, void *arg)
{
	struct nwamd_ipaddr_condition_walk_arg *wa = arg;
	boolean_t match = B_FALSE;
	uchar_t *addr1, *addr2;

	if (family == AF_INET) {
		addr1 = (uchar_t *)&(((struct sockaddr_in *)
		    ifa->ifa_addr)->sin_addr.s_addr);
		addr2 = (uchar_t *)&(((struct sockaddr_in *)
		    &(wa->sockaddr))->sin_addr.s_addr);
	} else {
		addr1 = (uchar_t *)&(((struct sockaddr_in6 *)
		    ifa->ifa_addr)->sin6_addr.s6_addr);
		addr2 = (uchar_t *)&(((struct sockaddr_in6 *)
		    &(wa->sockaddr))->sin6_addr.s6_addr);
	}

	match = prefixmatch(addr1, addr2, wa->prefixlen);

	nlog(LOG_DEBUG, "check_ipaddr: match %d\n", match);
	switch (wa->condition) {
	case NWAM_CONDITION_IS:
	case NWAM_CONDITION_IS_IN_RANGE:
		wa->res = match;
		if (match)
			return (1);
		return (0);
	case NWAM_CONDITION_IS_NOT:
	case NWAM_CONDITION_IS_NOT_IN_RANGE:
		wa->res = !match;
		return (0);
	default:
		return (0);
	}
}

static boolean_t
test_condition_ip_address(nwam_condition_t condition,
    const char *ip_address_string)
{
	sa_family_t family;
	char *copy, *ip_address, *prefixlen_string, *lasts;
	struct nwamd_ipaddr_condition_walk_arg wa;
	struct ifaddrs *ifap, *ifa;

	if ((copy = strdup(ip_address_string)) == NULL)
		return (B_FALSE);

	if ((ip_address = strtok_r(copy, " \t/", &lasts)) == NULL) {
		free(copy);
		return (B_FALSE);
	}

	prefixlen_string = strtok_r(NULL, " \t", &lasts);

	if (nwamd_str2sockaddr(AF_INET, ip_address, &wa.sockaddr) != NULL) {
		family = AF_INET;
		wa.prefixlen = IP_ABITS;
	} else if (nwamd_str2sockaddr(AF_INET6, ip_address, &wa.sockaddr)
	    != NULL) {
		family = AF_INET6;
		wa.prefixlen = IPV6_ABITS;
	} else {
		nlog(LOG_ERR, "test_condition_ip_address: "
		    "nwamd_str2sockaddr failed for %s: %s", ip_address,
		    strerror(errno));
		free(copy);
		return (B_FALSE);
	}

	if (prefixlen_string != NULL)
		wa.prefixlen = atoi(prefixlen_string);

	wa.condition = condition;

	switch (condition) {
	case NWAM_CONDITION_IS:
	case NWAM_CONDITION_IS_IN_RANGE:
		wa.res = B_FALSE;
		break;
	case NWAM_CONDITION_IS_NOT:
	case NWAM_CONDITION_IS_NOT_IN_RANGE:
		wa.res = B_TRUE;
		break;
	default:
		free(copy);
		return (B_FALSE);
	}
	free(copy);

	if (getifaddrs(&ifa) == -1) {
		nlog(LOG_ERR, "test_condition_ip_address: "
		    "getifaddrs failed: %s", strerror(errno));
		return (wa.res);
	}
	for (ifap = ifa; ifap != NULL; ifap = ifap->ifa_next) {
		if (ifap->ifa_addr->ss_family != family)
			continue;
		if (check_ipaddr(family, ifap, &wa) == 1)
			break;
	}
	freeifaddrs(ifa);

	return (wa.res);
}

struct nwamd_wlan_condition_walk_arg {
	nwam_condition_t condition;
	const char *exp_essid;
	const char *exp_bssid;
	uint_t num_connected;
	boolean_t res;
};

static int
check_wlan(const char *linkname, void *arg)
{
	struct nwamd_wlan_condition_walk_arg *wa = arg;
	datalink_id_t linkid;
	dladm_wlan_linkattr_t attr;
	dladm_status_t status;
	char cur_essid[DLADM_STRSIZE];
	char cur_bssid[DLADM_STRSIZE];
	char errmsg[DLADM_STRSIZE];

	if ((status = dladm_name2info(dld_handle, linkname, &linkid, NULL, NULL,
	    NULL)) != DLADM_STATUS_OK) {
		nlog(LOG_DEBUG, "check_wlan: dladm_name2info() for %s "
		    "failed: %s", linkname,
		    dladm_status2str(status, errmsg));
		return (DLADM_WALK_CONTINUE);
	}

	status = dladm_wlan_get_linkattr(dld_handle, linkid, &attr);
	if (status != DLADM_STATUS_OK) {
		nlog(LOG_DEBUG, "check_wlan: dladm_wlan_get_linkattr() for %s "
		    "failed: %s", linkname,
		    dladm_status2str(status, errmsg));
		return (DLADM_WALK_CONTINUE);
	}
	if (attr.la_status == DLADM_WLAN_LINK_DISCONNECTED)
		return (DLADM_WALK_TERMINATE);

	wa->num_connected++;

	if (wa->exp_essid != NULL) {
		/* Is the NIC associated with the expected access point? */
		(void) dladm_wlan_essid2str(&attr.la_wlan_attr.wa_essid,
		    cur_essid);
		switch (wa->condition) {
		case NWAM_CONDITION_IS:
			wa->res = strcmp(cur_essid, wa->exp_essid) == 0;
			if (wa->res)
				return (DLADM_WALK_TERMINATE);
			break;
		case NWAM_CONDITION_IS_NOT:
			wa->res = strcmp(cur_essid, wa->exp_essid) != 0;
			if (!wa->res)
				return (DLADM_WALK_TERMINATE);
			break;
		case NWAM_CONDITION_CONTAINS:
			wa->res = strstr(cur_essid, wa->exp_essid) != NULL;
			if (wa->res)
				return (DLADM_WALK_TERMINATE);
			break;
		case NWAM_CONDITION_DOES_NOT_CONTAIN:
			wa->res = strstr(cur_essid, wa->exp_essid) == NULL;
			if (!wa->res)
				return (DLADM_WALK_TERMINATE);
			break;
		default:
			return (DLADM_WALK_TERMINATE);
		}
		return (DLADM_WALK_CONTINUE);
	}
	if (wa->exp_bssid != NULL) {
		/* Is the NIC associated with the expected access point? */
		(void) dladm_wlan_bssid2str(&attr.la_wlan_attr.wa_bssid,
		    cur_bssid);
		switch (wa->condition) {
		case NWAM_CONDITION_IS:
			wa->res = strcmp(cur_bssid, wa->exp_bssid) == 0;
			if (wa->res)
				return (DLADM_WALK_TERMINATE);
			break;
		case NWAM_CONDITION_IS_NOT:
			wa->res = strcmp(cur_bssid, wa->exp_bssid) != 0;
			if (!wa->res)
				return (DLADM_WALK_TERMINATE);
			break;
		default:
			return (DLADM_WALK_TERMINATE);
		}
		return (DLADM_WALK_CONTINUE);
	}
	/*
	 * Neither an ESSID or BSSID match is required - being connected to a
	 * WLAN is enough.
	 */
	switch (wa->condition) {
	case NWAM_CONDITION_IS:
		wa->res = B_TRUE;
		return (DLADM_WALK_TERMINATE);
	default:
		wa->res = B_FALSE;
		return (DLADM_WALK_TERMINATE);
	}
	/*NOTREACHED*/
	return (DLADM_WALK_CONTINUE);
}

static boolean_t
test_condition_wireless_essid(nwam_condition_t condition,
    const char *essid)
{
	struct nwamd_wlan_condition_walk_arg wa;

	wa.condition = condition;
	wa.exp_essid = essid;
	wa.exp_bssid = NULL;
	wa.num_connected = 0;
	wa.res = B_FALSE;

	(void) dladm_walk(check_wlan, dld_handle, &wa, DATALINK_CLASS_PHYS,
	    DL_WIFI, DLADM_OPT_ACTIVE);

	return (wa.num_connected > 0 && wa.res == B_TRUE);
}

static boolean_t
test_condition_wireless_bssid(nwam_condition_t condition,
    const char *bssid)
{
	struct nwamd_wlan_condition_walk_arg wa;

	wa.condition = condition;
	wa.exp_bssid = bssid;
	wa.exp_essid = NULL;
	wa.num_connected = 0;
	wa.res = B_FALSE;

	(void) dladm_walk(check_wlan, dld_handle, &wa, DATALINK_CLASS_PHYS,
	    DL_WIFI, DLADM_OPT_ACTIVE);

	return (wa.num_connected > 0 && wa.res == B_TRUE);
}

/*
 * This function takes an activation mode and a string representation of a
 * condition and evaluates it.
 */
boolean_t
nwamd_check_conditions(nwam_activation_mode_t activation_mode,
    char **condition_strings, uint_t num_conditions)
{
	boolean_t ret;
	nwam_condition_t condition;
	nwam_condition_object_type_t object_type;
	char *object_name;
	int i, j;

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

		if (nwam_condition_string_to_condition(condition_strings[i],
		    &object_type, &condition, &object_name) != NWAM_SUCCESS) {
			nlog(LOG_ERR, "check_conditions: invalid condition %s",
			    condition_strings[i]);
			return (B_FALSE);
		}
		ret = B_FALSE;

		for (j = 0; j < (sizeof (condition_map) /
		    sizeof (struct nwamd_condition_map)); j++) {
			if (condition_map[j].object_type == object_type)
				ret = condition_map[j].condition_func(condition,
				    object_name);
		}

		free(object_name);

		if (activation_mode == NWAM_ACTIVATION_MODE_CONDITIONAL_ANY &&
		    ret) {
			return (B_TRUE);
		}
		if (activation_mode == NWAM_ACTIVATION_MODE_CONDITIONAL_ALL &&
		    !ret) {
			return (B_FALSE);
		}
	}
	if (activation_mode == NWAM_ACTIVATION_MODE_CONDITIONAL_ANY && ret)
		return (B_TRUE);
	if (activation_mode == NWAM_ACTIVATION_MODE_CONDITIONAL_ALL && ret)
		return (B_TRUE);

	return (B_FALSE);
}

/*
 * In rating activation conditions, we take the best-rated CONDITIONAL_ANY
 * condition, or sum all the CONDITIONAL_ALL condition ratings. This allows
 * us to compare between location activation conditions to pick the best.
 */
uint64_t
nwamd_rate_conditions(nwam_activation_mode_t activation_mode,
    char **conditions, uint_t num_conditions)
{
	nwam_condition_t condition;
	nwam_condition_object_type_t object_type;
	char *object_name;
	int i;
	uint64_t rating = 0, total_rating = 0;

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

		object_name = NULL;
		if (nwam_condition_string_to_condition(conditions[i],
		    &object_type, &condition, &object_name) != NWAM_SUCCESS ||
		    nwam_condition_rate(object_type, condition, &rating)
		    != NWAM_SUCCESS) {
			nlog(LOG_ERR, "nwamd_rate_conditions: could not rate "
			    "condition");
			free(object_name);
			return (0);
		}
		free(object_name);

		if (activation_mode == NWAM_ACTIVATION_MODE_CONDITIONAL_ANY) {
			if (rating > total_rating)
				total_rating = rating;
		} else if (activation_mode ==
		    NWAM_ACTIVATION_MODE_CONDITIONAL_ALL) {
			total_rating += rating;
		}
	}
	return (total_rating);
}

/*
 * Different from nwamd_triggered_check_all_conditions() in that this
 * function enqueues a timed check event.
 */
void
nwamd_set_timed_check_all_conditions(void)
{
	nwamd_event_t check_event = nwamd_event_init
	    (NWAM_EVENT_TYPE_TIMED_CHECK_CONDITIONS, NWAM_OBJECT_TYPE_UNKNOWN,
	    0, NULL);
	if (check_event != NULL) {
		/* Add another timed event to recheck conditions */
		nwamd_event_enqueue_timed(check_event,
		    condition_check_interval > CONDITION_CHECK_INTERVAL_MIN ?
		    condition_check_interval : CONDITION_CHECK_INTERVAL_MIN);
	}
}

/*
 * Does not enqueue another check event.
 */
void
nwamd_check_all_conditions(void)
{
	nwamd_enm_check_conditions();
	nwamd_loc_check_conditions();
}

void
nwamd_create_timed_condition_check_event(void)
{
	nwamd_event_t check_event = nwamd_event_init
	    (NWAM_EVENT_TYPE_TIMED_CHECK_CONDITIONS, NWAM_OBJECT_TYPE_UNKNOWN,
	    0, NULL);
	if (check_event != NULL)
		nwamd_event_enqueue(check_event);
}

void
nwamd_create_triggered_condition_check_event(uint32_t when)
{
	nwamd_event_t check_event;

	if (!nwamd_event_enqueued(NWAM_EVENT_TYPE_TRIGGERED_CHECK_CONDITIONS,
	    NWAM_OBJECT_TYPE_UNKNOWN, NULL)) {
		check_event = nwamd_event_init
		    (NWAM_EVENT_TYPE_TRIGGERED_CHECK_CONDITIONS,
		    NWAM_OBJECT_TYPE_UNKNOWN, 0, NULL);
		if (check_event != NULL)
			nwamd_event_enqueue_timed(check_event, when);
	}
}