usr/src/lib/libnwam/common/libnwam_ncp.c

   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 }