1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #include <assert.h>
28 #include <ctype.h>
29 #include <sys/param.h>
30 #include <sys/types.h>
31 #include <sys/stat.h>
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <strings.h>
35 #include <unistd.h>
36 #include <libscf.h>
37 
38 #include "libnwam_impl.h"
39 #include <libnwam_priv.h>
40 #include <libnwam.h>
41 
42 /*
43  * Functions to support creating, modifying, destroying, querying the
44  * state of and changing the state of location objects. Locations
45  * represent the configuration to be applied once basic network configuration
46  * has been established - name services, IPsec config, etc, and can be enabled
47  * either manually or conditionally for a combination of the set of
48  * available conditions (an IP address is present, an ENM is active etc).
49  */
50 
51 #define	NSSWITCH_PREFIX		"/etc/nsswitch."
52 
53 typedef nwam_error_t (*nwam_loc_prop_validate_func_t)(nwam_value_t);
54 
55 static nwam_error_t valid_loc_activation_mode(nwam_value_t);
56 static nwam_error_t valid_loc_condition(nwam_value_t);
57 static nwam_error_t valid_nameservices(nwam_value_t);
58 static nwam_error_t valid_configsrc(nwam_value_t);
59 
60 struct nwam_prop_table_entry loc_prop_table_entries[] = {
61 	{NWAM_LOC_PROP_ACTIVATION_MODE, NWAM_VALUE_TYPE_UINT64, B_FALSE, 1, 1,
62 	    valid_loc_activation_mode,
63 	    "specifies the location activation mode - valid values are:\n"
64 	    "\'manual\', \'conditional-any\' and \'conditional-all\'",
65 	    NWAM_TYPE_ANY, NWAM_CLASS_ANY},
66 	{NWAM_LOC_PROP_CONDITIONS, NWAM_VALUE_TYPE_STRING, B_FALSE, 0,
67 	    NWAM_MAX_NUM_VALUES, valid_loc_condition,
68 	    "specifies the activation condition. Conditions are of the form:\n"
69 	    "ncp|ncu|enm name is|is-not active\n"
70 	    "ip-address is|is-not|is-in-range|is-not-in-range| 1.2.3.4[/24]\n"
71 	    "advertised-domain is|is-not|contains|does-not-contain string\n"
72 	    "system-domain is|is-not|contains|does-not-contain string\n"
73 	    "essid is|is-not|contains|does-not-contain string\n"
74 	    "bssid is|is-not string",
75 	    NWAM_TYPE_ANY, NWAM_CLASS_ANY},
76 	{NWAM_LOC_PROP_ENABLED, NWAM_VALUE_TYPE_BOOLEAN, B_TRUE, 1, 1,
77 	    nwam_valid_boolean,
78 	    "specifies if location is to be enabled",
79 	    NWAM_TYPE_ANY, NWAM_CLASS_ANY},
80 	{NWAM_LOC_PROP_NAMESERVICES, NWAM_VALUE_TYPE_UINT64, B_FALSE, 1,
81 	    NWAM_MAX_NUM_VALUES, valid_nameservices,
82 	    "specifies name service(s) to be used - valid values are:\n"
83 	    "\'files\', \'dns\', \'nis\', and \'ldap\'",
84 	    NWAM_TYPE_ANY, NWAM_CLASS_ANY},
85 	{NWAM_LOC_PROP_NAMESERVICES_CONFIG_FILE, NWAM_VALUE_TYPE_STRING,
86 	    B_FALSE, 0, 1, nwam_valid_file,
87 	    "specifies path to configuration file for name services switch "
88 	    "for this location - see nsswitch.conf(4)",
89 	    NWAM_TYPE_ANY, NWAM_CLASS_ANY},
90 	{NWAM_LOC_PROP_DNS_NAMESERVICE_CONFIGSRC, NWAM_VALUE_TYPE_UINT64,
91 	    B_FALSE, 0, NWAM_MAX_NUM_VALUES, valid_configsrc,
92 	    "specifies sources of DNS configuration parameters - valid values "
93 	    "are:\n\'dhcp\', or \'manual\'",
94 	    NWAM_TYPE_ANY, NWAM_CLASS_ANY},
95 	{NWAM_LOC_PROP_DNS_NAMESERVICE_DOMAIN, NWAM_VALUE_TYPE_STRING, B_FALSE,
96 	    0, 1, nwam_valid_domain,
97 	    "specifies DNS domain name to be set for this location",
98 	    NWAM_TYPE_ANY, NWAM_CLASS_ANY},
99 	{NWAM_LOC_PROP_DNS_NAMESERVICE_SERVERS, NWAM_VALUE_TYPE_STRING, B_FALSE,
100 	    0, NWAM_MAX_NUM_VALUES, nwam_valid_host_any,
101 	    "specifies DNS server host address(es)",
102 	    NWAM_TYPE_ANY, NWAM_CLASS_ANY},
103 	{NWAM_LOC_PROP_DNS_NAMESERVICE_SEARCH, NWAM_VALUE_TYPE_STRING, B_FALSE,
104 	    0, NWAM_MAX_NUM_VALUES, nwam_valid_domain,
105 	    "specifies DNS search list for host name lookup",
106 	    NWAM_TYPE_ANY, NWAM_CLASS_ANY},
107 	{NWAM_LOC_PROP_NIS_NAMESERVICE_CONFIGSRC, NWAM_VALUE_TYPE_UINT64,
108 	    B_FALSE, 0, NWAM_MAX_NUM_VALUES, valid_configsrc,
109 	    "specifies sources of NIS configuration parameters - valid values "
110 	    "are:\n\'dhcp\', or \'manual\'",
111 	    NWAM_TYPE_ANY, NWAM_CLASS_ANY},
112 	{NWAM_LOC_PROP_NIS_NAMESERVICE_SERVERS, NWAM_VALUE_TYPE_STRING, B_FALSE,
113 	    0, NWAM_MAX_NUM_VALUES, nwam_valid_host_any,
114 	    "specifies NIS server host address(es)",
115 	    NWAM_TYPE_ANY, NWAM_CLASS_ANY},
116 	{NWAM_LOC_PROP_LDAP_NAMESERVICE_CONFIGSRC, NWAM_VALUE_TYPE_UINT64,
117 	    B_FALSE, 0, NWAM_MAX_NUM_VALUES, valid_configsrc,
118 	    "specifies sources of NIS configuration parameters - currently, "
119 	    "the only valid value is \'manual\'",
120 	    NWAM_TYPE_ANY, NWAM_CLASS_ANY},
121 	{NWAM_LOC_PROP_LDAP_NAMESERVICE_SERVERS, NWAM_VALUE_TYPE_STRING,
122 	    B_FALSE, 0, NWAM_MAX_NUM_VALUES, nwam_valid_host_or_domain,
123 	    "specifies LDAP server host address(es)",
124 	    NWAM_TYPE_ANY, NWAM_CLASS_ANY},
125 	{NWAM_LOC_PROP_DEFAULT_DOMAIN, NWAM_VALUE_TYPE_STRING, B_FALSE, 0, 1,
126 	    nwam_valid_domain,
127 	    "specifies the domainname(1M) to be set for this location",
128 	    NWAM_TYPE_ANY, NWAM_CLASS_ANY},
129 	{NWAM_LOC_PROP_NFSV4_DOMAIN, NWAM_VALUE_TYPE_STRING, B_FALSE, 0, 1,
130 	    nwam_valid_domain,
131 	    "specifies an NFSv4 domain for this location",
132 	    NWAM_TYPE_ANY, NWAM_CLASS_ANY},
133 	{NWAM_LOC_PROP_IPFILTER_CONFIG_FILE, NWAM_VALUE_TYPE_STRING, B_FALSE,
134 	    0, 1, nwam_valid_file,
135 	    "specifies an absolute path to an ipf.conf(4) file for this "
136 	    "location",
137 	    NWAM_TYPE_ANY, NWAM_CLASS_ANY},
138 	{NWAM_LOC_PROP_IPFILTER_V6_CONFIG_FILE, NWAM_VALUE_TYPE_STRING,
139 	    B_FALSE, 0, 1, nwam_valid_file,
140 	    "specifies an absolute path to an ipf6.conf file for this "
141 	    "location",
142 	    NWAM_TYPE_ANY, NWAM_CLASS_ANY},
143 	{NWAM_LOC_PROP_IPNAT_CONFIG_FILE, NWAM_VALUE_TYPE_STRING, B_FALSE, 0,
144 	    1, nwam_valid_file,
145 	    "specifies an absolute path to an ipnat.conf(4) file for this "
146 	    "location",
147 	    NWAM_TYPE_ANY, NWAM_CLASS_ANY},
148 	{NWAM_LOC_PROP_IPPOOL_CONFIG_FILE, NWAM_VALUE_TYPE_STRING, B_FALSE, 0,
149 	    1, nwam_valid_file,
150 	    "specifies an absolute path to an ippool.conf(4) file for this "
151 	    "location",
152 	    NWAM_TYPE_ANY, NWAM_CLASS_ANY},
153 	{NWAM_LOC_PROP_IKE_CONFIG_FILE, NWAM_VALUE_TYPE_STRING, B_FALSE, 0, 1,
154 	    nwam_valid_file,
155 	    "specifies an absolute path to an ike config file "
156 	    "(see ike.config(4))",
157 	    NWAM_TYPE_ANY, NWAM_CLASS_ANY},
158 	{NWAM_LOC_PROP_IPSECPOLICY_CONFIG_FILE, NWAM_VALUE_TYPE_STRING,
159 	    B_FALSE, 0, 1, nwam_valid_file,
160 	    "specifies an absolute path to an IPsec policy configuration file "
161 	    "(see ipsecconf(1M)",
162 	    NWAM_TYPE_ANY, NWAM_CLASS_ANY},
163 };
164 
165 #define	NWAM_NUM_LOC_PROPS	(sizeof (loc_prop_table_entries) / \
166 				sizeof (*loc_prop_table_entries))
167 
168 struct nwam_prop_table loc_prop_table =
169 	{ NWAM_NUM_LOC_PROPS, loc_prop_table_entries };
170 
171 static uint64_t
172 nwam_loc_activation_to_flag(nwam_activation_mode_t activation)
173 {
174 	switch (activation) {
175 	case NWAM_ACTIVATION_MODE_MANUAL:
176 		return (NWAM_FLAG_ACTIVATION_MODE_MANUAL);
177 	case NWAM_ACTIVATION_MODE_SYSTEM:
178 		return (NWAM_FLAG_ACTIVATION_MODE_SYSTEM);
179 	case NWAM_ACTIVATION_MODE_CONDITIONAL_ANY:
180 		return (NWAM_FLAG_ACTIVATION_MODE_CONDITIONAL_ANY);
181 	case NWAM_ACTIVATION_MODE_CONDITIONAL_ALL:
182 		return (NWAM_FLAG_ACTIVATION_MODE_CONDITIONAL_ALL);
183 	default:
184 		return (0);
185 	}
186 }
187 
188 nwam_error_t
189 nwam_loc_read(const char *name, uint64_t flags, nwam_loc_handle_t *lochp)
190 {
191 	return (nwam_read(NWAM_OBJECT_TYPE_LOC, NWAM_LOC_CONF_FILE, name,
192 	    flags, lochp));
193 }
194 
195 nwam_error_t
196 nwam_loc_create(const char *name, nwam_loc_handle_t *lochp)
197 {
198 	nwam_error_t err;
199 	nwam_value_t val = NULL;
200 	char *nsswitch = NULL;
201 
202 	assert(lochp != NULL && name != NULL);
203 
204 	if ((err = nwam_create(NWAM_OBJECT_TYPE_LOC, NWAM_LOC_CONF_FILE, name,
205 	    lochp)) != NWAM_SUCCESS)
206 		return (err);
207 
208 	/* Create new object list for loc */
209 	if ((err = nwam_alloc_object_list(&((*lochp)->nwh_data)))
210 	    != NWAM_SUCCESS)
211 		goto finish;
212 
213 	/* NWAM_LOC_PROP_ACTIVATION_MODE is mandatory */
214 	if ((err = nwam_value_create_uint64(NWAM_ACTIVATION_MODE_MANUAL, &val))
215 	    != NWAM_SUCCESS) {
216 		goto finish;
217 	}
218 	if ((err = nwam_set_prop_value((*lochp)->nwh_data,
219 	    NWAM_LOC_PROP_ACTIVATION_MODE, val)) != NWAM_SUCCESS) {
220 		goto finish;
221 	}
222 	nwam_value_free(val);
223 	val = NULL;
224 
225 	/*
226 	 * NWAM_LOC_PROP_ENABLED defaults to false.
227 	 */
228 	if ((err = nwam_value_create_boolean(B_FALSE, &val)) != NWAM_SUCCESS)
229 		goto finish;
230 	if ((err = nwam_set_prop_value((*lochp)->nwh_data,
231 	    NWAM_LOC_PROP_ENABLED, val)) != NWAM_SUCCESS)
232 		goto finish;
233 	nwam_value_free(val);
234 	val = NULL;
235 
236 	/*
237 	 * Initialize name service properties: use DNS, configured
238 	 * via DHCP, with default nsswitch (/etc/nsswitch.dns).
239 	 */
240 	if ((err = nwam_value_create_uint64(NWAM_NAMESERVICES_DNS, &val)) !=
241 	    NWAM_SUCCESS)
242 		goto finish;
243 	if ((err = nwam_set_prop_value((*lochp)->nwh_data,
244 	    NWAM_LOC_PROP_NAMESERVICES, val)) != NWAM_SUCCESS)
245 		goto finish;
246 	nwam_value_free(val);
247 	val = NULL;
248 
249 	if ((err = nwam_value_create_uint64(NWAM_CONFIGSRC_DHCP, &val)) !=
250 	    NWAM_SUCCESS)
251 		goto finish;
252 	if ((err = nwam_set_prop_value((*lochp)->nwh_data,
253 	    NWAM_LOC_PROP_DNS_NAMESERVICE_CONFIGSRC, val)) != NWAM_SUCCESS)
254 		goto finish;
255 	nwam_value_free(val);
256 	val = NULL;
257 
258 	/* concatenate these two strings */
259 	nsswitch = strdup(NSSWITCH_PREFIX NWAM_NAMESERVICES_DNS_STRING);
260 	if (nsswitch == NULL) {
261 		err = NWAM_NO_MEMORY;
262 		goto finish;
263 	}
264 	if ((err = nwam_value_create_string(nsswitch, &val)) != NWAM_SUCCESS)
265 		goto finish;
266 	err = nwam_set_prop_value((*lochp)->nwh_data,
267 	    NWAM_LOC_PROP_NAMESERVICES_CONFIG_FILE, val);
268 
269 finish:
270 	if (nsswitch != NULL)
271 		free(nsswitch);
272 	if (val != NULL)
273 		nwam_value_free(val);
274 	if (err != NWAM_SUCCESS) {
275 		nwam_loc_free(*lochp);
276 		*lochp = NULL;
277 	}
278 	return (err);
279 }
280 
281 nwam_error_t
282 nwam_loc_get_name(nwam_loc_handle_t loch, char **namep)
283 {
284 	return (nwam_get_name(loch, namep));
285 }
286 
287 nwam_error_t
288 nwam_loc_set_name(nwam_loc_handle_t loch, const char *name)
289 {
290 	return (nwam_set_name(loch, name));
291 }
292 
293 boolean_t
294 nwam_loc_can_set_name(nwam_loc_handle_t loch)
295 {
296 	return (!loch->nwh_committed);
297 }
298 
299 /* ARGSUSED2 */
300 static int
301 loc_selectcb(struct nwam_handle *hp, uint64_t flags, void *data)
302 {
303 	nwam_loc_handle_t loch = hp;
304 	char *locname;
305 	uint64_t activation, actflag, walkfilter;
306 	nwam_value_t activationval;
307 
308 	/* Skip the Legacy location in all cases */
309 	if (nwam_loc_get_name(loch, &locname) != NWAM_SUCCESS)
310 		return (NWAM_INVALID_ARG);
311 	if (strcmp(locname, NWAM_LOC_NAME_LEGACY) == 0) {
312 		free(locname);
313 		return (NWAM_INVALID_ARG);
314 	}
315 	free(locname);
316 
317 	/*
318 	 * Get a bitmapped flag value corresponding to this loc's
319 	 * activation.
320 	 */
321 	if (nwam_loc_get_prop_value(loch, NWAM_LOC_PROP_ACTIVATION_MODE,
322 	    &activationval) != NWAM_SUCCESS) {
323 		return (NWAM_INVALID_ARG);
324 	}
325 	if (nwam_value_get_uint64(activationval, &activation) != NWAM_SUCCESS) {
326 		nwam_value_free(activationval);
327 		return (NWAM_INVALID_ARG);
328 	}
329 
330 	actflag = nwam_loc_activation_to_flag(activation);
331 	nwam_value_free(activationval);
332 	if ((walkfilter = (flags & NWAM_WALK_FILTER_MASK)) == 0)
333 		walkfilter = NWAM_FLAG_ACTIVATION_MODE_ALL;
334 	if (actflag & walkfilter)
335 		return (NWAM_SUCCESS);
336 	return (NWAM_INVALID_ARG);
337 }
338 
339 nwam_error_t
340 nwam_walk_locs(int(*cb)(nwam_loc_handle_t, void *), void *data, uint64_t flags,
341     int *retp)
342 {
343 	nwam_error_t err = nwam_valid_flags(flags,
344 	    NWAM_FLAG_ACTIVATION_MODE_ALL | NWAM_FLAG_BLOCKING);
345 
346 	if (err != NWAM_SUCCESS)
347 		return (err);
348 
349 	return (nwam_walk(NWAM_OBJECT_TYPE_LOC, NWAM_LOC_CONF_FILE,
350 	    cb, data, flags, retp, loc_selectcb));
351 }
352 
353 void
354 nwam_loc_free(nwam_loc_handle_t loch)
355 {
356 	nwam_free(loch);
357 }
358 
359 nwam_error_t
360 nwam_loc_delete_prop(nwam_loc_handle_t loch, const char *propname)
361 {
362 	nwam_error_t err;
363 	boolean_t ro;
364 	void *olddata;
365 
366 	assert(loch != NULL && propname != NULL);
367 
368 	if ((err = nwam_loc_prop_read_only(propname, &ro)) != NWAM_SUCCESS)
369 		return (err);
370 	if (ro)
371 		return (NWAM_ENTITY_READ_ONLY);
372 
373 	/*
374 	 * Duplicate data, remove property and validate. If validation
375 	 * fails, revert to data duplicated prior to remove.
376 	 */
377 	if ((err = nwam_dup_object_list(loch->nwh_data, &olddata))
378 	    != NWAM_SUCCESS)
379 		return (err);
380 	if ((err = nwam_delete_prop(loch->nwh_data, propname))
381 	    != NWAM_SUCCESS) {
382 		nwam_free_object_list(loch->nwh_data);
383 		loch->nwh_data = olddata;
384 		return (err);
385 	}
386 	if ((err = nwam_loc_validate(loch, NULL)) != NWAM_SUCCESS) {
387 		nwam_free_object_list(loch->nwh_data);
388 		loch->nwh_data = olddata;
389 		return (err);
390 	}
391 	nwam_free_object_list(olddata);
392 
393 	return (NWAM_SUCCESS);
394 }
395 
396 nwam_error_t
397 nwam_loc_set_prop_value(nwam_loc_handle_t loch, const char *propname,
398     nwam_value_t value)
399 {
400 	nwam_error_t err;
401 	boolean_t ro;
402 
403 	assert(loch != NULL && propname != NULL && value  != NULL);
404 
405 	if ((err = nwam_loc_validate_prop(loch, propname, value))
406 	    != NWAM_SUCCESS ||
407 	    (err = nwam_loc_prop_read_only(propname, &ro)) != NWAM_SUCCESS)
408 		return (err);
409 	if (ro)
410 		return (NWAM_ENTITY_READ_ONLY);
411 
412 	return (nwam_set_prop_value(loch->nwh_data, propname, value));
413 }
414 
415 nwam_error_t
416 nwam_loc_get_prop_value(nwam_loc_handle_t loch, const char *propname,
417     nwam_value_t *valuep)
418 {
419 	return (nwam_get_prop_value(loch->nwh_data, propname, valuep));
420 }
421 
422 nwam_error_t
423 nwam_loc_walk_props(nwam_loc_handle_t loch,
424     int (*cb)(const char *, nwam_value_t, void *),
425     void *data, uint64_t flags, int *retp)
426 {
427 	return (nwam_walk_props(loch, cb, data, flags, retp));
428 }
429 
430 nwam_error_t
431 nwam_loc_commit(nwam_loc_handle_t loch, uint64_t flags)
432 {
433 	nwam_error_t err;
434 
435 	assert(loch != NULL && loch->nwh_data != NULL);
436 
437 	if ((err = nwam_loc_validate(loch, NULL)) != NWAM_SUCCESS)
438 		return (err);
439 
440 	return (nwam_commit(NWAM_LOC_CONF_FILE, loch, flags));
441 }
442 
443 nwam_error_t
444 nwam_loc_destroy(nwam_loc_handle_t loch, uint64_t flags)
445 {
446 	nwam_error_t err;
447 	nwam_value_t actval;
448 	uint64_t activation;
449 
450 	/*
451 	 * Automatic and NoNet are not destroyable and Legacy is
452 	 * destroyable by netadm only.  These have system activation-mode.
453 	 */
454 	if ((err = nwam_loc_get_prop_value(loch, NWAM_LOC_PROP_ACTIVATION_MODE,
455 	    &actval)) != NWAM_SUCCESS)
456 		return (err);
457 	err = nwam_value_get_uint64(actval, &activation);
458 	nwam_value_free(actval);
459 	if (err != NWAM_SUCCESS)
460 		return (err);
461 
462 	if (activation == NWAM_ACTIVATION_MODE_SYSTEM) {
463 		if (strcmp(loch->nwh_name, NWAM_LOC_NAME_LEGACY) == 0) {
464 			if (!nwam_uid_is_netadm())
465 				return (NWAM_ENTITY_NOT_DESTROYABLE);
466 		} else {
467 			return (NWAM_ENTITY_NOT_DESTROYABLE);
468 		}
469 	}
470 
471 	return (nwam_destroy(NWAM_LOC_CONF_FILE, loch, flags));
472 }
473 
474 nwam_error_t
475 nwam_loc_get_prop_description(const char *propname, const char **descriptionp)
476 {
477 	return (nwam_get_prop_description(loc_prop_table, propname,
478 	    descriptionp));
479 }
480 
481 nwam_error_t
482 nwam_loc_prop_read_only(const char *propname, boolean_t *readp)
483 {
484 	return (nwam_prop_read_only(loc_prop_table, propname, readp));
485 }
486 
487 static nwam_error_t
488 valid_loc_activation_mode(nwam_value_t value)
489 {
490 	uint64_t activation_mode;
491 
492 	if (nwam_value_get_uint64(value, &activation_mode) != NWAM_SUCCESS)
493 		return (NWAM_ENTITY_INVALID_VALUE);
494 
495 	switch (activation_mode) {
496 	case NWAM_ACTIVATION_MODE_MANUAL:
497 	case NWAM_ACTIVATION_MODE_SYSTEM:
498 	case NWAM_ACTIVATION_MODE_CONDITIONAL_ANY:
499 	case NWAM_ACTIVATION_MODE_CONDITIONAL_ALL:
500 		return (NWAM_SUCCESS);
501 	}
502 	return (NWAM_ENTITY_INVALID_VALUE);
503 }
504 
505 /*
506  * Identical to nwam_valid_condition(), except locations cannot specify other
507  * location's activation as a condition, e.g. loc2 cannot specify
508  * "loc1 is active" since only one location is active at a time, and
509  * as a consequence the condition is unsatisfiable.
510  */
511 nwam_error_t
512 valid_loc_condition(nwam_value_t value)
513 {
514 	char **conditions;
515 	uint_t i, numvalues;
516 	nwam_condition_object_type_t object_type;
517 	nwam_condition_t condition;
518 
519 	if (nwam_value_get_string_array(value, &conditions, &numvalues)
520 	    != NWAM_SUCCESS)
521 		return (NWAM_ENTITY_INVALID_VALUE);
522 
523 	for (i = 0; i < numvalues; i++) {
524 		char *object_name = NULL;
525 
526 		if (nwam_condition_string_to_condition(conditions[i],
527 		    &object_type, &condition, &object_name) != NWAM_SUCCESS)
528 			return (NWAM_ENTITY_INVALID_VALUE);
529 		if (object_type == NWAM_CONDITION_OBJECT_TYPE_LOC &&
530 		    condition == NWAM_CONDITION_IS) {
531 			free(object_name);
532 			return (NWAM_ENTITY_INVALID_VALUE);
533 		}
534 		if (object_name != NULL)
535 			free(object_name);
536 	}
537 	return (NWAM_SUCCESS);
538 }
539 
540 static nwam_error_t
541 valid_nameservices(nwam_value_t value)
542 {
543 	uint64_t *nameservices;
544 	uint_t i, numvalues;
545 
546 	if (nwam_value_get_uint64_array(value, &nameservices, &numvalues)
547 	    != NWAM_SUCCESS)
548 		return (NWAM_ENTITY_INVALID_VALUE);
549 
550 	for (i = 0; i < numvalues; i++) {
551 		if (nameservices[i] > NWAM_NAMESERVICES_LDAP)
552 			return (NWAM_ENTITY_INVALID_VALUE);
553 	}
554 	return (NWAM_SUCCESS);
555 }
556 
557 static nwam_error_t
558 valid_configsrc(nwam_value_t value)
559 {
560 	uint64_t *configsrcs;
561 	uint_t i, numvalues;
562 
563 	if (nwam_value_get_uint64_array(value, &configsrcs, &numvalues)
564 	    != NWAM_SUCCESS)
565 		return (NWAM_ENTITY_INVALID_VALUE);
566 
567 	for (i = 0; i < numvalues; i++) {
568 		if (configsrcs[i] > NWAM_CONFIGSRC_DHCP)
569 			return (NWAM_ENTITY_INVALID_VALUE);
570 	}
571 	return (NWAM_SUCCESS);
572 }
573 
574 /*
575  * Validates that the activation-mode is system for Automatic and NoNet
576  * locations, and not system for all other locations.
577  */
578 static nwam_error_t
579 nwam_loc_validate_activation_mode(nwam_loc_handle_t loch, nwam_value_t actval)
580 {
581 	nwam_error_t err;
582 	uint64_t activation;
583 
584 	if ((err = nwam_value_get_uint64(actval, &activation)) != NWAM_SUCCESS)
585 		return (err);
586 
587 	if (NWAM_LOC_NAME_PRE_DEFINED(loch->nwh_name)) {
588 		if (activation != NWAM_ACTIVATION_MODE_SYSTEM)
589 			return (NWAM_ENTITY_INVALID_VALUE);
590 	} else {
591 		if (activation == NWAM_ACTIVATION_MODE_SYSTEM)
592 			return (NWAM_ENTITY_INVALID_VALUE);
593 	}
594 	return (NWAM_SUCCESS);
595 }
596 
597 /*
598  * Helper function to validate one nameservice, used by
599  * nwam_loc_validate_all_nameservices().
600  *
601  * requiredprop denotes the property that is mandatory when the
602  * configsrcprop is manual.  errpropp is used to return the invalid
603  * property.
604  */
605 static nwam_error_t
606 nwam_loc_validate_one_nameservice(nwam_loc_handle_t loch,
607     const char *configsrcprop, const char *requiredprop, const char **errpropp)
608 {
609 	nwam_value_t configsrcval, requiredval;
610 	uint64_t *configsrcs;
611 	uint_t i, numvalues;
612 
613 	if (nwam_loc_get_prop_value(loch, configsrcprop, &configsrcval)
614 	    != NWAM_SUCCESS) {
615 		if (errpropp != NULL)
616 			*errpropp = configsrcprop;
617 		return (NWAM_ENTITY_MISSING_MEMBER);
618 	}
619 
620 	if (nwam_value_get_uint64_array(configsrcval, &configsrcs, &numvalues)
621 	    != NWAM_SUCCESS) {
622 		if (errpropp != NULL)
623 			*errpropp = configsrcprop;
624 		nwam_value_free(configsrcval);
625 		return (NWAM_ENTITY_NO_VALUE);
626 	}
627 
628 	/* If -configsrc is manual, requiredprop is required */
629 	for (i = 0; i < numvalues; i++) {
630 		if (configsrcs[i] == NWAM_CONFIGSRC_MANUAL) {
631 			if (nwam_loc_get_prop_value(loch, requiredprop,
632 			    &requiredval) != NWAM_SUCCESS) {
633 				if (errpropp != NULL)
634 					*errpropp = requiredprop;
635 				return (NWAM_ENTITY_MISSING_MEMBER);
636 			}
637 			nwam_value_free(requiredval);
638 		}
639 	}
640 	nwam_value_free(configsrcval);
641 
642 	return (NWAM_SUCCESS);
643 }
644 
645 /*
646  * Helper function to validate LDAP nameservice, used by
647  * nwam_loc_validate_all_nameservices().  Separated because LDAP must be
648  * configured manually only and both default-domain and -servers are required.
649  */
650 static nwam_error_t
651 nwam_loc_validate_ldap_nameservice(nwam_loc_handle_t loch,
652     const char **errpropp)
653 {
654 	nwam_value_t val;
655 	uint64_t *configsrcs;
656 	uint_t i, numvalues;
657 
658 	if (nwam_loc_get_prop_value(loch,
659 	    NWAM_LOC_PROP_LDAP_NAMESERVICE_CONFIGSRC, &val) != NWAM_SUCCESS) {
660 		if (errpropp != NULL)
661 			*errpropp = NWAM_LOC_PROP_LDAP_NAMESERVICE_CONFIGSRC;
662 		return (NWAM_ENTITY_MISSING_MEMBER);
663 	}
664 	/* -configsrc is defined as an array */
665 	if (nwam_value_get_uint64_array(val, &configsrcs, &numvalues)
666 	    != NWAM_SUCCESS) {
667 		if (errpropp != NULL)
668 			*errpropp = NWAM_LOC_PROP_LDAP_NAMESERVICE_CONFIGSRC;
669 		nwam_value_free(val);
670 		return (NWAM_ENTITY_NO_VALUE);
671 	}
672 
673 	/* -configsrc must be manual */
674 	for (i = 0; i < numvalues; i++) {
675 		if (configsrcs[i] != NWAM_CONFIGSRC_MANUAL) {
676 			if (errpropp != NULL)
677 				*errpropp =
678 				    NWAM_LOC_PROP_LDAP_NAMESERVICE_CONFIGSRC;
679 			nwam_value_free(val);
680 			return (NWAM_ENTITY_INVALID_VALUE);
681 		}
682 	}
683 	nwam_value_free(val);
684 
685 	/* both default-domain and -servers are required */
686 	if (nwam_loc_get_prop_value(loch,
687 	    NWAM_LOC_PROP_DEFAULT_DOMAIN, &val) != NWAM_SUCCESS) {
688 		if (errpropp != NULL)
689 			*errpropp = NWAM_LOC_PROP_DEFAULT_DOMAIN;
690 		return (NWAM_ENTITY_MISSING_MEMBER);
691 	}
692 	nwam_value_free(val);
693 
694 	if (nwam_loc_get_prop_value(loch,
695 	    NWAM_LOC_PROP_LDAP_NAMESERVICE_SERVERS, &val) != NWAM_SUCCESS) {
696 		if (errpropp != NULL)
697 			*errpropp = NWAM_LOC_PROP_LDAP_NAMESERVICE_SERVERS;
698 		return (NWAM_ENTITY_MISSING_MEMBER);
699 	}
700 	nwam_value_free(val);
701 
702 	return (NWAM_SUCCESS);
703 }
704 
705 /*
706  * Validates the different nameservices properties.
707  *
708  * If "nameservices" property has more than one nameservice to configure,
709  * "nameservices-config-file" must be specified.  If only one nameservice
710  * is configured and "nameservices-config-file" is missing, set the
711  * property with the appropriately suffixed nsswitch file.
712  *
713  * For any nameservice being configured, the respective -configsrc property
714  * must be specified.  For DNS, -servers is required if -configsrc is
715  * manual.  For NIS and LDAP, default-domain is required if -configsrc is
716  * manual.  For LDAP, -configsrc must be manual and -servers is required.
717  */
718 static nwam_error_t
719 nwam_loc_validate_all_nameservices(nwam_loc_handle_t loch,
720     nwam_value_t nameservicesval, const char **errpropp)
721 {
722 	nwam_error_t err;
723 	nwam_value_t val;
724 	uint64_t *nameservices;
725 	uint_t i, numvalues;
726 
727 	if ((err = nwam_value_get_uint64_array(nameservicesval, &nameservices,
728 	    &numvalues)) != NWAM_SUCCESS)
729 		return (err);
730 
731 	/*
732 	 * nameservices-config-file is required if nameservices has more
733 	 * than one value.
734 	 */
735 	if (numvalues > 1) {
736 		if (nwam_loc_get_prop_value(loch,
737 		    NWAM_LOC_PROP_NAMESERVICES_CONFIG_FILE, &val)
738 		    != NWAM_SUCCESS) {
739 			if (errpropp != NULL)
740 				*errpropp =
741 				    NWAM_LOC_PROP_NAMESERVICES_CONFIG_FILE;
742 			return (NWAM_ENTITY_MISSING_MEMBER);
743 		}
744 		nwam_value_free(val);
745 	} else if (numvalues == 1) {
746 		/*
747 		 * If only one nameservice is being configured and
748 		 * nameservices-config-file doesn't exist, create it to
749 		 * point to the respective nsswitch file.
750 		 */
751 		err = nwam_loc_get_prop_value(loch,
752 		    NWAM_LOC_PROP_NAMESERVICES_CONFIG_FILE, &val);
753 		if (err == NWAM_INVALID_ARG || err == NWAM_ENTITY_NOT_FOUND) {
754 			char *nsswitch;
755 			const char *nsswitch_suffix;
756 
757 			/* get the single nameservice being configured */
758 			if ((err = nwam_uint64_get_value_string(
759 			    NWAM_LOC_PROP_NAMESERVICES, nameservices[0],
760 			    &nsswitch_suffix)) != NWAM_SUCCESS)
761 				goto config_file_fail;
762 			if ((nsswitch = malloc(MAXPATHLEN)) == NULL) {
763 				err = NWAM_NO_MEMORY;
764 				goto config_file_fail;
765 			}
766 
767 			/* create appropriately suffixed nsswitch name */
768 			(void) snprintf(nsswitch, MAXPATHLEN, "%s%s",
769 			    NSSWITCH_PREFIX, nsswitch_suffix);
770 			if ((err = nwam_value_create_string(nsswitch, &val))
771 			    != NWAM_SUCCESS) {
772 				free(nsswitch);
773 				goto config_file_fail;
774 			}
775 
776 			err = nwam_set_prop_value(loch->nwh_data,
777 			    NWAM_LOC_PROP_NAMESERVICES_CONFIG_FILE, val);
778 			free(nsswitch);
779 			nwam_value_free(val);
780 			if (err != NWAM_SUCCESS) {
781 				nwam_value_free(val);
782 				goto config_file_fail;
783 			}
784 		} else if (err != NWAM_SUCCESS) {
785 			goto config_file_fail;
786 		} else {
787 			nwam_value_free(val);
788 		}
789 	}
790 
791 	/*
792 	 * validate the -configsrc property and the required default-domain
793 	 * and/or -servers property for each nameservice being configured.
794 	 */
795 	for (i = 0; i < numvalues; i++) {
796 		switch (nameservices[i]) {
797 		case NWAM_NAMESERVICES_DNS:
798 			if ((err = nwam_loc_validate_one_nameservice(loch,
799 			    NWAM_LOC_PROP_DNS_NAMESERVICE_CONFIGSRC,
800 			    NWAM_LOC_PROP_DNS_NAMESERVICE_SERVERS, errpropp))
801 			    != NWAM_SUCCESS)
802 				return (err);
803 			break;
804 		case NWAM_NAMESERVICES_NIS:
805 			if ((err = nwam_loc_validate_one_nameservice(loch,
806 			    NWAM_LOC_PROP_NIS_NAMESERVICE_CONFIGSRC,
807 			    NWAM_LOC_PROP_DEFAULT_DOMAIN, errpropp))
808 			    != NWAM_SUCCESS)
809 				return (err);
810 			break;
811 		case NWAM_NAMESERVICES_LDAP:
812 			if ((err = nwam_loc_validate_ldap_nameservice(loch,
813 			    errpropp)) != NWAM_SUCCESS)
814 				return (err);
815 			break;
816 		case NWAM_NAMESERVICES_FILES:
817 			break;
818 		default:
819 			return (NWAM_ENTITY_INVALID_VALUE);
820 		}
821 	}
822 	return (NWAM_SUCCESS);
823 
824 config_file_fail:
825 	if (errpropp != NULL)
826 		*errpropp =  NWAM_LOC_PROP_NAMESERVICES_CONFIG_FILE;
827 	return (err);
828 }
829 
830 nwam_error_t
831 nwam_loc_validate(nwam_loc_handle_t loch, const char **errpropp)
832 {
833 	nwam_error_t err;
834 	nwam_value_t activationval, conditionval, nameservicesval;
835 	uint64_t activation;
836 	char **conditions, *name;
837 	uint_t i, numvalues;
838 	nwam_condition_object_type_t object_type;
839 	nwam_condition_t condition;
840 
841 	assert(loch != NULL);
842 
843 	/*
844 	 * Make sure loc is internally consistent: if activation type is
845 	 * conditional, the condition string must be specified.
846 	 */
847 	if (nwam_loc_get_prop_value(loch, NWAM_LOC_PROP_ACTIVATION_MODE,
848 	    &activationval) != NWAM_SUCCESS) {
849 		if (errpropp != NULL)
850 			*errpropp = NWAM_LOC_PROP_ACTIVATION_MODE;
851 		return (NWAM_ENTITY_MISSING_MEMBER);
852 	}
853 
854 	if (nwam_value_get_uint64(activationval, &activation)
855 	    != NWAM_SUCCESS) {
856 		if (errpropp != NULL)
857 			*errpropp = NWAM_LOC_PROP_ACTIVATION_MODE;
858 		nwam_value_free(activationval);
859 		return (NWAM_ENTITY_NO_VALUE);
860 	}
861 
862 	/* validate activation against the location first */
863 	if ((err = nwam_loc_validate_activation_mode(loch, activationval))
864 	    != NWAM_SUCCESS) {
865 		if (errpropp != NULL)
866 			*errpropp = NWAM_LOC_PROP_ACTIVATION_MODE;
867 		nwam_value_free(activationval);
868 		return (err);
869 	}
870 	nwam_value_free(activationval);
871 
872 	if (activation == NWAM_ACTIVATION_MODE_CONDITIONAL_ANY ||
873 	    activation == NWAM_ACTIVATION_MODE_CONDITIONAL_ALL) {
874 		if (nwam_loc_get_prop_value(loch, NWAM_LOC_PROP_CONDITIONS,
875 		    &conditionval) != NWAM_SUCCESS) {
876 			if (errpropp != NULL)
877 				*errpropp = NWAM_LOC_PROP_CONDITIONS;
878 			return (NWAM_ENTITY_MISSING_MEMBER);
879 		}
880 		/*
881 		 * Are conditions self-referential? In other words, do any
882 		 * of the activation conditions refer to this location?
883 		 */
884 		if (nwam_value_get_string_array(conditionval, &conditions,
885 		    &numvalues) != NWAM_SUCCESS) {
886 			nwam_value_free(conditionval);
887 			if (errpropp != NULL)
888 				*errpropp = NWAM_LOC_PROP_CONDITIONS;
889 			return (NWAM_ENTITY_INVALID_VALUE);
890 		}
891 		if (nwam_loc_get_name(loch, &name) != NWAM_SUCCESS) {
892 			nwam_value_free(conditionval);
893 			return (NWAM_INVALID_ARG);
894 		}
895 		for (i = 0; i < numvalues; i++) {
896 			char *object_name = NULL;
897 
898 			if (nwam_condition_string_to_condition(conditions[i],
899 			    &object_type, &condition, &object_name)
900 			    != NWAM_SUCCESS) {
901 				if (errpropp != NULL)
902 					*errpropp = NWAM_LOC_PROP_CONDITIONS;
903 				free(name);
904 				nwam_value_free(conditionval);
905 				return (NWAM_ENTITY_INVALID_VALUE);
906 			}
907 			if (object_name != NULL &&
908 			    object_type == NWAM_CONDITION_OBJECT_TYPE_LOC &&
909 			    strcmp(object_name, name) == 0) {
910 				if (errpropp != NULL)
911 					*errpropp = NWAM_LOC_PROP_CONDITIONS;
912 				free(name);
913 				free(object_name);
914 				nwam_value_free(conditionval);
915 				return (NWAM_ENTITY_INVALID_VALUE);
916 			}
917 			free(object_name);
918 		}
919 		free(name);
920 		nwam_value_free(conditionval);
921 	}
922 
923 	/* validate namerservices */
924 	if (nwam_loc_get_prop_value(loch, NWAM_LOC_PROP_NAMESERVICES,
925 	    &nameservicesval) != NWAM_SUCCESS) {
926 		if (errpropp != NULL)
927 			*errpropp = NWAM_LOC_PROP_NAMESERVICES;
928 		return (NWAM_ENTITY_MISSING_MEMBER);
929 	}
930 	err = nwam_loc_validate_all_nameservices(loch, nameservicesval,
931 	    errpropp);
932 	nwam_value_free(nameservicesval);
933 	if (err != NWAM_SUCCESS)
934 		return (err);
935 
936 	return (nwam_validate(loc_prop_table, loch, errpropp));
937 }
938 
939 nwam_error_t
940 nwam_loc_validate_prop(nwam_loc_handle_t loch, const char *propname,
941     nwam_value_t value)
942 {
943 	nwam_error_t err;
944 
945 	assert(loch != NULL);
946 
947 	if (strcmp(propname, NWAM_LOC_PROP_ACTIVATION_MODE) == 0) {
948 		if ((err = nwam_loc_validate_activation_mode(loch, value))
949 		    != NWAM_SUCCESS)
950 			return (err);
951 	}
952 
953 	return (nwam_validate_prop(loc_prop_table, loch, propname, value));
954 }
955 
956 nwam_error_t
957 nwam_loc_copy(nwam_loc_handle_t oldloch, const char *newname,
958     nwam_loc_handle_t *newlochp)
959 {
960 	nwam_error_t err;
961 	nwam_value_t val;
962 
963 	if ((err = nwam_copy(NWAM_LOC_CONF_FILE, oldloch, newname, newlochp))
964 	    != NWAM_SUCCESS)
965 		return (err);
966 
967 	/* If the activation-mode is system, change it to manual */
968 	if ((err = nwam_loc_get_prop_value(*newlochp,
969 	    NWAM_LOC_PROP_ACTIVATION_MODE, &val)) != NWAM_SUCCESS)
970 		goto finish;
971 	err = nwam_loc_validate_activation_mode(*newlochp, val);
972 	nwam_value_free(val);
973 	if (err != NWAM_SUCCESS) {
974 		if ((err = nwam_value_create_uint64(NWAM_ACTIVATION_MODE_MANUAL,
975 		    &val)) != NWAM_SUCCESS)
976 			goto finish;
977 		err = nwam_set_prop_value((*newlochp)->nwh_data,
978 		    NWAM_LOC_PROP_ACTIVATION_MODE, val);
979 		nwam_value_free(val);
980 		if (err != NWAM_SUCCESS)
981 			goto finish;
982 
983 		if ((err = nwam_value_create_boolean(B_FALSE, &val))
984 		    != NWAM_SUCCESS)
985 			goto finish;
986 		err = nwam_set_prop_value((*newlochp)->nwh_data,
987 		    NWAM_LOC_PROP_ENABLED, val);
988 		nwam_value_free(val);
989 		if (err != NWAM_SUCCESS)
990 			goto finish;
991 	}
992 
993 	return (NWAM_SUCCESS);
994 
995 finish:
996 	nwam_loc_free(*newlochp);
997 	*newlochp = NULL;
998 	return (err);
999 }
1000 
1001 /*
1002  * Given a property, return expected property data type
1003  */
1004 nwam_error_t
1005 nwam_loc_get_prop_type(const char *propname, nwam_value_type_t *typep)
1006 {
1007 	return (nwam_get_prop_type(loc_prop_table, propname, typep));
1008 }
1009 
1010 nwam_error_t
1011 nwam_loc_prop_multivalued(const char *propname, boolean_t *multip)
1012 {
1013 	return (nwam_prop_multivalued(loc_prop_table, propname, multip));
1014 }
1015 
1016 /*
1017  * Determine if the location has manual activation-mode or not.
1018  */
1019 nwam_error_t
1020 nwam_loc_is_manual(nwam_loc_handle_t loch, boolean_t *manualp)
1021 {
1022 	nwam_error_t err;
1023 	nwam_value_t actval;
1024 	uint64_t activation;
1025 
1026 	assert(loch != NULL);
1027 
1028 	if ((err = nwam_loc_get_prop_value(loch, NWAM_LOC_PROP_ACTIVATION_MODE,
1029 	    &actval)) != NWAM_SUCCESS)
1030 		return (err);
1031 	err = nwam_value_get_uint64(actval, &activation);
1032 	nwam_value_free(actval);
1033 	if (err != NWAM_SUCCESS)
1034 		return (err);
1035 
1036 	if (activation == NWAM_ACTIVATION_MODE_MANUAL)
1037 		*manualp = B_TRUE;
1038 	else
1039 		*manualp = B_FALSE;
1040 	return (NWAM_SUCCESS);
1041 }
1042 
1043 /* Determine if location is enabled or not */
1044 static nwam_error_t
1045 nwam_loc_is_enabled(nwam_loc_handle_t loch, boolean_t *enabledp)
1046 {
1047 	nwam_error_t err;
1048 	nwam_value_t enabledval;
1049 
1050 	assert(loch != NULL);
1051 
1052 	if ((err = nwam_loc_get_prop_value(loch, NWAM_LOC_PROP_ENABLED,
1053 	    &enabledval)) != NWAM_SUCCESS)
1054 		return (err);
1055 	err = nwam_value_get_boolean(enabledval, enabledp);
1056 	nwam_value_free(enabledval);
1057 	return (err);
1058 }
1059 
1060 /*
1061  * Callback to disable all locations other than one to enable, the handle
1062  * of which we pass in as an argument. If the argument is NULL, we disable
1063  * all locations.
1064  */
1065 static int
1066 loc_set_enabled(nwam_loc_handle_t loch, void *data)
1067 {
1068 	nwam_value_t enabledval;
1069 	boolean_t enabled = B_FALSE;
1070 	nwam_loc_handle_t testloch = data;
1071 	nwam_error_t err = NWAM_SUCCESS;
1072 
1073 	if (testloch != NULL) {
1074 		char *name, *testname;
1075 
1076 		if (nwam_loc_get_name(loch, &name) == NWAM_SUCCESS &&
1077 		    nwam_loc_get_name(testloch, &testname) == NWAM_SUCCESS &&
1078 		    strcmp(name, testname) == 0) {
1079 			/* We enable this location. */
1080 			enabled = B_TRUE;
1081 		}
1082 	}
1083 	if (nwam_value_create_boolean(enabled, &enabledval) != NWAM_SUCCESS)
1084 		return (0);
1085 	if (nwam_set_prop_value(loch->nwh_data, NWAM_LOC_PROP_ENABLED,
1086 	    enabledval) == NWAM_SUCCESS)
1087 		err = nwam_loc_commit(loch, NWAM_FLAG_ENTITY_ENABLE);
1088 
1089 	nwam_value_free(enabledval);
1090 	return (err);
1091 }
1092 
1093 /*
1094  * Update the enabled property for this location (and for all others
1095  * if necessary.
1096  */
1097 static int
1098 nwam_loc_update_enabled(nwam_loc_handle_t loch, boolean_t enabled)
1099 {
1100 	nwam_error_t err;
1101 	int cb_ret;
1102 
1103 	if (enabled) {
1104 		/*
1105 		 * Disable all other locations that are manually enabled
1106 		 * and enable this one - a maximum of 1 location can be
1107 		 * enabled at once.
1108 		 */
1109 		err = nwam_walk_locs(loc_set_enabled, loch, 0, &cb_ret);
1110 		if (err != NWAM_SUCCESS && err != NWAM_WALK_HALTED)
1111 			cb_ret = err;
1112 	} else {
1113 		cb_ret = loc_set_enabled(loch, NULL);
1114 	}
1115 	return (cb_ret);
1116 }
1117 
1118 nwam_error_t
1119 nwam_loc_enable(nwam_loc_handle_t loch)
1120 {
1121 	nwam_error_t err;
1122 	boolean_t enabled;
1123 
1124 	assert(loch != NULL);
1125 
1126 	/* Make sure location is not enabled */
1127 	if ((err = nwam_loc_is_enabled(loch, &enabled)) != NWAM_SUCCESS)
1128 		return (err);
1129 	if (enabled)
1130 		return (NWAM_SUCCESS);
1131 
1132 	if ((err = nwam_loc_update_enabled(loch, B_TRUE)) != NWAM_SUCCESS)
1133 		return (err);
1134 
1135 	err = nwam_enable(NULL, loch);
1136 
1137 	/* nwamd may not be running, that's okay. */
1138 	if (err == NWAM_ERROR_BIND)
1139 		return (NWAM_SUCCESS);
1140 	else
1141 		return (err);
1142 }
1143 
1144 nwam_error_t
1145 nwam_loc_disable(nwam_loc_handle_t loch)
1146 {
1147 	nwam_error_t err;
1148 	boolean_t enabled;
1149 
1150 	assert(loch != NULL);
1151 
1152 	/* Make sure location is enabled */
1153 	if ((err = nwam_loc_is_enabled(loch, &enabled)) != NWAM_SUCCESS)
1154 		return (err);
1155 	if (!enabled)
1156 		return (NWAM_SUCCESS);
1157 
1158 	if ((err = nwam_loc_update_enabled(loch, B_FALSE)) != NWAM_SUCCESS)
1159 		return (err);
1160 
1161 	err = nwam_disable(NULL, loch);
1162 
1163 	/* nwamd may not be running, that's okay. */
1164 	if (err == NWAM_ERROR_BIND)
1165 		return (NWAM_SUCCESS);
1166 	else
1167 		return (err);
1168 }
1169 
1170 nwam_error_t
1171 nwam_loc_get_default_proplist(const char ***prop_list, uint_t *numvaluesp)
1172 {
1173 	return (nwam_get_default_proplist(loc_prop_table,
1174 	    NWAM_TYPE_ANY, NWAM_CLASS_ANY, prop_list, numvaluesp));
1175 }
1176 
1177 nwam_error_t
1178 nwam_loc_get_state(nwam_loc_handle_t loch, nwam_state_t *statep,
1179     nwam_aux_state_t *auxp)
1180 {
1181 	return (nwam_get_state(NULL, loch, statep, auxp));
1182 }
1183