1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2010 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #include <assert.h>
28 #include <ctype.h>
29 #include <libgen.h>
30 #include <netdb.h>
31 #include <sys/param.h>
32 #include <sys/types.h>
33 #include <sys/stat.h>
34 #include <sys/socket.h>
35 #include <netinet/in.h>
36 #include <arpa/inet.h>
37 #include <stdio.h>
38 #include <stdlib.h>
39 #include <strings.h>
40 #include <unistd.h>
41 #include <libdladm.h>
42
43 #include "libnwam_impl.h"
44 #include <libnwam_priv.h>
45 #include <libnwam.h>
46
47 /*
48 * Functions to support creating, modifying, destroying, querying the
49 * state of and changing the state of NCP (Network Configuration Profiles)
50 * and the NCUs (Network Configuration Units) that are contained in those
51 * NCP objects. An NCP is simply a container for a set of NCUs which represent
52 * the datalink and interface configuration preferences for the system.
53 * An NCP can consist a set of prioritized link NCUs, e.g. wired links preferred
54 * over wireless, a set of manually enabled/diasbled NCUs, or a combination
55 * of both. Interface NCUs inherit activation from their underlying links,
56 * so if wired is preferred over wireless and a cable is plugged in,
57 * the wired link NCU will be active, as will the IP interface NCU above it.
58 */
59
60 /*
61 * The NCU property table is used to mapping property types to property name
62 * strings, their associated value types etc. The table is used for validation
63 * purposes, and for commit()ing and read()ing NCUs.
64 */
65
66 static nwam_error_t valid_type(nwam_value_t);
67 static nwam_error_t valid_class(nwam_value_t);
68 static nwam_error_t valid_ncp(nwam_value_t);
69 static nwam_error_t valid_priority_mode(nwam_value_t);
70 static nwam_error_t valid_ncu_activation_mode(nwam_value_t);
71 static nwam_error_t valid_link_autopush(nwam_value_t);
72 static nwam_error_t valid_link_mtu(nwam_value_t);
73 static nwam_error_t valid_ip_version(nwam_value_t);
74 static nwam_error_t valid_addrsrc_v4(nwam_value_t);
75 static nwam_error_t valid_addrsrc_v6(nwam_value_t);
76
77 struct nwam_prop_table_entry ncu_prop_table_entries[] = {
78 {NWAM_NCU_PROP_TYPE, NWAM_VALUE_TYPE_UINT64, B_FALSE, 1, 1, valid_type,
79 "specifies the NCU type - valid values are \'datalink\' and \'ip\'",
80 NWAM_FLAG_NCU_TYPE_ALL, NWAM_FLAG_NCU_CLASS_ALL},
81 {NWAM_NCU_PROP_CLASS, NWAM_VALUE_TYPE_UINT64, B_FALSE, 1, 1,
82 valid_class,
83 "specifies the NCU class - valid values are "
84 "\'phys\' and \'ip\'",
85 NWAM_FLAG_NCU_TYPE_ALL, NWAM_FLAG_NCU_CLASS_ALL},
86 {NWAM_NCU_PROP_PARENT_NCP, NWAM_VALUE_TYPE_STRING, B_FALSE, 1, 1,
87 valid_ncp,
88 "specifies the parent NCP name",
89 NWAM_FLAG_NCU_TYPE_ALL, NWAM_FLAG_NCU_CLASS_ALL},
90 {NWAM_NCU_PROP_ACTIVATION_MODE, NWAM_VALUE_TYPE_UINT64, B_FALSE, 1, 1,
91 valid_ncu_activation_mode,
92 "specifies the NCU activation mode - valid values are:\n"
93 "\'prioritized\' and \'manual\'",
94 NWAM_FLAG_NCU_TYPE_LINK, NWAM_FLAG_NCU_CLASS_ALL_LINK},
95 {NWAM_NCU_PROP_ENABLED, NWAM_VALUE_TYPE_BOOLEAN, B_TRUE, 0, 1,
96 nwam_valid_boolean,
97 "specifies if manual NCU is to be enabled",
98 NWAM_FLAG_NCU_TYPE_ALL, NWAM_FLAG_NCU_CLASS_ALL},
99 {NWAM_NCU_PROP_PRIORITY_GROUP, NWAM_VALUE_TYPE_UINT64, B_FALSE, 0, 1,
100 nwam_valid_uint64,
101 "specifies the priority grouping of NCUs - lower values are "
102 "prioritized, negative values are invalid",
103 NWAM_FLAG_NCU_TYPE_LINK, NWAM_FLAG_NCU_CLASS_ALL_LINK},
104 {NWAM_NCU_PROP_PRIORITY_MODE, NWAM_VALUE_TYPE_UINT64, B_FALSE, 0, 1,
105 valid_priority_mode,
106 "specifies the mode of prioritization - valid values are:\n"
107 "\'exclusive\', \'shared\' and \'all\'",
108 NWAM_FLAG_NCU_TYPE_LINK, NWAM_FLAG_NCU_CLASS_ALL_LINK},
109 {NWAM_NCU_PROP_LINK_MAC_ADDR, NWAM_VALUE_TYPE_STRING, B_FALSE, 0, 1,
110 nwam_valid_mac_addr,
111 "specifies MAC address of form aa:bb:cc:dd:ee:ff for the link",
112 NWAM_FLAG_NCU_TYPE_LINK, NWAM_FLAG_NCU_CLASS_ALL_LINK},
113 {NWAM_NCU_PROP_LINK_AUTOPUSH, NWAM_VALUE_TYPE_STRING, B_FALSE, 0,
114 NWAM_MAX_NUM_VALUES, valid_link_autopush,
115 "specifies modules to autopush on link",
116 NWAM_FLAG_NCU_TYPE_LINK, NWAM_FLAG_NCU_CLASS_ALL_LINK},
117 {NWAM_NCU_PROP_LINK_MTU, NWAM_VALUE_TYPE_UINT64, B_FALSE, 0, 1,
118 valid_link_mtu,
119 "specifies MTU for link",
120 NWAM_FLAG_NCU_TYPE_LINK, NWAM_FLAG_NCU_CLASS_ALL_LINK},
121 {NWAM_NCU_PROP_IP_VERSION, NWAM_VALUE_TYPE_UINT64, B_FALSE, 0,
122 NWAM_MAX_NUM_VALUES, valid_ip_version,
123 "specifies IP versions for IP NCU - valid values are:\n"
124 "\'ipv4\' and \'ipv6\'",
125 NWAM_FLAG_NCU_TYPE_INTERFACE, NWAM_FLAG_NCU_CLASS_ALL_INTERFACE},
126 {NWAM_NCU_PROP_IPV4_ADDRSRC, NWAM_VALUE_TYPE_UINT64, B_FALSE, 0,
127 NWAM_MAX_NUM_VALUES, valid_addrsrc_v4,
128 "specifies IPv4 address source(s) - valid values are:\n"
129 "\'dhcp\' and \'static\'",
130 NWAM_FLAG_NCU_TYPE_INTERFACE, NWAM_FLAG_NCU_CLASS_ALL_INTERFACE},
131 {NWAM_NCU_PROP_IPV4_ADDR, NWAM_VALUE_TYPE_STRING, B_FALSE, 0,
132 NWAM_MAX_NUM_VALUES, nwam_valid_host_v4,
133 "specifies static IPv4 host address(es)",
134 NWAM_FLAG_NCU_TYPE_INTERFACE, NWAM_FLAG_NCU_CLASS_ALL_INTERFACE},
135 {NWAM_NCU_PROP_IPV4_DEFAULT_ROUTE, NWAM_VALUE_TYPE_STRING, B_FALSE, 0,
136 1, nwam_valid_route_v4,
137 "specifies per-interface default IPv4 route",
138 NWAM_FLAG_NCU_TYPE_INTERFACE, NWAM_FLAG_NCU_CLASS_ALL_INTERFACE},
139 {NWAM_NCU_PROP_IPV6_ADDRSRC, NWAM_VALUE_TYPE_UINT64, B_FALSE, 0,
140 NWAM_MAX_NUM_VALUES, valid_addrsrc_v6,
141 "specifies IPv6 address source(s) - valid values are:\n"
142 "\'dhcp\', \'autoconf\' and \'static\'.\n"
143 "\'dhcp\' and \'autoconf\' are mandatory values.",
144 NWAM_FLAG_NCU_TYPE_INTERFACE, NWAM_FLAG_NCU_CLASS_ALL_INTERFACE},
145 {NWAM_NCU_PROP_IPV6_ADDR, NWAM_VALUE_TYPE_STRING, B_FALSE, 0,
146 NWAM_MAX_NUM_VALUES, nwam_valid_host_v6,
147 "specifies static IPv6 host address(es)",
148 NWAM_FLAG_NCU_TYPE_INTERFACE, NWAM_FLAG_NCU_CLASS_ALL_INTERFACE},
149 {NWAM_NCU_PROP_IPV6_DEFAULT_ROUTE, NWAM_VALUE_TYPE_STRING, B_FALSE, 0,
150 1, nwam_valid_route_v6,
151 "specifies per-interface default IPv6 route",
152 NWAM_FLAG_NCU_TYPE_INTERFACE, NWAM_FLAG_NCU_CLASS_ALL_INTERFACE}
153 };
154
155 #define NWAM_NUM_NCU_PROPS (sizeof (ncu_prop_table_entries) / \
156 sizeof (*ncu_prop_table_entries))
157
158 struct nwam_prop_table ncu_prop_table =
159 { NWAM_NUM_NCU_PROPS, ncu_prop_table_entries };
160
161 nwam_error_t
162 nwam_ncp_get_name(nwam_ncp_handle_t ncph, char **namep)
163 {
164 return (nwam_get_name(ncph, namep));
165 }
166
167 static nwam_error_t
168 nwam_ncp_name_to_file(const char *name, char **filename)
169 {
170 assert(name != NULL && filename != NULL);
171
172 if ((*filename = malloc(MAXPATHLEN)) == NULL)
173 return (NWAM_NO_MEMORY);
174
175 (void) snprintf(*filename, MAXPATHLEN, "%s%s%s%s", NWAM_CONF_DIR,
176 NWAM_NCP_CONF_FILE_PRE, name, NWAM_NCP_CONF_FILE_SUF);
177
178 return (NWAM_SUCCESS);
179 }
180
181 /* ARGSUSED1 */
182 nwam_error_t
183 nwam_ncp_create(const char *name, uint64_t flags, nwam_ncp_handle_t *ncphp)
184 {
185 nwam_error_t err;
186 char *ncpfile;
187
188 if ((err = nwam_handle_create(NWAM_OBJECT_TYPE_NCP, name, ncphp))
189 != NWAM_SUCCESS)
190 return (err);
191
192 /* Create empty container for NCUs */
193 if ((err = nwam_ncp_name_to_file(name, &ncpfile))
194 != NWAM_SUCCESS) {
195 nwam_free(*ncphp);
196 *ncphp = NULL;
197 return (err);
198 }
199
200 if ((err = nwam_commit(ncpfile, *ncphp, flags)) != NWAM_SUCCESS) {
201 nwam_free(*ncphp);
202 *ncphp = NULL;
203 }
204
205 free(ncpfile);
206
207 return (err);
208 }
209
210 /* Used by libnwam_files.c */
211 nwam_error_t
212 nwam_ncp_file_to_name(const char *path, char **name)
213 {
214 char path_copy[MAXPATHLEN];
215 char *filename, *suffix;
216
217 assert(path != NULL && name != NULL);
218
219 /* Make a copy as basename(3c) may modify string */
220 (void) strlcpy(path_copy, path, MAXPATHLEN);
221
222 if ((*name = malloc(NWAM_MAX_NAME_LEN)) == NULL)
223 return (NWAM_NO_MEMORY);
224
225 if ((filename = basename(path_copy)) == NULL) {
226 free(*name);
227 return (NWAM_ENTITY_INVALID);
228 }
229
230 /* Ensure filename begins/ends with right prefix/suffix */
231 if (sscanf(filename, NWAM_NCP_CONF_FILE_PRE "%256[^\n]s", *name) < 1) {
232 free(*name);
233 return (NWAM_ENTITY_INVALID);
234 }
235 suffix = *name + strlen(*name) - strlen(NWAM_NCP_CONF_FILE_SUF);
236 if (strstr(*name, NWAM_NCP_CONF_FILE_SUF) != suffix) {
237 free(*name);
238 return (NWAM_ENTITY_INVALID);
239 }
240 suffix[0] = '\0';
241
242 return (NWAM_SUCCESS);
243 }
244
245 /* ARGSUSED1 */
246 nwam_error_t
247 nwam_ncp_read(const char *name, uint64_t flags, nwam_ncp_handle_t *ncphp)
248 {
249 char *filename;
250 nwam_error_t err;
251
252 assert(name != NULL && ncphp != NULL);
253
254 /* try to read the associated ncp configuration */
255 if ((err = nwam_ncp_name_to_file(name, &filename)) != NWAM_SUCCESS) {
256 *ncphp = NULL;
257 return (err);
258 }
259
260 err = nwam_read(NWAM_OBJECT_TYPE_NCP, filename, name, flags, ncphp);
261 free(filename);
262 return (err);
263 }
264
265 static nwam_error_t
266 nwam_ncu_get_parent_ncp_name(nwam_ncu_handle_t ncuh, char **parentnamep)
267 {
268 nwam_value_t parentval = NULL;
269 char *parentname;
270 nwam_error_t err;
271
272 if ((err = nwam_ncu_get_prop_value(ncuh, NWAM_NCU_PROP_PARENT_NCP,
273 &parentval)) != NWAM_SUCCESS ||
274 (err = nwam_value_get_string(parentval, &parentname))
275 != NWAM_SUCCESS ||
276 (*parentnamep = strdup(parentname)) == NULL) {
277 if (parentval != NULL)
278 nwam_value_free(parentval);
279 *parentnamep = NULL;
280 return (err);
281 }
282 nwam_value_free(parentval);
283
284 return (NWAM_SUCCESS);
285 }
286
287 static int
288 nwam_ncp_copy_callback(nwam_ncu_handle_t oldncuh, void *arg)
289 {
290 nwam_error_t err;
291 nwam_ncu_handle_t newncuh = NULL;
292 char *oldparent;
293 char *oldfilename = NULL, *newfilename = NULL;
294 nwam_ncp_handle_t newncph = (nwam_ncp_handle_t)arg;
295 nwam_value_t newparentval;
296
297 /* Get filenames for the new and old NCU's */
298 if ((err = nwam_ncu_get_parent_ncp_name(oldncuh, &oldparent))
299 != NWAM_SUCCESS)
300 return (err);
301 err = nwam_ncp_name_to_file(oldparent, &oldfilename);
302 free(oldparent);
303 if (err != NWAM_SUCCESS)
304 return (err);
305 if ((err = nwam_ncp_name_to_file(newncph->nwh_name, &newfilename))
306 != NWAM_SUCCESS)
307 goto fail;
308
309 /* new NCU name (and typedname) is the same as the old name */
310 if ((err = nwam_handle_create(NWAM_OBJECT_TYPE_NCU, oldncuh->nwh_name,
311 &newncuh)) != NWAM_SUCCESS)
312 goto fail;
313 /* Duplicate the old NCU's data */
314 if ((err = nwam_dup_object_list(oldncuh->nwh_data,
315 &(newncuh->nwh_data))) != NWAM_SUCCESS)
316 goto fail;
317
318 /* Update the parent property for the new NCU */
319 if ((err = nwam_value_create_string(newncph->nwh_name, &newparentval))
320 != NWAM_SUCCESS)
321 goto fail;
322 err = nwam_set_prop_value(newncuh->nwh_data, NWAM_NCU_PROP_PARENT_NCP,
323 newparentval);
324 nwam_value_free(newparentval);
325 if (err != NWAM_SUCCESS)
326 goto fail;
327
328 /* Save the new NCU */
329 err = nwam_commit(newfilename, newncuh, 0);
330
331 fail:
332 free(oldfilename);
333 free(newfilename);
334 nwam_ncu_free(newncuh);
335 return (err);
336 }
337
338 nwam_error_t
339 nwam_ncp_copy(nwam_ncp_handle_t oldncph, const char *newname,
340 nwam_ncp_handle_t *newncphp)
341 {
342 nwam_ncp_handle_t ncph;
343 nwam_error_t err;
344 int cb_ret;
345
346 assert(oldncph != NULL && newname != NULL && newncphp != NULL);
347
348 /* check if newname NCP already exists */
349 if (nwam_ncp_read(newname, 0, &ncph) == NWAM_SUCCESS) {
350 nwam_ncp_free(ncph);
351 *newncphp = NULL;
352 return (NWAM_ENTITY_EXISTS);
353 }
354
355 /* create new handle */
356 if ((err = nwam_ncp_create(newname, 0, newncphp)) != NWAM_SUCCESS)
357 return (err);
358
359 err = nwam_ncp_walk_ncus(oldncph, nwam_ncp_copy_callback, *newncphp,
360 NWAM_FLAG_NCU_TYPE_CLASS_ALL, &cb_ret);
361 if (err != NWAM_SUCCESS) {
362 /* remove the NCP even if any NCU's had already been copied */
363 (void) nwam_ncp_destroy(*newncphp, 0);
364 *newncphp = NULL;
365 if (err == NWAM_WALK_HALTED)
366 return (cb_ret);
367 else
368 return (err);
369 }
370
371 return (NWAM_SUCCESS);
372 }
373
374 /*
375 * Convert type to flag
376 */
377 static uint64_t
378 nwam_ncu_type_to_flag(nwam_ncu_type_t type)
379 {
380 switch (type) {
381 case NWAM_NCU_TYPE_LINK:
382 return (NWAM_FLAG_NCU_TYPE_LINK);
383 case NWAM_NCU_TYPE_INTERFACE:
384 return (NWAM_FLAG_NCU_TYPE_INTERFACE);
385 case NWAM_NCU_TYPE_ANY:
386 return (NWAM_FLAG_NCU_TYPE_ALL);
387 default:
388 return (0);
389 }
390 }
391
392 /*
393 * Convert class to flag
394 */
395 uint64_t
396 nwam_ncu_class_to_flag(nwam_ncu_class_t class)
397 {
398 switch (class) {
399 case NWAM_NCU_CLASS_PHYS:
400 return (NWAM_FLAG_NCU_CLASS_PHYS);
401 case NWAM_NCU_CLASS_IP:
402 return (NWAM_FLAG_NCU_CLASS_IP);
403 case NWAM_NCU_CLASS_ANY:
404 return (NWAM_FLAG_NCU_CLASS_ALL);
405 default:
406 return (0);
407 }
408 }
409
410 /*
411 * Infer NCU type from NCU class
412 */
413 nwam_ncu_type_t
414 nwam_ncu_class_to_type(nwam_ncu_class_t class)
415 {
416 switch (class) {
417 case NWAM_NCU_CLASS_PHYS:
418 return (NWAM_NCU_TYPE_LINK);
419 case NWAM_NCU_CLASS_IP:
420 return (NWAM_NCU_TYPE_INTERFACE);
421 case NWAM_NCU_CLASS_ANY:
422 return (NWAM_NCU_TYPE_ANY);
423 default:
424 return (NWAM_NCU_TYPE_UNKNOWN);
425 }
426 }
427
428 /*
429 * Make ncp active, deactivating any other active ncp.
430 */
431 nwam_error_t
432 nwam_ncp_enable(nwam_ncp_handle_t ncph)
433 {
434 nwam_error_t err;
435 char *name;
436
437 assert(ncph != NULL);
438
439 err = nwam_enable(NULL, ncph);
440
441 if (err == NWAM_ERROR_BIND) {
442 /*
443 * nwamd is not running, set active_ncp property so when
444 * nwamd is next started, this NCP will be used.
445 */
446 if ((err = nwam_ncp_get_name(ncph, &name)) != NWAM_SUCCESS)
447 return (err);
448
449 err = nwam_set_smf_string_property(NWAM_FMRI, NWAM_PG,
450 NWAM_PROP_ACTIVE_NCP, name);
451 free(name);
452 }
453
454 return (err);
455 }
456
457 /* Compare NCP names c1 and c2 using strcasecmp() */
458 static int
459 ncpname_cmp(const void *c1, const void *c2)
460 {
461 return (strcasecmp(*(const char **)c1, *(const char **)c2));
462 }
463
464 /* ARGSUSED1 */
465 nwam_error_t
466 nwam_walk_ncps(int (*cb)(nwam_ncp_handle_t, void *), void *data,
467 uint64_t flags, int *retp)
468 {
469 char *ncpname, **ncpfiles;
470 nwam_ncp_handle_t ncph;
471 nwam_error_t err;
472 nwam_value_t value;
473 void *objlist;
474 uint_t i, num_ncpfiles;
475 int ret = 0;
476
477 assert(cb != NULL);
478
479 if ((err = nwam_valid_flags(flags, NWAM_FLAG_BLOCKING)) != NWAM_SUCCESS)
480 return (err);
481 /*
482 * To get list of NCP files, call nwam_read_object_from_backend()
483 * with "parent" argument set to NULL. We get back an object list
484 * consisting of string arrays for each object type - NCP, ENM
485 * and location. We retrieve the NCP list, which corresponds to
486 * the set of NCP backend parent objects (these are files at present).
487 */
488 if ((err = nwam_read_object_from_backend(NULL, NULL, flags,
489 &objlist)) != NWAM_SUCCESS)
490 return (err);
491
492 if ((err = nwam_get_prop_value(objlist, NWAM_NCP_OBJECT_STRING, &value))
493 != NWAM_SUCCESS) {
494 nwam_free_object_list(objlist);
495 return (err);
496 }
497 if ((err = nwam_value_get_string_array(value, &ncpfiles,
498 &num_ncpfiles)) != NWAM_SUCCESS) {
499 nwam_value_free(value);
500 nwam_free_object_list(objlist);
501 return (err);
502 }
503
504 /* sort the NCP names alphabetically */
505 qsort(ncpfiles, num_ncpfiles, sizeof (char *), ncpname_cmp);
506
507 for (i = 0; i < num_ncpfiles; i++) {
508 if (nwam_ncp_file_to_name(ncpfiles[i], &ncpname)
509 != NWAM_SUCCESS)
510 continue;
511 if ((err = nwam_handle_create(NWAM_OBJECT_TYPE_NCP, ncpname,
512 &ncph)) != NWAM_SUCCESS) {
513 free(ncpname);
514 break;
515 }
516 ret = cb(ncph, data);
517 free(ncph);
518 free(ncpname);
519 if (ret != 0) {
520 err = NWAM_WALK_HALTED;
521 break;
522 }
523 }
524 nwam_value_free(value);
525 nwam_free_object_list(objlist);
526
527 if (retp != NULL)
528 *retp = ret;
529 return (err);
530 }
531
532 /*
533 * Checks if NCP is read-only. Only NWAM_NCP_NAME_AUTOMATIC is read-only
534 * for all but the netadm user (which nwamd runs as).
535 */
536 nwam_error_t
537 nwam_ncp_get_read_only(nwam_ncp_handle_t ncph, boolean_t *readp)
538 {
539 nwam_error_t err;
540 char *name;
541
542 assert(ncph != NULL && readp != NULL);
543
544 if ((err = nwam_ncp_get_name(ncph, &name)) != NWAM_SUCCESS)
545 return (err);
546
547 if (NWAM_NCP_AUTOMATIC(name))
548 *readp = !nwam_uid_is_special();
549 else
550 *readp = B_FALSE;
551
552 free(name);
553 return (NWAM_SUCCESS);
554 }
555
556 /* Checks if NCU is writable depending on its parent */
557 nwam_error_t
558 nwam_ncu_get_read_only(nwam_ncu_handle_t ncuh, boolean_t *readp)
559 {
560 nwam_error_t err;
561 nwam_ncp_handle_t ncph;
562
563 assert(ncuh != NULL && readp != NULL);
564
565 if ((err = nwam_ncu_get_ncp(ncuh, &ncph)) != NWAM_SUCCESS)
566 return (err);
567
568 err = nwam_ncp_get_read_only(ncph, readp);
569 nwam_ncp_free(ncph);
570 return (err);
571 }
572
573 /* Returns true if the NCP is active */
574 static boolean_t
575 nwam_ncp_is_active(nwam_ncp_handle_t ncph)
576 {
577 char *active_ncp, *name;
578 boolean_t ret;
579
580 assert(ncph != NULL);
581
582 /*
583 * Determine which NCP is active via the nwamd/active_ncp property
584 * value. This allows us to determine which NCP is active even
585 * if nwamd is not running.
586 */
587 if (nwam_ncp_get_name(ncph, &name) != NWAM_SUCCESS ||
588 nwam_get_smf_string_property(NWAM_FMRI, NWAM_PG,
589 NWAM_PROP_ACTIVE_NCP, &active_ncp) != NWAM_SUCCESS)
590 return (B_FALSE);
591
592 ret = (strcmp(name, active_ncp) == 0);
593
594 free(active_ncp);
595 free(name);
596
597 return (ret);
598 }
599
600 nwam_error_t
601 nwam_ncp_destroy(nwam_ncp_handle_t ncph, uint64_t flags)
602 {
603 char *filename;
604 nwam_error_t err;
605 boolean_t read_only;
606
607 assert(ncph != NULL);
608
609 if ((err = nwam_ncp_get_read_only(ncph, &read_only)) != NWAM_SUCCESS)
610 return (err);
611 if (read_only)
612 return (NWAM_ENTITY_NOT_DESTROYABLE);
613
614 if (nwam_ncp_is_active(ncph))
615 return (NWAM_ENTITY_IN_USE);
616
617 if ((err = nwam_ncp_name_to_file(ncph->nwh_name, &filename))
618 != NWAM_SUCCESS)
619 return (err);
620
621 err = nwam_destroy(filename, ncph, flags);
622 free(filename);
623
624 return (NWAM_SUCCESS);
625 }
626
627 static nwam_error_t
628 nwam_ncu_internal_name_to_name(const char *internalname,
629 nwam_ncu_type_t *typep, char **namep)
630 {
631 char *prefixstr;
632
633 assert(internalname != NULL && namep != NULL);
634
635 if (strncasecmp(internalname, NWAM_NCU_LINK_NAME_PRE,
636 strlen(NWAM_NCU_LINK_NAME_PRE)) == 0) {
637 prefixstr = NWAM_NCU_LINK_NAME_PRE;
638 *typep = NWAM_NCU_TYPE_LINK;
639 } else if (strncasecmp(internalname, NWAM_NCU_INTERFACE_NAME_PRE,
640 strlen(NWAM_NCU_INTERFACE_NAME_PRE)) == 0) {
641 prefixstr = NWAM_NCU_INTERFACE_NAME_PRE;
642 *typep = NWAM_NCU_TYPE_INTERFACE;
643 } else {
644 return (NWAM_INVALID_ARG);
645 }
646
647 *namep = strdup(internalname + strlen(prefixstr));
648 if (*namep == NULL)
649 return (NWAM_NO_MEMORY);
650 return (NWAM_SUCCESS);
651 }
652
653 /* ARGSUSED2 */
654 static int
655 ncu_selectcb(struct nwam_handle *hp, uint64_t flags, void *data)
656 {
657 nwam_ncu_handle_t ncuh = hp;
658 nwam_value_t typeval = NULL, classval = NULL;
659 uint64_t type, class, matchflags, walkfilter;
660
661 if (nwam_ncu_get_prop_value(ncuh, NWAM_NCU_PROP_TYPE, &typeval)
662 != NWAM_SUCCESS ||
663 nwam_ncu_get_prop_value(ncuh, NWAM_NCU_PROP_CLASS, &classval)
664 != NWAM_SUCCESS) {
665 if (typeval != NULL)
666 nwam_value_free(typeval);
667 return (NWAM_INVALID_ARG);
668 }
669 if (nwam_value_get_uint64(typeval, &type) != NWAM_SUCCESS ||
670 nwam_value_get_uint64(classval, &class) != NWAM_SUCCESS) {
671 nwam_value_free(typeval);
672 nwam_value_free(classval);
673 return (NWAM_INVALID_ARG);
674 }
675
676 matchflags = nwam_ncu_type_to_flag(type) |
677 nwam_ncu_class_to_flag(class);
678 nwam_value_free(typeval);
679 nwam_value_free(classval);
680
681 if ((walkfilter = (flags & NWAM_WALK_FILTER_MASK)) == 0)
682 walkfilter = NWAM_FLAG_NCU_TYPE_CLASS_ALL;
683
684 if (matchflags & walkfilter)
685 return (NWAM_SUCCESS);
686 return (NWAM_INVALID_ARG);
687 }
688
689 nwam_error_t
690 nwam_ncp_walk_ncus(nwam_ncp_handle_t ncph,
691 int(*cb)(nwam_ncu_handle_t, void *), void *data, uint64_t flags, int *retp)
692 {
693 char *ncpfile;
694 nwam_error_t err;
695
696 assert(ncph != NULL && cb != NULL);
697
698 if ((err = nwam_valid_flags(flags,
699 NWAM_FLAG_NCU_TYPE_CLASS_ALL | NWAM_FLAG_BLOCKING)) != NWAM_SUCCESS)
700 return (err);
701
702 if ((err = nwam_ncp_name_to_file(ncph->nwh_name, &ncpfile))
703 != NWAM_SUCCESS)
704 return (err);
705
706 err = nwam_walk(NWAM_OBJECT_TYPE_NCU, ncpfile, cb, data, flags,
707 retp, ncu_selectcb);
708 free(ncpfile);
709
710 return (err);
711 }
712
713 void
714 nwam_ncp_free(nwam_ncp_handle_t ncph)
715 {
716 nwam_free(ncph);
717 }
718
719 /*
720 * Are ncu type and class compatible?
721 */
722 static boolean_t
723 nwam_ncu_type_class_compatible(nwam_ncu_type_t type, nwam_ncu_class_t class)
724 {
725 switch (type) {
726 case NWAM_NCU_TYPE_LINK:
727 return (class == NWAM_NCU_CLASS_PHYS);
728 case NWAM_NCU_TYPE_INTERFACE:
729 return (class == NWAM_NCU_CLASS_IP);
730 default:
731 return (B_FALSE);
732 }
733 }
734
735 /* Name to validate may be internal name. If so, convert it before validating */
736 static boolean_t
737 valid_ncu_name(const char *name)
738 {
739 char *n;
740 boolean_t ret;
741 nwam_ncu_type_t type;
742
743 if (nwam_ncu_internal_name_to_name(name, &type, &n) == NWAM_SUCCESS) {
744
745 ret = dladm_valid_linkname(n);
746 free(n);
747 } else {
748 ret = dladm_valid_linkname(name);
749 }
750
751 return (ret);
752 }
753
754 nwam_error_t
755 nwam_ncu_create(nwam_ncp_handle_t ncph, const char *name,
756 nwam_ncu_type_t type, nwam_ncu_class_t class, nwam_ncu_handle_t *ncuhp)
757 {
758 nwam_ncu_handle_t ncuh;
759 nwam_value_t typeval = NULL, classval = NULL, parentval = NULL;
760 nwam_value_t enabledval = NULL;
761 nwam_error_t err;
762 boolean_t read_only;
763 char *typedname;
764
765 assert(ncph != NULL && name != NULL && ncuhp != NULL);
766
767 if (!valid_ncu_name(name))
768 return (NWAM_INVALID_ARG);
769
770 if ((err = nwam_ncp_get_read_only(ncph, &read_only)) != NWAM_SUCCESS)
771 return (err);
772 if (read_only)
773 return (NWAM_ENTITY_READ_ONLY);
774
775 if (nwam_ncu_read(ncph, name, type, 0, &ncuh) == NWAM_SUCCESS) {
776 nwam_ncu_free(ncuh);
777 return (NWAM_ENTITY_EXISTS);
778 }
779
780 if (!valid_ncu_name(name) ||
781 !nwam_ncu_type_class_compatible(type, class))
782 return (NWAM_INVALID_ARG);
783
784 if ((err = nwam_ncu_name_to_typed_name(name, type, &typedname))
785 != NWAM_SUCCESS)
786 return (err);
787
788 /* Create handle */
789 if ((err = nwam_handle_create(NWAM_OBJECT_TYPE_NCU, typedname, ncuhp))
790 != NWAM_SUCCESS)
791 return (err);
792 free(typedname);
793
794 /*
795 * Create new object list for NCU. The new NCU is initialized with
796 * the appropriate type and class.
797 */
798 if ((err = nwam_alloc_object_list(&(*ncuhp)->nwh_data)) != NWAM_SUCCESS)
799 goto finish;
800
801 if ((err = nwam_value_create_uint64(type, &typeval))
802 != NWAM_SUCCESS ||
803 (err = nwam_value_create_uint64(class, &classval))
804 != NWAM_SUCCESS ||
805 (err = nwam_value_create_string(ncph->nwh_name, &parentval))
806 != NWAM_SUCCESS ||
807 (err = nwam_value_create_boolean(B_TRUE, &enabledval))
808 != NWAM_SUCCESS) {
809 goto finish;
810 }
811 if ((err = nwam_set_prop_value((*ncuhp)->nwh_data, NWAM_NCU_PROP_TYPE,
812 typeval)) != NWAM_SUCCESS ||
813 (err = nwam_set_prop_value((*ncuhp)->nwh_data, NWAM_NCU_PROP_CLASS,
814 classval)) != NWAM_SUCCESS ||
815 (err = nwam_set_prop_value((*ncuhp)->nwh_data,
816 NWAM_NCU_PROP_PARENT_NCP, parentval)) != NWAM_SUCCESS ||
817 (err = nwam_set_prop_value((*ncuhp)->nwh_data,
818 NWAM_NCU_PROP_ENABLED, enabledval)) != NWAM_SUCCESS) {
819 goto finish;
820 }
821
822 /* Set default IP, datalink properties */
823 if (type == NWAM_NCU_TYPE_INTERFACE && class == NWAM_NCU_CLASS_IP) {
824
825 uint64_t ver[] = { IPV4_VERSION, IPV6_VERSION };
826 uint64_t v6src[] = { NWAM_ADDRSRC_DHCP, NWAM_ADDRSRC_AUTOCONF };
827 uint_t vercnt = 2, v6srccnt = 2;
828 nwam_value_t ipver = NULL, v4addrsrc = NULL, v6addrsrc = NULL;
829
830 if ((err = nwam_value_create_uint64_array(ver, vercnt, &ipver))
831 != NWAM_SUCCESS ||
832 (err = nwam_value_create_uint64(NWAM_ADDRSRC_DHCP,
833 &v4addrsrc)) != NWAM_SUCCESS ||
834 (err = nwam_value_create_uint64_array(v6src, v6srccnt,
835 &v6addrsrc)) != NWAM_SUCCESS) {
836 nwam_value_free(ipver);
837 nwam_value_free(v4addrsrc);
838 goto finish;
839 }
840 if ((err = nwam_set_prop_value((*ncuhp)->nwh_data,
841 NWAM_NCU_PROP_IP_VERSION, ipver)) == NWAM_SUCCESS &&
842 (err = nwam_set_prop_value((*ncuhp)->nwh_data,
843 NWAM_NCU_PROP_IPV4_ADDRSRC, v4addrsrc)) == NWAM_SUCCESS) {
844 err = nwam_set_prop_value((*ncuhp)->nwh_data,
845 NWAM_NCU_PROP_IPV6_ADDRSRC, v6addrsrc);
846 }
847 nwam_value_free(ipver);
848 nwam_value_free(v4addrsrc);
849 nwam_value_free(v6addrsrc);
850 } else {
851 nwam_value_t actval = NULL;
852 if ((err = nwam_value_create_uint64(NWAM_ACTIVATION_MODE_MANUAL,
853 &actval)) != NWAM_SUCCESS)
854 goto finish;
855 err = nwam_set_prop_value((*ncuhp)->nwh_data,
856 NWAM_NCU_PROP_ACTIVATION_MODE, actval);
857 nwam_value_free(actval);
858 }
859
860 finish:
861 nwam_value_free(typeval);
862 nwam_value_free(classval);
863 nwam_value_free(parentval);
864 nwam_value_free(enabledval);
865 if (err != NWAM_SUCCESS) {
866 nwam_ncu_free(*ncuhp);
867 *ncuhp = NULL;
868 }
869 return (err);
870 }
871
872 nwam_error_t
873 nwam_ncu_read(nwam_ncp_handle_t ncph, const char *name,
874 nwam_ncu_type_t type, uint64_t flags, nwam_ncu_handle_t *ncuhp)
875 {
876 char *ncpfile, *typedname;
877 nwam_error_t err, err_ip, err_link;
878 nwam_ncu_handle_t ncuh_ip, ncuh_link;
879
880 assert(ncph != NULL && name != NULL && ncuhp != NULL);
881
882 if ((err = nwam_ncp_name_to_file(ncph->nwh_name, &ncpfile))
883 != NWAM_SUCCESS)
884 return (err);
885
886 if (type == NWAM_NCU_TYPE_ANY) {
887
888 free(ncpfile);
889
890 /*
891 * If we get to this point, we have discovered that no
892 * NCU type is discernable from name or type arguments.
893 * Either exactly one NCU called name must exist of either
894 * type, or the operation should fail.
895 */
896 err_ip = nwam_ncu_read(ncph, name, NWAM_NCU_TYPE_INTERFACE,
897 flags, &ncuh_ip);
898 err_link = nwam_ncu_read(ncph, name, NWAM_NCU_TYPE_LINK,
899 flags, &ncuh_link);
900
901 *ncuhp = NULL;
902
903 if (err_ip == NWAM_SUCCESS && err_link == NWAM_SUCCESS) {
904 nwam_ncu_free(ncuh_ip);
905 nwam_ncu_free(ncuh_link);
906 err = NWAM_ENTITY_MULTIPLE_VALUES;
907 } else if (err_ip != NWAM_SUCCESS && err_link != NWAM_SUCCESS) {
908 err = NWAM_ENTITY_NOT_FOUND;
909 } else {
910 if (err_ip == NWAM_SUCCESS) {
911 *ncuhp = ncuh_ip;
912 } else {
913 *ncuhp = ncuh_link;
914 }
915 err = NWAM_SUCCESS;
916 }
917
918 return (err);
919 }
920 if ((err = nwam_ncu_name_to_typed_name(name, type, &typedname)) !=
921 NWAM_SUCCESS) {
922 free(ncpfile);
923 return (err);
924 }
925 err = nwam_read(NWAM_OBJECT_TYPE_NCU, ncpfile, typedname, flags, ncuhp);
926
927 free(typedname);
928 free(ncpfile);
929
930 return (err);
931 }
932
933 nwam_error_t
934 nwam_ncu_get_name(nwam_ncu_handle_t ncuh, char **namep)
935 {
936 nwam_ncu_type_t type;
937
938 assert(ncuh != NULL && namep != NULL);
939
940 return (nwam_ncu_internal_name_to_name(ncuh->nwh_name, &type, namep));
941 }
942
943 nwam_error_t
944 nwam_ncu_name_to_typed_name(const char *name, nwam_ncu_type_t type,
945 char **typednamep)
946 {
947 char *prefixstr;
948 size_t typednamesz;
949
950 assert(name != NULL && typednamep != NULL);
951
952 switch (type) {
953 case NWAM_NCU_TYPE_INTERFACE:
954 prefixstr = NWAM_NCU_INTERFACE_NAME_PRE;
955 break;
956 case NWAM_NCU_TYPE_LINK:
957 prefixstr = NWAM_NCU_LINK_NAME_PRE;
958 break;
959 default:
960 return (NWAM_INVALID_ARG);
961 }
962 typednamesz = strlen(name) + strlen(prefixstr) + 1;
963 if ((*typednamep = malloc(typednamesz)) == NULL)
964 return (NWAM_NO_MEMORY);
965
966 /* Name may be already qualified by type */
967 if (strncasecmp(prefixstr, name, strlen(prefixstr)) == 0) {
968 (void) snprintf(*typednamep, typednamesz, "%s", name);
969 } else {
970 (void) snprintf(*typednamep, typednamesz, "%s%s",
971 prefixstr, name);
972 }
973
974 return (NWAM_SUCCESS);
975 }
976
977 nwam_error_t
978 nwam_ncu_typed_name_to_name(const char *typed_name, nwam_ncu_type_t *typep,
979 char **name)
980 {
981 return (nwam_ncu_internal_name_to_name(typed_name, typep, name));
982 }
983
984 void
985 nwam_ncu_free(nwam_ncu_handle_t ncuh)
986 {
987 nwam_free(ncuh);
988 }
989
990 nwam_error_t
991 nwam_ncu_copy(nwam_ncu_handle_t oldncuh, const char *newname,
992 nwam_ncu_handle_t *newncuhp)
993 {
994 nwam_ncp_handle_t ncph;
995 nwam_ncu_handle_t ncuh;
996 nwam_error_t err;
997 nwam_value_t typeval;
998 uint64_t type;
999 char *typednewname;
1000
1001 assert(oldncuh != NULL && newname != NULL && newncuhp != NULL);
1002
1003 if (nwam_ncu_get_prop_value(oldncuh, NWAM_NCU_PROP_TYPE,
1004 &typeval) != NWAM_SUCCESS) {
1005 return (NWAM_INVALID_ARG);
1006 }
1007 if (nwam_value_get_uint64(typeval, &type) != NWAM_SUCCESS) {
1008 nwam_value_free(typeval);
1009 return (NWAM_INVALID_ARG);
1010 }
1011 nwam_value_free(typeval);
1012
1013 /* check if newname NCU already exists */
1014 if ((err = nwam_ncu_get_ncp(oldncuh, &ncph)) != NWAM_SUCCESS)
1015 return (err);
1016 if (nwam_ncu_read(ncph, newname, type, 0, &ncuh) == NWAM_SUCCESS) {
1017 nwam_ncu_free(ncuh);
1018 nwam_ncp_free(ncph);
1019 return (NWAM_ENTITY_EXISTS);
1020 }
1021 nwam_ncp_free(ncph);
1022
1023 if ((err = nwam_ncu_name_to_typed_name(newname, type, &typednewname))
1024 != NWAM_SUCCESS)
1025 return (err);
1026
1027 err = nwam_handle_create(NWAM_OBJECT_TYPE_NCU, typednewname, newncuhp);
1028 free(typednewname);
1029 if (err != NWAM_SUCCESS)
1030 return (err);
1031 if ((err = nwam_dup_object_list(oldncuh->nwh_data,
1032 &((*newncuhp)->nwh_data))) != NWAM_SUCCESS) {
1033 free(*newncuhp);
1034 *newncuhp = NULL;
1035 return (err);
1036 }
1037
1038 return (NWAM_SUCCESS);
1039 }
1040
1041 nwam_error_t
1042 nwam_ncu_delete_prop(nwam_ncu_handle_t ncuh, const char *propname)
1043 {
1044 boolean_t ro_ncu, ro_prop;
1045 nwam_error_t err;
1046 void *olddata;
1047
1048 assert(ncuh != NULL && propname != NULL);
1049
1050 if ((err = nwam_ncu_get_read_only(ncuh, &ro_ncu)) != NWAM_SUCCESS ||
1051 (err = nwam_ncu_prop_read_only(propname, &ro_prop)) != NWAM_SUCCESS)
1052 return (err);
1053 if (ro_ncu || ro_prop)
1054 return (NWAM_ENTITY_READ_ONLY);
1055
1056 /*
1057 * Duplicate data, remove property and validate. If validation
1058 * fails, revert to data duplicated prior to remove.
1059 */
1060 if ((err = nwam_dup_object_list(ncuh->nwh_data, &olddata))
1061 != NWAM_SUCCESS)
1062 return (err);
1063 if ((err = nwam_delete_prop(ncuh->nwh_data, propname))
1064 != NWAM_SUCCESS) {
1065 nwam_free_object_list(ncuh->nwh_data);
1066 ncuh->nwh_data = olddata;
1067 return (err);
1068 }
1069 if ((err = nwam_ncu_validate(ncuh, NULL)) != NWAM_SUCCESS) {
1070 nwam_free_object_list(ncuh->nwh_data);
1071 ncuh->nwh_data = olddata;
1072 return (err);
1073 }
1074 nwam_free_object_list(olddata);
1075
1076 return (NWAM_SUCCESS);
1077 }
1078
1079 nwam_error_t
1080 nwam_ncu_set_prop_value(nwam_ncu_handle_t ncuh, const char *propname,
1081 nwam_value_t value)
1082 {
1083 boolean_t ro_ncu, ro_prop;
1084 nwam_error_t err;
1085 nwam_ncp_handle_t ncph;
1086
1087 assert(ncuh != NULL && propname != NULL && value != NULL);
1088
1089 if ((err = nwam_ncu_get_read_only(ncuh, &ro_ncu)) != NWAM_SUCCESS ||
1090 (err = nwam_ncu_prop_read_only(propname, &ro_prop)) != NWAM_SUCCESS)
1091 return (err);
1092 if (ro_ncu || ro_prop)
1093 return (NWAM_ENTITY_READ_ONLY);
1094
1095 err = nwam_ncu_get_ncp(ncuh, &ncph);
1096 if (err != NWAM_SUCCESS && err != NWAM_INVALID_ARG) {
1097 /*
1098 * If "parent" property doesn't exist, NWAM_INVALID_ARG
1099 * is returned. Allow the setting to continue.
1100 */
1101 return (err);
1102 }
1103 nwam_ncp_free(ncph);
1104
1105 /* Need to ensure property, type and value are valid */
1106 if ((err = nwam_ncu_validate_prop(ncuh, propname, value))
1107 != NWAM_SUCCESS)
1108 return (err);
1109
1110 return (nwam_set_prop_value(ncuh->nwh_data, propname, value));
1111 }
1112
1113 nwam_error_t
1114 nwam_ncu_get_prop_value(nwam_ncu_handle_t ncuh, const char *propname,
1115 nwam_value_t *valuep)
1116 {
1117 assert(ncuh != NULL && propname != NULL && valuep != NULL);
1118
1119 return (nwam_get_prop_value(ncuh->nwh_data, propname, valuep));
1120 }
1121
1122 nwam_error_t
1123 nwam_ncu_walk_props(nwam_ncu_handle_t ncuh,
1124 int (*cb)(const char *, nwam_value_t, void *),
1125 void *data, uint64_t flags, int *retp)
1126 {
1127 return (nwam_walk_props(ncuh, cb, data, flags, retp));
1128 }
1129
1130 nwam_error_t
1131 nwam_ncu_get_ncp(nwam_ncu_handle_t ncuh, nwam_ncp_handle_t *ncphp)
1132 {
1133 nwam_error_t err;
1134 char *parentname = NULL;
1135
1136 if ((err = nwam_ncu_get_parent_ncp_name(ncuh, &parentname))
1137 != NWAM_SUCCESS ||
1138 (err = nwam_handle_create(NWAM_OBJECT_TYPE_NCP, parentname, ncphp))
1139 != NWAM_SUCCESS) {
1140 if (parentname != NULL)
1141 free(parentname);
1142 return (err);
1143 }
1144 free(parentname);
1145
1146 return (NWAM_SUCCESS);
1147 }
1148
1149 nwam_error_t
1150 nwam_ncu_commit(nwam_ncu_handle_t ncuh, uint64_t flags)
1151 {
1152 nwam_error_t err;
1153 boolean_t read_only;
1154 char *ncpfile, *ncpname;
1155
1156 assert(ncuh != NULL && ncuh->nwh_data != NULL);
1157
1158 if ((err = nwam_ncu_get_read_only(ncuh, &read_only)) != NWAM_SUCCESS)
1159 return (err);
1160 if (read_only)
1161 return (NWAM_ENTITY_READ_ONLY);
1162
1163 if ((err = nwam_ncu_validate(ncuh, NULL)) != NWAM_SUCCESS ||
1164 (err = nwam_ncu_get_parent_ncp_name(ncuh, &ncpname))
1165 != NWAM_SUCCESS)
1166 return (err);
1167
1168 if ((err = nwam_ncp_name_to_file(ncpname, &ncpfile)) != NWAM_SUCCESS) {
1169 free(ncpname);
1170 return (err);
1171 }
1172
1173 err = nwam_commit(ncpfile, ncuh, flags);
1174
1175 free(ncpname);
1176 free(ncpfile);
1177
1178 return (err);
1179 }
1180 /* Get the NCU type */
1181 nwam_error_t
1182 nwam_ncu_get_ncu_type(nwam_ncu_handle_t ncuh, nwam_ncu_type_t *typep)
1183 {
1184 nwam_error_t err;
1185 nwam_value_t typeval;
1186 uint64_t type;
1187
1188 if ((err = nwam_ncu_get_prop_value(ncuh, NWAM_NCU_PROP_TYPE, &typeval))
1189 != NWAM_SUCCESS)
1190 return (err);
1191 err = nwam_value_get_uint64(typeval, &type);
1192 nwam_value_free(typeval);
1193 if (err != NWAM_SUCCESS)
1194 return (err);
1195
1196 *typep = type;
1197 return (NWAM_SUCCESS);
1198 }
1199
1200 /* Get the NCU class */
1201 nwam_error_t
1202 nwam_ncu_get_ncu_class(nwam_ncu_handle_t ncuh, nwam_ncu_class_t *classp)
1203 {
1204 nwam_error_t err;
1205 nwam_value_t classval;
1206 uint64_t class;
1207
1208 if ((err = nwam_ncu_get_prop_value(ncuh, NWAM_NCU_PROP_CLASS,
1209 &classval)) != NWAM_SUCCESS)
1210 return (err);
1211 err = nwam_value_get_uint64(classval, &class);
1212 nwam_value_free(classval);
1213 if (err != NWAM_SUCCESS)
1214 return (err);
1215
1216 *classp = class;
1217 return (NWAM_SUCCESS);
1218 }
1219
1220 /*
1221 * Determine if the NCU has manual activation-mode or not.
1222 */
1223 nwam_error_t
1224 nwam_ncu_is_manual(nwam_ncu_handle_t ncuh, boolean_t *manualp)
1225 {
1226 nwam_error_t err;
1227 nwam_value_t actval;
1228 uint64_t activation;
1229
1230 assert(ncuh != NULL);
1231
1232 if ((err = nwam_ncu_get_prop_value(ncuh, NWAM_NCU_PROP_ACTIVATION_MODE,
1233 &actval)) != NWAM_SUCCESS)
1234 return (err);
1235 err = nwam_value_get_uint64(actval, &activation);
1236 nwam_value_free(actval);
1237 if (err != NWAM_SUCCESS)
1238 return (err);
1239
1240 if (activation == NWAM_ACTIVATION_MODE_MANUAL)
1241 *manualp = B_TRUE;
1242 else
1243 *manualp = B_FALSE;
1244 return (NWAM_SUCCESS);
1245 }
1246
1247 /* Determine if NCU is enabled or not */
1248 static nwam_error_t
1249 nwam_ncu_is_enabled(nwam_ncu_handle_t ncuh, boolean_t *enabledp)
1250 {
1251 nwam_error_t err;
1252 nwam_value_t enabledval;
1253
1254 assert(ncuh != NULL);
1255
1256 if ((err = nwam_ncu_get_prop_value(ncuh, NWAM_NCU_PROP_ENABLED,
1257 &enabledval)) != NWAM_SUCCESS)
1258 return (err);
1259 err = nwam_value_get_boolean(enabledval, enabledp);
1260 nwam_value_free(enabledval);
1261 return (err);
1262 }
1263
1264 /* Update the enabled property */
1265 static nwam_error_t
1266 nwam_ncu_update_enabled(nwam_ncu_handle_t ncuh, boolean_t enabled)
1267 {
1268 nwam_error_t err;
1269 nwam_value_t enabledval;
1270
1271 if ((err = nwam_value_create_boolean(enabled, &enabledval))
1272 != NWAM_SUCCESS)
1273 return (err);
1274 err = nwam_set_prop_value(ncuh->nwh_data, NWAM_NCU_PROP_ENABLED,
1275 enabledval);
1276 nwam_value_free(enabledval);
1277 if (err != NWAM_SUCCESS)
1278 return (err);
1279 return (nwam_ncu_commit(ncuh, NWAM_FLAG_ENTITY_ENABLE));
1280 }
1281
1282 /*
1283 * Make ncu active; fails if the NCU's parent NCP is not active.
1284 */
1285 nwam_error_t
1286 nwam_ncu_enable(nwam_ncu_handle_t ncuh)
1287 {
1288 char *ncpname = NULL;
1289 nwam_error_t err;
1290 nwam_ncu_type_t type;
1291 boolean_t read_only, enabled, manual;
1292
1293 assert(ncuh != NULL);
1294
1295 /* Don't allow NCUs of Automatic NCP to be enabled */
1296 if ((err = nwam_ncu_get_read_only(ncuh, &read_only)) != NWAM_SUCCESS)
1297 return (err);
1298 if (read_only)
1299 return (NWAM_ENTITY_NOT_MANUAL);
1300
1301 /* Link NCUs with manual activation-mode or IP NCUs can be enabled */
1302 if ((err = nwam_ncu_get_ncu_type(ncuh, &type)) != NWAM_SUCCESS)
1303 return (err);
1304
1305 if (type == NWAM_NCU_TYPE_LINK) {
1306 if ((err = nwam_ncu_is_manual(ncuh, &manual)) != NWAM_SUCCESS)
1307 return (err);
1308 if (!manual)
1309 return (NWAM_ENTITY_NOT_MANUAL);
1310 }
1311
1312 /* Make sure NCU is not enabled */
1313 if ((err = nwam_ncu_is_enabled(ncuh, &enabled)) != NWAM_SUCCESS ||
1314 (err = nwam_ncu_get_parent_ncp_name(ncuh, &ncpname))
1315 != NWAM_SUCCESS)
1316 return (err);
1317
1318 if (enabled) {
1319 free(ncpname);
1320 return (NWAM_SUCCESS);
1321 }
1322
1323 if ((err = nwam_ncu_update_enabled(ncuh, B_TRUE)) != NWAM_SUCCESS) {
1324 free(ncpname);
1325 return (err);
1326 }
1327
1328 err = nwam_enable(ncpname, ncuh);
1329 free(ncpname);
1330
1331 /* nwamd may not be running, that's okay. */
1332 if (err == NWAM_ERROR_BIND)
1333 return (NWAM_SUCCESS);
1334 else
1335 return (err);
1336 }
1337
1338 /*
1339 * Disable ncu; fails if the NCU's parent NCP is not active, or if the
1340 * NCU is not currently active.
1341 */
1342 nwam_error_t
1343 nwam_ncu_disable(nwam_ncu_handle_t ncuh)
1344 {
1345 char *ncpname = NULL;
1346 nwam_error_t err;
1347 nwam_ncu_type_t type;
1348 boolean_t read_only, enabled, manual;
1349
1350 assert(ncuh != NULL);
1351
1352 /* Don't allow NCUs of Automatic NCP to be disabled */
1353 if ((err = nwam_ncu_get_read_only(ncuh, &read_only)) != NWAM_SUCCESS)
1354 return (err);
1355 if (read_only)
1356 return (NWAM_ENTITY_NOT_MANUAL);
1357
1358 /* Link NCUs with manual activation-mode or IP NCUs can be disabled */
1359 if ((err = nwam_ncu_get_ncu_type(ncuh, &type)) != NWAM_SUCCESS)
1360 return (err);
1361
1362 if (type == NWAM_NCU_TYPE_LINK) {
1363 if ((err = nwam_ncu_is_manual(ncuh, &manual)) != NWAM_SUCCESS)
1364 return (err);
1365 if (!manual)
1366 return (NWAM_ENTITY_NOT_MANUAL);
1367 }
1368
1369 /* Make sure NCU is enabled */
1370 if ((err = nwam_ncu_is_enabled(ncuh, &enabled)) != NWAM_SUCCESS ||
1371 (err = nwam_ncu_get_parent_ncp_name(ncuh, &ncpname))
1372 != NWAM_SUCCESS)
1373 return (err);
1374
1375 if (!enabled) {
1376 free(ncpname);
1377 return (NWAM_SUCCESS);
1378 }
1379
1380 if ((err = nwam_ncu_update_enabled(ncuh, B_FALSE)) != NWAM_SUCCESS) {
1381 free(ncpname);
1382 return (err);
1383 }
1384
1385 err = nwam_disable(ncpname, ncuh);
1386 free(ncpname);
1387
1388 /* nwamd may not be running, that's okay. */
1389 if (err == NWAM_ERROR_BIND)
1390 return (NWAM_SUCCESS);
1391 else
1392 return (err);
1393 }
1394
1395 nwam_error_t
1396 nwam_ncu_destroy(nwam_ncu_handle_t ncuh, uint64_t flags)
1397 {
1398 char *ncpname, *ncpfile;
1399 boolean_t read_only;
1400 nwam_error_t err;
1401
1402 assert(ncuh != NULL);
1403
1404 if ((err = nwam_ncu_get_read_only(ncuh, &read_only)) != NWAM_SUCCESS)
1405 return (err);
1406 if (read_only)
1407 return (NWAM_ENTITY_NOT_DESTROYABLE);
1408
1409 if ((err = nwam_ncu_get_parent_ncp_name(ncuh, &ncpname))
1410 != NWAM_SUCCESS)
1411 return (err);
1412 if ((err = nwam_ncp_name_to_file(ncpname, &ncpfile))
1413 != NWAM_SUCCESS) {
1414 free(ncpname);
1415 return (err);
1416 }
1417
1418 err = nwam_destroy(ncpfile, ncuh, flags);
1419
1420 free(ncpname);
1421 free(ncpfile);
1422
1423 return (err);
1424 }
1425
1426 nwam_error_t
1427 nwam_ncu_get_prop_description(const char *propname, const char **descriptionp)
1428 {
1429 return (nwam_get_prop_description(ncu_prop_table, propname,
1430 descriptionp));
1431 }
1432
1433 /* Get expected property data type */
1434 nwam_error_t
1435 nwam_ncu_get_prop_type(const char *propname, nwam_value_type_t *typep)
1436 {
1437 return (nwam_get_prop_type(ncu_prop_table, propname, typep));
1438 }
1439
1440 nwam_error_t
1441 nwam_ncu_prop_read_only(const char *propname, boolean_t *readp)
1442 {
1443 if ((*readp = NWAM_NCU_PROP_SETONCE(propname)) == B_TRUE)
1444 return (NWAM_SUCCESS);
1445
1446 return (nwam_prop_read_only(ncu_prop_table, propname, readp));
1447 }
1448
1449 nwam_error_t
1450 nwam_ncu_prop_multivalued(const char *propname, boolean_t *multip)
1451 {
1452 return (nwam_prop_multivalued(ncu_prop_table, propname, multip));
1453 }
1454
1455 /*
1456 * Ensure that the properties in the ncu, determined by that ncu's
1457 * type and class, belong there.
1458 */
1459 static nwam_error_t
1460 nwam_ncu_validate_prop_membership(nwam_ncu_handle_t ncuh, const char *propname)
1461 {
1462 struct nwam_prop_table_entry *pte;
1463 nwam_value_t typeval, classval;
1464 uint64_t type, class;
1465 uint64_t typeflags = 0, classflags = 0;
1466
1467 /* Get type/class from ncu */
1468 if (nwam_ncu_get_prop_value(ncuh, NWAM_NCU_PROP_TYPE, &typeval)
1469 != NWAM_SUCCESS)
1470 return (NWAM_ENTITY_INVALID);
1471 if (nwam_value_get_uint64(typeval, &type) != NWAM_SUCCESS) {
1472 nwam_value_free(typeval);
1473 return (NWAM_ENTITY_INVALID);
1474 }
1475 typeflags = nwam_ncu_type_to_flag((nwam_ncu_type_t)type);
1476 nwam_value_free(typeval);
1477
1478 if (nwam_ncu_get_prop_value(ncuh, NWAM_NCU_PROP_CLASS, &classval)
1479 != NWAM_SUCCESS)
1480 return (NWAM_ENTITY_INVALID);
1481 if (nwam_value_get_uint64(classval, &class) != NWAM_SUCCESS) {
1482 nwam_value_free(classval);
1483 return (NWAM_ENTITY_INVALID);
1484 }
1485 classflags = nwam_ncu_class_to_flag((nwam_ncu_class_t)class);
1486 nwam_value_free(classval);
1487
1488 if ((pte = nwam_get_prop_table_entry(ncu_prop_table, propname)) == NULL)
1489 return (NWAM_INVALID_ARG);
1490
1491 if (typeflags & pte->prop_type_membership &&
1492 classflags & pte->prop_class_membership) {
1493 return (NWAM_SUCCESS);
1494 } else {
1495 return (NWAM_ENTITY_INVALID_MEMBER);
1496 }
1497 }
1498
1499 /* Validate property's ncu membership and type, number and range of values */
1500 nwam_error_t
1501 nwam_ncu_validate_prop(nwam_ncu_handle_t ncuh, const char *propname,
1502 nwam_value_t value)
1503 {
1504 nwam_error_t err;
1505
1506 assert(ncuh != NULL && propname != NULL);
1507
1508 /* First, determine if this property is valid for this ncu */
1509 if ((err = nwam_ncu_validate_prop_membership(ncuh, propname))
1510 != NWAM_SUCCESS)
1511 return (err);
1512
1513 return (nwam_validate_prop(ncu_prop_table, ncuh, propname, value));
1514 }
1515
1516 /* Property-specific value validation functions follow */
1517
1518 static nwam_error_t
1519 valid_type(nwam_value_t value)
1520 {
1521 uint64_t type;
1522
1523 if (nwam_value_get_uint64(value, &type) != NWAM_SUCCESS ||
1524 type > NWAM_NCU_TYPE_INTERFACE)
1525 return (NWAM_ENTITY_INVALID_VALUE);
1526 return (NWAM_SUCCESS);
1527 }
1528
1529 static nwam_error_t
1530 valid_class(nwam_value_t value)
1531 {
1532 uint64_t class;
1533
1534 if (nwam_value_get_uint64(value, &class) != NWAM_SUCCESS ||
1535 class > NWAM_NCU_CLASS_IP)
1536 return (NWAM_ENTITY_INVALID_VALUE);
1537 return (NWAM_SUCCESS);
1538 }
1539
1540 static nwam_error_t
1541 valid_ncp(nwam_value_t value)
1542 {
1543 char *ncp;
1544
1545 if (nwam_value_get_string(value, &ncp) != NWAM_SUCCESS)
1546 return (NWAM_ENTITY_INVALID_VALUE);
1547 return (NWAM_SUCCESS);
1548 }
1549
1550 static nwam_error_t
1551 valid_priority_mode(nwam_value_t value)
1552 {
1553 uint64_t priority_mode;
1554
1555 if (nwam_value_get_uint64(value, &priority_mode) != NWAM_SUCCESS ||
1556 priority_mode > NWAM_PRIORITY_MODE_ALL)
1557 return (NWAM_ENTITY_INVALID_VALUE);
1558 return (NWAM_SUCCESS);
1559 }
1560
1561 static nwam_error_t
1562 valid_ncu_activation_mode(nwam_value_t value)
1563 {
1564 uint64_t activation_mode;
1565
1566 if (nwam_value_get_uint64(value, &activation_mode) != NWAM_SUCCESS)
1567 return (NWAM_ENTITY_INVALID_VALUE);
1568
1569 switch (activation_mode) {
1570 case NWAM_ACTIVATION_MODE_MANUAL:
1571 case NWAM_ACTIVATION_MODE_PRIORITIZED:
1572 return (NWAM_SUCCESS);
1573 }
1574 return (NWAM_ENTITY_INVALID_VALUE);
1575 }
1576
1577 /* ARGSUSED0 */
1578 static nwam_error_t
1579 valid_link_autopush(nwam_value_t value)
1580 {
1581 return (NWAM_SUCCESS);
1582 }
1583
1584 static nwam_error_t
1585 valid_ip_version(nwam_value_t value)
1586 {
1587 uint64_t *versions;
1588 uint_t i, numvalues;
1589
1590 if (nwam_value_get_uint64_array(value, &versions, &numvalues)
1591 != NWAM_SUCCESS)
1592 return (NWAM_ENTITY_INVALID_VALUE);
1593
1594 for (i = 0; i < numvalues; i++) {
1595 if (versions[i] != IPV4_VERSION &&
1596 versions[i] != IPV6_VERSION)
1597 return (NWAM_ENTITY_INVALID_VALUE);
1598 }
1599 return (NWAM_SUCCESS);
1600 }
1601
1602 static nwam_error_t
1603 valid_addrsrc_v4(nwam_value_t value)
1604 {
1605 uint64_t *addrsrc;
1606 uint_t i, numvalues;
1607
1608 if (nwam_value_get_uint64_array(value, &addrsrc, &numvalues)
1609 != NWAM_SUCCESS)
1610 return (NWAM_ENTITY_INVALID_VALUE);
1611
1612 for (i = 0; i < numvalues; i++) {
1613 if (addrsrc[i] != NWAM_ADDRSRC_DHCP &&
1614 addrsrc[i] != NWAM_ADDRSRC_STATIC)
1615 return (NWAM_ENTITY_INVALID_VALUE);
1616 }
1617 return (NWAM_SUCCESS);
1618 }
1619
1620 static nwam_error_t
1621 valid_addrsrc_v6(nwam_value_t value)
1622 {
1623 uint64_t *addrsrc;
1624 uint_t i, numvalues;
1625 boolean_t dhcp_found = B_FALSE, autoconf_found = B_FALSE;
1626
1627 if (nwam_value_get_uint64_array(value, &addrsrc, &numvalues)
1628 != NWAM_SUCCESS)
1629 return (NWAM_ENTITY_INVALID_VALUE);
1630
1631 for (i = 0; i < numvalues; i++) {
1632 if (addrsrc[i] != NWAM_ADDRSRC_DHCP &&
1633 addrsrc[i] != NWAM_ADDRSRC_STATIC &&
1634 addrsrc[i] != NWAM_ADDRSRC_AUTOCONF)
1635 return (NWAM_ENTITY_INVALID_VALUE);
1636 if (addrsrc[i] == NWAM_ADDRSRC_DHCP)
1637 dhcp_found = B_TRUE;
1638 if (addrsrc[i] == NWAM_ADDRSRC_AUTOCONF)
1639 autoconf_found = B_TRUE;
1640 }
1641 /*
1642 * DHCP and AUTOCONF need to be specified as v6 address sources
1643 * since there is no way to switch them off in NWAM at present.
1644 */
1645 if (dhcp_found && autoconf_found)
1646 return (NWAM_SUCCESS);
1647 else
1648 return (NWAM_ENTITY_INVALID_VALUE);
1649 }
1650
1651 /* ARGSUSED0 */
1652 static nwam_error_t
1653 valid_link_mtu(nwam_value_t value)
1654 {
1655 return (NWAM_SUCCESS);
1656 }
1657
1658 nwam_error_t
1659 nwam_ncu_validate(nwam_ncu_handle_t ncuh, const char **errpropp)
1660 {
1661 return (nwam_validate(ncu_prop_table, ncuh, errpropp));
1662 }
1663
1664 /*
1665 * Given the ncu type and ncu class, return the list of properties that needs
1666 * to be set. Note this list is a complete property list that includes both
1667 * the required ones and the optional ones. Caller needs to free prop_list.
1668 */
1669 nwam_error_t
1670 nwam_ncu_get_default_proplist(nwam_ncu_type_t type, nwam_ncu_class_t class,
1671 const char ***prop_list, uint_t *numvalues)
1672 {
1673 uint64_t typeflags = nwam_ncu_type_to_flag(type);
1674 uint64_t classflags = nwam_ncu_class_to_flag(class);
1675
1676 return (nwam_get_default_proplist(ncu_prop_table, typeflags,
1677 classflags, prop_list, numvalues));
1678 }
1679
1680 nwam_error_t
1681 nwam_ncp_get_state(nwam_ncp_handle_t ncph, nwam_state_t *statep,
1682 nwam_aux_state_t *auxp)
1683 {
1684 return (nwam_get_state(ncph->nwh_name, ncph, statep, auxp));
1685 }
1686
1687 nwam_error_t
1688 nwam_ncu_get_state(nwam_ncu_handle_t ncuh, nwam_state_t *statep,
1689 nwam_aux_state_t *auxp)
1690 {
1691 nwam_ncp_handle_t ncph;
1692 char *ncpname;
1693 nwam_error_t err;
1694
1695 assert(ncuh != NULL);
1696
1697 if ((err = nwam_ncu_get_ncp(ncuh, &ncph)) != NWAM_SUCCESS)
1698 return (err);
1699 if (!nwam_ncp_is_active(ncph)) {
1700 nwam_ncp_free(ncph);
1701 return (NWAM_ENTITY_INVALID);
1702 }
1703 nwam_ncp_free(ncph);
1704
1705 if ((err = nwam_ncu_get_parent_ncp_name(ncuh, &ncpname))
1706 != NWAM_SUCCESS)
1707 return (err);
1708
1709 err = nwam_request_state(NWAM_OBJECT_TYPE_NCU, ncuh->nwh_name, ncpname,
1710 statep, auxp);
1711 free(ncpname);
1712 return (err);
1713 }
1714
1715 nwam_error_t
1716 nwam_ncp_get_active_priority_group(int64_t *priorityp)
1717 {
1718 return (nwam_request_active_priority_group(priorityp));
1719 }