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