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 (c) 2010, Oracle and/or its affiliates. All rights reserved.
24  * Copyright (c) 2016, Chris Fraire <cfraire@me.com>.
25  */
26 
27 /*
28  * nwamcfg is a lex/yacc based command interpreter used to manage network
29  * configurations.  The lexer (see nwamcfg_lex.l) builds up tokens, which
30  * the grammar (see nwamcfg_grammar.y) builds up into commands, some of
31  * which takes resources and/or properties as arguments.
32  */
33 
34 #include <arpa/inet.h>
35 #include <assert.h>
36 #include <ctype.h>
37 #include <errno.h>
38 #include <libnwam.h>
39 #include <libtecla.h>
40 #include <locale.h>
41 #include <stdarg.h>
42 #include <stdio.h>
43 #include <string.h>
44 #include <sys/stat.h>
45 #include <sys/sysmacros.h>
46 #include <sys/types.h>
47 #include <unistd.h>
48 
49 #include "nwamcfg.h"
50 
51 #if !defined(TEXT_DOMAIN)		/* should be defined by cc -D */
52 #define	TEXT_DOMAIN	"SYS_TEST"	/* Use this only if it wasn't */
53 #endif
54 
55 struct help {
56 	uint_t		cmd_num;
57 	const char	*cmd_name;
58 	const char	*cmd_usage;
59 };
60 
61 extern int yyparse(void);
62 extern int lex_lineno;
63 
64 #define	MAX_LINE_LEN	1024
65 #define	MAX_CMD_HIST	1024
66 
67 /* usage of commands */
68 #define	SHELP_CANCEL	"cancel"
69 #define	SHELP_CLEAR	"clear <prop-name>"
70 #define	SHELP_COMMIT	"commit"
71 #define	SHELP_CREATE	"create [-t <template>] <object-type> [<class>] " \
72 			"<object-name>"
73 #define	SHELP_DESTROY	"destroy {-a | <object-type> [<class>] <object-name>}"
74 #define	SHELP_END	"end"
75 #define	SHELP_EXIT	"exit"
76 #define	SHELP_EXPORT	"export [-d] [-f <output-file>] " \
77 			"[<object-type> [<class>] <object-name>]"
78 #define	SHELP_GET	"get [-V] <prop-name>"
79 #define	SHELP_HELP	"help [command-name]"
80 #define	SHELP_LIST	"list [-a] [<object-type> [<class>] <object-name>]"
81 #define	SHELP_REVERT	"revert"
82 #define	SHELP_SELECT	"select <object-type> [<class>] <object-name>"
83 #define	SHELP_SET	"set <prop-name>=<value1>[,<value2>...]"
84 #define	SHELP_VERIFY	"verify"
85 #define	SHELP_WALK	"walkprop [-a]"
86 
87 /*
88  * Scope Definitions:
89  * Locations, ENMs, NCPs and Known WLANs are one scope level below global (GBL).
90  * NCUs are one more level beneath the NCP scope.
91  * Because the commands in Locations/ENM/Known WLAN and NCP level are different,
92  * the scope are divided accordingly.
93  *     GBL->LOC, GBL->ENM, GBL->WLAN or GBL->NCP->NCU
94  */
95 #define	NWAM_SCOPE_GBL	0
96 #define	NWAM_SCOPE_LOC	1
97 #define	NWAM_SCOPE_ENM	2
98 #define	NWAM_SCOPE_WLAN	3
99 #define	NWAM_SCOPE_NCP	4
100 #define	NWAM_SCOPE_NCU	5
101 
102 /* delimiter used for list of values */
103 #define	NWAM_VALUE_DELIMITER_CHAR	','
104 #define	NWAM_VALUE_DELIMITER_STR	","
105 
106 /* the max number of values for an enum used by some properties in libnwam */
107 
108 /*
109  * All arrays/tables are null-terminated, rather than defining the length of
110  * the array.  When looping, check for NULL rather than using the size.
111  */
112 
113 static struct help helptab[] = {
114 	{ CMD_CANCEL,	"cancel",	SHELP_CANCEL	},
115 	{ CMD_CLEAR,	"clear",	SHELP_CLEAR	},
116 	{ CMD_COMMIT,	"commit",	SHELP_COMMIT	},
117 	{ CMD_CREATE,	"create",	SHELP_CREATE	},
118 	{ CMD_DESTROY,	"destroy",	SHELP_DESTROY	},
119 	{ CMD_END,	"end",		SHELP_END	},
120 	{ CMD_EXIT,	"exit",		SHELP_EXIT	},
121 	{ CMD_EXPORT,	"export",	SHELP_EXPORT	},
122 	{ CMD_GET,	"get",		SHELP_GET	},
123 	{ CMD_HELP,	"help",		SHELP_HELP	},
124 	{ CMD_LIST,	"list",		SHELP_LIST	},
125 	{ CMD_REVERT,	"revert",	SHELP_REVERT	},
126 	{ CMD_SELECT,	"select",	SHELP_SELECT	},
127 	{ CMD_SET,	"set",		SHELP_SET	},
128 	{ CMD_VERIFY,	"verify",	SHELP_VERIFY	},
129 	{ CMD_WALKPROP,	"walkprop",	SHELP_WALK	},
130 	{ 0, NULL, NULL }
131 };
132 
133 /* These *must* match the order of the RT1_ define's from nwamcfg.h */
134 static char *res1_types[] = {
135 	"unknown",
136 	"loc",
137 	"ncp",
138 	"enm",
139 	"wlan",
140 	NULL
141 };
142 
143 /* These *must* match the order of the RT2_ define's from nwamcfg.h */
144 static char *res2_types[] = {
145 	"unknown",
146 	"ncu",
147 	NULL
148 };
149 
150 /*
151  * No array for NCU_CLASS_.  The #define's in nwamcfg.h matches the
152  * enum nwam_ncu_class_t in libnwam and thus uses libnwam functions to
153  * retrieve the string representation.
154  */
155 
156 /* These *MUST* match the order of the PT_ define's from nwamcfg.h */
157 static char *pt_types[] = {
158 	"unknown",
159 	NWAM_NCU_PROP_ACTIVATION_MODE,
160 	NWAM_NCU_PROP_ENABLED,
161 	NWAM_NCU_PROP_TYPE,
162 	NWAM_NCU_PROP_CLASS,
163 	NWAM_NCU_PROP_PARENT_NCP,
164 	NWAM_NCU_PROP_PRIORITY_GROUP,
165 	NWAM_NCU_PROP_PRIORITY_MODE,
166 	NWAM_NCU_PROP_LINK_MAC_ADDR,
167 	NWAM_NCU_PROP_LINK_AUTOPUSH,
168 	NWAM_NCU_PROP_LINK_MTU,
169 	NWAM_NCU_PROP_IP_VERSION,
170 	NWAM_NCU_PROP_IPV4_ADDRSRC,
171 	NWAM_NCU_PROP_IPV4_ADDR,
172 	NWAM_NCU_PROP_IPV4_DEFAULT_ROUTE,
173 	NWAM_NCU_PROP_IPV6_ADDRSRC,
174 	NWAM_NCU_PROP_IPV6_ADDR,
175 	NWAM_NCU_PROP_IPV6_DEFAULT_ROUTE,
176 	NWAM_LOC_PROP_CONDITIONS,
177 	NWAM_ENM_PROP_FMRI,
178 	NWAM_ENM_PROP_START,
179 	NWAM_ENM_PROP_STOP,
180 	NWAM_LOC_PROP_NAMESERVICES,
181 	NWAM_LOC_PROP_NAMESERVICES_CONFIG_FILE,
182 	NWAM_LOC_PROP_DNS_NAMESERVICE_CONFIGSRC,
183 	NWAM_LOC_PROP_DNS_NAMESERVICE_DOMAIN,
184 	NWAM_LOC_PROP_DNS_NAMESERVICE_SERVERS,
185 	NWAM_LOC_PROP_DNS_NAMESERVICE_SEARCH,
186 	NWAM_LOC_PROP_NIS_NAMESERVICE_CONFIGSRC,
187 	NWAM_LOC_PROP_NIS_NAMESERVICE_SERVERS,
188 	NWAM_LOC_PROP_LDAP_NAMESERVICE_CONFIGSRC,
189 	NWAM_LOC_PROP_LDAP_NAMESERVICE_SERVERS,
190 	NWAM_LOC_PROP_DEFAULT_DOMAIN,
191 	NWAM_LOC_PROP_NFSV4_DOMAIN,
192 	NWAM_LOC_PROP_IPFILTER_CONFIG_FILE,
193 	NWAM_LOC_PROP_IPFILTER_V6_CONFIG_FILE,
194 	NWAM_LOC_PROP_IPNAT_CONFIG_FILE,
195 	NWAM_LOC_PROP_IPPOOL_CONFIG_FILE,
196 	NWAM_LOC_PROP_IKE_CONFIG_FILE,
197 	NWAM_LOC_PROP_IPSECPOLICY_CONFIG_FILE,
198 	NWAM_KNOWN_WLAN_PROP_BSSIDS,
199 	NWAM_KNOWN_WLAN_PROP_PRIORITY,
200 	NWAM_KNOWN_WLAN_PROP_KEYNAME,
201 	NWAM_KNOWN_WLAN_PROP_KEYSLOT,
202 	NWAM_KNOWN_WLAN_PROP_SECURITY_MODE,
203 	NWAM_NCU_PROP_IP_PRIMARY,
204 	NWAM_NCU_PROP_IP_REQHOST
205 };
206 
207 /* properties table: maps PT_* constants to property names */
208 typedef struct prop_table_entry {
209 	int			pte_type;
210 	const char		*pte_name;
211 } prop_table_entry_t;
212 
213 /* NCU properties table */
214 static prop_table_entry_t ncu_prop_table[] = {
215 	{ PT_TYPE, 			NWAM_NCU_PROP_TYPE },
216 	{ PT_CLASS, 			NWAM_NCU_PROP_CLASS },
217 	{ PT_PARENT, 			NWAM_NCU_PROP_PARENT_NCP },
218 	{ PT_ACTIVATION_MODE,		NWAM_NCU_PROP_ACTIVATION_MODE },
219 	{ PT_ENABLED, 			NWAM_NCU_PROP_ENABLED },
220 	{ PT_PRIORITY_GROUP, 		NWAM_NCU_PROP_PRIORITY_GROUP },
221 	{ PT_PRIORITY_MODE,		NWAM_NCU_PROP_PRIORITY_MODE },
222 	{ PT_LINK_MACADDR, 		NWAM_NCU_PROP_LINK_MAC_ADDR },
223 	{ PT_LINK_AUTOPUSH, 		NWAM_NCU_PROP_LINK_AUTOPUSH },
224 	{ PT_LINK_MTU, 			NWAM_NCU_PROP_LINK_MTU },
225 	{ PT_IP_VERSION, 		NWAM_NCU_PROP_IP_VERSION },
226 	{ PT_IPV4_ADDRSRC, 		NWAM_NCU_PROP_IPV4_ADDRSRC },
227 	{ PT_IPV4_ADDR, 		NWAM_NCU_PROP_IPV4_ADDR },
228 	{ PT_IPV4_DEFAULT_ROUTE,	NWAM_NCU_PROP_IPV4_DEFAULT_ROUTE },
229 	{ PT_IPV6_ADDRSRC, 		NWAM_NCU_PROP_IPV6_ADDRSRC },
230 	{ PT_IPV6_ADDR, 		NWAM_NCU_PROP_IPV6_ADDR },
231 	{ PT_IPV6_DEFAULT_ROUTE,	NWAM_NCU_PROP_IPV6_DEFAULT_ROUTE },
232 	{ PT_IP_PRIMARY,		NWAM_NCU_PROP_IP_PRIMARY },
233 	{ PT_IP_REQHOST,		NWAM_NCU_PROP_IP_REQHOST },
234 	{ 0, NULL }
235 };
236 
237 /* ENM properties table */
238 static prop_table_entry_t enm_prop_table[] = {
239 	{ PT_ENM_FMRI, 		NWAM_ENM_PROP_FMRI },
240 	{ PT_ENM_START, 	NWAM_ENM_PROP_START },
241 	{ PT_ENM_STOP, 		NWAM_ENM_PROP_STOP },
242 	{ PT_ACTIVATION_MODE, 	NWAM_ENM_PROP_ACTIVATION_MODE },
243 	{ PT_CONDITIONS, 	NWAM_ENM_PROP_CONDITIONS },
244 	{ PT_ENABLED, 		NWAM_ENM_PROP_ENABLED },
245 	{ 0, NULL }
246 };
247 
248 /* LOCation properties table */
249 static prop_table_entry_t loc_prop_table[] = {
250 	{ PT_ACTIVATION_MODE, 	NWAM_LOC_PROP_ACTIVATION_MODE },
251 	{ PT_CONDITIONS, 	NWAM_LOC_PROP_CONDITIONS },
252 	{ PT_ENABLED, 		NWAM_LOC_PROP_ENABLED },
253 	{ PT_LOC_NAMESERVICES, 	NWAM_LOC_PROP_NAMESERVICES },
254 	{ PT_LOC_NAMESERVICES_CONFIG, NWAM_LOC_PROP_NAMESERVICES_CONFIG_FILE },
255 	{ PT_LOC_DNS_CONFIGSRC, NWAM_LOC_PROP_DNS_NAMESERVICE_CONFIGSRC },
256 	{ PT_LOC_DNS_DOMAIN, 	NWAM_LOC_PROP_DNS_NAMESERVICE_DOMAIN },
257 	{ PT_LOC_DNS_SERVERS, 	NWAM_LOC_PROP_DNS_NAMESERVICE_SERVERS },
258 	{ PT_LOC_DNS_SEARCH, 	NWAM_LOC_PROP_DNS_NAMESERVICE_SEARCH },
259 	{ PT_LOC_NIS_CONFIGSRC, NWAM_LOC_PROP_NIS_NAMESERVICE_CONFIGSRC },
260 	{ PT_LOC_NIS_SERVERS, 	NWAM_LOC_PROP_NIS_NAMESERVICE_SERVERS },
261 	{ PT_LOC_LDAP_CONFIGSRC, NWAM_LOC_PROP_LDAP_NAMESERVICE_CONFIGSRC },
262 	{ PT_LOC_LDAP_SERVERS,	NWAM_LOC_PROP_LDAP_NAMESERVICE_SERVERS },
263 	{ PT_LOC_DEFAULT_DOMAIN, NWAM_LOC_PROP_DEFAULT_DOMAIN },
264 	{ PT_LOC_NFSV4_DOMAIN, 	NWAM_LOC_PROP_NFSV4_DOMAIN },
265 	{ PT_LOC_IPF_CONFIG, 	NWAM_LOC_PROP_IPFILTER_CONFIG_FILE },
266 	{ PT_LOC_IPF_V6_CONFIG, NWAM_LOC_PROP_IPFILTER_V6_CONFIG_FILE },
267 	{ PT_LOC_IPNAT_CONFIG, 	NWAM_LOC_PROP_IPNAT_CONFIG_FILE },
268 	{ PT_LOC_IPPOOL_CONFIG, NWAM_LOC_PROP_IPPOOL_CONFIG_FILE },
269 	{ PT_LOC_IKE_CONFIG, 	NWAM_LOC_PROP_IKE_CONFIG_FILE },
270 	{ PT_LOC_IPSECPOL_CONFIG, NWAM_LOC_PROP_IPSECPOLICY_CONFIG_FILE },
271 	{ 0, NULL }
272 };
273 
274 /* Known WLAN properties table */
275 static prop_table_entry_t wlan_prop_table[] = {
276 	{ PT_WLAN_BSSIDS, 	NWAM_KNOWN_WLAN_PROP_BSSIDS },
277 	{ PT_WLAN_PRIORITY, 	NWAM_KNOWN_WLAN_PROP_PRIORITY },
278 	{ PT_WLAN_KEYNAME, 	NWAM_KNOWN_WLAN_PROP_KEYNAME },
279 	{ PT_WLAN_KEYSLOT, 	NWAM_KNOWN_WLAN_PROP_KEYSLOT },
280 	{ PT_WLAN_SECURITY_MODE, NWAM_KNOWN_WLAN_PROP_SECURITY_MODE },
281 	{ 0, NULL }
282 };
283 
284 /* Returns the appropriate properties table for the given object type */
285 static prop_table_entry_t *
286 get_prop_table(nwam_object_type_t object_type)
287 {
288 	switch (object_type) {
289 	case NWAM_OBJECT_TYPE_NCU:
290 		return (ncu_prop_table);
291 	case NWAM_OBJECT_TYPE_LOC:
292 		return (loc_prop_table);
293 	case NWAM_OBJECT_TYPE_ENM:
294 		return (enm_prop_table);
295 	case NWAM_OBJECT_TYPE_KNOWN_WLAN:
296 		return (wlan_prop_table);
297 	}
298 	return (NULL);
299 }
300 
301 /* Global variables */
302 
303 /* set early in main(), never modified thereafter, used all over the place */
304 static char *execname;
305 
306 /* set in modifying functions, checked in read_input() */
307 boolean_t saw_error = B_FALSE;
308 
309 /* set in yacc parser, checked in read_input() */
310 boolean_t newline_terminated;
311 
312 /* set in main(), checked in lex error handler */
313 boolean_t cmd_file_mode = B_FALSE;
314 
315 /* set in exit_func(), checked in read_input() */
316 static boolean_t time_to_exit = B_FALSE;
317 
318 /* used in nerr() and nwamerr() */
319 static char *cmd_file_name = NULL;
320 
321 /* used with cmd_file to destroy all configurations */
322 static boolean_t remove_all_configurations = B_FALSE;
323 
324 /* checked in read_input() and other places */
325 static boolean_t ok_to_prompt = B_FALSE;
326 
327 /* initialized in do_interactive(), checked in initialize() */
328 static boolean_t interactive_mode;
329 
330 static boolean_t need_to_commit = B_FALSE;
331 
332 /* The gl_get_line() resource object */
333 static GetLine *gl;
334 
335 /* set when create or read objects, used by other func */
336 static nwam_loc_handle_t loc_h = NULL;
337 static nwam_enm_handle_t enm_h = NULL;
338 static nwam_known_wlan_handle_t wlan_h = NULL;
339 static nwam_ncu_handle_t ncu_h = NULL;
340 static nwam_ncp_handle_t ncp_h = NULL;
341 
342 static int current_scope = NWAM_SCOPE_GBL;
343 
344 /* obj1_* are used in NWAM_SCOPE_{NCP,LOC,ENM,WLAN} */
345 static int obj1_type;
346 static char obj1_name[NWAM_MAX_NAME_LEN + 1];
347 
348 /* obj2_* are used in NWAM_SCOPE_NCU only */
349 static int obj2_type;
350 static char obj2_name[NWAM_MAX_NAME_LEN + 1];
351 
352 /* arrays for tab-completion */
353 /* commands at NWAM_SCOPE_GBL */
354 static const char *global_scope_cmds[] = {
355 	"create ",
356 	"destroy ",
357 	"end ",
358 	"exit ",
359 	"export ",
360 	"help ",
361 	"list ",
362 	"select ",
363 	NULL
364 };
365 
366 static const char *global_create_cmds[] = {
367 	"create loc ",
368 	"create enm ",
369 	"create ncp ",
370 	"create wlan ",
371 	"create -t ",		/* template */
372 	NULL
373 };
374 
375 static const char *global_destroy_cmds[] = {
376 	"destroy -a ",
377 	"destroy loc ",
378 	"destroy enm ",
379 	"destroy ncp ",
380 	"destroy wlan ",
381 	NULL
382 };
383 
384 static const char *global_export_cmds[] = {
385 	"export ",
386 	"export -d ",		/* add destroy -a */
387 	"export -f ",		/* to file */
388 	"export -d -f ",	/* add destroy -a to file */
389 	"export loc ",
390 	"export enm ",
391 	"export ncp ",
392 	"export wlan ",
393 	NULL
394 };
395 
396 static const char *global_list_cmds[] = {
397 	"list ",
398 	"list loc ",
399 	"list enm ",
400 	"list ncp ",
401 	"list wlan ",
402 	"list -a loc ",
403 	"list -a enm ",
404 	"list -a wlan ",
405 	NULL
406 };
407 
408 static const char *global_select_cmds[] = {
409 	"select loc ",
410 	"select enm ",
411 	"select ncp ",
412 	"select wlan ",
413 	NULL
414 };
415 
416 /* commands at NWAM_SCOPE_LOC, _ENM, _WLAN and _NCU */
417 static const char *non_ncp_scope_cmds[] = {
418 	"cancel ",
419 	"clear ",
420 	"commit ",
421 	"end ",
422 	"exit ",
423 	"export ",
424 	"export -f ",
425 	"get ",
426 	"get -V ",	/* value only */
427 	"help ",
428 	"list ",
429 	"list -a ",	/* all properties */
430 	"revert ",
431 	"set ",
432 	"verify ",
433 	"walkprop ",
434 	"walkprop -a ",	/* all properties */
435 	NULL
436 };
437 
438 /* commands at NWAM_SCOPE_NCP */
439 static const char *ncp_scope_cmds[] = {
440 	"cancel ",
441 	"create ",
442 	"destroy ",
443 	"end ",
444 	"exit ",
445 	"export ",
446 	"help ",
447 	"list ",
448 	"select ",
449 	NULL
450 };
451 
452 static const char *ncp_create_cmds[] = {
453 	"create ncu ip ",
454 	"create ncu phys ",
455 	"create -t ",		/* template */
456 	NULL
457 };
458 
459 static const char *ncp_destroy_cmds[] = {
460 	"destroy ncu ",
461 	"destroy ncu ip ",
462 	"destroy ncu phys ",
463 	NULL
464 };
465 
466 static const char *ncp_export_cmds[] = {
467 	"export ",
468 	"export -f ",		/* to file */
469 	"export ncu ",
470 	"export ncu ip ",
471 	"export ncu phys ",
472 	NULL
473 };
474 
475 static const char *ncp_list_cmds[] = {
476 	"list ",
477 	"list ncu ",
478 	"list ncu ip ",
479 	"list ncu phys ",
480 	"list -a ncu ",
481 	"list -a ncu ip ",
482 	"list -a ncu phys ",
483 	NULL
484 };
485 
486 static const char *ncp_select_cmds[] = {
487 	"select ncu ",
488 	"select ncu ip ",
489 	"select ncu phys ",
490 	NULL
491 };
492 
493 /* Functions begin here */
494 
495 cmd_t *
496 alloc_cmd(void)
497 {
498 	cmd_t *cmd = calloc(1, sizeof (cmd_t));
499 	if (cmd == NULL) {
500 		nerr("Out of memory");
501 		return (NULL);
502 	}
503 	cmd->cmd_argc = 0;
504 	cmd->cmd_argv[0] = NULL;
505 
506 	return (cmd);
507 }
508 
509 void
510 free_cmd(cmd_t *cmd)
511 {
512 	int i;
513 
514 	for (i = 0; i < cmd->cmd_argc; i++)
515 		free(cmd->cmd_argv[i]);
516 	free(cmd);
517 }
518 
519 void
520 array_free(void **array, int nelem)
521 {
522 	int i;
523 	for (i = 0; i < nelem; i++)
524 		free(array[i]);
525 	free(array);
526 }
527 
528 static boolean_t
529 initial_match(const char *line1, const char *line2, int word_end)
530 {
531 	if (word_end <= 0)
532 		return (B_TRUE);
533 	return (strncmp(line1, line2, word_end) == 0);
534 }
535 
536 static int
537 add_stuff(WordCompletion *cpl, const char *line1, const char **list,
538     int word_end)
539 {
540 	int i, err;
541 
542 	for (i = 0; list[i] != NULL; i++) {
543 		if (initial_match(line1, list[i], word_end)) {
544 			err = cpl_add_completion(cpl, line1, 0, word_end,
545 			    list[i] + word_end, "", "");
546 			if (err != 0)
547 				return (err);
548 		}
549 	}
550 	return (0);
551 }
552 
553 /*
554  * To fill in the rest of a string when user types the tab key.
555  * First digital number is the length of the string, the second digital number
556  * is the min number of chars that is needed to uniquely identify a string.
557  */
558 #define	MINI_STR(l, s, m, n) strncmp(l, s, MAX(MIN(sizeof (s) - 1, m), n))
559 
560 /* ARGSUSED */
561 static
562 CPL_MATCH_FN(cmd_cpl_fn)
563 {
564 	/* tab-complete according to the current scope */
565 	switch (current_scope) {
566 	case NWAM_SCOPE_GBL:
567 		if (MINI_STR(line, "create ", word_end, 2) == 0)
568 			return (add_stuff(cpl, line, global_create_cmds,
569 			    word_end));
570 		if (MINI_STR(line, "destroy ", word_end, 1) == 0)
571 			return (add_stuff(cpl, line, global_destroy_cmds,
572 			    word_end));
573 		if (MINI_STR(line, "export ", word_end, 3) == 0)
574 			return (add_stuff(cpl, line, global_export_cmds,
575 			    word_end));
576 		if (MINI_STR(line, "list ", word_end, 1) == 0)
577 			return (add_stuff(cpl, line, global_list_cmds,
578 			    word_end));
579 		if (MINI_STR(line, "select ", word_end, 1) == 0)
580 			return (add_stuff(cpl, line, global_select_cmds,
581 			    word_end));
582 		return (add_stuff(cpl, line, global_scope_cmds, word_end));
583 	case NWAM_SCOPE_LOC:
584 	case NWAM_SCOPE_ENM:
585 	case NWAM_SCOPE_WLAN:
586 	case NWAM_SCOPE_NCU:
587 		return (add_stuff(cpl, line, non_ncp_scope_cmds, word_end));
588 	case NWAM_SCOPE_NCP:
589 		if (MINI_STR(line, "create ", word_end, 2) == 0)
590 			return (add_stuff(cpl, line, ncp_create_cmds,
591 			    word_end));
592 		if (MINI_STR(line, "destroy ", word_end, 1) == 0)
593 			return (add_stuff(cpl, line, ncp_destroy_cmds,
594 			    word_end));
595 		if (MINI_STR(line, "export ", word_end, 3) == 0)
596 			return (add_stuff(cpl, line, ncp_export_cmds,
597 			    word_end));
598 		if (MINI_STR(line, "list ", word_end, 1) == 0)
599 			return (add_stuff(cpl, line, ncp_list_cmds, word_end));
600 		if (MINI_STR(line, "select ", word_end, 1) == 0)
601 			return (add_stuff(cpl, line, ncp_select_cmds,
602 			    word_end));
603 		return (add_stuff(cpl, line, ncp_scope_cmds, word_end));
604 	}
605 	/* should never get here */
606 	return (0);
607 }
608 
609 const char *
610 cmd_to_str(int cmd_num)
611 {
612 	assert(cmd_num >= CMD_MIN && cmd_num <= CMD_MAX);
613 	return (helptab[cmd_num].cmd_name);
614 }
615 
616 /* Returns "loc", "enm", "wlan" or "ncp" as string */
617 static const char *
618 rt1_to_str(int res_type)
619 {
620 	assert(res_type >= RT1_MIN && res_type <= RT1_MAX);
621 	return (res1_types[res_type]);
622 }
623 
624 /* Returns "ncu" as string */
625 static const char *
626 rt2_to_str(int res_type)
627 {
628 	assert(res_type >= RT2_MIN && res_type <= RT2_MAX);
629 	return (res2_types[res_type]);
630 }
631 
632 /* Returns "ncp, "ncu", "loc", "enm", or "wlan" according to the scope */
633 static const char *
634 scope_to_str(int scope)
635 {
636 	switch (scope) {
637 	case NWAM_SCOPE_GBL:
638 		return ("global");
639 	case NWAM_SCOPE_NCP:
640 		return ("ncp");
641 	case NWAM_SCOPE_NCU:
642 		return ("ncu");
643 	case NWAM_SCOPE_LOC:
644 		return ("loc");
645 	case NWAM_SCOPE_ENM:
646 		return ("enm");
647 	case NWAM_SCOPE_WLAN:
648 		return ("wlan");
649 	default:
650 		return ("invalid");
651 	}
652 }
653 
654 /* Given an enm property and value, returns it as a string */
655 static const char *
656 propval_to_str(const char *propname, uint64_t value)
657 {
658 	const char *str;
659 
660 	if (nwam_uint64_get_value_string(propname, value, &str) == NWAM_SUCCESS)
661 		return (str);
662 	return (NULL);
663 }
664 
665 /* Given an int for a prop, returns it as string */
666 static const char *
667 pt_to_str(int prop_type)
668 {
669 	assert(prop_type >= PT_MIN && prop_type <= PT_MAX);
670 	return (pt_types[prop_type]);
671 }
672 
673 /*
674  * Return B_TRUE if string starts with "t" or "on" or is 1;
675  * B_FALSE otherwise
676  */
677 static boolean_t
678 str_to_boolean(const char *str)
679 {
680 	if (strncasecmp(str, "t", 1) == 0 || strncasecmp(str, "on", 2) == 0 ||
681 	    atoi(str) == 1)
682 		return (B_TRUE);
683 	else
684 		return (B_FALSE);
685 }
686 
687 /*
688  * This is a separate function rather than a set of define's because of the
689  * gettext() wrapping.
690  */
691 
692 /*
693  * TRANSLATION_NOTE
694  * Each string below should have \t follow \n whenever needed; the
695  * initial \t and the terminal \n will be provided by the calling function.
696  */
697 
698 static const char *
699 long_help(int cmd_num)
700 {
701 	assert(cmd_num >= CMD_MIN && cmd_num <= CMD_MAX);
702 	switch (cmd_num) {
703 		case CMD_CANCEL:
704 			return (gettext("Cancels the current configuration "
705 			    "changes."));
706 		case CMD_CLEAR:
707 			return (gettext("Clears the value for the specified "
708 			    "property."));
709 		case CMD_COMMIT:
710 			return (gettext("Commits the current configuration."));
711 		case CMD_CREATE:
712 			return (gettext("Creates a new profile or resource."));
713 		case CMD_DESTROY:
714 			return (gettext("Destroys the specified profile or "
715 			    "resource."));
716 		case CMD_END:
717 			return (gettext("Ends specification of a resource."));
718 		case CMD_EXIT:
719 			return (gettext("Exits the program."));
720 		case CMD_EXPORT:
721 			return (gettext("Exports the configuration."));
722 		case CMD_GET:
723 			return (gettext("Gets the value of the specified "
724 			    "property."));
725 		case CMD_HELP:
726 			return (gettext("Prints help message."));
727 		case CMD_LIST:
728 			return (gettext("Lists existing objects."));
729 		case CMD_REVERT:
730 			return (gettext("Reverts to the previous "
731 			    "configuration."));
732 		case CMD_SELECT:
733 			return (gettext("Selects a resource to modify."));
734 		case CMD_SET:
735 			return (gettext("Sets the value of the specified "
736 			    "property."));
737 		case CMD_VERIFY:
738 			return (gettext("Verifies an object."));
739 		case CMD_WALKPROP:
740 			return (gettext("Iterates over properties."));
741 		default:
742 			return (gettext("Unknown command."));
743 	}
744 }
745 
746 void
747 command_usage(int command)
748 {
749 	if (command < CMD_MIN || command > CMD_MAX) {
750 		nerr("Unknown command");
751 	} else {
752 		nerr("%s: %s: %s", gettext("Error"), gettext("usage"),
753 		    helptab[command].cmd_usage);
754 	}
755 }
756 
757 static void
758 long_usage(uint_t cmd_num)
759 {
760 	(void) printf("%s: %s\n", gettext("usage"),
761 	    helptab[cmd_num].cmd_usage);
762 	(void) printf("\t%s\n", long_help(cmd_num));
763 }
764 
765 /* Prints usage for command line options */
766 static void
767 cmd_line_usage()
768 {
769 	(void) printf("%s:\t%s\t\t\t\t(%s)\n", gettext("usage"), execname,
770 	    gettext("interactive-mode"));
771 	(void) printf("\t%s <%s> [%s...]\n", execname, gettext("command"),
772 	    gettext("options"));
773 	(void) printf("\t%s [-d] -f <%s>\n", execname, gettext("command-file"));
774 	(void) printf("\t%s %s [<%s>]\n", execname, cmd_to_str(CMD_HELP),
775 	    gettext("command"));
776 }
777 
778 /* Prints the line number of the current command if in command-file mode */
779 static void
780 print_lineno()
781 {
782 	static int last_lineno;
783 
784 	/* lex_lineno has already been incremented in the lexer; compensate */
785 	if (cmd_file_mode && lex_lineno > last_lineno) {
786 		if (strcmp(cmd_file_name, "-") == 0)
787 			(void) fprintf(stderr, gettext("On line %d:\n"),
788 			    lex_lineno - 1);
789 		else
790 			(void) fprintf(stderr, gettext("On line %d of %s:\n"),
791 			    lex_lineno - 1, cmd_file_name);
792 		last_lineno = lex_lineno;
793 	}
794 }
795 
796 /* PRINTFLIKE1 */
797 void
798 nerr(const char *format, ...)
799 {
800 	va_list	alist;
801 
802 	print_lineno();
803 
804 	format = gettext(format);
805 	va_start(alist, format);
806 	(void) vfprintf(stderr, format, alist);
807 	va_end(alist);
808 	(void) fprintf(stderr, "\n");
809 
810 	saw_error = B_TRUE;
811 }
812 
813 /* PRINTFLIKE2 */
814 static void
815 nwamerr(nwam_error_t err, const char *format, ...)
816 {
817 	va_list	alist;
818 
819 	print_lineno();
820 
821 	format = gettext(format);
822 	va_start(alist, format);
823 	(void) vfprintf(stderr, format, alist);
824 	va_end(alist);
825 	(void) fprintf(stderr, ": %s\n", nwam_strerror(err));
826 
827 	saw_error = B_TRUE;
828 }
829 
830 void
831 properr(const char *prop)
832 {
833 	nerr("Invalid property: '%s'", prop);
834 }
835 
836 /*
837  * If free_ncu_only == B_TRUE, only ncu handle is freed, ncp handle remains the
838  * same.  Since nwam_ncp_free() takes care of its ncus, no need to explicitly
839  * call nwam_ncu_free() afterwards.
840  */
841 static void
842 free_handle(boolean_t free_ncu_only)
843 {
844 	if (ncp_h != NULL) {
845 		if (!free_ncu_only) {
846 			nwam_ncp_free(ncp_h);
847 			ncp_h = NULL;
848 			ncu_h = NULL;
849 		} else if (ncu_h != NULL) {
850 			nwam_ncu_free(ncu_h);
851 			ncu_h = NULL;
852 		}
853 	}
854 
855 	if (enm_h != NULL) {
856 		nwam_enm_free(enm_h);
857 		enm_h = NULL;
858 	}
859 
860 	if (loc_h != NULL) {
861 		nwam_loc_free(loc_h);
862 		loc_h = NULL;
863 	}
864 
865 	if (wlan_h != NULL) {
866 		nwam_known_wlan_free(wlan_h);
867 		wlan_h = NULL;
868 	}
869 }
870 
871 /*
872  * On input, TRUE => yes, FALSE => no.
873  * On return, TRUE => 1, FALSE => no, could not ask => -1.
874  */
875 static int
876 ask_yesno(boolean_t default_answer, const char *question)
877 {
878 	char line[64];  /* should be enough to answer yes or no */
879 
880 	if (!ok_to_prompt) {
881 		saw_error = B_TRUE;
882 		return (-1);
883 	}
884 	for (;;) {
885 		if (printf("%s (%s)? ", gettext(question),
886 		    default_answer ? "[y]/n" : "y/[n]") < 0)
887 			return (-1);
888 		if (fgets(line, sizeof (line), stdin) == NULL)
889 			return (-1);
890 
891 		if (line[0] == '\n')
892 			return (default_answer ? 1 : 0);
893 		if (tolower(line[0]) == 'y')
894 			return (1);
895 		if (tolower(line[0]) == 'n')
896 			return (0);
897 	}
898 }
899 
900 /* This is the back-end helper function for read_input() below. */
901 static int
902 cleanup()
903 {
904 	int answer;
905 
906 	if (!interactive_mode && !cmd_file_mode) {
907 		/*
908 		 * If we're not in interactive mode, and we're not in command
909 		 * file mode, then we must be in commands-from-the-command-line
910 		 * mode.  As such, we can't loop back and ask for more input.
911 		 * It was OK to prompt for such things as whether or not to
912 		 * really delete something in the command handler called from
913 		 * yyparse() above, but "really quit?" makes no sense in this
914 		 * context.  So disable prompting.
915 		 */
916 		ok_to_prompt = B_FALSE;
917 	}
918 	if (need_to_commit) {
919 		answer = ask_yesno(B_FALSE,
920 		    "Configuration not saved; really quit");
921 		switch (answer) {
922 		case -1:
923 			/* issue error here */
924 			return (NWAM_ERR);
925 		case 1:
926 			/*
927 			 * don't want to save, just exit. handles are freed at
928 			 * end_func() or exit_func().
929 			 */
930 			return (NWAM_OK);
931 		default:
932 			/* loop back to read input */
933 			time_to_exit = B_FALSE;
934 			yyin = stdin;
935 			return (NWAM_REPEAT);
936 		}
937 	}
938 	return (saw_error ? NWAM_ERR : NWAM_OK);
939 }
940 
941 static int
942 string_to_yyin(char *string)
943 {
944 	if ((yyin = tmpfile()) == NULL)
945 		goto error;
946 	if (fwrite(string, strlen(string), 1, yyin) != 1)
947 		goto error;
948 	if (fseek(yyin, 0, SEEK_SET) != 0)
949 		goto error;
950 
951 	return (NWAM_OK);
952 
953 error:
954 	nerr("problem creating temporary file");
955 	return (NWAM_ERR);
956 }
957 
958 /*
959  * read_input() is the driver of this program.  It is a wrapper around
960  * yyparse(), printing appropriate prompts when needed, checking for
961  * exit conditions and reacting appropriately.  This function is
962  * called when in interactive mode or command-file mode.
963  */
964 static int
965 read_input(void)
966 {
967 	boolean_t yyin_is_a_tty = isatty(fileno(yyin));
968 	/*
969 	 * The prompt is "e> " or "e:t1:o1> " or "e:t1:o1:t2:o2> " where e is
970 	 * execname, t is resource type, o is object name.
971 	 */
972 	char prompt[MAXPATHLEN + (2 * (NWAM_MAX_TYPE_LEN + NWAM_MAX_NAME_LEN))
973 	    + sizeof ("::::> ")];
974 	char *line;
975 
976 	/* yyin should have been set to the appropriate (FILE *) if not stdin */
977 	newline_terminated = B_TRUE;
978 	for (;;) {
979 		if (yyin_is_a_tty) {
980 			if (newline_terminated) {
981 				switch (current_scope) {
982 				case NWAM_SCOPE_GBL:
983 					(void) snprintf(prompt, sizeof (prompt),
984 					    "%s> ", execname);
985 					break;
986 				case NWAM_SCOPE_LOC:
987 				case NWAM_SCOPE_ENM:
988 				case NWAM_SCOPE_WLAN:
989 				case NWAM_SCOPE_NCP:
990 					(void) snprintf(prompt, sizeof (prompt),
991 					    "%s:%s:%s> ", execname,
992 					    rt1_to_str(obj1_type), obj1_name);
993 
994 					break;
995 				case NWAM_SCOPE_NCU:
996 					(void) snprintf(prompt, sizeof (prompt),
997 					    "%s:%s:%s:%s:%s> ", execname,
998 					    rt1_to_str(obj1_type), obj1_name,
999 					    rt2_to_str(obj2_type), obj2_name);
1000 				}
1001 			}
1002 			/*
1003 			 * If the user hits ^C then we want to catch it and
1004 			 * start over.  If the user hits EOF then we want to
1005 			 * bail out.
1006 			 */
1007 			line = gl_get_line(gl, prompt, NULL, -1);
1008 			if (gl_return_status(gl) == GLR_SIGNAL) {
1009 				gl_abandon_line(gl);
1010 				continue;
1011 			}
1012 			if (line == NULL)
1013 				break;
1014 			if (string_to_yyin(line) != NWAM_OK)
1015 				break;
1016 			while (!feof(yyin)) {
1017 				yyparse();
1018 
1019 				/*
1020 				 * If any command on a list of commands
1021 				 * give an error, don't continue with the
1022 				 * remaining commands.
1023 				 */
1024 				if (saw_error || time_to_exit)
1025 					break;
1026 			}
1027 		} else {
1028 			yyparse();
1029 		}
1030 
1031 		/* Bail out on an error in command-file mode. */
1032 		if (saw_error && cmd_file_mode && !interactive_mode)
1033 			time_to_exit = B_TRUE;
1034 		if (time_to_exit || (!yyin_is_a_tty && feof(yyin)))
1035 			break;
1036 	}
1037 	return (cleanup());
1038 }
1039 
1040 /*
1041  * This function is used in the interactive-mode scenario: it just calls
1042  * read_input() until we are done.
1043  */
1044 static int
1045 do_interactive(void)
1046 {
1047 	int err;
1048 
1049 	interactive_mode = B_TRUE;
1050 	do {
1051 		err = read_input();
1052 	} while (err == NWAM_REPEAT);
1053 	return (err);
1054 }
1055 
1056 /* Calls the help_func() to print the usage of all commands */
1057 void
1058 help_wrap()
1059 {
1060 	cmd_t *help_cmd;
1061 
1062 	if ((help_cmd = alloc_cmd()) == NULL)
1063 		exit(NWAM_ERR);
1064 	help_func(help_cmd);
1065 	free_cmd(help_cmd);
1066 }
1067 
1068 /* Check if the given command is allowed in the current scope */
1069 boolean_t
1070 check_scope(int cmd)
1071 {
1072 	/* allowed in all scopes */
1073 	switch (cmd) {
1074 	case CMD_END:
1075 	case CMD_EXIT:
1076 	case CMD_HELP:
1077 	case CMD_LIST:
1078 	case CMD_EXPORT:
1079 		return (B_TRUE);
1080 	}
1081 	/* scope-specific */
1082 	switch (current_scope) {
1083 	case NWAM_SCOPE_GBL:
1084 		switch (cmd) {
1085 		case CMD_CREATE:
1086 		case CMD_DESTROY:
1087 		case CMD_SELECT:
1088 			return (B_TRUE);
1089 		}
1090 		break;
1091 	case NWAM_SCOPE_LOC:
1092 	case NWAM_SCOPE_ENM:
1093 	case NWAM_SCOPE_WLAN:
1094 	case NWAM_SCOPE_NCU:
1095 		switch (cmd) {
1096 		case CMD_CANCEL:
1097 		case CMD_CLEAR:
1098 		case CMD_COMMIT:
1099 		case CMD_GET:
1100 		case CMD_REVERT:
1101 		case CMD_SET:
1102 		case CMD_VERIFY:
1103 		case CMD_WALKPROP:
1104 			return (B_TRUE);
1105 		}
1106 		break;
1107 	case NWAM_SCOPE_NCP:
1108 		switch (cmd) {
1109 		case CMD_CANCEL:
1110 		case CMD_CREATE:
1111 		case CMD_DESTROY:
1112 		case CMD_SELECT:
1113 			return (B_TRUE);
1114 		}
1115 		break;
1116 	default:
1117 		nerr("Invalid scope");
1118 	}
1119 	nerr("'%s' is not allowed at this scope", cmd_to_str(cmd));
1120 	return (B_FALSE);
1121 }
1122 
1123 /* Returns the active object type depending on which handle is not NULL */
1124 static nwam_object_type_t
1125 active_object_type()
1126 {
1127 	/* Check ncu_h before ncp_h, ncp_h must be loaded before ncu_h */
1128 	if (ncu_h != NULL)
1129 		return (NWAM_OBJECT_TYPE_NCU);
1130 	else if (ncp_h != NULL)
1131 		return (NWAM_OBJECT_TYPE_NCP);
1132 	else if (loc_h != NULL)
1133 		return (NWAM_OBJECT_TYPE_LOC);
1134 	else if (enm_h != NULL)
1135 		return (NWAM_OBJECT_TYPE_ENM);
1136 	else if (wlan_h != NULL)
1137 		return (NWAM_OBJECT_TYPE_KNOWN_WLAN);
1138 	else
1139 		return (NWAM_OBJECT_TYPE_UNKNOWN);
1140 }
1141 
1142 /* Retrive the name of the object from its handle */
1143 static nwam_error_t
1144 object_name_from_handle(nwam_object_type_t object_type, void *handle,
1145     char **namep)
1146 {
1147 	switch (object_type) {
1148 	case NWAM_OBJECT_TYPE_NCP:
1149 		return (nwam_ncp_get_name(handle, namep));
1150 	case NWAM_OBJECT_TYPE_NCU:
1151 		return (nwam_ncu_get_name(handle, namep));
1152 	case NWAM_OBJECT_TYPE_LOC:
1153 		return (nwam_loc_get_name(handle, namep));
1154 	case NWAM_OBJECT_TYPE_ENM:
1155 		return (nwam_enm_get_name(handle, namep));
1156 	case NWAM_OBJECT_TYPE_KNOWN_WLAN:
1157 		return (nwam_known_wlan_get_name(handle, namep));
1158 	}
1159 	return (NWAM_INVALID_ARG);
1160 }
1161 
1162 static void
1163 do_commit()
1164 {
1165 	nwam_error_t	ret = NWAM_SUCCESS;
1166 	const char	*errprop;
1167 
1168 	if (!need_to_commit)
1169 		return;
1170 
1171 	switch (active_object_type()) {
1172 	case NWAM_OBJECT_TYPE_NCU:
1173 		ret = nwam_ncu_commit(ncu_h, 0);
1174 		break;
1175 	case NWAM_OBJECT_TYPE_ENM:
1176 		ret = nwam_enm_commit(enm_h, 0);
1177 		break;
1178 	case NWAM_OBJECT_TYPE_LOC:
1179 		ret = nwam_loc_commit(loc_h, 0);
1180 		break;
1181 	case NWAM_OBJECT_TYPE_KNOWN_WLAN:
1182 		ret = nwam_known_wlan_commit(wlan_h, 0);
1183 		break;
1184 	}
1185 
1186 	if (ret == NWAM_SUCCESS) {
1187 		need_to_commit = B_FALSE;
1188 		if (interactive_mode)
1189 			(void) printf(gettext("Committed changes\n"));
1190 	} else {
1191 		nwam_error_t verr;
1192 
1193 		/* Find property that caused failure */
1194 		switch (active_object_type()) {
1195 		case NWAM_OBJECT_TYPE_NCU:
1196 			verr = nwam_ncu_validate(ncu_h, &errprop);
1197 			break;
1198 		case NWAM_OBJECT_TYPE_ENM:
1199 			verr = nwam_enm_validate(enm_h, &errprop);
1200 			break;
1201 		case NWAM_OBJECT_TYPE_LOC:
1202 			verr = nwam_loc_validate(loc_h, &errprop);
1203 			break;
1204 		case NWAM_OBJECT_TYPE_KNOWN_WLAN:
1205 			verr = nwam_known_wlan_validate(wlan_h, &errprop);
1206 			break;
1207 		}
1208 
1209 		if (verr != NWAM_SUCCESS)
1210 			nwamerr(ret, "Commit error on property '%s'", errprop);
1211 		else
1212 			nwamerr(ret, "Commit error");
1213 	}
1214 }
1215 
1216 /*
1217  * Saves the current configuration to persistent storage.
1218  */
1219 /* ARGSUSED */
1220 void
1221 commit_func(cmd_t *cmd)
1222 {
1223 	if (!need_to_commit) {
1224 		if (interactive_mode)
1225 			(void) printf(gettext("Nothing to commit\n"));
1226 	} else {
1227 		do_commit();
1228 	}
1229 }
1230 
1231 static void
1232 do_cancel()
1233 {
1234 	switch (current_scope) {
1235 	case NWAM_SCOPE_NCU:
1236 		current_scope = NWAM_SCOPE_NCP;
1237 		obj2_type = 0;
1238 		free_handle(B_TRUE);
1239 		break;
1240 	case NWAM_SCOPE_NCP:
1241 	case NWAM_SCOPE_ENM:
1242 	case NWAM_SCOPE_WLAN:
1243 	case NWAM_SCOPE_LOC:
1244 		current_scope = NWAM_SCOPE_GBL;
1245 		obj1_type = 0;
1246 		free_handle(B_FALSE);
1247 		break;
1248 	case NWAM_SCOPE_GBL:
1249 		free_handle(B_FALSE);
1250 		break;
1251 	default:
1252 		nerr("Invalid scope");
1253 		return;
1254 	}
1255 	need_to_commit = B_FALSE;
1256 }
1257 
1258 /*
1259  * End operation on current scope and go up one scope.
1260  * Changes are not saved, no prompt either.
1261  */
1262 /* ARGSUSED */
1263 void
1264 cancel_func(cmd_t *cmd)
1265 {
1266 	do_cancel();
1267 }
1268 
1269 /*
1270  * Removes leading and trailing quotes from a string.
1271  * Caller must free returned string.
1272  */
1273 static char *
1274 trim_quotes(const char *quoted_str)
1275 {
1276 	char *str;
1277 	int end;
1278 
1279 	/* export_func() and list_func() can pass NULL here */
1280 	if (quoted_str == NULL)
1281 		return (NULL);
1282 
1283 	/* remove leading quote */
1284 	if (quoted_str[0] == '"')
1285 		str = strdup(quoted_str + 1);
1286 	else
1287 		str = strdup(quoted_str);
1288 	if (str == NULL)
1289 		return (NULL);
1290 
1291 	/* remove trailing quote and newline */
1292 	end = strlen(str) - 1;
1293 	while (end >= 0 && (str[end] == '"' || str[end] == '\n'))
1294 		end--;
1295 	str[end+1] = 0;
1296 
1297 	return (str);
1298 }
1299 
1300 /*
1301  * Creates a new resource and enters the scope of that resource.
1302  * The new resource can also be a copy of an existing resource (-t option).
1303  * If in interactive mode, then after creation call walkprop_func()
1304  * to do walk the properties for the new object.
1305  */
1306 void
1307 create_func(cmd_t *cmd)
1308 {
1309 	nwam_error_t	ret = NWAM_SUCCESS;
1310 	int		c;
1311 	boolean_t	template = B_FALSE;
1312 	char		*newname = NULL, *oldname = NULL;
1313 	cmd_t		*walkprop_cmd;
1314 
1315 	/* make sure right command at the right scope */
1316 	if (current_scope == NWAM_SCOPE_GBL &&
1317 	    cmd->cmd_res2_type == RT2_NCU) {
1318 		nerr("cannot create ncu at global scope");
1319 		return;
1320 	}
1321 	if (current_scope == NWAM_SCOPE_NCP &&
1322 	    cmd->cmd_res2_type != RT2_NCU) {
1323 		nerr("Cannot create given object at this scope");
1324 		return;
1325 	}
1326 
1327 	assert(cmd->cmd_argc > 0);
1328 	optind = 0;
1329 	while ((c = getopt(cmd->cmd_argc, cmd->cmd_argv, "t:")) != EOF) {
1330 		switch (c) {
1331 		case 't':
1332 			template = B_TRUE;
1333 			break;
1334 		default:
1335 			command_usage(CMD_CREATE);
1336 			return;
1337 		}
1338 	}
1339 
1340 	if (!template) {
1341 		/* no template given */
1342 		/* argv[0] is name */
1343 		newname = trim_quotes(cmd->cmd_argv[0]);
1344 		if (cmd->cmd_res1_type == RT1_ENM) {
1345 			ret = nwam_enm_create(newname, NULL, &enm_h);
1346 		} else if (cmd->cmd_res1_type == RT1_LOC) {
1347 			ret = nwam_loc_create(newname, &loc_h);
1348 		} else if (cmd->cmd_res1_type == RT1_WLAN) {
1349 			ret = nwam_known_wlan_create(newname, &wlan_h);
1350 		} else if (cmd->cmd_res1_type == RT1_NCP &&
1351 		    current_scope == NWAM_SCOPE_GBL) {
1352 			ret = nwam_ncp_create(newname, 0, &ncp_h);
1353 		} else if (cmd->cmd_res2_type == RT2_NCU) {
1354 			nwam_ncu_type_t		ncu_type;
1355 			nwam_ncu_class_t	ncu_class;
1356 
1357 			/* ncp must already be read */
1358 			if (ncp_h == NULL) {
1359 				nerr("Create error: NCP has not been read");
1360 				goto done;
1361 			}
1362 
1363 			ncu_class = (nwam_ncu_class_t)cmd->cmd_ncu_class_type;
1364 			ncu_type = nwam_ncu_class_to_type(ncu_class);
1365 			ret = nwam_ncu_create(ncp_h, newname, ncu_type,
1366 			    ncu_class, &ncu_h);
1367 		}
1368 
1369 		if (ret != NWAM_SUCCESS) {
1370 			nwamerr(ret, "Create error");
1371 			goto done;
1372 		}
1373 
1374 	} else {
1375 		/* template given */
1376 		/* argv[0] is -t, argv[1] is old name, argv[2] is new name */
1377 		oldname = trim_quotes(cmd->cmd_argv[1]);
1378 		newname = trim_quotes(cmd->cmd_argv[2]);
1379 		if (cmd->cmd_res1_type == RT1_ENM) {
1380 			nwam_enm_handle_t oldenm_h;
1381 
1382 			ret = nwam_enm_read(oldname, 0, &oldenm_h);
1383 			if (ret != NWAM_SUCCESS)
1384 				goto read_error;
1385 			ret = nwam_enm_copy(oldenm_h, newname, &enm_h);
1386 			nwam_enm_free(oldenm_h);
1387 		} else if (cmd->cmd_res1_type == RT1_LOC) {
1388 			nwam_loc_handle_t oldloc_h;
1389 
1390 			ret = nwam_loc_read(oldname, 0, &oldloc_h);
1391 			if (ret != NWAM_SUCCESS)
1392 				goto read_error;
1393 			ret = nwam_loc_copy(oldloc_h, newname, &loc_h);
1394 			nwam_loc_free(oldloc_h);
1395 		} else if (cmd->cmd_res1_type == RT1_WLAN) {
1396 			nwam_known_wlan_handle_t oldwlan_h;
1397 
1398 			ret = nwam_known_wlan_read(oldname, 0, &oldwlan_h);
1399 			if (ret != NWAM_SUCCESS)
1400 				goto read_error;
1401 			ret = nwam_known_wlan_copy(oldwlan_h, newname, &wlan_h);
1402 			nwam_known_wlan_free(oldwlan_h);
1403 		} else if (cmd->cmd_res1_type == RT1_NCP &&
1404 		    current_scope == NWAM_SCOPE_GBL) {
1405 			nwam_ncp_handle_t oldncp_h;
1406 
1407 			ret = nwam_ncp_read(oldname, 0, &oldncp_h);
1408 			if (ret != NWAM_SUCCESS)
1409 				goto read_error;
1410 			ret = nwam_ncp_copy(oldncp_h, newname, &ncp_h);
1411 			nwam_ncp_free(oldncp_h);
1412 		} else if (cmd->cmd_res2_type == RT2_NCU) {
1413 			nwam_ncu_handle_t	oldncu_h;
1414 			nwam_ncu_type_t		ncu_type;
1415 			nwam_ncu_class_t	ncu_class;
1416 
1417 			/* ncp must already be read */
1418 			if (ncp_h == NULL) {
1419 				nerr("Copy error: NCP has not been read");
1420 				goto done;
1421 			}
1422 			ncu_class = (nwam_ncu_class_t)cmd->cmd_ncu_class_type;
1423 			ncu_type = nwam_ncu_class_to_type(ncu_class);
1424 			ret = nwam_ncu_read(ncp_h, oldname, ncu_type, 0,
1425 			    &oldncu_h);
1426 			if (ret != NWAM_SUCCESS)
1427 				goto read_error;
1428 			ret = nwam_ncu_copy(oldncu_h, newname, &ncu_h);
1429 			nwam_ncu_free(oldncu_h);
1430 		}
1431 
1432 		if (ret != NWAM_SUCCESS) {
1433 			nwamerr(ret, "Copy error");
1434 			goto done;
1435 		}
1436 	}
1437 
1438 	if (current_scope == NWAM_SCOPE_GBL) {
1439 		(void) strlcpy(obj1_name, newname, sizeof (obj1_name));
1440 		obj1_type = cmd->cmd_res1_type;
1441 		if (obj1_type == RT1_ENM)
1442 			current_scope = NWAM_SCOPE_ENM;
1443 		else if (obj1_type == RT1_LOC)
1444 			current_scope = NWAM_SCOPE_LOC;
1445 		else if (obj1_type == RT1_WLAN)
1446 			current_scope = NWAM_SCOPE_WLAN;
1447 		else if (obj1_type == RT1_NCP)
1448 			current_scope = NWAM_SCOPE_NCP;
1449 	} else {
1450 		(void) strlcpy(obj2_name, newname, sizeof (obj2_name));
1451 		current_scope = NWAM_SCOPE_NCU;
1452 		obj2_type = cmd->cmd_res2_type;
1453 	}
1454 	if (current_scope != NWAM_SCOPE_NCP)
1455 		need_to_commit = B_TRUE;
1456 
1457 	/* do a walk of the properties if in interactive mode */
1458 	if (interactive_mode && current_scope != NWAM_SCOPE_NCP) {
1459 		(void) printf(gettext("Created %s '%s'.  "
1460 		    "Walking properties ...\n"),
1461 		    scope_to_str(current_scope), newname);
1462 		if ((walkprop_cmd = alloc_cmd()) == NULL)
1463 			goto done;
1464 		walkprop_func(walkprop_cmd);
1465 		free(walkprop_cmd);
1466 	}
1467 
1468 read_error:
1469 	if (ret != NWAM_SUCCESS)
1470 		nwamerr(ret, "Copy error reading '%s'", oldname);
1471 
1472 done:
1473 	free(oldname);
1474 	free(newname);
1475 }
1476 
1477 /* Processing of return value for destroy_*_callback() */
1478 static int
1479 destroy_ret(nwam_object_type_t object_type, nwam_error_t ret, void *handle)
1480 {
1481 	if (ret == NWAM_ENTITY_NOT_DESTROYABLE) {
1482 		/* log a message to stderr, but don't consider it an error */
1483 		char *name;
1484 		if (object_name_from_handle(object_type, handle, &name)
1485 		    == NWAM_SUCCESS) {
1486 			(void) fprintf(stderr,
1487 			    gettext("%s '%s' cannot be removed\n"),
1488 			    nwam_object_type_to_string(object_type), name);
1489 			free(name);
1490 		}
1491 		return (0);
1492 	}
1493 
1494 	if (ret == NWAM_SUCCESS || ret == NWAM_ENTITY_IN_USE)
1495 		return (0);
1496 
1497 	return (1);
1498 }
1499 
1500 /*
1501  * NWAM_FLAG_DO_NOT_FREE is passed to nwam_*_destory() so that it does not
1502  * free the handle.  The calling nwam_walk_*() function frees this handle
1503  * as it is the function that created the handle.
1504  *
1505  * Objects that are not destroyable or are active cannot be destroyed.
1506  * Don't return error in these situations so the walk can continue.
1507  */
1508 /* ARGSUSED */
1509 static int
1510 destroy_ncp_callback(nwam_ncp_handle_t ncp, void *arg)
1511 {
1512 	/* The file is deleted, so NCUs are also removed */
1513 	nwam_error_t ret = nwam_ncp_destroy(ncp, NWAM_FLAG_DO_NOT_FREE);
1514 	return (destroy_ret(NWAM_OBJECT_TYPE_NCP, ret, ncp));
1515 }
1516 
1517 /* ARGSUSED */
1518 static int
1519 destroy_loc_callback(nwam_loc_handle_t loc, void *arg)
1520 {
1521 	nwam_error_t ret = nwam_loc_destroy(loc, NWAM_FLAG_DO_NOT_FREE);
1522 	return (destroy_ret(NWAM_OBJECT_TYPE_LOC, ret, loc));
1523 }
1524 
1525 /* ARGSUSED */
1526 static int
1527 destroy_enm_callback(nwam_enm_handle_t enm, void *arg)
1528 {
1529 	nwam_error_t ret = nwam_enm_destroy(enm, NWAM_FLAG_DO_NOT_FREE);
1530 	return (destroy_ret(NWAM_OBJECT_TYPE_ENM, ret, enm));
1531 }
1532 
1533 /* ARGSUSED */
1534 static int
1535 destroy_wlan_callback(nwam_known_wlan_handle_t wlan, void *arg)
1536 {
1537 	nwam_error_t ret = nwam_known_wlan_destroy(wlan, NWAM_FLAG_DO_NOT_FREE);
1538 	return (destroy_ret(NWAM_OBJECT_TYPE_KNOWN_WLAN, ret, wlan));
1539 }
1540 
1541 /*
1542  * Remove all existing configuration that are not read-only.
1543  * walk through all ncps, locs, enms, wlans and destroy each one.
1544  */
1545 static nwam_error_t
1546 destroy_all(void)
1547 {
1548 	nwam_error_t	ret;
1549 
1550 	assert(remove_all_configurations);
1551 
1552 	ret = nwam_walk_ncps(destroy_ncp_callback, NULL, 0, NULL);
1553 	if (ret != NWAM_SUCCESS)
1554 		goto done;
1555 
1556 	ret = nwam_walk_enms(destroy_enm_callback, NULL,
1557 	    NWAM_FLAG_ACTIVATION_MODE_ALL, NULL);
1558 	if (ret != NWAM_SUCCESS)
1559 		goto done;
1560 
1561 	ret = nwam_walk_locs(destroy_loc_callback, NULL,
1562 	    NWAM_FLAG_ACTIVATION_MODE_ALL, NULL);
1563 	if (ret != NWAM_SUCCESS)
1564 		goto done;
1565 
1566 	ret = nwam_walk_known_wlans(destroy_wlan_callback, NULL, 0, NULL);
1567 	if (ret != NWAM_SUCCESS)
1568 		goto done;
1569 
1570 	if (interactive_mode)
1571 		(void) printf(gettext("All user-defined entities destroyed\n"));
1572 	remove_all_configurations = B_FALSE;
1573 
1574 done:
1575 	if (ret != NWAM_SUCCESS) {
1576 		nwamerr(ret, "Destroy error: "
1577 		    "could not destroy all configurations");
1578 	}
1579 	return (ret);
1580 }
1581 
1582 /*
1583  * Destroys an instance in persistent repository, and is permanent.
1584  * If interactive mode, it is allowed at global scope only
1585  * option -a destroys everything.
1586  */
1587 void
1588 destroy_func(cmd_t *cmd)
1589 {
1590 	nwam_error_t	ret;
1591 	char		*name, *realname = NULL;
1592 
1593 	if (current_scope == NWAM_SCOPE_NCP &&
1594 	    (cmd->cmd_res1_type == RT1_ENM || cmd->cmd_res1_type == RT1_LOC ||
1595 	    cmd->cmd_res1_type == RT1_WLAN)) {
1596 		nerr("Destroy error: only NCUs can be destroyed in NCP scope");
1597 		return;
1598 	}
1599 
1600 	assert(cmd->cmd_argc > 0);
1601 
1602 	/* res1_type is -1 if -a flag is used */
1603 	if (cmd->cmd_res1_type == -1) {
1604 		int c;
1605 
1606 		if (current_scope != NWAM_SCOPE_GBL) {
1607 			nerr("Cannot destroy all configurations in a "
1608 			    "non-global scope");
1609 			return;
1610 		}
1611 
1612 		optind = 0;
1613 		while ((c = getopt(cmd->cmd_argc, cmd->cmd_argv, "a")) != EOF) {
1614 			switch (c) {
1615 			case 'a':
1616 				remove_all_configurations = B_TRUE;
1617 				break;
1618 			default:
1619 				command_usage(CMD_DESTROY);
1620 				return;
1621 			}
1622 		}
1623 		if (remove_all_configurations) {
1624 			(void) destroy_all();
1625 			return;
1626 		}
1627 	}
1628 
1629 	/* argv[0] is name */
1630 	name = trim_quotes(cmd->cmd_argv[0]);
1631 	if (cmd->cmd_res2_type == RT2_NCU) {
1632 		nwam_ncu_type_t		ncu_type;
1633 		nwam_ncu_class_t	ncu_class;
1634 
1635 		/* ncp must already be read */
1636 		if (ncp_h == NULL) {
1637 			nerr("Destroy ncu error: NCP has not been read");
1638 			return;
1639 		}
1640 		ncu_class = (nwam_ncu_class_t)cmd->cmd_ncu_class_type;
1641 		ncu_type = nwam_ncu_class_to_type(ncu_class);
1642 		ret = nwam_ncu_read(ncp_h, name, ncu_type, 0, &ncu_h);
1643 		if (ret != NWAM_SUCCESS)
1644 			goto done;
1645 		(void) object_name_from_handle(NWAM_OBJECT_TYPE_NCU, ncu_h,
1646 		    &realname);
1647 		ret = nwam_ncu_destroy(ncu_h, 0);
1648 		ncu_h = NULL;
1649 	} else if (cmd->cmd_res1_type == RT1_ENM) {
1650 		if ((ret = nwam_enm_read(name, 0, &enm_h)) != NWAM_SUCCESS)
1651 			goto done;
1652 		(void) object_name_from_handle(NWAM_OBJECT_TYPE_ENM, enm_h,
1653 		    &realname);
1654 		ret = nwam_enm_destroy(enm_h, 0);
1655 		enm_h = NULL;
1656 	} else if (cmd->cmd_res1_type == RT1_LOC) {
1657 		if ((ret = nwam_loc_read(name, 0, &loc_h)) != NWAM_SUCCESS)
1658 			goto done;
1659 		(void) object_name_from_handle(NWAM_OBJECT_TYPE_LOC, loc_h,
1660 		    &realname);
1661 		ret = nwam_loc_destroy(loc_h, 0);
1662 		loc_h = NULL;
1663 	} else if (cmd->cmd_res1_type == RT1_WLAN) {
1664 		if ((ret = nwam_known_wlan_read(name, 0, &wlan_h))
1665 		    != NWAM_SUCCESS)
1666 			goto done;
1667 		(void) object_name_from_handle(NWAM_OBJECT_TYPE_KNOWN_WLAN,
1668 		    wlan_h, &realname);
1669 		ret = nwam_known_wlan_destroy(wlan_h, 0);
1670 		wlan_h = NULL;
1671 	} else if (cmd->cmd_res1_type == RT1_NCP) {
1672 		if ((ret = nwam_ncp_read(name, 0, &ncp_h)) != NWAM_SUCCESS)
1673 			goto done;
1674 		(void) object_name_from_handle(NWAM_OBJECT_TYPE_NCP, ncp_h,
1675 		    &realname);
1676 		ret = nwam_ncp_destroy(ncp_h, 0);
1677 		ncp_h = NULL;
1678 	} else {
1679 		nerr("Destroy error: unknown object-type");
1680 	}
1681 
1682 done:
1683 	if (ret == NWAM_ENTITY_IN_USE)  {
1684 		nerr("Destroy error: active entity cannot be destroyed");
1685 	} else if (ret != NWAM_SUCCESS) {
1686 		nwamerr(ret, "Destroy error");
1687 	} else if (interactive_mode) {
1688 		(void) printf(gettext("Destroyed %s '%s'\n"),
1689 		    (cmd->cmd_res2_type == RT2_NCU ?
1690 		    rt2_to_str(cmd->cmd_res2_type) :
1691 		    rt1_to_str(cmd->cmd_res1_type)),
1692 		    realname != NULL ? realname : name);
1693 	}
1694 	free(name);
1695 	free(realname);
1696 }
1697 
1698 /*
1699  * End operation on current scope and go up one scope.
1700  * Changes are saved.
1701  */
1702 /* ARGSUSED */
1703 void
1704 end_func(cmd_t *cmd)
1705 {
1706 	/* if need_to_commit is set, commit changes */
1707 	if (need_to_commit)
1708 		do_commit();
1709 
1710 	/*
1711 	 * Call do_cancel() to go up one scope.  If commit fails,
1712 	 * need_to_commit is not reset and users are asked if they want to end.
1713 	 */
1714 	if (!need_to_commit ||
1715 	    (need_to_commit && (ask_yesno(B_FALSE,
1716 	    "Configuration not saved; really end")) == 1)) {
1717 		/* set time_to_exit if in global scope */
1718 		if (current_scope == NWAM_SCOPE_GBL)
1719 			time_to_exit = B_TRUE;
1720 		/* call do_cancel() to go up one scope */
1721 		do_cancel();
1722 	}
1723 }
1724 
1725 /*
1726  * Exit immediately.  Configuration changes are saved by calling end_func().
1727  */
1728 /* ARGSUSED */
1729 void
1730 exit_func(cmd_t *cmd)
1731 {
1732 	cmd_t *end_cmd;
1733 
1734 	if (need_to_commit) {
1735 		if ((end_cmd = alloc_cmd()) == NULL) {
1736 			nerr("Exit error");
1737 			return;
1738 		}
1739 		end_func(end_cmd);
1740 		free_cmd(end_cmd);
1741 	}
1742 
1743 	/*
1744 	 * If need_to_commit is still set, then the commit failed.
1745 	 * Otherwise, exit.
1746 	 */
1747 	if (!need_to_commit)
1748 		time_to_exit = B_TRUE;
1749 }
1750 
1751 void
1752 help_func(cmd_t *cmd)
1753 {
1754 	int i;
1755 
1756 	if (cmd->cmd_argc == 0) {
1757 		(void) printf(gettext("commands:\n"));
1758 		for (i = CMD_MIN; i <= CMD_MAX; i++)
1759 			(void) printf("\t%s\n", helptab[i].cmd_usage);
1760 		return;
1761 	}
1762 
1763 	for (i = CMD_MIN; i <= CMD_MAX; i++) {
1764 		if (strcmp(cmd->cmd_argv[0], cmd_to_str(i)) == 0) {
1765 			long_usage(i);
1766 			return;
1767 		}
1768 	}
1769 	(void) fprintf(stderr, gettext("Unknown command: '%s'\n"),
1770 	    cmd->cmd_argv[0]);
1771 	help_wrap();
1772 }
1773 
1774 /*
1775  * Revert configuration of an instance to latest previous version.
1776  * Free the handle and read again.
1777  */
1778 /* ARGSUSED */
1779 void
1780 revert_func(cmd_t *cmd)
1781 {
1782 	nwam_error_t		ret;
1783 	char			*name = NULL;
1784 	nwam_ncu_type_t		ncu_type;
1785 	nwam_object_type_t	object_type = active_object_type();
1786 
1787 	switch (object_type) {
1788 	case NWAM_OBJECT_TYPE_NCU:
1789 		/* retrieve name and type to use later */
1790 		if ((ret = nwam_ncu_get_ncu_type(ncu_h, &ncu_type))
1791 		    != NWAM_SUCCESS) {
1792 			nwamerr(ret, "Revert error: Get ncu type error");
1793 			return;
1794 		}
1795 		if ((ret = nwam_ncu_get_name(ncu_h, &name)) != NWAM_SUCCESS)
1796 			goto name_error;
1797 		nwam_ncu_free(ncu_h);
1798 		ncu_h = NULL;
1799 		ret = nwam_ncu_read(ncp_h, name, ncu_type, 0, &ncu_h);
1800 		break;
1801 	case NWAM_OBJECT_TYPE_ENM:
1802 		if ((ret = nwam_enm_get_name(enm_h, &name)) != NWAM_SUCCESS)
1803 			goto name_error;
1804 		nwam_enm_free(enm_h);
1805 		enm_h = NULL;
1806 		ret = nwam_enm_read(name, 0, &enm_h);
1807 		break;
1808 	case NWAM_OBJECT_TYPE_LOC:
1809 		if ((ret = nwam_loc_get_name(loc_h, &name)) != NWAM_SUCCESS)
1810 			goto name_error;
1811 		nwam_loc_free(loc_h);
1812 		loc_h = NULL;
1813 		ret = nwam_loc_read(name, 0, &loc_h);
1814 		break;
1815 	case NWAM_OBJECT_TYPE_KNOWN_WLAN:
1816 		if ((ret = nwam_known_wlan_get_name(wlan_h, &name))
1817 		    != NWAM_SUCCESS)
1818 			goto name_error;
1819 		nwam_known_wlan_free(wlan_h);
1820 		wlan_h = NULL;
1821 		ret = nwam_known_wlan_read(name, 0, &wlan_h);
1822 		break;
1823 	}
1824 
1825 	/* Exit this scope because handle already freed (call do_cancel()) */
1826 	need_to_commit = B_FALSE;
1827 
1828 	if (ret != NWAM_SUCCESS) {
1829 		if (ret == NWAM_ENTITY_NOT_FOUND) {
1830 			nerr("%s '%s' does not exist to revert to, removing it",
1831 			    nwam_object_type_to_string(object_type), name);
1832 		} else {
1833 			nwamerr(ret, "Revert error");
1834 		}
1835 		do_cancel();
1836 	}
1837 	free(name);
1838 	return;
1839 
1840 name_error:
1841 	if (ret != NWAM_SUCCESS)
1842 		nwamerr(ret, "Revert error: get name error");
1843 }
1844 
1845 /*
1846  * Load a resource from persistent repository and enter the scope
1847  * of that resource.
1848  */
1849 void
1850 select_func(cmd_t *cmd)
1851 {
1852 	nwam_error_t	ret;
1853 	char		*name, *realname = NULL;
1854 
1855 	assert(cmd->cmd_argc > 0);
1856 	if (current_scope == NWAM_SCOPE_NCP && cmd->cmd_res2_type != RT2_NCU) {
1857 		nerr("cannot select '%s' at this scope",
1858 		    rt1_to_str(cmd->cmd_res1_type));
1859 		return;
1860 	}
1861 
1862 	/* argv[0] is name */
1863 	name = trim_quotes(cmd->cmd_argv[0]);
1864 	switch (cmd->cmd_res1_type) {
1865 	case RT1_LOC:
1866 		ret = nwam_loc_read(name, 0, &loc_h);
1867 		if (ret == NWAM_SUCCESS) {
1868 			current_scope = NWAM_SCOPE_LOC;
1869 			(void) object_name_from_handle(NWAM_OBJECT_TYPE_LOC,
1870 			    loc_h, &realname);
1871 		}
1872 		break;
1873 	case RT1_ENM:
1874 		ret = nwam_enm_read(name, 0, &enm_h);
1875 		if (ret == NWAM_SUCCESS) {
1876 			current_scope = NWAM_SCOPE_ENM;
1877 			(void) object_name_from_handle(NWAM_OBJECT_TYPE_ENM,
1878 			    enm_h, &realname);
1879 		}
1880 		break;
1881 	case RT1_WLAN:
1882 		ret = nwam_known_wlan_read(name, 0, &wlan_h);
1883 		if (ret == NWAM_SUCCESS) {
1884 			current_scope = NWAM_SCOPE_WLAN;
1885 			(void) object_name_from_handle
1886 			    (NWAM_OBJECT_TYPE_KNOWN_WLAN, wlan_h, &realname);
1887 		}
1888 		break;
1889 	case RT1_NCP:
1890 		if (cmd->cmd_res2_type == RT2_NCU) {
1891 			nwam_ncu_type_t		ncu_type;
1892 			nwam_ncu_class_t	ncu_class;
1893 
1894 			/* ncp must already be read */
1895 			if (ncp_h == NULL) {
1896 				nerr("Select error: NCP has not been read");
1897 				free(name);
1898 				return;
1899 			}
1900 			ncu_class = (nwam_ncu_class_t)cmd->cmd_ncu_class_type;
1901 			ncu_type = nwam_ncu_class_to_type(ncu_class);
1902 			ret = nwam_ncu_read(ncp_h, name, ncu_type, 0, &ncu_h);
1903 			if (ret == NWAM_SUCCESS) {
1904 				current_scope = NWAM_SCOPE_NCU;
1905 				(void) object_name_from_handle
1906 				    (NWAM_OBJECT_TYPE_NCU, ncu_h, &realname);
1907 			}
1908 		} else {
1909 			ret = nwam_ncp_read(name, 0, &ncp_h);
1910 			if (ret == NWAM_SUCCESS) {
1911 				current_scope = NWAM_SCOPE_NCP;
1912 				(void) object_name_from_handle
1913 				    (NWAM_OBJECT_TYPE_NCP, ncp_h, &realname);
1914 			}
1915 		}
1916 		break;
1917 	default:
1918 		nerr("Select error: unknown object-type");
1919 		free(name);
1920 		return;
1921 	}
1922 
1923 	if (ret != NWAM_SUCCESS) {
1924 		nwamerr(ret, "Select error");
1925 	} else {
1926 		/* set the obj*_name or obj*_type depending on current scope */
1927 		if (current_scope == NWAM_SCOPE_NCU) {
1928 			obj2_type = RT2_NCU;
1929 			(void) strlcpy(obj2_name,
1930 			    realname != NULL ? realname : name,
1931 			    sizeof (obj2_name));
1932 		} else {
1933 			(void) strlcpy(obj1_name,
1934 			    realname != NULL ? realname : name,
1935 			    sizeof (obj1_name));
1936 			obj1_type = cmd->cmd_res1_type;
1937 		}
1938 	}
1939 	free(name);
1940 	free(realname);
1941 }
1942 
1943 /* Given an int for prop, returns it as string */
1944 static const char *
1945 pt_to_prop_name(nwam_object_type_t object_type, int pt_type)
1946 {
1947 	int i;
1948 	prop_table_entry_t *prop_table = get_prop_table(object_type);
1949 
1950 	for (i = 0; prop_table[i].pte_name != NULL; i++) {
1951 		if (pt_type == prop_table[i].pte_type)
1952 			return (prop_table[i].pte_name);
1953 	}
1954 	return (NULL);
1955 }
1956 
1957 /* Given a prop as a string, returns it as an int */
1958 static int
1959 prop_to_pt(nwam_object_type_t object_type, const char *prop)
1960 {
1961 	int i;
1962 	prop_table_entry_t *prop_table = get_prop_table(object_type);
1963 
1964 	for (i = 0; prop_table[i].pte_name != NULL; i++) {
1965 		if (strcmp(prop, prop_table[i].pte_name) == 0)
1966 			return (prop_table[i].pte_type);
1967 	}
1968 	return (-1);
1969 }
1970 
1971 /* Given a prop as an int, returns its type (nwam_value_type_t) */
1972 static nwam_value_type_t
1973 prop_value_type(nwam_object_type_t object_type, const char *prop)
1974 {
1975 	nwam_error_t		ret;
1976 	nwam_value_type_t	value_type;
1977 
1978 	switch (object_type) {
1979 	case NWAM_OBJECT_TYPE_NCU:
1980 		ret = nwam_ncu_get_prop_type(prop, &value_type);
1981 		break;
1982 	case NWAM_OBJECT_TYPE_LOC:
1983 		ret = nwam_loc_get_prop_type(prop, &value_type);
1984 		break;
1985 	case NWAM_OBJECT_TYPE_ENM:
1986 		ret = nwam_enm_get_prop_type(prop, &value_type);
1987 		break;
1988 	case NWAM_OBJECT_TYPE_KNOWN_WLAN:
1989 		ret = nwam_known_wlan_get_prop_type(prop, &value_type);
1990 		break;
1991 	}
1992 
1993 	if (ret != NWAM_SUCCESS)
1994 		value_type = NWAM_VALUE_TYPE_UNKNOWN;
1995 
1996 	return (value_type);
1997 }
1998 
1999 /*
2000  * Converts input_str to an array nwam_value.
2001  * If is_list_prop, break input_str into array of strings first.
2002  */
2003 static nwam_value_t
2004 str_to_nwam_value(nwam_object_type_t object_type, char *input_str, int pt_type,
2005     boolean_t is_list_prop)
2006 {
2007 	int		i, n = 0, ret;
2008 	nwam_value_t	data;
2009 	char		**val;
2010 	int		max_str_num;
2011 
2012 	nwam_value_type_t	value_type;
2013 	int64_t			*int_vals;
2014 	uint64_t		*uint_vals;
2015 	boolean_t		*boolean_vals;
2016 
2017 	/*
2018 	 * Worst case is that each char separated by DELIMITER, so the
2019 	 * max number of sub strings is half of string length + 1.
2020 	 */
2021 	max_str_num = strlen(input_str) / 2 + 1;
2022 
2023 	val = calloc(max_str_num, sizeof (char *));
2024 	if (val == NULL) {
2025 		nerr("Out of memory");
2026 		return (NULL);
2027 	}
2028 
2029 	if (is_list_prop) {
2030 		char *tmp, *next;
2031 		/*
2032 		 * Break down input_str and save as array of sub strings.
2033 		 * Set num as the number of the sub strings.
2034 		 * Use nwam_tokenize_by_unescaped_delim() rather than strtok()
2035 		 * because DELIMITER may be escaped
2036 		 */
2037 		tmp = (char *)input_str;
2038 		while ((tmp = nwam_tokenize_by_unescaped_delim(tmp,
2039 		    NWAM_VALUE_DELIMITER_CHAR, &next)) != NULL) {
2040 			val[n++] = trim_quotes(tmp);
2041 			tmp = next;
2042 		}
2043 	} else {
2044 		val[n++] = trim_quotes(input_str);
2045 	}
2046 
2047 	/* initialize int_vals or booleans_vals depending on pt_type */
2048 	value_type = prop_value_type(object_type,
2049 	    pt_to_prop_name(object_type, pt_type));
2050 	if (value_type == NWAM_VALUE_TYPE_INT64) {
2051 		int_vals = calloc(n, sizeof (int64_t));
2052 		if (int_vals == NULL) {
2053 			nerr("Out of memory");
2054 			array_free((void **)val, max_str_num);
2055 			return (NULL);
2056 		}
2057 	} else if (value_type == NWAM_VALUE_TYPE_UINT64) {
2058 		uint_vals = calloc(n, sizeof (uint64_t));
2059 		if (uint_vals == NULL) {
2060 			nerr("Out of memory");
2061 			array_free((void **)val, max_str_num);
2062 			return (NULL);
2063 		}
2064 	} else if (value_type == NWAM_VALUE_TYPE_BOOLEAN) {
2065 		boolean_vals = calloc(n, sizeof (boolean_t));
2066 		if (boolean_vals == NULL) {
2067 			nerr("Out of memory");
2068 			array_free((void **)val, max_str_num);
2069 			return (NULL);
2070 		}
2071 	}
2072 	/* set the appropriate array */
2073 	for (i = 0; i < n; i++) {
2074 		switch (value_type) {
2075 		case NWAM_VALUE_TYPE_STRING:
2076 			/* nothing to do - val already has the char** array */
2077 			break;
2078 		case NWAM_VALUE_TYPE_INT64:
2079 		{
2080 			int_vals[i] = (int64_t)atoi(val[i]);
2081 			break;
2082 		}
2083 		case NWAM_VALUE_TYPE_UINT64:
2084 		{
2085 			uint64_t str_as_enum;
2086 			char *endptr;
2087 
2088 			ret = nwam_value_string_get_uint64(
2089 			    pt_to_prop_name(object_type, pt_type),
2090 			    val[i], &str_as_enum);
2091 			/*
2092 			 * Returns _SUCCESS if value for enum is valid.
2093 			 * Returns _INVALID_ARG if property is not an enum.
2094 			 */
2095 			if (ret == NWAM_SUCCESS) {
2096 				uint_vals[i] = str_as_enum;
2097 			} else if (ret == NWAM_INVALID_ARG) {
2098 				uint_vals[i] = strtoul(val[i], &endptr, 10);
2099 				/* verify conversion is valid */
2100 				if (endptr == val[i]) {
2101 					free(uint_vals);
2102 					array_free((void **)val, max_str_num);
2103 					return (NULL);
2104 				}
2105 			} else {
2106 				free(uint_vals);
2107 				array_free((void **)val, max_str_num);
2108 				return (NULL);
2109 			}
2110 			break;
2111 		}
2112 		case NWAM_VALUE_TYPE_BOOLEAN:
2113 			boolean_vals[i] = str_to_boolean(val[i]);
2114 			break;
2115 		default:
2116 			array_free((void **)val, max_str_num);
2117 			return (NULL);
2118 		}
2119 	}
2120 
2121 	/* create nwam_value_t */
2122 	if (value_type == NWAM_VALUE_TYPE_STRING) {
2123 		ret = nwam_value_create_string_array(val, n, &data);
2124 	} else if (value_type == NWAM_VALUE_TYPE_INT64) {
2125 		ret = nwam_value_create_int64_array(int_vals, n, &data);
2126 		free(int_vals);
2127 	} else if (value_type == NWAM_VALUE_TYPE_UINT64) {
2128 		ret = nwam_value_create_uint64_array(uint_vals, n, &data);
2129 		free(uint_vals);
2130 	} else if (value_type == NWAM_VALUE_TYPE_BOOLEAN) {
2131 		ret = nwam_value_create_boolean_array(boolean_vals, n, &data);
2132 		free(boolean_vals);
2133 	}
2134 	array_free((void **)val, max_str_num);
2135 
2136 	if (ret != NWAM_SUCCESS) {
2137 		nwamerr(ret, "Failed creating nwam_value");
2138 		return (NULL);
2139 	}
2140 
2141 	return (data);
2142 }
2143 
2144 /*
2145  * Displaying/Skipping of properties
2146  * ---------------------------------
2147  *
2148  * This table shows if a specific property should be shown if some
2149  * other property has a specific value.  This table is used by
2150  * show_prop_test(), which is called by set_func() and walkprop_func().
2151  *
2152  * An entry in the table looks like:
2153  *	{ property1, property2, { val1, val2, -1 } }
2154  * This is read as:
2155  *	"show property1 only if property2 has value val1 or val2"
2156  *
2157  * NB: If a property does not appear in this table, then that implies
2158  * that the property is always shown.
2159  *
2160  * A property can have more than one rule.  In such a case, the property is
2161  * displayed only any of the rules is satisfied.  This checking, however,
2162  * is recursive.  If a rule says that a property can be displayed, then the
2163  * property that's checked should also satisfy its rules.  In the above
2164  * example, if property1 is to be displayed, then property2 should also
2165  * satisfy its rules and be displayable.  This recursion is necessary as
2166  * properties that are not displayed (because rules are not satisfied) are
2167  * not deleted.
2168  */
2169 
2170 /* The most number of values in pde_checkvals below */
2171 #define	NWAM_CHECKVALS_MAX	5
2172 
2173 typedef struct prop_display_entry {
2174 	const char	*pde_name;		/* property to show */
2175 	const char	*pde_checkname;		/* property to check */
2176 	int64_t	pde_checkvals[NWAM_CHECKVALS_MAX]; /* show prop for these */
2177 } prop_display_entry_t;
2178 
2179 /* Rules for showing properties: commented for clarity */
2180 
2181 /*
2182  * Rules for NCUs
2183  * NB: There is no need to have an entry if a property is for IP only.
2184  *     This is taken care of in libnwam_ncp.c
2185  */
2186 static prop_display_entry_t ncu_prop_display_entry_table[] = {
2187 	/* show priority-{group,mode} if activation == prioritized */
2188 	{ NWAM_NCU_PROP_PRIORITY_GROUP, NWAM_NCU_PROP_ACTIVATION_MODE,
2189 	    { NWAM_ACTIVATION_MODE_PRIORITIZED, -1 } },
2190 	{ NWAM_NCU_PROP_PRIORITY_MODE, NWAM_NCU_PROP_ACTIVATION_MODE,
2191 	    { NWAM_ACTIVATION_MODE_PRIORITIZED, -1 } },
2192 	/* show ipv4-addrsrc if ip-version == ipv4 */
2193 	{ NWAM_NCU_PROP_IPV4_ADDRSRC, NWAM_NCU_PROP_IP_VERSION,
2194 	    { IPV4_VERSION, -1 } },
2195 	/* show ipv4-addr if ipv4-addrsrc == static */
2196 	{ NWAM_NCU_PROP_IPV4_ADDR, NWAM_NCU_PROP_IPV4_ADDRSRC,
2197 	    { NWAM_ADDRSRC_STATIC, -1 } },
2198 	/* show ipv4-default-route if ip-version == ipv4 */
2199 	{ NWAM_NCU_PROP_IPV4_DEFAULT_ROUTE, NWAM_NCU_PROP_IP_VERSION,
2200 	    { IPV4_VERSION, -1 } },
2201 	/* show ipv6-addrsrc if ip-version == ipv6 */
2202 	{ NWAM_NCU_PROP_IPV6_ADDRSRC, NWAM_NCU_PROP_IP_VERSION,
2203 	    { IPV6_VERSION, -1 } },
2204 	/* show ipv6-addr if ipv6-addrsrc == static */
2205 	{ NWAM_NCU_PROP_IPV6_ADDR, NWAM_NCU_PROP_IPV6_ADDRSRC,
2206 	    { NWAM_ADDRSRC_STATIC, -1 } },
2207 	/* show ipv6-default-route if ip-version == ipv6 */
2208 	{ NWAM_NCU_PROP_IPV6_DEFAULT_ROUTE, NWAM_NCU_PROP_IP_VERSION,
2209 	    { IPV6_VERSION, -1 } },
2210 	/* show ip-primary if ipv4-addrsrc == dhcp */
2211 	{ NWAM_NCU_PROP_IP_PRIMARY, NWAM_NCU_PROP_IPV4_ADDRSRC,
2212 	    { NWAM_ADDRSRC_DHCP, -1 } },
2213 	/* show ip-reqhost if ipv4-addrsrc == dhcp */
2214 	{ NWAM_NCU_PROP_IP_REQHOST, NWAM_NCU_PROP_IPV4_ADDRSRC,
2215 	    { NWAM_ADDRSRC_DHCP, -1 } },
2216 	{ NULL, NULL, { -1 } }
2217 };
2218 
2219 /* Rules for ENMs */
2220 static prop_display_entry_t enm_prop_display_entry_table[] = {
2221 	/* show conditions if activation-mode == conditional-{all,any} */
2222 	{ NWAM_ENM_PROP_CONDITIONS, NWAM_ENM_PROP_ACTIVATION_MODE,
2223 	    { NWAM_ACTIVATION_MODE_CONDITIONAL_ALL,
2224 	    NWAM_ACTIVATION_MODE_CONDITIONAL_ANY, -1 } },
2225 	{ NULL, NULL, { -1 } }
2226 };
2227 
2228 /* Rules for LOCations */
2229 static prop_display_entry_t loc_prop_display_entry_table[] = {
2230 	/* show conditions if activation-mode == conditional-{all,any} */
2231 	{ NWAM_LOC_PROP_CONDITIONS, NWAM_LOC_PROP_ACTIVATION_MODE,
2232 	    { NWAM_ACTIVATION_MODE_CONDITIONAL_ALL,
2233 	    NWAM_ACTIVATION_MODE_CONDITIONAL_ANY, -1 } },
2234 	/* show dns-nameservice-configsrc if nameservices == dns */
2235 	{ NWAM_LOC_PROP_DNS_NAMESERVICE_CONFIGSRC, NWAM_LOC_PROP_NAMESERVICES,
2236 	    { NWAM_NAMESERVICES_DNS, -1 } },
2237 	/* show other DNS options if dns-nameservices-configsrc == manual */
2238 	{ NWAM_LOC_PROP_DNS_NAMESERVICE_DOMAIN,
2239 	    NWAM_LOC_PROP_DNS_NAMESERVICE_CONFIGSRC,
2240 	    { NWAM_CONFIGSRC_MANUAL, -1 } },
2241 	{ NWAM_LOC_PROP_DNS_NAMESERVICE_SERVERS,
2242 	    NWAM_LOC_PROP_DNS_NAMESERVICE_CONFIGSRC,
2243 	    { NWAM_CONFIGSRC_MANUAL, -1 } },
2244 	{ NWAM_LOC_PROP_DNS_NAMESERVICE_SEARCH,
2245 	    NWAM_LOC_PROP_DNS_NAMESERVICE_CONFIGSRC,
2246 	    { NWAM_CONFIGSRC_MANUAL, -1 } },
2247 	/* show nis-nameservice-configsrc if nameservices == nis */
2248 	{ NWAM_LOC_PROP_NIS_NAMESERVICE_CONFIGSRC, NWAM_LOC_PROP_NAMESERVICES,
2249 	    { NWAM_NAMESERVICES_NIS, -1 } },
2250 	/* show nis-nameservice-servers if nis-nameservice-configsrc = manual */
2251 	{ NWAM_LOC_PROP_NIS_NAMESERVICE_SERVERS,
2252 	    NWAM_LOC_PROP_NIS_NAMESERVICE_CONFIGSRC,
2253 	    { NWAM_CONFIGSRC_MANUAL, -1 } },
2254 	/* show ldap-nameservice-configsrc if nameservices == ldap */
2255 	{ NWAM_LOC_PROP_LDAP_NAMESERVICE_CONFIGSRC, NWAM_LOC_PROP_NAMESERVICES,
2256 	    { NWAM_NAMESERVICES_LDAP, -1 } },
2257 	/* show ldap-nameservice-servers if ldap-nameservice-configsrc=manual */
2258 	{ NWAM_LOC_PROP_LDAP_NAMESERVICE_SERVERS,
2259 	    NWAM_LOC_PROP_LDAP_NAMESERVICE_CONFIGSRC,
2260 	    { NWAM_CONFIGSRC_MANUAL, -1 } },
2261 	/* show default-domain if {nis,ldap}-nameservice-configsrc == manual */
2262 	{ NWAM_LOC_PROP_DEFAULT_DOMAIN, NWAM_LOC_PROP_NIS_NAMESERVICE_CONFIGSRC,
2263 	    { NWAM_CONFIGSRC_MANUAL, -1 } },
2264 	{ NWAM_LOC_PROP_DEFAULT_DOMAIN,
2265 	    NWAM_LOC_PROP_LDAP_NAMESERVICE_CONFIGSRC,
2266 	    { NWAM_CONFIGSRC_MANUAL, -1 } },
2267 	{ NULL, NULL, { -1 } }
2268 };
2269 
2270 /* Rules for Known WLANs */
2271 static prop_display_entry_t wlan_prop_display_entry_table[] = {
2272 	/* no rules for WLANs */
2273 	{ NULL, NULL, { -1 } }
2274 };
2275 
2276 /* Returns the appropriate rules table for the given object type */
2277 static prop_display_entry_t *
2278 get_prop_display_table(nwam_object_type_t object_type)
2279 {
2280 	switch (object_type) {
2281 	case NWAM_OBJECT_TYPE_NCU:
2282 		return (ncu_prop_display_entry_table);
2283 	case NWAM_OBJECT_TYPE_LOC:
2284 		return (loc_prop_display_entry_table);
2285 	case NWAM_OBJECT_TYPE_ENM:
2286 		return (enm_prop_display_entry_table);
2287 	case NWAM_OBJECT_TYPE_KNOWN_WLAN:
2288 		return (wlan_prop_display_entry_table);
2289 	}
2290 	return (NULL);
2291 }
2292 
2293 /*
2294  * Tests whether prop must be shown during a walk depending on the
2295  * value of a different property.
2296  *
2297  * This function is also used by set_func() to determine whether the
2298  * property being set should be allowed or not.  If the property
2299  * would not be displayed in a walk, then it should not be set.
2300  *
2301  * The checked_props and num_checked arguments are used to avoid circular
2302  * dependencies between properties.  When this function recursively calls
2303  * itself, it adds the property that it just checked to the checked_props
2304  * list.
2305  */
2306 static boolean_t
2307 show_prop_test(nwam_object_type_t object_type, const char *prop,
2308     prop_display_entry_t *display_list, char **checked_props, int num_checked)
2309 {
2310 	nwam_error_t		ret;
2311 	nwam_value_t		prop_val;
2312 	nwam_value_type_t	prop_type;
2313 	int			i, j, k;
2314 	boolean_t		prop_found = B_FALSE, show_prop = B_FALSE;
2315 
2316 	/*
2317 	 * Check if this property has already been checked previously in
2318 	 * the recursion.  If so, return B_FALSE so that the initial prop
2319 	 * is not displayed.
2320 	 */
2321 	for (i = 0; i < num_checked; i++) {
2322 		if (strcmp(prop, checked_props[i]) == 0) {
2323 			free(checked_props);
2324 			return (B_FALSE);
2325 		}
2326 	}
2327 
2328 	for (i = 0; display_list[i].pde_name != NULL; i++) {
2329 		if (strcmp(prop, display_list[i].pde_name) != 0)
2330 			continue;
2331 		prop_found = B_TRUE;
2332 
2333 		/* get the value(s) of the (other) property to check */
2334 		switch (object_type) {
2335 		case NWAM_OBJECT_TYPE_NCU:
2336 			ret = nwam_ncu_get_prop_value(ncu_h,
2337 			    display_list[i].pde_checkname, &prop_val);
2338 			break;
2339 		case NWAM_OBJECT_TYPE_LOC:
2340 			ret = nwam_loc_get_prop_value(loc_h,
2341 			    display_list[i].pde_checkname, &prop_val);
2342 			break;
2343 		case NWAM_OBJECT_TYPE_ENM:
2344 			ret = nwam_enm_get_prop_value(enm_h,
2345 			    display_list[i].pde_checkname, &prop_val);
2346 			break;
2347 		case NWAM_OBJECT_TYPE_KNOWN_WLAN:
2348 			return (B_TRUE);
2349 		}
2350 		if (ret != NWAM_SUCCESS)
2351 			continue;
2352 
2353 		/* prop_val may contain a uint64 array or a boolean */
2354 		if (nwam_value_get_type(prop_val, &prop_type) != NWAM_SUCCESS)
2355 			continue;
2356 
2357 		if (prop_type == NWAM_VALUE_TYPE_UINT64) {
2358 			uint64_t	*prop_uvals;
2359 			int64_t		*check_uvals;
2360 			uint_t		numvals;
2361 
2362 			if (nwam_value_get_uint64_array(prop_val, &prop_uvals,
2363 			    &numvals) != NWAM_SUCCESS) {
2364 				nwam_value_free(prop_val);
2365 				continue;
2366 			}
2367 
2368 			/* for each value in uvals, check each value in table */
2369 			for (j = 0; j < numvals; j++) {
2370 				check_uvals = display_list[i].pde_checkvals;
2371 				for (k = 0; check_uvals[k] != -1; k++) {
2372 					/* show if uvals[j] matches */
2373 					if (prop_uvals[j] ==
2374 					    (uint64_t)check_uvals[k]) {
2375 						show_prop = B_TRUE;
2376 						goto next_rule;
2377 					}
2378 				}
2379 			}
2380 		} else if (prop_type == NWAM_VALUE_TYPE_BOOLEAN) {
2381 			boolean_t bval;
2382 
2383 			if (nwam_value_get_boolean(prop_val, &bval) !=
2384 			    NWAM_SUCCESS) {
2385 				nwam_value_free(prop_val);
2386 				continue;
2387 			}
2388 
2389 			for (k = 0;
2390 			    display_list[i].pde_checkvals[k] != -1;
2391 			    k++) {
2392 				/* show if bval matches */
2393 				if (bval == (boolean_t)
2394 				    display_list[i].pde_checkvals[k]) {
2395 					show_prop = B_TRUE;
2396 					goto next_rule;
2397 				}
2398 			}
2399 		}
2400 
2401 next_rule:
2402 		nwam_value_free(prop_val);
2403 		/*
2404 		 * If show_prop is set, then a rule is satisfied; no need to
2405 		 * check other rules for this prop.  However, recursively
2406 		 * check if the checked prop (pde_checkname) satisfies its
2407 		 * rules.  Also, update the check_props array with this prop.
2408 		 */
2409 		if (show_prop) {
2410 			char **newprops = realloc(checked_props,
2411 			    ++num_checked * sizeof (char *));
2412 			if (newprops == NULL) {
2413 				free(checked_props);
2414 				return (B_FALSE);
2415 			}
2416 			checked_props = newprops;
2417 			checked_props[num_checked - 1] = (char *)prop;
2418 
2419 			return (show_prop_test(object_type,
2420 			    display_list[i].pde_checkname, display_list,
2421 			    checked_props, num_checked));
2422 		}
2423 	}
2424 
2425 	/*
2426 	 * If we are here and prop_found is set, it means that no rules were
2427 	 * satisfied by prop; return B_FALSE.  If prop_found is not set, then
2428 	 * prop did not have a rule so it must be displayed; return B_TRUE.
2429 	 */
2430 	free(checked_props);
2431 	if (prop_found)
2432 		return (B_FALSE);
2433 	else
2434 		return (B_TRUE);
2435 }
2436 
2437 /*
2438  * Returns true if the given property is read-only and cannot be modified.
2439  */
2440 static boolean_t
2441 is_prop_read_only(nwam_object_type_t object_type, const char *prop)
2442 {
2443 	boolean_t ro;
2444 
2445 	switch (object_type) {
2446 	case NWAM_OBJECT_TYPE_NCU:
2447 		if (nwam_ncu_prop_read_only(prop, &ro) == NWAM_SUCCESS && ro)
2448 			return (B_TRUE);
2449 		break;
2450 	case NWAM_OBJECT_TYPE_ENM:
2451 		if (nwam_enm_prop_read_only(prop, &ro) == NWAM_SUCCESS && ro)
2452 			return (B_TRUE);
2453 		break;
2454 	case NWAM_OBJECT_TYPE_LOC:
2455 		if (nwam_loc_prop_read_only(prop, &ro) == NWAM_SUCCESS && ro)
2456 			return (B_TRUE);
2457 		break;
2458 	case NWAM_OBJECT_TYPE_KNOWN_WLAN:
2459 		/* no read-only properties for WLANs */
2460 		return (B_FALSE);
2461 	}
2462 	return (B_FALSE);
2463 }
2464 
2465 /* Returns true if the property is multi-valued */
2466 static boolean_t
2467 is_prop_multivalued(nwam_object_type_t object_type, const char *prop)
2468 {
2469 	nwam_error_t	ret;
2470 	boolean_t	multi;
2471 
2472 	switch (object_type) {
2473 	case NWAM_OBJECT_TYPE_NCU:
2474 		ret = nwam_ncu_prop_multivalued(prop, &multi);
2475 		break;
2476 	case NWAM_OBJECT_TYPE_LOC:
2477 		ret = nwam_loc_prop_multivalued(prop, &multi);
2478 		break;
2479 	case NWAM_OBJECT_TYPE_ENM:
2480 		ret = nwam_enm_prop_multivalued(prop, &multi);
2481 		break;
2482 	case NWAM_OBJECT_TYPE_KNOWN_WLAN:
2483 		ret = nwam_known_wlan_prop_multivalued(prop, &multi);
2484 		break;
2485 	}
2486 
2487 	if (ret != NWAM_SUCCESS)
2488 		multi = B_FALSE;
2489 	return (multi);
2490 }
2491 
2492 /*
2493  * Prints out error message specific to property that could not be set.
2494  * Property description is used to help guide user in entering correct value.
2495  */
2496 static void
2497 invalid_set_prop_msg(const char *prop, nwam_error_t err)
2498 {
2499 	const char *description;
2500 
2501 	if (err == NWAM_SUCCESS)
2502 		return;
2503 
2504 	if (err != NWAM_ENTITY_INVALID_VALUE) {
2505 		nwamerr(err, "Set error");
2506 		return;
2507 	}
2508 
2509 	switch (active_object_type()) {
2510 	case NWAM_OBJECT_TYPE_NCU:
2511 		(void) nwam_ncu_get_prop_description(prop, &description);
2512 		break;
2513 	case NWAM_OBJECT_TYPE_LOC:
2514 		(void) nwam_loc_get_prop_description(prop, &description);
2515 		break;
2516 	case NWAM_OBJECT_TYPE_ENM:
2517 		(void) nwam_enm_get_prop_description(prop, &description);
2518 		break;
2519 	case NWAM_OBJECT_TYPE_KNOWN_WLAN:
2520 		(void) nwam_known_wlan_get_prop_description(prop,
2521 		    &description);
2522 		break;
2523 	}
2524 	nerr("Set error: invalid value\n'%s' %s", prop, description);
2525 }
2526 
2527 /*
2528  * Sets the property value.
2529  * Read-only properties and objects cannot be set.
2530  * "read-only" is a special in that it can be set on a read-only object.
2531  * The object has to be committed before other properties can be set.
2532  * Also uses show_prop_test() to test if the property being set would
2533  * be skipped during a walk (as determined by the value of some other
2534  * property).  If so, then it cannot be set.
2535  */
2536 void
2537 set_func(cmd_t *cmd)
2538 {
2539 	int			pt_type = cmd->cmd_prop_type;
2540 	nwam_error_t		ret = NWAM_SUCCESS;
2541 	nwam_value_t		prop_value;
2542 	const char		*prop;
2543 	boolean_t		is_listprop = B_FALSE;
2544 	nwam_object_type_t	object_type;
2545 	prop_display_entry_t	*prop_table;
2546 	char			**checked = NULL;
2547 
2548 	assert(cmd->cmd_argc > 0);
2549 
2550 	object_type = active_object_type();
2551 	prop_table = get_prop_display_table(object_type);
2552 
2553 	/* argv[0] is property value */
2554 	if ((prop = pt_to_prop_name(object_type, pt_type)) == NULL) {
2555 		nerr("Set error: invalid %s property: '%s'",
2556 		    scope_to_str(current_scope), pt_to_str(pt_type));
2557 		return;
2558 	}
2559 
2560 	/* check if property can be set */
2561 	if (is_prop_read_only(object_type, prop)) {
2562 		nerr("Set error: property '%s' is read-only", prop);
2563 		return;
2564 	}
2565 	if (!show_prop_test(object_type, prop, prop_table, checked, 0)) {
2566 		if (interactive_mode) {
2567 			(void) printf(gettext("setting property '%s' "
2568 			    "has no effect\n"), prop);
2569 		}
2570 	}
2571 
2572 	is_listprop = is_prop_multivalued(object_type, prop);
2573 	prop_value = str_to_nwam_value(object_type, cmd->cmd_argv[0], pt_type,
2574 	    is_listprop);
2575 	if (prop_value == NULL) {
2576 		invalid_set_prop_msg(prop, NWAM_ENTITY_INVALID_VALUE);
2577 		return;
2578 	}
2579 
2580 	/* set the property value */
2581 	switch (object_type) {
2582 	case NWAM_OBJECT_TYPE_NCU:
2583 		ret = nwam_ncu_set_prop_value(ncu_h, prop, prop_value);
2584 		break;
2585 	case NWAM_OBJECT_TYPE_LOC:
2586 		ret = nwam_loc_set_prop_value(loc_h, prop, prop_value);
2587 		break;
2588 	case NWAM_OBJECT_TYPE_ENM:
2589 		ret = nwam_enm_set_prop_value(enm_h, prop, prop_value);
2590 		break;
2591 	case NWAM_OBJECT_TYPE_KNOWN_WLAN:
2592 		ret = nwam_known_wlan_set_prop_value(wlan_h, prop, prop_value);
2593 		break;
2594 	}
2595 	nwam_value_free(prop_value);
2596 
2597 	/* delete other properties if needed */
2598 	if (ret == NWAM_SUCCESS)
2599 		need_to_commit = B_TRUE;
2600 	else
2601 		invalid_set_prop_msg(prop, ret);
2602 }
2603 
2604 static int
2605 list_callback(nwam_object_type_t object_type, void *handle,
2606     boolean_t *list_msgp, const char *msg)
2607 {
2608 	nwam_error_t		ret;
2609 	char			*name;
2610 	nwam_ncu_class_t	class;
2611 
2612 	if (*list_msgp) {
2613 		(void) printf("%s:\n", msg);
2614 		*list_msgp = B_FALSE;
2615 	}
2616 
2617 	ret = object_name_from_handle(object_type, handle, &name);
2618 	if (ret != NWAM_SUCCESS) {
2619 		nwamerr(ret, "List error: failed to get name");
2620 		return (1);
2621 	}
2622 
2623 	/* If NCU, get its class and print */
2624 	if (object_type == NWAM_OBJECT_TYPE_NCU) {
2625 		if ((ret = nwam_ncu_get_ncu_class(handle, &class))
2626 		    != NWAM_SUCCESS) {
2627 			nwamerr(ret, "List error: failed to get ncu class");
2628 			free(name);
2629 			return (1);
2630 		} else {
2631 			(void) printf("\t%s",
2632 			    propval_to_str(NWAM_NCU_PROP_CLASS, class));
2633 		}
2634 	}
2635 	(void) printf("\t%s\n", name);
2636 
2637 	free(name);
2638 	return (0);
2639 }
2640 
2641 /* Print out name, type and status */
2642 static int
2643 list_loc_callback(nwam_loc_handle_t loc, void *arg)
2644 {
2645 	return (list_callback(NWAM_OBJECT_TYPE_LOC, loc, arg, "Locations"));
2646 }
2647 
2648 static int
2649 list_enm_callback(nwam_enm_handle_t enm, void *arg)
2650 {
2651 	return (list_callback(NWAM_OBJECT_TYPE_ENM, enm, arg, "ENMs"));
2652 }
2653 
2654 static int
2655 list_wlan_callback(nwam_known_wlan_handle_t wlan, void *arg)
2656 {
2657 	return (list_callback(NWAM_OBJECT_TYPE_KNOWN_WLAN, wlan, arg, "WLANs"));
2658 }
2659 
2660 static int
2661 list_ncp_callback(nwam_ncp_handle_t ncp, void *arg)
2662 {
2663 	return (list_callback(NWAM_OBJECT_TYPE_NCP, ncp, arg, "NCPs"));
2664 }
2665 
2666 static int
2667 list_ncu_callback(nwam_ncu_handle_t ncu, void *arg)
2668 {
2669 	return (list_callback(NWAM_OBJECT_TYPE_NCU, ncu, arg, "NCUs"));
2670 }
2671 
2672 /* functions to convert a value to a string */
2673 /* ARGSUSED */
2674 static const char *
2675 str2str(void *s, const char *prop, char *str)
2676 {
2677 	(void) snprintf(str, NWAM_MAX_VALUE_LEN, "%s", s);
2678 	return (str);
2679 }
2680 
2681 /* ARGSUSED */
2682 static const char *
2683 str2qstr(void *s, const char *prop, char *qstr)
2684 {
2685 	/* quoted strings */
2686 	(void) snprintf(qstr, NWAM_MAX_VALUE_LEN, "\"%s\"", s);
2687 	return (qstr);
2688 }
2689 
2690 /* ARGSUSED */
2691 static const char *
2692 int2str(void *in, const char *prop, char *instr)
2693 {
2694 	(void) snprintf(instr, NWAM_MAX_VALUE_LEN, "%lld", *((int64_t *)in));
2695 	return (instr);
2696 }
2697 
2698 static const char *
2699 uint2str(void *uin, const char *prop, char *uintstr)
2700 {
2701 	/* returns NWAM_SUCCESS if prop is enum with string in uintstr */
2702 	if (nwam_uint64_get_value_string(prop, *((uint64_t *)uin),
2703 	    (const char **)&uintstr) != NWAM_SUCCESS) {
2704 		(void) snprintf(uintstr, NWAM_MAX_VALUE_LEN, "%lld",
2705 		    *((uint64_t *)uin));
2706 	}
2707 	return (uintstr);
2708 }
2709 
2710 /* ARGSUSED */
2711 static const char *
2712 bool2str(void *bool, const char *prop, char *boolstr)
2713 {
2714 	(void) snprintf(boolstr, NWAM_MAX_VALUE_LEN, "%s",
2715 	    *((boolean_t *)bool) ? "true" : "false");
2716 	return (boolstr);
2717 }
2718 
2719 /*
2720  * Print the value (enums are converted to string), use DELIMITER for
2721  * array.  If strings are to be "quoted", pass B_TRUE for quoted_strings.
2722  */
2723 static void
2724 output_prop_val(const char *prop_name, nwam_value_t value, FILE *wf,
2725     boolean_t quoted_strings)
2726 {
2727 	nwam_value_type_t	value_type;
2728 	uint_t			num;
2729 
2730 	/* arrays for values retrieved according to the type of value */
2731 	char		**svals;
2732 	uint64_t	*uvals;
2733 	int64_t		*ivals;
2734 	boolean_t	*bvals;
2735 
2736 	/* pointer to function to generate string representation of value */
2737 	const char	*(*tostr)(void *, const char *, char *);
2738 	char		str[NWAM_MAX_VALUE_LEN]; /* to store the string */
2739 	int		i;
2740 
2741 	if (nwam_value_get_type(value, &value_type) != NWAM_SUCCESS) {
2742 		nerr("Get value type error");
2743 		return;
2744 	}
2745 
2746 	if (value_type == NWAM_VALUE_TYPE_STRING) {
2747 		if (nwam_value_get_string_array(value, &svals, &num) !=
2748 		    NWAM_SUCCESS) {
2749 			nerr("Get string array error");
2750 			return;
2751 		}
2752 		tostr = quoted_strings ? str2qstr : str2str;
2753 	} else if (value_type == NWAM_VALUE_TYPE_INT64) {
2754 		if (nwam_value_get_int64_array(value, &ivals, &num) !=
2755 		    NWAM_SUCCESS) {
2756 			nerr("Get int64 array error");
2757 			return;
2758 		}
2759 		tostr = int2str;
2760 	} else if (value_type == NWAM_VALUE_TYPE_UINT64) {
2761 		if (nwam_value_get_uint64_array(value, &uvals, &num) !=
2762 		    NWAM_SUCCESS) {
2763 			nerr("Get uint64 array error");
2764 			return;
2765 		}
2766 		tostr = uint2str;
2767 	} else if (value_type == NWAM_VALUE_TYPE_BOOLEAN) {
2768 		if (nwam_value_get_boolean_array(value, &bvals, &num) !=
2769 		    NWAM_SUCCESS) {
2770 			nerr("Get boolean array error");
2771 			return;
2772 		}
2773 		tostr = bool2str;
2774 	}
2775 
2776 	/* now, loop and print each value */
2777 	for (i = 0; i < num; i++) {
2778 		void *val;
2779 
2780 		/* get the pointer to the ith value to pass to func() */
2781 		if (value_type == NWAM_VALUE_TYPE_STRING)
2782 			val = svals[i];
2783 		else if (value_type == NWAM_VALUE_TYPE_UINT64)
2784 			val = &(uvals[i]);
2785 		else if (value_type == NWAM_VALUE_TYPE_INT64)
2786 			val = &(ivals[i]);
2787 		else if (value_type == NWAM_VALUE_TYPE_BOOLEAN)
2788 			val = &(bvals[i]);
2789 
2790 		(void) fprintf(wf, "%s%s", tostr(val, prop_name, str),
2791 		    i != num-1 ? NWAM_VALUE_DELIMITER_STR : "");
2792 	}
2793 }
2794 
2795 /* Prints the property names aligned (for list/get) or "prop=" (for export) */
2796 static int
2797 output_propname_common(const char *prop, nwam_value_t values, void *arg,
2798     int width)
2799 {
2800 	FILE *of = (arg == NULL) ? stdout : arg;
2801 
2802 	/* arg is NULL for list/get, not NULL for export */
2803 	if (arg == NULL)
2804 		(void) fprintf(of, "\t%-*s\t", width, prop);
2805 	else
2806 		(void) fprintf(of, "%s=", prop);
2807 
2808 	if (values != NULL)
2809 		output_prop_val(prop, values, of, B_TRUE);
2810 
2811 	(void) fprintf(of, "\n");
2812 	return (0);
2813 }
2814 
2815 static int
2816 output_propname(const char *prop, nwam_value_t values, void *arg)
2817 {
2818 	return (output_propname_common(prop, values, arg, 16));
2819 }
2820 
2821 /* For locations because of longer property names */
2822 static int
2823 output_loc_propname(const char *prop, nwam_value_t values, void *arg)
2824 {
2825 	return (output_propname_common(prop, values, arg, 25));
2826 }
2827 
2828 /*
2829  * all_props specifies whether properties that have not been set should be
2830  * printed or not.  ncp and ncu_type are used only when the object_type is
2831  * NCU.
2832  */
2833 static nwam_error_t
2834 listprop(nwam_object_type_t object_type, void *handle, const char *name,
2835     boolean_t all_props, nwam_ncp_handle_t ncp, nwam_ncu_type_t ncu_type)
2836 {
2837 	nwam_error_t	ret;
2838 	char		*lname = NULL, *realname = NULL;
2839 	boolean_t	lhandle = B_FALSE;
2840 	const char	**props = NULL;
2841 	uint_t		prop_num;
2842 	int		i;
2843 	nwam_value_t	vals;
2844 
2845 	/*
2846 	 * handle is NULL if called from a scope higher than the object's
2847 	 * scope, but name must be given; so get the handle.
2848 	 */
2849 	if (handle == NULL) {
2850 		lname = trim_quotes(name); /* name may have quotes */
2851 		switch (object_type) {
2852 		case NWAM_OBJECT_TYPE_NCP:
2853 			if ((ret = nwam_ncp_read(lname, 0,
2854 			    (nwam_ncp_handle_t *)&handle)) != NWAM_SUCCESS)
2855 				goto readfail;
2856 			break;
2857 		case NWAM_OBJECT_TYPE_NCU:
2858 			ret = nwam_ncu_read(ncp, lname, ncu_type, 0,
2859 			    (nwam_ncu_handle_t *)&handle);
2860 			if (ret == NWAM_ENTITY_MULTIPLE_VALUES) {
2861 				/*
2862 				 * Multiple NCUs with the given name exists.
2863 				 * Call listprop() for each NCU type.
2864 				 */
2865 				if ((ret = listprop(object_type, NULL, lname,
2866 				    all_props, ncp, NWAM_NCU_TYPE_LINK))
2867 				    != NWAM_SUCCESS)
2868 					goto done;
2869 				ret = listprop(object_type, NULL, lname,
2870 				    all_props, ncp, NWAM_NCU_TYPE_INTERFACE);
2871 				goto done;
2872 			} else if (ret != NWAM_SUCCESS) {
2873 				goto readfail;
2874 			}
2875 			break;
2876 		case NWAM_OBJECT_TYPE_LOC:
2877 			if ((ret = nwam_loc_read(lname, 0,
2878 			    (nwam_loc_handle_t *)&handle)) != NWAM_SUCCESS)
2879 				goto readfail;
2880 			break;
2881 		case NWAM_OBJECT_TYPE_ENM:
2882 			if ((ret = nwam_enm_read(lname, 0,
2883 			    (nwam_enm_handle_t *)&handle)) != NWAM_SUCCESS)
2884 				goto readfail;
2885 			break;
2886 		case NWAM_OBJECT_TYPE_KNOWN_WLAN:
2887 			if ((ret = nwam_known_wlan_read(lname, 0,
2888 			    (nwam_known_wlan_handle_t *)&handle))
2889 			    != NWAM_SUCCESS)
2890 				goto readfail;
2891 			break;
2892 		}
2893 		lhandle = B_TRUE;
2894 	}
2895 
2896 	if ((ret = object_name_from_handle(object_type, handle, &realname))
2897 	    != NWAM_SUCCESS)
2898 		goto done;
2899 
2900 	/* get the property list */
2901 	switch (object_type) {
2902 	case NWAM_OBJECT_TYPE_NCP:
2903 	{
2904 		/* walk NCUs */
2905 		boolean_t list_msg = B_TRUE;
2906 		ret = nwam_ncp_walk_ncus(handle, list_ncu_callback, &list_msg,
2907 		    NWAM_FLAG_NCU_TYPE_CLASS_ALL, NULL);
2908 		goto done;
2909 	}
2910 	case NWAM_OBJECT_TYPE_NCU:
2911 	{
2912 		nwam_ncu_type_t		ncu_type;
2913 		nwam_ncu_class_t	ncu_class;
2914 
2915 		if ((ret = nwam_ncu_get_ncu_type(handle, &ncu_type))
2916 		    != NWAM_SUCCESS)
2917 			goto done;
2918 		if ((ret = nwam_ncu_get_ncu_class(handle, &ncu_class))
2919 		    != NWAM_SUCCESS)
2920 			goto done;
2921 
2922 		ret = nwam_ncu_get_default_proplist(ncu_type, ncu_class, &props,
2923 		    &prop_num);
2924 		break;
2925 	}
2926 	case NWAM_OBJECT_TYPE_LOC:
2927 		ret = nwam_loc_get_default_proplist(&props, &prop_num);
2928 		break;
2929 	case NWAM_OBJECT_TYPE_ENM:
2930 		ret = nwam_enm_get_default_proplist(&props, &prop_num);
2931 		break;
2932 	case NWAM_OBJECT_TYPE_KNOWN_WLAN:
2933 		ret = nwam_known_wlan_get_default_proplist(&props, &prop_num);
2934 		break;
2935 	}
2936 	if (ret != NWAM_SUCCESS)
2937 		goto done;
2938 
2939 	/* print object type and name */
2940 	(void) printf("%s:%s\n", nwam_object_type_to_string(object_type),
2941 	    realname);
2942 
2943 	/* Loop through the properties and print */
2944 	for (i = 0; i < prop_num; i++) {
2945 		/* get the existing value for this property */
2946 		switch (object_type) {
2947 		case NWAM_OBJECT_TYPE_NCU:
2948 			ret = nwam_ncu_get_prop_value(handle, props[i], &vals);
2949 			break;
2950 		case NWAM_OBJECT_TYPE_LOC:
2951 			ret = nwam_loc_get_prop_value(handle, props[i], &vals);
2952 			break;
2953 		case NWAM_OBJECT_TYPE_ENM:
2954 			ret = nwam_enm_get_prop_value(handle, props[i], &vals);
2955 			break;
2956 		case NWAM_OBJECT_TYPE_KNOWN_WLAN:
2957 			ret = nwam_known_wlan_get_prop_value(handle, props[i],
2958 			    &vals);
2959 			break;
2960 		}
2961 		if (ret != NWAM_SUCCESS) {
2962 			/* _ENTITY_NOT_FOUND is ok if listing for all props */
2963 			if (!all_props)
2964 				continue;
2965 			else if (ret != NWAM_ENTITY_NOT_FOUND)
2966 				continue;
2967 		}
2968 
2969 		/* print property and value */
2970 		if (object_type == NWAM_OBJECT_TYPE_LOC)
2971 			output_loc_propname(props[i], vals, NULL);
2972 		else
2973 			output_propname(props[i], vals, NULL);
2974 		nwam_value_free(vals);
2975 	}
2976 
2977 done:
2978 	free(lname);
2979 	free(realname);
2980 	if (props != NULL)
2981 		free(props);
2982 	if (lhandle) {
2983 		switch (object_type) {
2984 		case NWAM_OBJECT_TYPE_NCP:
2985 			nwam_ncp_free(handle);
2986 			break;
2987 		case NWAM_OBJECT_TYPE_NCU:
2988 			nwam_ncu_free(handle);
2989 			break;
2990 		case NWAM_OBJECT_TYPE_LOC:
2991 			nwam_loc_free(handle);
2992 			break;
2993 		case NWAM_OBJECT_TYPE_ENM:
2994 			nwam_enm_free(handle);
2995 			break;
2996 		case NWAM_OBJECT_TYPE_KNOWN_WLAN:
2997 			nwam_known_wlan_free(handle);
2998 			break;
2999 		}
3000 	}
3001 	/* don't treat _ENTITY_NOT_FOUND as an error */
3002 	if (ret == NWAM_ENTITY_NOT_FOUND)
3003 		ret = NWAM_SUCCESS;
3004 	return (ret);
3005 
3006 readfail:
3007 	/* When nwam_*_read() fails */
3008 	free(lname);
3009 	return (ret);
3010 }
3011 
3012 /*
3013  * List profiles or property and its values.
3014  * If the -a option is specified, all properties are listed.
3015  */
3016 void
3017 list_func(cmd_t *cmd)
3018 {
3019 	nwam_error_t	ret = NWAM_SUCCESS;
3020 	boolean_t	list_msg = B_TRUE;
3021 
3022 	boolean_t	list_loc = B_FALSE, list_enm = B_FALSE;
3023 	boolean_t	list_ncp = B_FALSE, list_ncu = B_FALSE;
3024 	boolean_t	list_wlan = B_FALSE;
3025 
3026 	/* whether all properties should be listed, given by the -a option */
3027 	boolean_t	all_props = B_FALSE;
3028 
3029 	/*
3030 	 * list_props says whether the properties should be listed.
3031 	 * Note that, here NCUs are treated as properties of NCPs.
3032 	 */
3033 	boolean_t	list_props = B_FALSE;
3034 
3035 	/* determine which properties to list, also validity tests */
3036 	if (current_scope == NWAM_SCOPE_GBL) {
3037 		/* res1_type is -1 if only "list -a" is used */
3038 		if (cmd->cmd_res1_type == -1) {
3039 			nerr("'list' requires an object to be specified with "
3040 			    "the -a option in the global scope");
3041 			return;
3042 		}
3043 		if (cmd->cmd_res1_type == RT1_LOC) {
3044 			list_props = B_TRUE;
3045 			list_loc = B_TRUE;
3046 		} else if (cmd->cmd_res1_type == RT1_ENM) {
3047 			list_props = B_TRUE;
3048 			list_enm = B_TRUE;
3049 		} else if (cmd->cmd_res1_type == RT1_WLAN) {
3050 			list_props = B_TRUE;
3051 			list_wlan = B_TRUE;
3052 		} else if (cmd->cmd_res1_type == RT1_NCP) {
3053 			list_ncp = B_TRUE;
3054 			list_props = B_TRUE;
3055 		} else {
3056 			list_loc = B_TRUE;
3057 			list_enm = B_TRUE;
3058 			list_wlan = B_TRUE;
3059 			list_ncp = B_TRUE;
3060 		}
3061 	}
3062 	if ((current_scope == NWAM_SCOPE_LOC ||
3063 	    current_scope == NWAM_SCOPE_ENM ||
3064 	    current_scope == NWAM_SCOPE_WLAN ||
3065 	    current_scope == NWAM_SCOPE_NCU) &&
3066 	    (cmd->cmd_argc >= 1 && cmd->cmd_res1_type != -1)) {
3067 		nerr("Additional options are not allowed with the -a option "
3068 		    "at this scope");
3069 		return;
3070 	}
3071 	if (current_scope == NWAM_SCOPE_LOC) {
3072 		list_loc = B_TRUE;
3073 		list_props = B_TRUE;
3074 	}
3075 	if (current_scope == NWAM_SCOPE_ENM) {
3076 		list_enm = B_TRUE;
3077 		list_props = B_TRUE;
3078 	}
3079 	if (current_scope == NWAM_SCOPE_WLAN) {
3080 		list_wlan = B_TRUE;
3081 		list_props = B_TRUE;
3082 	}
3083 	if (current_scope == NWAM_SCOPE_NCP) {
3084 		if (cmd->cmd_res1_type == RT1_ENM ||
3085 		    cmd->cmd_res1_type == RT1_LOC ||
3086 		    cmd->cmd_res1_type == RT1_WLAN) {
3087 			nerr("only ncu can be listed at this scope");
3088 			return;
3089 		}
3090 		if (cmd->cmd_res2_type == RT2_NCU) {
3091 			list_ncu = B_TRUE;
3092 			list_props = B_TRUE;
3093 		} else {
3094 			list_ncp = B_TRUE;
3095 			list_props = B_TRUE;
3096 		}
3097 	}
3098 	if (current_scope == NWAM_SCOPE_NCU) {
3099 		list_ncu = B_TRUE;
3100 		list_props = B_TRUE;
3101 	}
3102 
3103 	/* Check if the -a option is specified to list all properties */
3104 	if (cmd->cmd_res1_type == -1 || cmd->cmd_argc == 2) {
3105 		int c, argc = 1;
3106 		char **argv;
3107 		optind = 0;
3108 
3109 		/* if res1_type is -1, option is in argv[0], else in argv[1] */
3110 		if (cmd->cmd_res1_type == -1)
3111 			argv = cmd->cmd_argv;
3112 		else
3113 			argv = &(cmd->cmd_argv[1]);
3114 		while ((c = getopt(argc, argv, "a")) != EOF) {
3115 			switch (c) {
3116 			case 'a':
3117 				all_props = B_TRUE;
3118 				break;
3119 			default:
3120 				command_usage(CMD_LIST);
3121 				return;
3122 			}
3123 		}
3124 		if (cmd->cmd_res1_type == -1)
3125 			cmd->cmd_argv[0] = NULL;
3126 	}
3127 
3128 	/*
3129 	 * Now, print objects and/or according to the flags set.
3130 	 * name, if requested, is in argv[0].
3131 	 */
3132 	if (list_ncp) {
3133 		list_msg = B_TRUE;
3134 		if (list_props) {
3135 			ret = listprop(NWAM_OBJECT_TYPE_NCP, ncp_h,
3136 			    cmd->cmd_argv[0], all_props, NULL, -1);
3137 		} else {
3138 			ret = nwam_walk_ncps(list_ncp_callback, &list_msg, 0,
3139 			    NULL);
3140 		}
3141 		if (ret != NWAM_SUCCESS)
3142 			goto done;
3143 	}
3144 
3145 	if (list_ncu) {
3146 		list_msg = B_TRUE;
3147 		if (ncp_h == NULL) {
3148 			nerr("NCP has not been read");
3149 			return;
3150 		}
3151 		if (list_props) {
3152 			nwam_ncu_class_t	ncu_class;
3153 			nwam_ncu_type_t		ncu_type;
3154 
3155 			/* determine the NCU type first */
3156 			if (ncu_h == NULL) {
3157 				ncu_class = (nwam_ncu_class_t)
3158 				    cmd->cmd_ncu_class_type;
3159 				ncu_type = nwam_ncu_class_to_type(ncu_class);
3160 			} else {
3161 				if ((ret = nwam_ncu_get_ncu_type(ncu_h,
3162 				    &ncu_type)) != NWAM_SUCCESS)
3163 					goto done;
3164 			}
3165 			ret = listprop(NWAM_OBJECT_TYPE_NCU, ncu_h,
3166 			    cmd->cmd_argv[0], all_props, ncp_h, ncu_type);
3167 			if (ret != NWAM_SUCCESS)
3168 				goto done;
3169 		}
3170 	}
3171 
3172 	if (list_loc) {
3173 		list_msg = B_TRUE;
3174 		if (list_props) {
3175 			ret = listprop(NWAM_OBJECT_TYPE_LOC, loc_h,
3176 			    cmd->cmd_argv[0], all_props, NULL, -1);
3177 		} else {
3178 			ret = nwam_walk_locs(list_loc_callback, &list_msg,
3179 			    NWAM_FLAG_ACTIVATION_MODE_ALL, NULL);
3180 		}
3181 		if (ret != NWAM_SUCCESS)
3182 			goto done;
3183 	}
3184 
3185 	if (list_enm) {
3186 		list_msg = B_TRUE;
3187 		if (list_props) {
3188 			ret = listprop(NWAM_OBJECT_TYPE_ENM, enm_h,
3189 			    cmd->cmd_argv[0], all_props, NULL, -1);
3190 		} else {
3191 			ret = nwam_walk_enms(list_enm_callback, &list_msg,
3192 			    NWAM_FLAG_ACTIVATION_MODE_ALL, NULL);
3193 		}
3194 		if (ret != NWAM_SUCCESS)
3195 			goto done;
3196 	}
3197 
3198 	if (list_wlan) {
3199 		list_msg = B_TRUE;
3200 		if (list_props) {
3201 			ret = listprop(NWAM_OBJECT_TYPE_KNOWN_WLAN, wlan_h,
3202 			    cmd->cmd_argv[0], all_props, NULL, -1);
3203 		} else {
3204 			ret = nwam_walk_known_wlans(list_wlan_callback,
3205 			    &list_msg, NWAM_FLAG_KNOWN_WLAN_WALK_PRIORITY_ORDER,
3206 			    NULL);
3207 		}
3208 		if (ret != NWAM_SUCCESS)
3209 			goto done;
3210 	}
3211 
3212 done:
3213 	if (ret != NWAM_SUCCESS)
3214 		nwamerr(ret, "List error");
3215 }
3216 
3217 static int
3218 write_export_command(nwam_object_type_t object_type, const char *prop,
3219     nwam_value_t values, FILE *of)
3220 {
3221 	/* exclude read-only properties */
3222 	if (is_prop_read_only(object_type, prop))
3223 		return (0);
3224 
3225 	(void) fprintf(of, "set ");
3226 	output_propname(prop, values, of);
3227 	return (0);
3228 }
3229 
3230 static int
3231 export_ncu_callback(nwam_ncu_handle_t ncu, void *arg)
3232 {
3233 	char		*name;
3234 	const char	**props;
3235 	nwam_ncu_type_t type;
3236 	nwam_ncu_class_t class;
3237 	nwam_value_t	vals;
3238 	nwam_error_t	ret;
3239 	uint_t		num;
3240 	int		i;
3241 	FILE		*of = arg;
3242 
3243 	assert(of != NULL);
3244 
3245 	/* get the NCU's type and class */
3246 	if ((ret = nwam_ncu_get_ncu_type(ncu, &type)) != NWAM_SUCCESS)
3247 		return (ret);
3248 	if ((ret = nwam_ncu_get_ncu_class(ncu, &class)) != NWAM_SUCCESS)
3249 		return (ret);
3250 
3251 	if ((ret = nwam_ncu_get_name(ncu, &name)) != NWAM_SUCCESS)
3252 		return (ret);
3253 
3254 	(void) fprintf(of, "create ncu %s \"%s\"\n",
3255 	    propval_to_str(NWAM_NCU_PROP_CLASS, class), name);
3256 	free(name);
3257 	/*
3258 	 * Because of dependencies between properties, they have to be
3259 	 * exported in the same order as when they are walked.
3260 	 */
3261 	if ((ret = nwam_ncu_get_default_proplist(type, class, &props, &num))
3262 	    != NWAM_SUCCESS)
3263 		return (ret);
3264 	for (i = 0; i < num; i++) {
3265 		ret = nwam_ncu_get_prop_value(ncu, props[i], &vals);
3266 		if (ret == NWAM_SUCCESS) {
3267 			write_export_command(NWAM_OBJECT_TYPE_NCU, props[i],
3268 			    vals, of);
3269 			nwam_value_free(vals);
3270 		}
3271 	}
3272 	(void) fprintf(of, "end\n");
3273 
3274 	free(props);
3275 	return (0);
3276 }
3277 
3278 static int
3279 export_ncp_callback(nwam_ncp_handle_t ncp, void *arg)
3280 {
3281 	char		*name;
3282 	nwam_error_t	ret;
3283 	FILE		*of = arg;
3284 
3285 	assert(of != NULL);
3286 
3287 	if ((ret = nwam_ncp_get_name(ncp, &name)) != NWAM_SUCCESS)
3288 		return (ret);
3289 
3290 	/* Do not export "automatic" NCP */
3291 	if (NWAM_NCP_AUTOMATIC(name)) {
3292 		free(name);
3293 		return (0);
3294 	}
3295 
3296 	(void) fprintf(of, "create ncp \"%s\"\n", name);
3297 	free(name);
3298 
3299 	/* now walk NCUs for this ncp */
3300 	ret = nwam_ncp_walk_ncus(ncp, export_ncu_callback, of,
3301 	    NWAM_FLAG_NCU_TYPE_CLASS_ALL, NULL);
3302 	if (ret != NWAM_SUCCESS) {
3303 		nwamerr(ret, "Export ncp error: failed to walk ncus");
3304 		return (ret);
3305 	}
3306 	(void) fprintf(of, "end\n");
3307 	return (0);
3308 }
3309 
3310 static int
3311 export_enm_callback(nwam_enm_handle_t enm, void *arg)
3312 {
3313 	char		*name;
3314 	const char	**props;
3315 	nwam_value_t	vals;
3316 	nwam_error_t	ret;
3317 	uint_t		num;
3318 	int		i;
3319 	FILE		*of = arg;
3320 
3321 	assert(of != NULL);
3322 
3323 	if ((ret = nwam_enm_get_name(enm, &name)) != NWAM_SUCCESS)
3324 		return (ret);
3325 
3326 	(void) fprintf(of, "create enm \"%s\"\n", name);
3327 	free(name);
3328 	/*
3329 	 * Because of dependencies between properties, they have to be
3330 	 * exported in the same order as when they are walked.
3331 	 */
3332 	if ((ret = nwam_enm_get_default_proplist(&props, &num)) != NWAM_SUCCESS)
3333 		return (ret);
3334 	for (i = 0; i < num; i++) {
3335 		ret = nwam_enm_get_prop_value(enm, props[i], &vals);
3336 		if (ret == NWAM_SUCCESS) {
3337 			write_export_command(NWAM_OBJECT_TYPE_ENM, props[i],
3338 			    vals, of);
3339 			nwam_value_free(vals);
3340 		}
3341 	}
3342 	(void) fprintf(of, "end\n");
3343 
3344 	free(props);
3345 	return (0);
3346 }
3347 
3348 static int
3349 export_loc_callback(nwam_loc_handle_t loc, void *arg)
3350 {
3351 	char		*name;
3352 	const char	**props;
3353 	nwam_value_t	vals;
3354 	nwam_error_t	ret;
3355 	uint_t		num;
3356 	int		i;
3357 	FILE		*of = arg;
3358 
3359 	assert(of != NULL);
3360 
3361 	if ((ret = nwam_loc_get_name(loc, &name)) != NWAM_SUCCESS)
3362 		return (ret);
3363 
3364 	/* Do not export Automatic, NoNet or Legacy locations */
3365 	if (NWAM_LOC_NAME_PRE_DEFINED(name)) {
3366 		free(name);
3367 		return (0);
3368 	}
3369 
3370 	(void) fprintf(of, "create loc \"%s\"\n", name);
3371 	free(name);
3372 	/*
3373 	 * Because of dependencies between properties, they have to be
3374 	 * exported in the same order as when they are walked.
3375 	 */
3376 	if ((ret = nwam_loc_get_default_proplist(&props, &num)) != NWAM_SUCCESS)
3377 		return (ret);
3378 	for (i = 0; i < num; i++) {
3379 		ret = nwam_loc_get_prop_value(loc, props[i], &vals);
3380 		if (ret == NWAM_SUCCESS) {
3381 			write_export_command(NWAM_OBJECT_TYPE_LOC, props[i],
3382 			    vals, of);
3383 			nwam_value_free(vals);
3384 		}
3385 	}
3386 	(void) fprintf(of, "end\n");
3387 
3388 	free(props);
3389 	return (0);
3390 }
3391 
3392 static int
3393 export_wlan_callback(nwam_known_wlan_handle_t wlan, void *arg)
3394 {
3395 	char		*name;
3396 	const char	**props;
3397 	nwam_value_t	vals;
3398 	nwam_error_t	ret;
3399 	uint_t		num;
3400 	int		i;
3401 	FILE		*of = arg;
3402 
3403 	assert(of != NULL);
3404 
3405 	if ((ret = nwam_known_wlan_get_name(wlan, &name)) != NWAM_SUCCESS)
3406 		return (ret);
3407 
3408 	(void) fprintf(of, "create wlan \"%s\"\n", name);
3409 	free(name);
3410 	/*
3411 	 * Because of dependencies between properties, they have to be
3412 	 * exported in the same order as when they are walked.
3413 	 */
3414 	if ((ret = nwam_known_wlan_get_default_proplist(&props, &num))
3415 	    != NWAM_SUCCESS)
3416 		return (ret);
3417 	for (i = 0; i < num; i++) {
3418 		ret = nwam_known_wlan_get_prop_value(wlan, props[i], &vals);
3419 		if (ret == NWAM_SUCCESS) {
3420 			write_export_command(NWAM_OBJECT_TYPE_KNOWN_WLAN,
3421 			    props[i], vals, of);
3422 			nwam_value_free(vals);
3423 		}
3424 	}
3425 	(void) fprintf(of, "end\n");
3426 
3427 	free(props);
3428 	return (0);
3429 }
3430 
3431 /*
3432  * Writes configuration to screen or file (with -f option).
3433  * Writes a "destroy -a" if option -d is given.
3434  */
3435 void
3436 export_func(cmd_t *cmd)
3437 {
3438 	int		c;
3439 	boolean_t	need_to_close = B_FALSE, write_to_file = B_FALSE;
3440 	boolean_t	add_destroy = B_FALSE, lhandle = B_FALSE;
3441 	char		filepath[MAXPATHLEN];
3442 	nwam_error_t	ret = NWAM_SUCCESS;
3443 	FILE		*of = NULL; /* either filename or stdout */
3444 
3445 	/* what to export */
3446 	boolean_t export_ncp = B_FALSE, export_ncu = B_FALSE;
3447 	boolean_t export_loc = B_FALSE, export_enm = B_FALSE;
3448 	boolean_t export_wlan = B_FALSE;
3449 	char *name = NULL;
3450 
3451 	/* check for -d and -f flags */
3452 	filepath[0] = '\0';
3453 	optind = 0;
3454 	while ((c = getopt(cmd->cmd_argc, cmd->cmd_argv, "df:")) != EOF) {
3455 		switch (c) {
3456 		case 'f':
3457 			write_to_file = B_TRUE;
3458 			break;
3459 		case 'd':
3460 			add_destroy = B_TRUE;
3461 			break;
3462 		default:
3463 			command_usage(CMD_EXPORT);
3464 			return;
3465 		}
3466 	}
3467 
3468 	/* determine where to export */
3469 	if (!write_to_file) {
3470 		of = stdout;
3471 	} else {
3472 		/*
3473 		 * If -d was specified with -f, then argv[2] is filename,
3474 		 * otherwise, argv[1] is filename.
3475 		 */
3476 		(void) strlcpy(filepath,
3477 		    (add_destroy ? cmd->cmd_argv[2] : cmd->cmd_argv[1]),
3478 		    sizeof (filepath));
3479 		if ((of = fopen(filepath, "w")) == NULL) {
3480 			nerr(gettext("opening file '%s': %s"), filepath,
3481 			    strerror(errno));
3482 			goto done;
3483 		}
3484 		setbuf(of, NULL);
3485 		need_to_close = B_TRUE;
3486 	}
3487 
3488 	if (add_destroy) {
3489 		/* only possible in global scope */
3490 		if (current_scope == NWAM_SCOPE_GBL) {
3491 			(void) fprintf(of, "destroy -a\n");
3492 		} else {
3493 			nerr("Option -d is not allowed in non-global scope");
3494 			goto done;
3495 		}
3496 	}
3497 
3498 	/* In the following scopes, only the -f argument is valid */
3499 	if (((current_scope == NWAM_SCOPE_LOC ||
3500 	    current_scope == NWAM_SCOPE_ENM ||
3501 	    current_scope == NWAM_SCOPE_WLAN ||
3502 	    current_scope == NWAM_SCOPE_NCU) &&
3503 	    cmd->cmd_argc != 0 && !write_to_file)) {
3504 		nerr("'export' does not take arguments at this scope");
3505 		goto done;
3506 	}
3507 	if (current_scope == NWAM_SCOPE_NCP) {
3508 		if (cmd->cmd_res1_type == RT1_ENM ||
3509 		    cmd->cmd_res1_type == RT1_LOC ||
3510 		    cmd->cmd_res1_type == RT1_WLAN) {
3511 			nerr("only ncu can be exported at this scope");
3512 			goto done;
3513 		}
3514 	}
3515 
3516 	/*
3517 	 * Determine what objects to export depending on scope and command
3518 	 * arguments.  If -f is specified, then the object name is argv[2].
3519 	 * Otherwise, argv[0] is name, unless exporting all in global
3520 	 * scope in which case name is set back to NULL.
3521 	 */
3522 	switch (current_scope) {
3523 	case NWAM_SCOPE_GBL:
3524 		name = (write_to_file ? trim_quotes(cmd->cmd_argv[2]) :
3525 		    trim_quotes(cmd->cmd_argv[0]));
3526 		switch (cmd->cmd_res1_type) {
3527 		case RT1_LOC:
3528 			export_loc = B_TRUE;
3529 			break;
3530 		case RT1_ENM:
3531 			export_enm = B_TRUE;
3532 			break;
3533 		case RT1_WLAN:
3534 			export_wlan = B_TRUE;
3535 			break;
3536 		case RT1_NCP:
3537 			export_ncp = B_TRUE;
3538 			if (cmd->cmd_res2_type == RT2_NCU) {
3539 				nerr("cannot export ncu at from global scope");
3540 				goto done;
3541 			}
3542 			break;
3543 		default:
3544 			/* export everything */
3545 			export_loc = B_TRUE;
3546 			export_enm = B_TRUE;
3547 			export_wlan = B_TRUE;
3548 			export_ncp = B_TRUE; /* NCP will export the NCUs */
3549 			free(name);
3550 			name = NULL; /* exporting all, undo name */
3551 			break;
3552 		}
3553 		break;
3554 	case NWAM_SCOPE_LOC:
3555 		export_loc = B_TRUE;
3556 		ret = nwam_loc_get_name(loc_h, &name);
3557 		if (ret != NWAM_SUCCESS)
3558 			goto fail;
3559 		break;
3560 	case NWAM_SCOPE_ENM:
3561 		export_enm = B_TRUE;
3562 		ret = nwam_enm_get_name(enm_h, &name);
3563 		if (ret != NWAM_SUCCESS)
3564 			goto fail;
3565 		break;
3566 	case NWAM_SCOPE_WLAN:
3567 		export_wlan = B_TRUE;
3568 		ret = nwam_known_wlan_get_name(wlan_h, &name);
3569 		if (ret != NWAM_SUCCESS)
3570 			goto fail;
3571 		break;
3572 	case NWAM_SCOPE_NCP:
3573 		if (cmd->cmd_res2_type == RT2_NCU) {
3574 			export_ncu = B_TRUE;
3575 			name = (write_to_file ? trim_quotes(cmd->cmd_argv[2]) :
3576 			    trim_quotes(cmd->cmd_argv[0]));
3577 		} else {
3578 			export_ncp = B_TRUE;
3579 			ret = nwam_ncp_get_name(ncp_h, &name);
3580 			if (ret != NWAM_SUCCESS)
3581 				goto fail;
3582 		}
3583 		break;
3584 	case NWAM_SCOPE_NCU:
3585 		export_ncu = B_TRUE;
3586 		ret = nwam_ncu_get_name(ncu_h, &name);
3587 		if (ret != NWAM_SUCCESS)
3588 			goto fail;
3589 		break;
3590 	default:
3591 		nerr("Invalid scope");
3592 		goto done;
3593 	}
3594 
3595 	/* Now, export objects according to the flags set */
3596 	if (export_ncp) {
3597 		lhandle = B_FALSE;
3598 		if (name == NULL) {
3599 			/* export all NCPs */
3600 			ret = nwam_walk_ncps(export_ncp_callback, of, 0, NULL);
3601 		} else if (NWAM_NCP_AUTOMATIC(name)) {
3602 			nerr("'%s' ncp cannot be exported", name);
3603 			goto fail;
3604 		} else {
3605 			if (ncp_h == NULL) {
3606 				ret = nwam_ncp_read(name, 0, &ncp_h);
3607 				if (ret != NWAM_SUCCESS)
3608 					goto fail;
3609 				lhandle = B_TRUE;
3610 			}
3611 			/* will export NCUs also */
3612 			ret = export_ncp_callback(ncp_h, of);
3613 			if (lhandle) {
3614 				nwam_ncp_free(ncp_h);
3615 				ncp_h = NULL;
3616 			}
3617 		}
3618 		if (ret != NWAM_SUCCESS)
3619 			goto fail;
3620 	}
3621 
3622 	if (export_ncu) {
3623 		if (name == NULL) {
3624 			/* export all NCUs */
3625 			ret = nwam_ncp_walk_ncus(ncp_h, export_ncu_callback, of,
3626 			    NWAM_FLAG_NCU_TYPE_CLASS_ALL, NULL);
3627 		} else {
3628 			if (ncu_h == NULL) {
3629 				/* no NCU handle -> called from NCP scope */
3630 				nwam_ncu_type_t		ncu_type;
3631 				nwam_ncu_class_t	ncu_class;
3632 
3633 				ncu_class = (nwam_ncu_class_t)
3634 				    cmd->cmd_ncu_class_type;
3635 				ncu_type = nwam_ncu_class_to_type(ncu_class);
3636 				ret = nwam_ncu_read(ncp_h, name,
3637 				    ncu_type, 0, &ncu_h);
3638 				if (ret == NWAM_SUCCESS) {
3639 					/* one NCU with given name */
3640 					ret = export_ncu_callback(ncu_h, of);
3641 					nwam_ncu_free(ncu_h);
3642 					ncu_h = NULL;
3643 				} else if (ret == NWAM_ENTITY_MULTIPLE_VALUES) {
3644 					/* multiple NCUs with given name */
3645 					ret = nwam_ncu_read(ncp_h, name,
3646 					    NWAM_NCU_TYPE_LINK, 0, &ncu_h);
3647 					if (ret != NWAM_SUCCESS)
3648 						goto fail;
3649 					ret = export_ncu_callback(ncu_h, of);
3650 					nwam_ncu_free(ncu_h);
3651 					ncu_h = NULL;
3652 
3653 					ret = nwam_ncu_read(ncp_h, name,
3654 					    NWAM_NCU_TYPE_INTERFACE, 0, &ncu_h);
3655 					if (ret != NWAM_SUCCESS)
3656 						goto fail;
3657 					ret = export_ncu_callback(ncu_h, of);
3658 					nwam_ncu_free(ncu_h);
3659 					ncu_h = NULL;
3660 				} else {
3661 					goto fail;
3662 				}
3663 			} else {
3664 				/* NCU handle exists */
3665 				ret = export_ncu_callback(ncu_h, of);
3666 			}
3667 		}
3668 		if (ret != NWAM_SUCCESS)
3669 			goto fail;
3670 	}
3671 
3672 	if (export_loc) {
3673 		lhandle = B_FALSE;
3674 		if (name == NULL) {
3675 			/* export all locations */
3676 			ret = nwam_walk_locs(export_loc_callback, of,
3677 			    NWAM_FLAG_ACTIVATION_MODE_ALL, NULL);
3678 		} else if (NWAM_LOC_NAME_PRE_DEFINED(name)) {
3679 			nerr("'%s' loc cannot be exported", name);
3680 			goto fail;
3681 		} else {
3682 			if (loc_h == NULL) {
3683 				ret = nwam_loc_read(name, 0, &loc_h);
3684 				if (ret != NWAM_SUCCESS)
3685 					goto fail;
3686 				lhandle = B_TRUE;
3687 			}
3688 			ret = export_loc_callback(loc_h, of);
3689 			if (lhandle) {
3690 				nwam_loc_free(loc_h);
3691 				loc_h = NULL;
3692 			}
3693 		}
3694 		if (ret != NWAM_SUCCESS)
3695 			goto fail;
3696 	}
3697 
3698 	if (export_enm) {
3699 		lhandle = B_FALSE;
3700 		if (name == NULL) {
3701 			/* export all ENMs */
3702 			ret = nwam_walk_enms(export_enm_callback, of,
3703 			    NWAM_FLAG_ACTIVATION_MODE_ALL, NULL);
3704 		} else {
3705 			if (enm_h == NULL) {
3706 				ret = nwam_enm_read(name, 0, &enm_h);
3707 				if (ret != NWAM_SUCCESS)
3708 					goto fail;
3709 				lhandle = B_TRUE;
3710 			}
3711 			ret = export_enm_callback(enm_h, of);
3712 			if (lhandle) {
3713 				nwam_enm_free(enm_h);
3714 				enm_h = NULL;
3715 			}
3716 		}
3717 		if (ret != NWAM_SUCCESS)
3718 			goto fail;
3719 	}
3720 
3721 	if (export_wlan) {
3722 		lhandle = B_FALSE;
3723 		if (name == NULL) {
3724 			/* export all WLANs */
3725 			ret = nwam_walk_known_wlans(export_wlan_callback, of,
3726 			    NWAM_FLAG_KNOWN_WLAN_WALK_PRIORITY_ORDER, NULL);
3727 		} else {
3728 			if (wlan_h == NULL) {
3729 				ret = nwam_known_wlan_read(name, 0,
3730 				    &wlan_h);
3731 				if (ret != NWAM_SUCCESS)
3732 					goto fail;
3733 				lhandle = B_TRUE;
3734 			}
3735 			ret = export_wlan_callback(wlan_h, of);
3736 			if (lhandle) {
3737 				nwam_known_wlan_free(wlan_h);
3738 				wlan_h = NULL;
3739 			}
3740 		}
3741 		if (ret != NWAM_SUCCESS)
3742 			goto fail;
3743 	}
3744 
3745 fail:
3746 	free(name);
3747 	if (ret != NWAM_SUCCESS)
3748 		nwamerr(ret, "Export error");
3749 
3750 done:
3751 	if (need_to_close)
3752 		(void) fclose(of);
3753 }
3754 
3755 /*
3756  * Get property value.  If the -V option is specified, only the value is
3757  * printed without the property name.
3758  */
3759 void
3760 get_func(cmd_t *cmd)
3761 {
3762 	nwam_error_t		ret = NWAM_SUCCESS;
3763 	nwam_value_t		prop_value;
3764 	const char		*prop;
3765 	boolean_t		value_only = B_FALSE;
3766 	nwam_object_type_t	object_type = active_object_type();
3767 
3768 	/* check if option is -V to print value only */
3769 	if (cmd->cmd_argc == 1) {
3770 		int c;
3771 
3772 		optind = 0;
3773 		while ((c = getopt(cmd->cmd_argc, cmd->cmd_argv, "V")) != EOF) {
3774 			switch (c) {
3775 			case 'V':
3776 				value_only = B_TRUE;
3777 				break;
3778 			default:
3779 				command_usage(CMD_GET);
3780 				return;
3781 			}
3782 		}
3783 	}
3784 
3785 	/* property to get is in cmd->cmd_prop_type */
3786 	if ((prop = pt_to_prop_name(object_type, cmd->cmd_prop_type)) == NULL) {
3787 		nerr("Get error: invalid %s property: '%s'",
3788 		    scope_to_str(current_scope), pt_to_str(cmd->cmd_prop_type));
3789 		return;
3790 	}
3791 
3792 	switch (object_type) {
3793 	case NWAM_OBJECT_TYPE_NCU:
3794 		ret = nwam_ncu_get_prop_value(ncu_h, prop, &prop_value);
3795 		break;
3796 	case NWAM_OBJECT_TYPE_LOC:
3797 		ret = nwam_loc_get_prop_value(loc_h, prop, &prop_value);
3798 		break;
3799 	case NWAM_OBJECT_TYPE_ENM:
3800 		ret = nwam_enm_get_prop_value(enm_h, prop, &prop_value);
3801 		break;
3802 	case NWAM_OBJECT_TYPE_KNOWN_WLAN:
3803 		ret = nwam_known_wlan_get_prop_value(wlan_h, prop, &prop_value);
3804 		break;
3805 	}
3806 
3807 	if (ret != NWAM_SUCCESS) {
3808 		if (ret == NWAM_ENTITY_NOT_FOUND)
3809 			nerr("Get error: property '%s' has not been set", prop);
3810 		else
3811 			nwamerr(ret, "Get error");
3812 		return;
3813 	}
3814 
3815 	if (value_only) {
3816 		output_prop_val(prop, prop_value, stdout, B_FALSE);
3817 		(void) printf("\n");
3818 	} else {
3819 		output_propname(prop, prop_value, NULL);
3820 	}
3821 	nwam_value_free(prop_value);
3822 }
3823 
3824 /*
3825  * Clears value of a property.
3826  * Read-only properties cannot be cleared.
3827  * If clearing a property invalidates the object, then that property
3828  * cannot be cleared.
3829  */
3830 void
3831 clear_func(cmd_t *cmd)
3832 {
3833 	nwam_error_t		ret;
3834 	const char		*prop;
3835 	nwam_object_type_t	object_type = active_object_type();
3836 
3837 	/* property to clear is in cmd->cmd_prop_type */
3838 	if ((prop = pt_to_prop_name(object_type, cmd->cmd_prop_type)) == NULL) {
3839 		nerr("Clear error: invalid %s property: '%s'",
3840 		    scope_to_str(current_scope), pt_to_str(cmd->cmd_prop_type));
3841 		return;
3842 	}
3843 	if (is_prop_read_only(object_type, prop)) {
3844 		nerr("Clear error: property '%s' is read-only", prop);
3845 		return;
3846 	}
3847 
3848 	switch (object_type) {
3849 	case NWAM_OBJECT_TYPE_NCU:
3850 		ret = nwam_ncu_delete_prop(ncu_h, prop);
3851 		break;
3852 	case NWAM_OBJECT_TYPE_LOC:
3853 		ret = nwam_loc_delete_prop(loc_h, prop);
3854 		break;
3855 	case NWAM_OBJECT_TYPE_ENM:
3856 		ret = nwam_enm_delete_prop(enm_h, prop);
3857 		break;
3858 	case NWAM_OBJECT_TYPE_KNOWN_WLAN:
3859 		ret = nwam_known_wlan_delete_prop(wlan_h, prop);
3860 		break;
3861 	}
3862 
3863 	if (ret != NWAM_SUCCESS) {
3864 		if (ret == NWAM_INVALID_ARG || ret == NWAM_ENTITY_NOT_FOUND) {
3865 			nerr("Clear error: property '%s' has not been set",
3866 			    prop);
3867 		} else {
3868 			nwamerr(ret, "Clear error");
3869 		}
3870 		return;
3871 	}
3872 
3873 	need_to_commit = B_TRUE;
3874 }
3875 
3876 /*
3877  * Prints all the choices available for an enum property [c1|c2|c3].
3878  * Prints [true|false] for a boolean property.
3879  */
3880 static void
3881 print_all_prop_choices(nwam_object_type_t object_type, const char *prop)
3882 {
3883 	uint64_t		i = 0;
3884 	const char		*str;
3885 	boolean_t		choices = B_FALSE;
3886 	nwam_value_type_t	value_type;
3887 	nwam_error_t		ret;
3888 
3889 	/* Special case: print object-specific options for activation-mode */
3890 	if (strcmp(prop, NWAM_NCU_PROP_ACTIVATION_MODE) == 0) {
3891 		/* "manual" for all objects */
3892 		(void) printf(" [%s|",
3893 		    propval_to_str(NWAM_NCU_PROP_ACTIVATION_MODE,
3894 		    NWAM_ACTIVATION_MODE_MANUAL));
3895 		if (object_type == NWAM_OBJECT_TYPE_NCU) {
3896 			(void) printf("%s]",
3897 			    propval_to_str(NWAM_NCU_PROP_ACTIVATION_MODE,
3898 			    NWAM_ACTIVATION_MODE_PRIORITIZED));
3899 		} else {
3900 			(void) printf("%s|%s]",
3901 			    propval_to_str(NWAM_NCU_PROP_ACTIVATION_MODE,
3902 			    NWAM_ACTIVATION_MODE_CONDITIONAL_ANY),
3903 			    propval_to_str(NWAM_NCU_PROP_ACTIVATION_MODE,
3904 			    NWAM_ACTIVATION_MODE_CONDITIONAL_ALL));
3905 		}
3906 		return;
3907 	}
3908 
3909 	/* Special case: only "manual" configsrc is allowed for LDAP */
3910 	if (strcmp(prop, NWAM_LOC_PROP_LDAP_NAMESERVICE_CONFIGSRC) == 0) {
3911 		(void) printf(" [%s]",
3912 		    propval_to_str(NWAM_LOC_PROP_LDAP_NAMESERVICE_CONFIGSRC,
3913 		    NWAM_CONFIGSRC_MANUAL));
3914 		return;
3915 	}
3916 
3917 	value_type = prop_value_type(object_type, prop);
3918 	switch (value_type) {
3919 	case NWAM_VALUE_TYPE_UINT64:
3920 		/* uint64 may be an enum, will print nothing if not an enum */
3921 		while ((ret = nwam_uint64_get_value_string(prop, i++, &str))
3922 		    == NWAM_SUCCESS || ret == NWAM_ENTITY_INVALID_VALUE) {
3923 			/* No string representation for i, continue. */
3924 			if (ret == NWAM_ENTITY_INVALID_VALUE)
3925 				continue;
3926 
3927 			if (!choices)
3928 				(void) printf("%s", " [");
3929 			(void) printf("%s%s", choices ? "|" : "", str);
3930 			choices = B_TRUE;
3931 		}
3932 		if (choices)
3933 			(void) putchar(']');
3934 		break;
3935 	case NWAM_VALUE_TYPE_BOOLEAN:
3936 		(void) printf(" [%s|%s]", "true", "false");
3937 		break;
3938 	case NWAM_VALUE_TYPE_STRING:
3939 		break;
3940 	}
3941 }
3942 
3943 /*
3944  * Walk through object properties.
3945  * For newly-created object, the property name with no value is displayed, and
3946  * the user can input a value for each property.
3947  * For existing object, the current value is displayed and user input overwrites
3948  * the existing one. If no input is given, the existing value remains.
3949  * Read-only properties are not displayed.
3950  * Read-only objects cannot be walked.
3951  * If the -a option is specified, no properties are skipped.
3952  */
3953 void
3954 walkprop_func(cmd_t *cmd)
3955 {
3956 	nwam_error_t	ret = NWAM_SUCCESS;
3957 	nwam_value_t	vals = NULL; /* freed in _wait_input() */
3958 	int		i;
3959 	uint_t		prop_num;
3960 	const char	**props;
3961 	boolean_t	read_only = B_FALSE, all_props = B_FALSE;
3962 
3963 	nwam_object_type_t object_type;
3964 	prop_display_entry_t *prop_table;
3965 
3966 	if (!interactive_mode) {
3967 		nerr("'walkprop' is only allowed in interactive mode");
3968 		return;
3969 	}
3970 
3971 	/* check if option -a is specified to show all properties */
3972 	if (cmd->cmd_argc == 1) {
3973 		int c;
3974 		optind = 0;
3975 		while ((c = getopt(cmd->cmd_argc, cmd->cmd_argv, "a")) != EOF) {
3976 			switch (c) {
3977 			case 'a':
3978 				all_props = B_TRUE;
3979 				break;
3980 			default:
3981 				command_usage(CMD_WALKPROP);
3982 				return;
3983 			}
3984 		}
3985 	}
3986 
3987 	/* read-only objects cannot be walked */
3988 	if (obj1_type == RT1_NCP) {
3989 		/* must be in NCU scope, NCP scope doesn't get here */
3990 		(void) nwam_ncu_get_read_only(ncu_h, &read_only);
3991 	}
3992 	if (read_only) {
3993 		nerr("'walkprop' cannot be used in read-only objects");
3994 		return;
3995 	}
3996 
3997 	/* get the current object type and the prop_display_table */
3998 	object_type = active_object_type();
3999 	prop_table = get_prop_display_table(object_type);
4000 
4001 	/* get the property list depending on the object type */
4002 	switch (object_type) {
4003 	case NWAM_OBJECT_TYPE_NCU:
4004 	{
4005 		nwam_ncu_type_t		ncu_type;
4006 		nwam_ncu_class_t	ncu_class;
4007 
4008 		if ((ret = nwam_ncu_get_ncu_type(ncu_h, &ncu_type))
4009 		    != NWAM_SUCCESS)
4010 			break;
4011 		if ((ret = nwam_ncu_get_ncu_class(ncu_h, &ncu_class))
4012 		    != NWAM_SUCCESS)
4013 			break;
4014 
4015 		ret = nwam_ncu_get_default_proplist(ncu_type, ncu_class, &props,
4016 		    &prop_num);
4017 		break;
4018 	}
4019 	case NWAM_OBJECT_TYPE_LOC:
4020 		ret = nwam_loc_get_default_proplist(&props, &prop_num);
4021 		break;
4022 	case NWAM_OBJECT_TYPE_ENM:
4023 		ret = nwam_enm_get_default_proplist(&props, &prop_num);
4024 		break;
4025 	case NWAM_OBJECT_TYPE_KNOWN_WLAN:
4026 		ret = nwam_known_wlan_get_default_proplist(&props, &prop_num);
4027 		break;
4028 	}
4029 	if (ret != NWAM_SUCCESS) {
4030 		nwamerr(ret, "Walkprop error: could not get property list");
4031 		return;
4032 	}
4033 
4034 	/* Loop through the properties */
4035 	if (all_props)
4036 		(void) printf(gettext("Walking all properties ...\n"));
4037 	for (i = 0; i < prop_num; i++) {
4038 		char line[NWAM_MAX_VALUE_LEN];
4039 		char **checked = NULL;
4040 
4041 		/* check if this property should be displayed */
4042 		if (is_prop_read_only(object_type, props[i]))
4043 			continue;
4044 		if (!all_props &&
4045 		    !show_prop_test(object_type, props[i], prop_table,
4046 		    checked, 0))
4047 			continue;
4048 
4049 		/* get the existing value for this property */
4050 		switch (object_type) {
4051 		case NWAM_OBJECT_TYPE_NCU:
4052 			ret = nwam_ncu_get_prop_value(ncu_h, props[i], &vals);
4053 			break;
4054 		case NWAM_OBJECT_TYPE_LOC:
4055 			ret = nwam_loc_get_prop_value(loc_h, props[i], &vals);
4056 			break;
4057 		case NWAM_OBJECT_TYPE_ENM:
4058 			ret = nwam_enm_get_prop_value(enm_h, props[i], &vals);
4059 			break;
4060 		case NWAM_OBJECT_TYPE_KNOWN_WLAN:
4061 			ret = nwam_known_wlan_get_prop_value(wlan_h, props[i],
4062 			    &vals);
4063 			break;
4064 		}
4065 		/* returns NWAM_ENTITY_NOT_FOUND if no existing value */
4066 		if (ret != NWAM_SUCCESS && ret != NWAM_ENTITY_NOT_FOUND)
4067 			continue;
4068 
4069 		/* print property */
4070 		(void) printf("%s", props[i]);
4071 		/* print the existing value(s) if they exist */
4072 		if (ret == NWAM_SUCCESS) {
4073 			(void) printf(" (");
4074 			output_prop_val(props[i], vals, stdout, B_TRUE);
4075 			(void) putchar(')');
4076 			nwam_value_free(vals);
4077 		}
4078 		/* print choices, won't print anything if there aren't any */
4079 		print_all_prop_choices(object_type, props[i]);
4080 		(void) printf("> ");
4081 
4082 		/* wait for user input */
4083 		if (fgets(line, sizeof (line), stdin) == NULL)
4084 			continue;
4085 
4086 		/* if user input new value, existing value is overrode */
4087 		if (line[0] != '\n') {
4088 			boolean_t is_listprop;
4089 			int pt_type = prop_to_pt(object_type, props[i]);
4090 
4091 			is_listprop = is_prop_multivalued(object_type,
4092 			    props[i]);
4093 			vals = str_to_nwam_value(object_type, line, pt_type,
4094 			    is_listprop);
4095 			if (vals == NULL) {
4096 				ret = NWAM_ENTITY_INVALID_VALUE;
4097 				goto repeat;
4098 			}
4099 
4100 			/* set the new value for the property */
4101 			switch (object_type) {
4102 			case NWAM_OBJECT_TYPE_NCU:
4103 				ret = nwam_ncu_set_prop_value(ncu_h, props[i],
4104 				    vals);
4105 				break;
4106 			case NWAM_OBJECT_TYPE_LOC:
4107 				ret = nwam_loc_set_prop_value(loc_h, props[i],
4108 				    vals);
4109 				break;
4110 			case NWAM_OBJECT_TYPE_ENM:
4111 				ret = nwam_enm_set_prop_value(enm_h, props[i],
4112 				    vals);
4113 				break;
4114 			case NWAM_OBJECT_TYPE_KNOWN_WLAN:
4115 				ret = nwam_known_wlan_set_prop_value(wlan_h,
4116 				    props[i], vals);
4117 				break;
4118 			}
4119 			nwam_value_free(vals);
4120 
4121 			if (ret != NWAM_SUCCESS)
4122 				goto repeat;
4123 
4124 			need_to_commit = B_TRUE;
4125 			continue;
4126 
4127 repeat:
4128 			invalid_set_prop_msg(props[i], ret);
4129 			i--; /* decrement i to repeat */
4130 		}
4131 	}
4132 
4133 	free(props);
4134 }
4135 
4136 /*
4137  * Verify whether all properties of a resource are valid.
4138  */
4139 /* ARGSUSED */
4140 void
4141 verify_func(cmd_t *cmd)
4142 {
4143 	nwam_error_t	ret;
4144 	const char	*errprop;
4145 
4146 	switch (active_object_type()) {
4147 	case NWAM_OBJECT_TYPE_NCU:
4148 		ret = nwam_ncu_validate(ncu_h, &errprop);
4149 		break;
4150 	case NWAM_OBJECT_TYPE_LOC:
4151 		ret = nwam_loc_validate(loc_h, &errprop);
4152 		break;
4153 	case NWAM_OBJECT_TYPE_ENM:
4154 		ret = nwam_enm_validate(enm_h, &errprop);
4155 		break;
4156 	case NWAM_OBJECT_TYPE_KNOWN_WLAN:
4157 		ret = nwam_known_wlan_validate(wlan_h, &errprop);
4158 		break;
4159 	}
4160 	if (ret != NWAM_SUCCESS)
4161 		nwamerr(ret, "Verify error on property '%s'", errprop);
4162 	else if (interactive_mode)
4163 		(void) printf(gettext("All properties verified\n"));
4164 }
4165 
4166 /*
4167  * command-line mode (# nwamcfg list or # nwamcfg "select loc test; list")
4168  */
4169 static int
4170 one_command_at_a_time(int argc, char *argv[])
4171 {
4172 	char *command;
4173 	size_t len = 2; /* terminal \n\0 */
4174 	int i, err;
4175 
4176 	for (i = 0; i < argc; i++)
4177 		len += strlen(argv[i]) + 1;
4178 	if ((command = malloc(len)) == NULL) {
4179 		nerr("Out of memory");
4180 		return (NWAM_ERR);
4181 	}
4182 	(void) strlcpy(command, argv[0], len);
4183 	for (i = 1; i < argc; i++) {
4184 		(void) strlcat(command, " ", len);
4185 		(void) strlcat(command, argv[i], len);
4186 	}
4187 	(void) strlcat(command, "\n", len);
4188 	err = string_to_yyin(command);
4189 	free(command);
4190 	if (err != NWAM_OK)
4191 		return (err);
4192 	while (!feof(yyin)) {
4193 		yyparse();
4194 
4195 		/*
4196 		 * If any command on a list of commands give an error,
4197 		 * don't continue with the remaining commands.
4198 		 */
4199 		if (saw_error || time_to_exit)
4200 			return (cleanup());
4201 	}
4202 
4203 	/* if there are changes to commit, commit it */
4204 	if (need_to_commit) {
4205 		do_commit();
4206 		/* if need_to_commit is not set, then there was a error */
4207 		if (need_to_commit)
4208 			return (NWAM_ERR);
4209 	}
4210 
4211 	if (!interactive_mode)
4212 		return (cleanup());
4213 	else {
4214 		yyin = stdin;
4215 		return (read_input());
4216 	}
4217 }
4218 
4219 /*
4220  * cmd_file is slightly more complicated, as it has to open the command file
4221  * and set yyin appropriately.  Once that is done, though, it just calls
4222  * read_input(), and only once, since prompting is not possible.
4223  */
4224 static int
4225 cmd_file(char *file)
4226 {
4227 	FILE *infile;
4228 	int err;
4229 	struct stat statbuf;
4230 	boolean_t using_real_file = (strcmp(file, "-") != 0);
4231 
4232 	if (using_real_file) {
4233 		/*
4234 		 * nerr() prints a line number in cmd_file_mode, which we do
4235 		 * not want here, so temporarily unset it.
4236 		 */
4237 		cmd_file_mode = B_FALSE;
4238 		if ((infile = fopen(file, "r")) == NULL) {
4239 			nerr(gettext("could not open file '%s': %s"),
4240 			    file, strerror(errno));
4241 			return (1);
4242 		}
4243 		if ((err = fstat(fileno(infile), &statbuf)) != 0) {
4244 			nerr(gettext("could not stat file '%s': %s"),
4245 			    file, strerror(errno));
4246 			err = 1;
4247 			goto done;
4248 		}
4249 		if (!S_ISREG(statbuf.st_mode)) {
4250 			nerr(gettext("'%s' is not a regular file."), file);
4251 			err = 1;
4252 			goto done;
4253 		}
4254 
4255 		/*
4256 		 * If -d was passed on the command-line, we need to
4257 		 * start by removing any existing configuration.
4258 		 * Alternatively, the file may begin with 'destroy -a';
4259 		 * but in that case, the line will go through the lexer
4260 		 * and be processed as it's encountered in the file.
4261 		 */
4262 		if (remove_all_configurations && destroy_all() != NWAM_SUCCESS)
4263 			goto done;
4264 
4265 		/* set up for lexer */
4266 		yyin = infile;
4267 		cmd_file_mode = B_TRUE;
4268 		ok_to_prompt = B_FALSE;
4269 	} else {
4270 		/*
4271 		 * "-f -" is essentially the same as interactive mode,
4272 		 * so treat it that way.
4273 		 */
4274 		interactive_mode = B_TRUE;
4275 	}
4276 	/* NWAM_REPEAT is for interactive mode; treat it like NWAM_ERR here. */
4277 	if ((err = read_input()) == NWAM_REPEAT)
4278 		err = NWAM_ERR;
4279 	if (err == NWAM_OK)
4280 		(void) printf(gettext("Configuration read.\n"));
4281 
4282 done:
4283 	if (using_real_file)
4284 		(void) fclose(infile);
4285 	return (err);
4286 }
4287 
4288 int
4289 main(int argc, char *argv[])
4290 {
4291 	int	err;
4292 	char	c;
4293 
4294 	/* This must be before anything goes to stdout. */
4295 	setbuf(stdout, NULL);
4296 
4297 	if ((execname = strrchr(argv[0], '/')) == NULL)
4298 		execname = argv[0];
4299 	else
4300 		execname++;
4301 
4302 	(void) setlocale(LC_ALL, "");
4303 	(void) textdomain(TEXT_DOMAIN);
4304 
4305 	while ((c = getopt(argc, argv, "?hf:d")) != EOF) {
4306 		switch (c) {
4307 		case 'f':
4308 			cmd_file_name = optarg;
4309 			cmd_file_mode = B_TRUE;
4310 			break;
4311 		case '?':
4312 		case 'h':
4313 			cmd_line_usage();
4314 			return (NWAM_OK);
4315 		case 'd':
4316 			remove_all_configurations = B_TRUE;
4317 			break;
4318 		default:
4319 			cmd_line_usage();
4320 			return (NWAM_ERR);
4321 		}
4322 	}
4323 	/* -d can only be used with -f */
4324 	if (remove_all_configurations && !cmd_file_mode) {
4325 		nerr("Option -d can only be used with -f");
4326 		return (NWAM_ERR);
4327 	}
4328 
4329 	/*
4330 	 * This may get set back to FALSE again in cmd_file() if cmd_file_name
4331 	 * is a "real" file as opposed to "-" (i.e. meaning use stdin).
4332 	 */
4333 	if (isatty(STDIN_FILENO))
4334 		ok_to_prompt = B_TRUE;
4335 	if ((gl = new_GetLine(MAX_LINE_LEN, MAX_CMD_HIST)) == NULL)
4336 		exit(NWAM_ERR);
4337 	if (gl_customize_completion(gl, NULL, cmd_cpl_fn) != 0)
4338 		exit(NWAM_ERR);
4339 	(void) sigset(SIGINT, SIG_IGN);
4340 
4341 	if (optind == argc) {
4342 		/* interactive or command-file mode */
4343 		if (!cmd_file_mode)
4344 			err = do_interactive();
4345 		else
4346 			err = cmd_file(cmd_file_name);
4347 	} else {
4348 		/* command-line mode */
4349 		err = one_command_at_a_time(argc - optind, &(argv[optind]));
4350 	}
4351 	(void) del_GetLine(gl);
4352 
4353 	return (err);
4354 }
4355