16185db85Sdougm /* 26185db85Sdougm * CDDL HEADER START 36185db85Sdougm * 46185db85Sdougm * The contents of this file are subject to the terms of the 56185db85Sdougm * Common Development and Distribution License (the "License"). 66185db85Sdougm * You may not use this file except in compliance with the License. 76185db85Sdougm * 86185db85Sdougm * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 96185db85Sdougm * or http://www.opensolaris.org/os/licensing. 106185db85Sdougm * See the License for the specific language governing permissions 116185db85Sdougm * and limitations under the License. 126185db85Sdougm * 136185db85Sdougm * When distributing Covered Code, include this CDDL HEADER in each 146185db85Sdougm * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 156185db85Sdougm * If applicable, add the following below this CDDL HEADER, with the 166185db85Sdougm * fields enclosed by brackets "[]" replaced with your own identifying 176185db85Sdougm * information: Portions Copyright [yyyy] [name of copyright owner] 186185db85Sdougm * 196185db85Sdougm * CDDL HEADER END 206185db85Sdougm */ 216185db85Sdougm 226185db85Sdougm /* 23148c5f43SAlan Wright * Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved. 24*b8dc1b43SJoyce McIntosh * Copyright 2018 Nexenta Systems, Inc. All rights reserved. 258a981c33SDaniel Hoffman * Copyright (c) 2016 by Delphix. All rights reserved. 266185db85Sdougm */ 276185db85Sdougm 286185db85Sdougm /* 296185db85Sdougm * Share control API 306185db85Sdougm */ 316185db85Sdougm #include <stdio.h> 326185db85Sdougm #include <string.h> 336185db85Sdougm #include <ctype.h> 346185db85Sdougm #include <sys/types.h> 356185db85Sdougm #include <sys/stat.h> 36a99982a7Sdougm #include <fcntl.h> 376185db85Sdougm #include <unistd.h> 386185db85Sdougm #include <libxml/parser.h> 396185db85Sdougm #include <libxml/tree.h> 406185db85Sdougm #include "libshare.h" 416185db85Sdougm #include "libshare_impl.h" 426185db85Sdougm #include <libscf.h> 436185db85Sdougm #include "scfutil.h" 446185db85Sdougm #include <ctype.h> 456185db85Sdougm #include <libintl.h> 46549ec3ffSdougm #include <thread.h> 47549ec3ffSdougm #include <synch.h> 48015408caSJean McCormack #include <errno.h> 496185db85Sdougm 50a99982a7Sdougm #define DFS_LOCK_FILE "/etc/dfs/fstypes" 5157b448deSdougm #define SA_STRSIZE 256 /* max string size for names */ 52a99982a7Sdougm 53da6c28aaSamw /* 54da6c28aaSamw * internal object type values returned by sa_get_object_type() 55da6c28aaSamw */ 56da6c28aaSamw #define SA_TYPE_UNKNOWN 0 57da6c28aaSamw #define SA_TYPE_GROUP 1 58da6c28aaSamw #define SA_TYPE_SHARE 2 59da6c28aaSamw #define SA_TYPE_RESOURCE 3 60da6c28aaSamw #define SA_TYPE_OPTIONSET 4 61da6c28aaSamw #define SA_TYPE_ALTSPACE 5 62da6c28aaSamw 636185db85Sdougm /* 646185db85Sdougm * internal data structures 656185db85Sdougm */ 666185db85Sdougm 676185db85Sdougm extern struct sa_proto_plugin *sap_proto_list; 686185db85Sdougm 696185db85Sdougm /* current SMF/SVC repository handle */ 70549ec3ffSdougm extern void getlegacyconfig(sa_handle_t, char *, xmlNodePtr *); 71549ec3ffSdougm extern int gettransients(sa_handle_impl_t, xmlNodePtr *); 728a981c33SDaniel Hoffman extern int get_one_transient(sa_handle_impl_t, xmlNodePtr *, char **, size_t); 736185db85Sdougm extern char *sa_fstype(char *); 746185db85Sdougm extern int sa_is_share(void *); 75da6c28aaSamw extern int sa_is_resource(void *); 766185db85Sdougm extern ssize_t scf_max_name_len; /* defined in scfutil during initialization */ 776185db85Sdougm extern int sa_group_is_zfs(sa_group_t); 786185db85Sdougm extern int sa_path_is_zfs(char *); 796185db85Sdougm extern int sa_zfs_set_sharenfs(sa_group_t, char *, int); 80da6c28aaSamw extern int sa_zfs_set_sharesmb(sa_group_t, char *, int); 81549ec3ffSdougm extern void update_legacy_config(sa_handle_t); 826185db85Sdougm extern int issubdir(char *, char *); 8357b448deSdougm extern int sa_zfs_init(sa_handle_impl_t); 84549ec3ffSdougm extern void sa_zfs_fini(sa_handle_impl_t); 85a99982a7Sdougm extern void sablocksigs(sigset_t *); 86a99982a7Sdougm extern void saunblocksigs(sigset_t *); 87da6c28aaSamw static sa_group_t sa_get_optionset_parent(sa_optionset_t); 88da6c28aaSamw static char *get_node_attr(void *, char *); 895b6e0c46Sdougm extern void sa_update_sharetab_ts(sa_handle_t); 906185db85Sdougm 91549ec3ffSdougm /* 92549ec3ffSdougm * Data structures for finding/managing the document root to access 93549ec3ffSdougm * handle mapping. The list isn't expected to grow very large so a 94549ec3ffSdougm * simple list is acceptable. The purpose is to provide a way to start 95549ec3ffSdougm * with a group or share and find the library handle needed for 96549ec3ffSdougm * various operations. 97549ec3ffSdougm */ 98549ec3ffSdougm mutex_t sa_global_lock; 99549ec3ffSdougm struct doc2handle { 100549ec3ffSdougm struct doc2handle *next; 101549ec3ffSdougm xmlNodePtr root; 102549ec3ffSdougm sa_handle_impl_t handle; 103549ec3ffSdougm }; 104549ec3ffSdougm 105148c5f43SAlan Wright mutex_t sa_dfstab_lock; 106148c5f43SAlan Wright 10757b448deSdougm /* definitions used in a couple of property functions */ 10857b448deSdougm #define SA_PROP_OP_REMOVE 1 10957b448deSdougm #define SA_PROP_OP_ADD 2 11057b448deSdougm #define SA_PROP_OP_UPDATE 3 11157b448deSdougm 112549ec3ffSdougm static struct doc2handle *sa_global_handles = NULL; 1136185db85Sdougm 1146185db85Sdougm /* helper functions */ 1156185db85Sdougm 116549ec3ffSdougm /* 117549ec3ffSdougm * sa_errorstr(err) 118549ec3ffSdougm * 119549ec3ffSdougm * convert an error value to an error string 120549ec3ffSdougm */ 121549ec3ffSdougm 1226185db85Sdougm char * 1236185db85Sdougm sa_errorstr(int err) 1246185db85Sdougm { 1256185db85Sdougm static char errstr[32]; 1266185db85Sdougm char *ret = NULL; 1276185db85Sdougm 1286185db85Sdougm switch (err) { 1296185db85Sdougm case SA_OK: 13057b448deSdougm ret = dgettext(TEXT_DOMAIN, "ok"); 13157b448deSdougm break; 1326185db85Sdougm case SA_NO_SUCH_PATH: 13357b448deSdougm ret = dgettext(TEXT_DOMAIN, "path doesn't exist"); 13457b448deSdougm break; 1356185db85Sdougm case SA_NO_MEMORY: 13657b448deSdougm ret = dgettext(TEXT_DOMAIN, "no memory"); 13757b448deSdougm break; 1386185db85Sdougm case SA_DUPLICATE_NAME: 13957b448deSdougm ret = dgettext(TEXT_DOMAIN, "name in use"); 14057b448deSdougm break; 1416185db85Sdougm case SA_BAD_PATH: 14257b448deSdougm ret = dgettext(TEXT_DOMAIN, "bad path"); 14357b448deSdougm break; 1446185db85Sdougm case SA_NO_SUCH_GROUP: 14557b448deSdougm ret = dgettext(TEXT_DOMAIN, "no such group"); 14657b448deSdougm break; 1476185db85Sdougm case SA_CONFIG_ERR: 14857b448deSdougm ret = dgettext(TEXT_DOMAIN, "configuration error"); 14957b448deSdougm break; 1506185db85Sdougm case SA_SYSTEM_ERR: 15157b448deSdougm ret = dgettext(TEXT_DOMAIN, "system error"); 15257b448deSdougm break; 1536185db85Sdougm case SA_SYNTAX_ERR: 15457b448deSdougm ret = dgettext(TEXT_DOMAIN, "syntax error"); 15557b448deSdougm break; 1566185db85Sdougm case SA_NO_PERMISSION: 15757b448deSdougm ret = dgettext(TEXT_DOMAIN, "no permission"); 15857b448deSdougm break; 1596185db85Sdougm case SA_BUSY: 16057b448deSdougm ret = dgettext(TEXT_DOMAIN, "busy"); 16157b448deSdougm break; 1626185db85Sdougm case SA_NO_SUCH_PROP: 16357b448deSdougm ret = dgettext(TEXT_DOMAIN, "no such property"); 16457b448deSdougm break; 1656185db85Sdougm case SA_INVALID_NAME: 16657b448deSdougm ret = dgettext(TEXT_DOMAIN, "invalid name"); 16757b448deSdougm break; 1686185db85Sdougm case SA_INVALID_PROTOCOL: 16957b448deSdougm ret = dgettext(TEXT_DOMAIN, "invalid protocol"); 17057b448deSdougm break; 1716185db85Sdougm case SA_NOT_ALLOWED: 17257b448deSdougm ret = dgettext(TEXT_DOMAIN, "operation not allowed"); 17357b448deSdougm break; 1746185db85Sdougm case SA_BAD_VALUE: 17557b448deSdougm ret = dgettext(TEXT_DOMAIN, "bad property value"); 17657b448deSdougm break; 1776185db85Sdougm case SA_INVALID_SECURITY: 17857b448deSdougm ret = dgettext(TEXT_DOMAIN, "invalid security type"); 17957b448deSdougm break; 1806185db85Sdougm case SA_NO_SUCH_SECURITY: 18157b448deSdougm ret = dgettext(TEXT_DOMAIN, "security type not found"); 18257b448deSdougm break; 1836185db85Sdougm case SA_VALUE_CONFLICT: 18457b448deSdougm ret = dgettext(TEXT_DOMAIN, "property value conflict"); 18557b448deSdougm break; 1866185db85Sdougm case SA_NOT_IMPLEMENTED: 18757b448deSdougm ret = dgettext(TEXT_DOMAIN, "not implemented"); 18857b448deSdougm break; 1896185db85Sdougm case SA_INVALID_PATH: 19057b448deSdougm ret = dgettext(TEXT_DOMAIN, "invalid path"); 19157b448deSdougm break; 1926185db85Sdougm case SA_NOT_SUPPORTED: 19357b448deSdougm ret = dgettext(TEXT_DOMAIN, "operation not supported"); 19457b448deSdougm break; 1956185db85Sdougm case SA_PROP_SHARE_ONLY: 19657b448deSdougm ret = dgettext(TEXT_DOMAIN, "property not valid for group"); 19757b448deSdougm break; 1986185db85Sdougm case SA_NOT_SHARED: 19957b448deSdougm ret = dgettext(TEXT_DOMAIN, "not shared"); 20057b448deSdougm break; 201da6c28aaSamw case SA_NO_SUCH_RESOURCE: 202da6c28aaSamw ret = dgettext(TEXT_DOMAIN, "no such resource"); 203da6c28aaSamw break; 204da6c28aaSamw case SA_RESOURCE_REQUIRED: 205da6c28aaSamw ret = dgettext(TEXT_DOMAIN, "resource name required"); 206da6c28aaSamw break; 207da6c28aaSamw case SA_MULTIPLE_ERROR: 208da6c28aaSamw ret = dgettext(TEXT_DOMAIN, "errors from multiple protocols"); 209da6c28aaSamw break; 210da6c28aaSamw case SA_PATH_IS_SUBDIR: 211da6c28aaSamw ret = dgettext(TEXT_DOMAIN, "path is a subpath of share"); 212da6c28aaSamw break; 213da6c28aaSamw case SA_PATH_IS_PARENTDIR: 214da6c28aaSamw ret = dgettext(TEXT_DOMAIN, "path is parent of a share"); 215da6c28aaSamw break; 2164bff34e3Sthurlow case SA_NO_SECTION: 2174bff34e3Sthurlow ret = dgettext(TEXT_DOMAIN, "protocol requires a section"); 2184bff34e3Sthurlow break; 2194bff34e3Sthurlow case SA_NO_PROPERTIES: 2204bff34e3Sthurlow ret = dgettext(TEXT_DOMAIN, "properties not found"); 2214bff34e3Sthurlow break; 2224bff34e3Sthurlow case SA_NO_SUCH_SECTION: 2234bff34e3Sthurlow ret = dgettext(TEXT_DOMAIN, "section not found"); 2244bff34e3Sthurlow break; 2254bff34e3Sthurlow case SA_PASSWORD_ENC: 2264bff34e3Sthurlow ret = dgettext(TEXT_DOMAIN, "passwords must be encrypted"); 2274bff34e3Sthurlow break; 2280616fd7fSPavel Filipensky case SA_SHARE_EXISTS: 2290616fd7fSPavel Filipensky ret = dgettext(TEXT_DOMAIN, "path or file is already shared"); 2300616fd7fSPavel Filipensky break; 2316185db85Sdougm default: 23257b448deSdougm (void) snprintf(errstr, sizeof (errstr), 23357b448deSdougm dgettext(TEXT_DOMAIN, "unknown %d"), err); 23457b448deSdougm ret = errstr; 2356185db85Sdougm } 2366185db85Sdougm return (ret); 2376185db85Sdougm } 2386185db85Sdougm 239549ec3ffSdougm /* 240549ec3ffSdougm * Document root to active handle mapping functions. These are only 241549ec3ffSdougm * used internally. A mutex is used to prevent access while the list 242549ec3ffSdougm * is changing. In general, the list will be relatively short - one 243549ec3ffSdougm * item per thread that has called sa_init(). 244549ec3ffSdougm */ 245549ec3ffSdougm 246549ec3ffSdougm sa_handle_impl_t 247549ec3ffSdougm get_handle_for_root(xmlNodePtr root) 248549ec3ffSdougm { 249549ec3ffSdougm struct doc2handle *item; 250549ec3ffSdougm 251549ec3ffSdougm (void) mutex_lock(&sa_global_lock); 252549ec3ffSdougm for (item = sa_global_handles; item != NULL; item = item->next) { 25357b448deSdougm if (item->root == root) 25457b448deSdougm break; 255549ec3ffSdougm } 256549ec3ffSdougm (void) mutex_unlock(&sa_global_lock); 257549ec3ffSdougm if (item != NULL) 25857b448deSdougm return (item->handle); 259549ec3ffSdougm return (NULL); 260549ec3ffSdougm } 261549ec3ffSdougm 262549ec3ffSdougm static int 263549ec3ffSdougm add_handle_for_root(xmlNodePtr root, sa_handle_impl_t handle) 264549ec3ffSdougm { 265549ec3ffSdougm struct doc2handle *item; 266549ec3ffSdougm int ret = SA_NO_MEMORY; 267549ec3ffSdougm 268549ec3ffSdougm item = (struct doc2handle *)calloc(sizeof (struct doc2handle), 1); 269549ec3ffSdougm if (item != NULL) { 27057b448deSdougm item->root = root; 27157b448deSdougm item->handle = handle; 27257b448deSdougm (void) mutex_lock(&sa_global_lock); 27357b448deSdougm item->next = sa_global_handles; 27457b448deSdougm sa_global_handles = item; 27557b448deSdougm (void) mutex_unlock(&sa_global_lock); 27657b448deSdougm ret = SA_OK; 277549ec3ffSdougm } 278549ec3ffSdougm return (ret); 279549ec3ffSdougm } 280549ec3ffSdougm 281549ec3ffSdougm /* 282549ec3ffSdougm * remove_handle_for_root(root) 283549ec3ffSdougm * 284549ec3ffSdougm * Walks the list of handles and removes the one for this "root" from 285549ec3ffSdougm * the list. It is up to the caller to free the data. 286549ec3ffSdougm */ 287549ec3ffSdougm 288549ec3ffSdougm static void 289549ec3ffSdougm remove_handle_for_root(xmlNodePtr root) 290549ec3ffSdougm { 291549ec3ffSdougm struct doc2handle *item, *prev; 292549ec3ffSdougm 293549ec3ffSdougm (void) mutex_lock(&sa_global_lock); 294549ec3ffSdougm for (prev = NULL, item = sa_global_handles; item != NULL; 29557b448deSdougm item = item->next) { 29657b448deSdougm if (item->root == root) { 29757b448deSdougm /* first in the list */ 29857b448deSdougm if (prev == NULL) 29957b448deSdougm sa_global_handles = sa_global_handles->next; 30057b448deSdougm else 30157b448deSdougm prev->next = item->next; 30257b448deSdougm /* Item is out of the list so free the list structure */ 30357b448deSdougm free(item); 30457b448deSdougm break; 305549ec3ffSdougm } 30657b448deSdougm prev = item; 307549ec3ffSdougm } 308549ec3ffSdougm (void) mutex_unlock(&sa_global_lock); 309549ec3ffSdougm } 310549ec3ffSdougm 311549ec3ffSdougm /* 312549ec3ffSdougm * sa_find_group_handle(sa_group_t group) 313549ec3ffSdougm * 314549ec3ffSdougm * Find the sa_handle_t for the configuration associated with this 315549ec3ffSdougm * group. 316549ec3ffSdougm */ 317549ec3ffSdougm sa_handle_t 318549ec3ffSdougm sa_find_group_handle(sa_group_t group) 319549ec3ffSdougm { 320549ec3ffSdougm xmlNodePtr node = (xmlNodePtr)group; 321549ec3ffSdougm sa_handle_t handle; 322549ec3ffSdougm 323549ec3ffSdougm while (node != NULL) { 32457b448deSdougm if (strcmp((char *)(node->name), "sharecfg") == 0) { 32557b448deSdougm /* have the root so get the handle */ 32657b448deSdougm handle = (sa_handle_t)get_handle_for_root(node); 32757b448deSdougm return (handle); 32857b448deSdougm } 32957b448deSdougm node = node->parent; 330549ec3ffSdougm } 331549ec3ffSdougm return (NULL); 332549ec3ffSdougm } 333549ec3ffSdougm 3346185db85Sdougm /* 3356185db85Sdougm * set_legacy_timestamp(root, path, timevalue) 3366185db85Sdougm * 3376185db85Sdougm * add the current timestamp value to the configuration for use in 3386185db85Sdougm * determining when to update the legacy files. For SMF, this 3396185db85Sdougm * property is kept in default/operation/legacy_timestamp 3406185db85Sdougm */ 3416185db85Sdougm 3426185db85Sdougm static void 3436185db85Sdougm set_legacy_timestamp(xmlNodePtr root, char *path, uint64_t tval) 3446185db85Sdougm { 3456185db85Sdougm xmlNodePtr node; 3466185db85Sdougm xmlChar *lpath = NULL; 347549ec3ffSdougm sa_handle_impl_t handle; 348549ec3ffSdougm 349549ec3ffSdougm /* Have to have a handle or else we weren't initialized. */ 350549ec3ffSdougm handle = get_handle_for_root(root); 351549ec3ffSdougm if (handle == NULL) 35257b448deSdougm return; 3536185db85Sdougm 3546185db85Sdougm for (node = root->xmlChildrenNode; node != NULL; 35557b448deSdougm node = node->next) { 35657b448deSdougm if (xmlStrcmp(node->name, (xmlChar *)"legacy") == 0) { 35757b448deSdougm /* a possible legacy node for this path */ 35857b448deSdougm lpath = xmlGetProp(node, (xmlChar *)"path"); 35957b448deSdougm if (lpath != NULL && 36057b448deSdougm xmlStrcmp(lpath, (xmlChar *)path) == 0) { 36157b448deSdougm xmlFree(lpath); 36257b448deSdougm break; 36357b448deSdougm } 36457b448deSdougm if (lpath != NULL) 36557b448deSdougm xmlFree(lpath); 3666185db85Sdougm } 3676185db85Sdougm } 3686185db85Sdougm if (node == NULL) { 36957b448deSdougm /* need to create the first legacy timestamp node */ 37057b448deSdougm node = xmlNewChild(root, NULL, (xmlChar *)"legacy", NULL); 3716185db85Sdougm } 3726185db85Sdougm if (node != NULL) { 37357b448deSdougm char tstring[32]; 37457b448deSdougm int ret; 37557b448deSdougm 37657b448deSdougm (void) snprintf(tstring, sizeof (tstring), "%lld", tval); 3774bff34e3Sthurlow (void) xmlSetProp(node, (xmlChar *)"timestamp", 3784bff34e3Sthurlow (xmlChar *)tstring); 3794bff34e3Sthurlow (void) xmlSetProp(node, (xmlChar *)"path", (xmlChar *)path); 38057b448deSdougm /* now commit to SMF */ 38157b448deSdougm ret = sa_get_instance(handle->scfhandle, "default"); 3826185db85Sdougm if (ret == SA_OK) { 38357b448deSdougm ret = sa_start_transaction(handle->scfhandle, 38457b448deSdougm "operation"); 38557b448deSdougm if (ret == SA_OK) { 38657b448deSdougm ret = sa_set_property(handle->scfhandle, 38757b448deSdougm "legacy-timestamp", tstring); 38857b448deSdougm if (ret == SA_OK) { 38957b448deSdougm (void) sa_end_transaction( 3905b6e0c46Sdougm handle->scfhandle, handle); 39157b448deSdougm } else { 39257b448deSdougm sa_abort_transaction(handle->scfhandle); 39357b448deSdougm } 39457b448deSdougm } 3956185db85Sdougm } 3966185db85Sdougm } 3976185db85Sdougm } 3986185db85Sdougm 3996185db85Sdougm /* 4006185db85Sdougm * is_shared(share) 4016185db85Sdougm * 4026185db85Sdougm * determine if the specified share is currently shared or not. 4036185db85Sdougm */ 4046185db85Sdougm static int 4056185db85Sdougm is_shared(sa_share_t share) 4066185db85Sdougm { 4076185db85Sdougm char *shared; 4086185db85Sdougm int result = 0; /* assume not */ 4096185db85Sdougm 4106185db85Sdougm shared = sa_get_share_attr(share, "shared"); 4116185db85Sdougm if (shared != NULL) { 41257b448deSdougm if (strcmp(shared, "true") == 0) 41357b448deSdougm result = 1; 41457b448deSdougm sa_free_attr_string(shared); 4156185db85Sdougm } 4166185db85Sdougm return (result); 4176185db85Sdougm } 4186185db85Sdougm 419da6c28aaSamw /* 420da6c28aaSamw * excluded_protocol(share, proto) 421da6c28aaSamw * 422da6c28aaSamw * Returns B_TRUE if the specified protocol appears in the "exclude" 423da6c28aaSamw * property. This is used to prevent sharing special case shares 424da6c28aaSamw * (e.g. subdirs when SMB wants a subdir and NFS doesn't. B_FALSE is 425da6c28aaSamw * returned if the protocol isn't in the list. 426da6c28aaSamw */ 427da6c28aaSamw static boolean_t 428da6c28aaSamw excluded_protocol(sa_share_t share, char *proto) 429da6c28aaSamw { 430da6c28aaSamw char *protolist; 431da6c28aaSamw char *str; 432da6c28aaSamw char *token; 433da6c28aaSamw 434da6c28aaSamw protolist = sa_get_share_attr(share, "exclude"); 435da6c28aaSamw if (protolist != NULL) { 436da6c28aaSamw str = protolist; 437da6c28aaSamw while ((token = strtok(str, ",")) != NULL) { 438da6c28aaSamw if (strcmp(token, proto) == 0) { 439da6c28aaSamw sa_free_attr_string(protolist); 440da6c28aaSamw return (B_TRUE); 441da6c28aaSamw } 442da6c28aaSamw str = NULL; 443da6c28aaSamw } 444da6c28aaSamw sa_free_attr_string(protolist); 445da6c28aaSamw } 446da6c28aaSamw return (B_FALSE); 447da6c28aaSamw } 448da6c28aaSamw 4496185db85Sdougm /* 450a99982a7Sdougm * checksubdirgroup(group, newpath, strictness) 451f345c0beSdougm * 452a99982a7Sdougm * check all the specified newpath against all the paths in the 453a99982a7Sdougm * group. This is a helper function for checksubdir to make it easier 454a99982a7Sdougm * to also check ZFS subgroups. 455a99982a7Sdougm * The strictness values mean: 456f345c0beSdougm * SA_CHECK_NORMAL == only check newpath against shares that are active 457f345c0beSdougm * SA_CHECK_STRICT == check newpath against both active shares and those 458f345c0beSdougm * stored in the repository 4596185db85Sdougm */ 4606185db85Sdougm static int 461a99982a7Sdougm checksubdirgroup(sa_group_t group, char *newpath, int strictness) 4626185db85Sdougm { 4636185db85Sdougm sa_share_t share; 464a99982a7Sdougm char *path; 465a99982a7Sdougm int issub = SA_OK; 466da6c28aaSamw int subdir; 467da6c28aaSamw int parent; 468da6c28aaSamw 469da6c28aaSamw if (newpath == NULL) 470da6c28aaSamw return (SA_INVALID_PATH); 4716185db85Sdougm 472a99982a7Sdougm for (share = sa_get_share(group, NULL); share != NULL; 473a99982a7Sdougm share = sa_get_next_share(share)) { 4746185db85Sdougm /* 4756185db85Sdougm * The original behavior of share never checked 4766185db85Sdougm * against the permanent configuration 4776185db85Sdougm * (/etc/dfs/dfstab). PIT has a number of cases where 4786185db85Sdougm * it depends on this older behavior even though it 4796185db85Sdougm * could be considered incorrect. We may tighten this 4806185db85Sdougm * up in the future. 4816185db85Sdougm */ 48257b448deSdougm if (strictness == SA_CHECK_NORMAL && !is_shared(share)) 48357b448deSdougm continue; 4846185db85Sdougm 48557b448deSdougm path = sa_get_share_attr(share, "path"); 486f345c0beSdougm /* 487f345c0beSdougm * If path is NULL, then a share is in the process of 488f345c0beSdougm * construction or someone has modified the property 489a99982a7Sdougm * group inappropriately. It should be 490a99982a7Sdougm * ignored. issubdir() comes from the original share 491a99982a7Sdougm * implementation and does the difficult part of 492a99982a7Sdougm * checking subdirectories. 493f345c0beSdougm */ 49457b448deSdougm if (path == NULL) 49557b448deSdougm continue; 496da6c28aaSamw 497da6c28aaSamw if (strcmp(path, newpath) == 0) { 49857b448deSdougm issub = SA_INVALID_PATH; 499da6c28aaSamw } else { 500da6c28aaSamw subdir = issubdir(newpath, path); 501da6c28aaSamw parent = issubdir(path, newpath); 502da6c28aaSamw if (subdir || parent) { 503da6c28aaSamw sa_free_attr_string(path); 504da6c28aaSamw path = NULL; 505da6c28aaSamw return (subdir ? 506da6c28aaSamw SA_PATH_IS_SUBDIR : SA_PATH_IS_PARENTDIR); 507da6c28aaSamw } 50857b448deSdougm } 5096185db85Sdougm sa_free_attr_string(path); 5106185db85Sdougm path = NULL; 511a99982a7Sdougm } 512a99982a7Sdougm return (issub); 513a99982a7Sdougm } 514a99982a7Sdougm 515a99982a7Sdougm /* 516a99982a7Sdougm * checksubdir(newpath, strictness) 517a99982a7Sdougm * 518a99982a7Sdougm * checksubdir determines if the specified path (newpath) is a 519a99982a7Sdougm * subdirectory of another share. It calls checksubdirgroup() to do 520a99982a7Sdougm * the complicated work. The strictness parameter determines how 521a99982a7Sdougm * strict a check to make against the path. The strictness values 522a99982a7Sdougm * mean: SA_CHECK_NORMAL == only check newpath against shares that are 523a99982a7Sdougm * active SA_CHECK_STRICT == check newpath against both active shares 524a99982a7Sdougm * and those * stored in the repository 525a99982a7Sdougm */ 526a99982a7Sdougm static int 527549ec3ffSdougm checksubdir(sa_handle_t handle, char *newpath, int strictness) 528a99982a7Sdougm { 529a99982a7Sdougm sa_group_t group; 530da6c28aaSamw int issub = SA_OK; 531a99982a7Sdougm char *path = NULL; 532a99982a7Sdougm 533da6c28aaSamw for (group = sa_get_group(handle, NULL); 534da6c28aaSamw group != NULL && issub == SA_OK; 535da6c28aaSamw group = sa_get_next_group(group)) { 53657b448deSdougm if (sa_group_is_zfs(group)) { 53757b448deSdougm sa_group_t subgroup; 53857b448deSdougm for (subgroup = sa_get_sub_group(group); 539da6c28aaSamw subgroup != NULL && issub == SA_OK; 54057b448deSdougm subgroup = sa_get_next_group(subgroup)) 54157b448deSdougm issub = checksubdirgroup(subgroup, newpath, 54257b448deSdougm strictness); 54357b448deSdougm } else { 54457b448deSdougm issub = checksubdirgroup(group, newpath, strictness); 54557b448deSdougm } 5466185db85Sdougm } 5476185db85Sdougm if (path != NULL) 54857b448deSdougm sa_free_attr_string(path); 5496185db85Sdougm return (issub); 5506185db85Sdougm } 5516185db85Sdougm 5526185db85Sdougm /* 553f345c0beSdougm * validpath(path, strictness) 5546185db85Sdougm * determine if the provided path is valid for a share. It shouldn't 5556185db85Sdougm * be a sub-dir of an already shared path or the parent directory of a 5566185db85Sdougm * share path. 5576185db85Sdougm */ 5586185db85Sdougm static int 559549ec3ffSdougm validpath(sa_handle_t handle, char *path, int strictness) 5606185db85Sdougm { 5616185db85Sdougm int error = SA_OK; 5626185db85Sdougm struct stat st; 5636185db85Sdougm sa_share_t share; 5646185db85Sdougm char *fstype; 5656185db85Sdougm 56657b448deSdougm if (*path != '/') 56757b448deSdougm return (SA_BAD_PATH); 56857b448deSdougm 5696185db85Sdougm if (stat(path, &st) < 0) { 57057b448deSdougm error = SA_NO_SUCH_PATH; 5716185db85Sdougm } else { 57257b448deSdougm share = sa_find_share(handle, path); 57357b448deSdougm if (share != NULL) 57457b448deSdougm error = SA_DUPLICATE_NAME; 57557b448deSdougm 57657b448deSdougm if (error == SA_OK) { 57757b448deSdougm /* 57857b448deSdougm * check for special case with file system 57957b448deSdougm * that might have restrictions. For now, ZFS 58057b448deSdougm * is the only case since it has its own idea 58157b448deSdougm * of how to configure shares. We do this 58257b448deSdougm * before subdir checking since things like 58357b448deSdougm * ZFS will do that for us. This should also 58457b448deSdougm * be done via plugin interface. 58557b448deSdougm */ 58657b448deSdougm fstype = sa_fstype(path); 58757b448deSdougm if (fstype != NULL && strcmp(fstype, "zfs") == 0) { 58857b448deSdougm if (sa_zfs_is_shared(handle, path)) 58957b448deSdougm error = SA_INVALID_NAME; 59057b448deSdougm } 59157b448deSdougm if (fstype != NULL) 59257b448deSdougm sa_free_fstype(fstype); 5936185db85Sdougm } 59457b448deSdougm if (error == SA_OK) 59557b448deSdougm error = checksubdir(handle, path, strictness); 5966185db85Sdougm } 5976185db85Sdougm return (error); 5986185db85Sdougm } 5996185db85Sdougm 6006185db85Sdougm /* 6016185db85Sdougm * check to see if group/share is persistent. 602da6c28aaSamw * 603da6c28aaSamw * "group" can be either an sa_group_t or an sa_share_t. (void *) 6045cb0d679SMarcel Telka * works since both these types are also void *. 605148c5f43SAlan Wright * If the share is a ZFS share, mark it as persistent. 6066185db85Sdougm */ 607da6c28aaSamw int 608da6c28aaSamw sa_is_persistent(void *group) 6096185db85Sdougm { 6106185db85Sdougm char *type; 6116185db85Sdougm int persist = 1; 612148c5f43SAlan Wright sa_group_t grp; 6136185db85Sdougm 614da6c28aaSamw type = sa_get_group_attr((sa_group_t)group, "type"); 615148c5f43SAlan Wright if (type != NULL) { 616148c5f43SAlan Wright if (strcmp(type, "transient") == 0) 617148c5f43SAlan Wright persist = 0; 61857b448deSdougm sa_free_attr_string(type); 619148c5f43SAlan Wright } 620148c5f43SAlan Wright 621148c5f43SAlan Wright grp = (sa_is_share(group)) ? sa_get_parent_group(group) : group; 622148c5f43SAlan Wright if (sa_group_is_zfs(grp)) 623148c5f43SAlan Wright persist = 1; 624148c5f43SAlan Wright 6256185db85Sdougm return (persist); 6266185db85Sdougm } 6276185db85Sdougm 6286185db85Sdougm /* 6296185db85Sdougm * sa_valid_group_name(name) 6306185db85Sdougm * 6316185db85Sdougm * check that the "name" contains only valid characters and otherwise 6326185db85Sdougm * fits the required naming conventions. Valid names must start with 6336185db85Sdougm * an alphabetic and the remainder may consist of only alphanumeric 6346185db85Sdougm * plus the '-' and '_' characters. This name limitation comes from 6356185db85Sdougm * inherent limitations in SMF. 6366185db85Sdougm */ 6376185db85Sdougm 6386185db85Sdougm int 6396185db85Sdougm sa_valid_group_name(char *name) 6406185db85Sdougm { 6416185db85Sdougm int ret = 1; 6426185db85Sdougm ssize_t len; 6436185db85Sdougm 6446185db85Sdougm if (name != NULL && isalpha(*name)) { 64557b448deSdougm char c; 64657b448deSdougm len = strlen(name); 64757b448deSdougm if (len < (scf_max_name_len - sizeof ("group:"))) { 64857b448deSdougm for (c = *name++; c != '\0' && ret != 0; c = *name++) { 64957b448deSdougm if (!isalnum(c) && c != '-' && c != '_') 65057b448deSdougm ret = 0; 65157b448deSdougm } 65257b448deSdougm } else { 6536185db85Sdougm ret = 0; 6546185db85Sdougm } 6556185db85Sdougm } else { 65657b448deSdougm ret = 0; 6576185db85Sdougm } 6586185db85Sdougm return (ret); 6596185db85Sdougm } 6606185db85Sdougm 6616185db85Sdougm 6626185db85Sdougm /* 6636185db85Sdougm * is_zfs_group(group) 6646185db85Sdougm * Determine if the specified group is a ZFS sharenfs group 6656185db85Sdougm */ 6666185db85Sdougm static int 6676185db85Sdougm is_zfs_group(sa_group_t group) 6686185db85Sdougm { 6696185db85Sdougm int ret = 0; 6706185db85Sdougm xmlNodePtr parent; 6716185db85Sdougm xmlChar *zfs; 6726185db85Sdougm 67357b448deSdougm if (strcmp((char *)((xmlNodePtr)group)->name, "share") == 0) 67457b448deSdougm parent = (xmlNodePtr)sa_get_parent_group(group); 67557b448deSdougm else 67657b448deSdougm parent = (xmlNodePtr)group; 6776185db85Sdougm zfs = xmlGetProp(parent, (xmlChar *)"zfs"); 6786185db85Sdougm if (zfs != NULL) { 67957b448deSdougm xmlFree(zfs); 68057b448deSdougm ret = 1; 6816185db85Sdougm } 6826185db85Sdougm return (ret); 6836185db85Sdougm } 6846185db85Sdougm 685da6c28aaSamw /* 686da6c28aaSamw * sa_get_object_type(object) 687da6c28aaSamw * 688da6c28aaSamw * This function returns a numeric value representing the object 689da6c28aaSamw * type. This allows using simpler checks when doing type specific 690da6c28aaSamw * operations. 691da6c28aaSamw */ 692da6c28aaSamw 693da6c28aaSamw static int 694da6c28aaSamw sa_get_object_type(void *object) 695da6c28aaSamw { 696da6c28aaSamw xmlNodePtr node = (xmlNodePtr)object; 697da6c28aaSamw int type; 698da6c28aaSamw 699da6c28aaSamw if (xmlStrcmp(node->name, (xmlChar *)"group") == 0) 700da6c28aaSamw type = SA_TYPE_GROUP; 701da6c28aaSamw else if (xmlStrcmp(node->name, (xmlChar *)"share") == 0) 702da6c28aaSamw type = SA_TYPE_SHARE; 703da6c28aaSamw else if (xmlStrcmp(node->name, (xmlChar *)"resource") == 0) 704da6c28aaSamw type = SA_TYPE_RESOURCE; 705da6c28aaSamw else if (xmlStrcmp(node->name, (xmlChar *)"optionset") == 0) 706da6c28aaSamw type = SA_TYPE_OPTIONSET; 707da6c28aaSamw else if (xmlStrcmp(node->name, (xmlChar *)"security") == 0) 708da6c28aaSamw type = SA_TYPE_ALTSPACE; 709da6c28aaSamw else 710da6c28aaSamw assert(0); 711da6c28aaSamw return (type); 712da6c28aaSamw } 713da6c28aaSamw 7146185db85Sdougm /* 7156185db85Sdougm * sa_optionset_name(optionset, oname, len, id) 7166185db85Sdougm * return the SMF name for the optionset. If id is not NULL, it 7176185db85Sdougm * will have the GUID value for a share and should be used 7186185db85Sdougm * instead of the keyword "optionset" which is used for 7196185db85Sdougm * groups. If the optionset doesn't have a protocol type 7206185db85Sdougm * associated with it, "default" is used. This shouldn't happen 7216185db85Sdougm * at this point but may be desirable in the future if there are 7226185db85Sdougm * protocol independent properties added. The name is returned in 7236185db85Sdougm * oname. 7246185db85Sdougm */ 7256185db85Sdougm 7266185db85Sdougm static int 7276185db85Sdougm sa_optionset_name(sa_optionset_t optionset, char *oname, size_t len, char *id) 7286185db85Sdougm { 7296185db85Sdougm char *proto; 730da6c28aaSamw void *parent; 731da6c28aaSamw int ptype; 7326185db85Sdougm 7336185db85Sdougm if (id == NULL) 73457b448deSdougm id = "optionset"; 7356185db85Sdougm 736da6c28aaSamw parent = sa_get_optionset_parent(optionset); 737da6c28aaSamw if (parent != NULL) { 738da6c28aaSamw ptype = sa_get_object_type(parent); 739da6c28aaSamw proto = sa_get_optionset_attr(optionset, "type"); 740da6c28aaSamw if (ptype != SA_TYPE_RESOURCE) { 741da6c28aaSamw len = snprintf(oname, len, "%s_%s", id, 742da6c28aaSamw proto ? proto : "default"); 743da6c28aaSamw } else { 744da6c28aaSamw char *index; 745da6c28aaSamw index = get_node_attr((void *)parent, "id"); 746fe1c642dSBill Krier if (index != NULL) { 747da6c28aaSamw len = snprintf(oname, len, "%s_%s_%s", id, 748da6c28aaSamw proto ? proto : "default", index); 749fe1c642dSBill Krier sa_free_attr_string(index); 750fe1c642dSBill Krier } else { 751da6c28aaSamw len = 0; 752fe1c642dSBill Krier } 753da6c28aaSamw } 7546185db85Sdougm 755da6c28aaSamw if (proto != NULL) 756da6c28aaSamw sa_free_attr_string(proto); 757da6c28aaSamw } else { 758da6c28aaSamw len = 0; 759da6c28aaSamw } 7606185db85Sdougm return (len); 7616185db85Sdougm } 7626185db85Sdougm 7636185db85Sdougm /* 7646185db85Sdougm * sa_security_name(optionset, oname, len, id) 7656185db85Sdougm * 7666185db85Sdougm * return the SMF name for the security. If id is not NULL, it will 7676185db85Sdougm * have the GUID value for a share and should be used instead of the 7686185db85Sdougm * keyword "optionset" which is used for groups. If the optionset 7696185db85Sdougm * doesn't have a protocol type associated with it, "default" is 7706185db85Sdougm * used. This shouldn't happen at this point but may be desirable in 7716185db85Sdougm * the future if there are protocol independent properties added. The 7726185db85Sdougm * name is returned in oname. The security type is also encoded into 7736185db85Sdougm * the name. In the future, this wil *be handled a bit differently. 7746185db85Sdougm */ 7756185db85Sdougm 7766185db85Sdougm static int 7776185db85Sdougm sa_security_name(sa_security_t security, char *oname, size_t len, char *id) 7786185db85Sdougm { 7796185db85Sdougm char *proto; 7806185db85Sdougm char *sectype; 7816185db85Sdougm 7826185db85Sdougm if (id == NULL) 78357b448deSdougm id = "optionset"; 7846185db85Sdougm 7856185db85Sdougm proto = sa_get_security_attr(security, "type"); 7866185db85Sdougm sectype = sa_get_security_attr(security, "sectype"); 78757b448deSdougm len = snprintf(oname, len, "%s_%s_%s", id, proto ? proto : "default", 78857b448deSdougm sectype ? sectype : "default"); 7896185db85Sdougm if (proto != NULL) 79057b448deSdougm sa_free_attr_string(proto); 7916185db85Sdougm if (sectype != NULL) 79257b448deSdougm sa_free_attr_string(sectype); 7936185db85Sdougm return (len); 7946185db85Sdougm } 7956185db85Sdougm 79657b448deSdougm /* 79757b448deSdougm * verifydefgroupopts(handle) 79857b448deSdougm * 79957b448deSdougm * Make sure a "default" group exists and has default protocols enabled. 80057b448deSdougm */ 80157b448deSdougm static void 80257b448deSdougm verifydefgroupopts(sa_handle_t handle) 80357b448deSdougm { 80457b448deSdougm sa_group_t defgrp; 80557b448deSdougm sa_optionset_t opt; 806da6c28aaSamw 80757b448deSdougm defgrp = sa_get_group(handle, "default"); 80857b448deSdougm if (defgrp != NULL) { 80957b448deSdougm opt = sa_get_optionset(defgrp, NULL); 81057b448deSdougm /* 81157b448deSdougm * NFS is the default for default group 81257b448deSdougm */ 81357b448deSdougm if (opt == NULL) 81457b448deSdougm opt = sa_create_optionset(defgrp, "nfs"); 81557b448deSdougm } 81657b448deSdougm } 81757b448deSdougm 8186185db85Sdougm /* 8198a981c33SDaniel Hoffman * sa_init_impl(init_service, arg) 8206185db85Sdougm * Initialize the API 8216185db85Sdougm * find all the shared objects 8226185db85Sdougm * init the tables with all objects 8236185db85Sdougm * read in the current configuration 8248a981c33SDaniel Hoffman * 8258a981c33SDaniel Hoffman * arg is a parameter passed in whose meaning is based on the init_service. 8268a981c33SDaniel Hoffman * See libshare.h under API initialization. 8276185db85Sdougm */ 82857b448deSdougm #define GETPROP(prop) scf_simple_prop_next_astring(prop) 82957b448deSdougm #define CHECKTSTAMP(st, tval) stat(SA_LEGACY_DFSTAB, &st) >= 0 && \ 83057b448deSdougm tval != TSTAMP(st.st_ctim) 8318a981c33SDaniel Hoffman static sa_handle_t 8328a981c33SDaniel Hoffman sa_init_impl(int init_service, void *arg) 8336185db85Sdougm { 8346185db85Sdougm struct stat st; 8358a981c33SDaniel Hoffman /* legacy is used for debugging only as far as I can tell */ 8366185db85Sdougm int legacy = 0; 8376185db85Sdougm uint64_t tval = 0; 838a99982a7Sdougm int lockfd; 839a99982a7Sdougm sigset_t old; 840a99982a7Sdougm int updatelegacy = B_FALSE; 841a99982a7Sdougm scf_simple_prop_t *prop; 842549ec3ffSdougm sa_handle_impl_t handle; 843549ec3ffSdougm int err; 844549ec3ffSdougm 845549ec3ffSdougm handle = calloc(sizeof (struct sa_handle_impl), 1); 8466185db85Sdougm 847549ec3ffSdougm if (handle != NULL) { 8488a981c33SDaniel Hoffman handle->sa_service = init_service; 849c5f58477Sdougm /* 850c5f58477Sdougm * Get protocol specific structures, but only if this 851c5f58477Sdougm * is the only handle. 852c5f58477Sdougm */ 853c5f58477Sdougm (void) mutex_lock(&sa_global_lock); 854c5f58477Sdougm if (sa_global_handles == NULL) 855c5f58477Sdougm (void) proto_plugin_init(); 856c5f58477Sdougm (void) mutex_unlock(&sa_global_lock); 8578a981c33SDaniel Hoffman if (init_service & (SA_INIT_SHARE_API | 8588a981c33SDaniel Hoffman SA_INIT_SHARE_API_SELECTIVE | SA_INIT_ONE_SHARE_FROM_NAME | 8598a981c33SDaniel Hoffman SA_INIT_ONE_SHARE_FROM_HANDLE)) { 860a99982a7Sdougm /* 86157b448deSdougm * initialize access into libzfs. We use this 86257b448deSdougm * when collecting info about ZFS datasets and 86357b448deSdougm * shares. 864a99982a7Sdougm */ 86557b448deSdougm if (sa_zfs_init(handle) == B_FALSE) { 86657b448deSdougm free(handle); 86789dc44ceSjose borrego (void) mutex_lock(&sa_global_lock); 86857b448deSdougm (void) proto_plugin_fini(); 86989dc44ceSjose borrego (void) mutex_unlock(&sa_global_lock); 87057b448deSdougm return (NULL); 87157b448deSdougm } 872a99982a7Sdougm /* 87357b448deSdougm * since we want to use SMF, initialize an svc handle 87457b448deSdougm * and find out what is there. 875a99982a7Sdougm */ 87657b448deSdougm handle->scfhandle = sa_scf_init(handle); 87757b448deSdougm if (handle->scfhandle != NULL) { 87857b448deSdougm /* 87957b448deSdougm * Need to lock the extraction of the 88057b448deSdougm * configuration if the dfstab file has 88157b448deSdougm * changed. Lock everything now and release if 88257b448deSdougm * not needed. Use a file that isn't being 88357b448deSdougm * manipulated by other parts of the system in 88457b448deSdougm * order to not interfere with locking. Using 88557b448deSdougm * dfstab doesn't work. 88657b448deSdougm */ 88757b448deSdougm sablocksigs(&old); 88857b448deSdougm lockfd = open(DFS_LOCK_FILE, O_RDWR); 88957b448deSdougm if (lockfd >= 0) { 89057b448deSdougm errno = 0; 89157b448deSdougm (void) lockf(lockfd, F_LOCK, 0); 892148c5f43SAlan Wright (void) mutex_lock(&sa_dfstab_lock); 89357b448deSdougm /* 89457b448deSdougm * Check whether we are going to need 89557b448deSdougm * to merge any dfstab changes. This 89657b448deSdougm * is done by comparing the value of 89757b448deSdougm * legacy-timestamp with the current 89857b448deSdougm * st_ctim of the file. If they are 89957b448deSdougm * different, an update is needed and 90057b448deSdougm * the file must remain locked until 90157b448deSdougm * the merge is done in order to 90257b448deSdougm * prevent multiple startups from 90357b448deSdougm * changing the SMF repository at the 90457b448deSdougm * same time. The first to get the 90557b448deSdougm * lock will make any changes before 90657b448deSdougm * the others can read the repository. 90757b448deSdougm */ 90857b448deSdougm prop = scf_simple_prop_get 90957b448deSdougm (handle->scfhandle->handle, 91057b448deSdougm (const char *)SA_SVC_FMRI_BASE 91157b448deSdougm ":default", "operation", 91257b448deSdougm "legacy-timestamp"); 91357b448deSdougm if (prop != NULL) { 91457b448deSdougm char *i64; 91557b448deSdougm i64 = GETPROP(prop); 91657b448deSdougm if (i64 != NULL) 91757b448deSdougm tval = strtoull(i64, 91857b448deSdougm NULL, 0); 91957b448deSdougm if (CHECKTSTAMP(st, tval)) 92057b448deSdougm updatelegacy = B_TRUE; 92157b448deSdougm scf_simple_prop_free(prop); 92257b448deSdougm } else { 92357b448deSdougm /* 92457b448deSdougm * We haven't set the 92557b448deSdougm * timestamp before so do it. 92657b448deSdougm */ 92757b448deSdougm updatelegacy = B_TRUE; 92857b448deSdougm } 929148c5f43SAlan Wright if (updatelegacy == B_FALSE) { 930148c5f43SAlan Wright (void) mutex_unlock( 931148c5f43SAlan Wright &sa_dfstab_lock); 932148c5f43SAlan Wright (void) lockf(lockfd, F_ULOCK, 933148c5f43SAlan Wright 0); 934148c5f43SAlan Wright (void) close(lockfd); 935148c5f43SAlan Wright } 9361d1813a7Sdougm 937148c5f43SAlan Wright } 93857b448deSdougm /* 93957b448deSdougm * It is essential that the document tree and 94057b448deSdougm * the internal list of roots to handles be 94157b448deSdougm * setup before anything that might try to 94257b448deSdougm * create a new object is called. The document 94357b448deSdougm * tree is the combination of handle->doc and 94457b448deSdougm * handle->tree. This allows searches, 94557b448deSdougm * etc. when all you have is an object in the 94657b448deSdougm * tree. 94757b448deSdougm */ 94857b448deSdougm handle->doc = xmlNewDoc((xmlChar *)"1.0"); 94957b448deSdougm handle->tree = xmlNewNode(NULL, 95057b448deSdougm (xmlChar *)"sharecfg"); 95157b448deSdougm if (handle->doc != NULL && 95257b448deSdougm handle->tree != NULL) { 9534bff34e3Sthurlow (void) xmlDocSetRootElement(handle->doc, 95457b448deSdougm handle->tree); 95557b448deSdougm err = add_handle_for_root(handle->tree, 95657b448deSdougm handle); 95757b448deSdougm if (err == SA_OK) 95857b448deSdougm err = sa_get_config( 95957b448deSdougm handle->scfhandle, 9601d1813a7Sdougm handle->tree, handle); 96157b448deSdougm } else { 96257b448deSdougm if (handle->doc != NULL) 96357b448deSdougm xmlFreeDoc(handle->doc); 96457b448deSdougm if (handle->tree != NULL) 96557b448deSdougm xmlFreeNode(handle->tree); 96657b448deSdougm err = SA_NO_MEMORY; 96757b448deSdougm } 96857b448deSdougm 96957b448deSdougm saunblocksigs(&old); 97057b448deSdougm 97157b448deSdougm if (err != SA_OK) { 97257b448deSdougm /* 97357b448deSdougm * If we couldn't add the tree handle 97457b448deSdougm * to the list, then things are going 97557b448deSdougm * to fail badly. Might as well undo 97657b448deSdougm * everything now and fail the 97757b448deSdougm * sa_init(). 97857b448deSdougm */ 97957b448deSdougm sa_fini(handle); 980148c5f43SAlan Wright if (updatelegacy == B_TRUE) { 981148c5f43SAlan Wright (void) mutex_unlock( 982148c5f43SAlan Wright &sa_dfstab_lock); 983148c5f43SAlan Wright (void) lockf(lockfd, 984148c5f43SAlan Wright F_ULOCK, 0); 985148c5f43SAlan Wright (void) close(lockfd); 986148c5f43SAlan Wright } 98757b448deSdougm return (NULL); 98857b448deSdougm } 9891d1813a7Sdougm 99057b448deSdougm if (tval == 0) { 99157b448deSdougm /* 99257b448deSdougm * first time so make sure 99357b448deSdougm * default is setup 99457b448deSdougm */ 99557b448deSdougm verifydefgroupopts(handle); 99657b448deSdougm } 997549ec3ffSdougm 998546405c3Sdougm if (updatelegacy == B_TRUE) { 999546405c3Sdougm sablocksigs(&old); 1000546405c3Sdougm getlegacyconfig((sa_handle_t)handle, 1001546405c3Sdougm SA_LEGACY_DFSTAB, &handle->tree); 1002546405c3Sdougm if (stat(SA_LEGACY_DFSTAB, &st) >= 0) 1003546405c3Sdougm set_legacy_timestamp( 1004546405c3Sdougm handle->tree, 1005546405c3Sdougm SA_LEGACY_DFSTAB, 1006546405c3Sdougm TSTAMP(st.st_ctim)); 1007546405c3Sdougm saunblocksigs(&old); 1008546405c3Sdougm /* 1009546405c3Sdougm * Safe to unlock now to allow 1010546405c3Sdougm * others to run 1011546405c3Sdougm */ 1012148c5f43SAlan Wright (void) mutex_unlock(&sa_dfstab_lock); 1013546405c3Sdougm (void) lockf(lockfd, F_ULOCK, 0); 1014546405c3Sdougm (void) close(lockfd); 1015546405c3Sdougm } 10165b6e0c46Sdougm /* Get sharetab timestamp */ 10175b6e0c46Sdougm sa_update_sharetab_ts((sa_handle_t)handle); 10185b6e0c46Sdougm 10195b6e0c46Sdougm /* Get lastupdate (transaction) timestamp */ 10205b6e0c46Sdougm prop = scf_simple_prop_get( 10215b6e0c46Sdougm handle->scfhandle->handle, 10225b6e0c46Sdougm (const char *)SA_SVC_FMRI_BASE ":default", 10235b6e0c46Sdougm "state", "lastupdate"); 10245b6e0c46Sdougm if (prop != NULL) { 10255b6e0c46Sdougm char *str; 10265b6e0c46Sdougm str = 10275b6e0c46Sdougm scf_simple_prop_next_astring(prop); 10285b6e0c46Sdougm if (str != NULL) 10295b6e0c46Sdougm handle->tstrans = 10305b6e0c46Sdougm strtoull(str, NULL, 0); 10315b6e0c46Sdougm else 10325b6e0c46Sdougm handle->tstrans = 0; 10335b6e0c46Sdougm scf_simple_prop_free(prop); 10345b6e0c46Sdougm } 10358a981c33SDaniel Hoffman /* 10368a981c33SDaniel Hoffman * In this conditional the library reads from 10378a981c33SDaniel Hoffman * zfs and /etc/dfs/sharetab to find datasets 10388a981c33SDaniel Hoffman * that must be shared. The result is a tree of 10398a981c33SDaniel Hoffman * groups that are stored in the handle for 10408a981c33SDaniel Hoffman * libshare to utilize later when asked to share 10418a981c33SDaniel Hoffman * or unshare datasets. 10428a981c33SDaniel Hoffman */ 10438a981c33SDaniel Hoffman if (init_service & 10448a981c33SDaniel Hoffman SA_INIT_SHARE_API_SELECTIVE) { 10458a981c33SDaniel Hoffman char **paths; 10468a981c33SDaniel Hoffman size_t paths_len, i; 10478a981c33SDaniel Hoffman 10488a981c33SDaniel Hoffman legacy |= sa_get_one_zfs_share(handle, 10498a981c33SDaniel Hoffman "zfs", 10508a981c33SDaniel Hoffman (sa_init_selective_arg_t *)arg, 10518a981c33SDaniel Hoffman &paths, &paths_len); 10528a981c33SDaniel Hoffman legacy |= get_one_transient(handle, 10538a981c33SDaniel Hoffman &handle->tree, paths, paths_len); 10548a981c33SDaniel Hoffman for (i = 0; i < paths_len; ++i) { 10558a981c33SDaniel Hoffman free(paths[i]); 10568a981c33SDaniel Hoffman } 10578a981c33SDaniel Hoffman free(paths); 10588a981c33SDaniel Hoffman } else if (init_service & 10598a981c33SDaniel Hoffman SA_INIT_ONE_SHARE_FROM_NAME) { 10608a981c33SDaniel Hoffman char path[ZFS_MAXPROPLEN]; 10618a981c33SDaniel Hoffman char *ptr = path; 10628a981c33SDaniel Hoffman char **ptr_to_path = &ptr; 10638a981c33SDaniel Hoffman 10648a981c33SDaniel Hoffman legacy |= 10658a981c33SDaniel Hoffman sa_get_zfs_share_for_name(handle, 10668a981c33SDaniel Hoffman "zfs", (char *)arg, path); 10678a981c33SDaniel Hoffman legacy |= get_one_transient(handle, 10688a981c33SDaniel Hoffman &handle->tree, ptr_to_path, 1); 10698a981c33SDaniel Hoffman } else if (init_service & 10708a981c33SDaniel Hoffman SA_INIT_ONE_SHARE_FROM_HANDLE) { 10718a981c33SDaniel Hoffman char path[ZFS_MAXPROPLEN]; 10728a981c33SDaniel Hoffman char *ptr = path; 10738a981c33SDaniel Hoffman char **ptr_to_path = &ptr; 10748a981c33SDaniel Hoffman 10758a981c33SDaniel Hoffman legacy |= 10768a981c33SDaniel Hoffman sa_get_zfs_share_for_name(handle, 10778a981c33SDaniel Hoffman "zfs", 10788a981c33SDaniel Hoffman zfs_get_name( 10798a981c33SDaniel Hoffman (zfs_handle_t *)arg), 10808a981c33SDaniel Hoffman path); 10818a981c33SDaniel Hoffman legacy |= get_one_transient(handle, 10828a981c33SDaniel Hoffman &handle->tree, ptr_to_path, 1); 10838a981c33SDaniel Hoffman } else { 10848a981c33SDaniel Hoffman legacy |= sa_get_zfs_shares(handle, 10858a981c33SDaniel Hoffman "zfs"); 10868a981c33SDaniel Hoffman legacy |= gettransients(handle, 10878a981c33SDaniel Hoffman &handle->tree); 10888a981c33SDaniel Hoffman } 10896185db85Sdougm } 10906185db85Sdougm } 10916185db85Sdougm } 1092549ec3ffSdougm return ((sa_handle_t)handle); 10936185db85Sdougm } 10946185db85Sdougm 10958a981c33SDaniel Hoffman /* 10968a981c33SDaniel Hoffman * sa_init exists as a legacy interface, new consumers should use sa_init_arg. 10978a981c33SDaniel Hoffman */ 10988a981c33SDaniel Hoffman sa_handle_t 10998a981c33SDaniel Hoffman sa_init(int init_service) 11008a981c33SDaniel Hoffman { 11018a981c33SDaniel Hoffman return (sa_init_impl(init_service, NULL)); 11028a981c33SDaniel Hoffman } 11038a981c33SDaniel Hoffman 11048a981c33SDaniel Hoffman /* 11058a981c33SDaniel Hoffman * See libshare.h "API Initialization" section for valid values of init_service 11068a981c33SDaniel Hoffman * as well as the appropriate argument type for a given init_service. 11078a981c33SDaniel Hoffman */ 11088a981c33SDaniel Hoffman sa_handle_t 11098a981c33SDaniel Hoffman sa_init_arg(int init_service, void *arg) 11108a981c33SDaniel Hoffman { 11118a981c33SDaniel Hoffman return (sa_init_impl(init_service, arg)); 11128a981c33SDaniel Hoffman } 11138a981c33SDaniel Hoffman 11146185db85Sdougm /* 1115549ec3ffSdougm * sa_fini(handle) 11166185db85Sdougm * Uninitialize the API structures including the configuration 11171cea05afSdougm * data structures and ZFS related data. 11186185db85Sdougm */ 11196185db85Sdougm 11206185db85Sdougm void 1121549ec3ffSdougm sa_fini(sa_handle_t handle) 11226185db85Sdougm { 1123549ec3ffSdougm sa_handle_impl_t impl_handle = (sa_handle_impl_t)handle; 1124549ec3ffSdougm 1125549ec3ffSdougm if (impl_handle != NULL) { 1126549ec3ffSdougm /* 1127549ec3ffSdougm * Free the config trees and any other data structures 1128549ec3ffSdougm * used in the handle. 1129549ec3ffSdougm */ 1130549ec3ffSdougm if (impl_handle->doc != NULL) 1131549ec3ffSdougm xmlFreeDoc(impl_handle->doc); 1132549ec3ffSdougm 1133549ec3ffSdougm /* Remove and free the entry in the global list. */ 1134549ec3ffSdougm remove_handle_for_root(impl_handle->tree); 1135549ec3ffSdougm 1136549ec3ffSdougm /* 1137549ec3ffSdougm * If this was the last handle to release, unload the 1138c5f58477Sdougm * plugins that were loaded. Use a mutex in case 1139c5f58477Sdougm * another thread is reinitializing. 1140549ec3ffSdougm */ 1141c5f58477Sdougm (void) mutex_lock(&sa_global_lock); 1142549ec3ffSdougm if (sa_global_handles == NULL) 114357b448deSdougm (void) proto_plugin_fini(); 1144c5f58477Sdougm (void) mutex_unlock(&sa_global_lock); 1145549ec3ffSdougm 11460fd77660Sgwr sa_scf_fini(impl_handle->scfhandle); 11470fd77660Sgwr sa_zfs_fini(impl_handle); 11480fd77660Sgwr 11490fd77660Sgwr /* Make sure we free the handle */ 11500fd77660Sgwr free(impl_handle); 11510fd77660Sgwr 11526185db85Sdougm } 11536185db85Sdougm } 11546185db85Sdougm 1155*b8dc1b43SJoyce McIntosh /* 1156*b8dc1b43SJoyce McIntosh * sa_service(sa_handle_t handle) 1157*b8dc1b43SJoyce McIntosh * 1158*b8dc1b43SJoyce McIntosh * Returns the service for which the handle is currently initialized. 1159*b8dc1b43SJoyce McIntosh */ 1160*b8dc1b43SJoyce McIntosh int 1161*b8dc1b43SJoyce McIntosh sa_service(sa_handle_t handle) 1162*b8dc1b43SJoyce McIntosh { 1163*b8dc1b43SJoyce McIntosh if (handle == NULL) 1164*b8dc1b43SJoyce McIntosh return (0); 1165*b8dc1b43SJoyce McIntosh 1166*b8dc1b43SJoyce McIntosh return (((sa_handle_impl_t)handle)->sa_service); 1167*b8dc1b43SJoyce McIntosh } 1168*b8dc1b43SJoyce McIntosh 11696185db85Sdougm /* 11706185db85Sdougm * sa_get_protocols(char **protocol) 11716185db85Sdougm * Get array of protocols that are supported 11726185db85Sdougm * Returns pointer to an allocated and NULL terminated 11736185db85Sdougm * array of strings. Caller must free. 11746185db85Sdougm * This really should be determined dynamically. 11756185db85Sdougm * If there aren't any defined, return -1. 11766185db85Sdougm * Use free() to return memory. 11776185db85Sdougm */ 11786185db85Sdougm 11796185db85Sdougm int 11806185db85Sdougm sa_get_protocols(char ***protocols) 11816185db85Sdougm { 11826185db85Sdougm int numproto = -1; 11836185db85Sdougm 11846185db85Sdougm if (protocols != NULL) { 118557b448deSdougm struct sa_proto_plugin *plug; 118657b448deSdougm for (numproto = 0, plug = sap_proto_list; plug != NULL; 11876185db85Sdougm plug = plug->plugin_next) { 118857b448deSdougm numproto++; 118957b448deSdougm } 119057b448deSdougm 119157b448deSdougm *protocols = calloc(numproto + 1, sizeof (char *)); 119257b448deSdougm if (*protocols != NULL) { 119357b448deSdougm int ret = 0; 119457b448deSdougm for (plug = sap_proto_list; plug != NULL; 119557b448deSdougm plug = plug->plugin_next) { 119657b448deSdougm /* faking for now */ 119757b448deSdougm (*protocols)[ret++] = 119857b448deSdougm plug->plugin_ops->sa_protocol; 119957b448deSdougm } 120057b448deSdougm } else { 120157b448deSdougm numproto = -1; 12026185db85Sdougm } 12036185db85Sdougm } 12046185db85Sdougm return (numproto); 12056185db85Sdougm } 12066185db85Sdougm 12076185db85Sdougm /* 12086185db85Sdougm * find_group_by_name(node, group) 12096185db85Sdougm * 12106185db85Sdougm * search the XML document subtree specified by node to find the group 12116185db85Sdougm * specified by group. Searching subtree allows subgroups to be 12126185db85Sdougm * searched for. 12136185db85Sdougm */ 12146185db85Sdougm 12156185db85Sdougm static xmlNodePtr 12166185db85Sdougm find_group_by_name(xmlNodePtr node, xmlChar *group) 12176185db85Sdougm { 12186185db85Sdougm xmlChar *name = NULL; 12196185db85Sdougm 12206185db85Sdougm for (node = node->xmlChildrenNode; node != NULL; 12216185db85Sdougm node = node->next) { 122257b448deSdougm if (xmlStrcmp(node->name, (xmlChar *)"group") == 0) { 122357b448deSdougm /* if no groupname, return the first found */ 122457b448deSdougm if (group == NULL) 122557b448deSdougm break; 122657b448deSdougm name = xmlGetProp(node, (xmlChar *)"name"); 122757b448deSdougm if (name != NULL && xmlStrcmp(name, group) == 0) 122857b448deSdougm break; 122957b448deSdougm if (name != NULL) { 123057b448deSdougm xmlFree(name); 123157b448deSdougm name = NULL; 123257b448deSdougm } 12336185db85Sdougm } 12346185db85Sdougm } 12356185db85Sdougm if (name != NULL) 123657b448deSdougm xmlFree(name); 12376185db85Sdougm return (node); 12386185db85Sdougm } 12396185db85Sdougm 12406185db85Sdougm /* 12416185db85Sdougm * sa_get_group(groupname) 12426185db85Sdougm * Return the "group" specified. If groupname is NULL, 12436185db85Sdougm * return the first group of the list of groups. 12446185db85Sdougm */ 12456185db85Sdougm sa_group_t 1246549ec3ffSdougm sa_get_group(sa_handle_t handle, char *groupname) 12476185db85Sdougm { 12486185db85Sdougm xmlNodePtr node = NULL; 12496185db85Sdougm char *subgroup = NULL; 12506185db85Sdougm char *group = NULL; 1251549ec3ffSdougm sa_handle_impl_t impl_handle = (sa_handle_impl_t)handle; 12526185db85Sdougm 1253549ec3ffSdougm if (impl_handle != NULL && impl_handle->tree != NULL) { 125457b448deSdougm if (groupname != NULL) { 125557b448deSdougm group = strdup(groupname); 1256a3351425Sdougm if (group != NULL) { 1257a3351425Sdougm subgroup = strchr(group, '/'); 1258a3351425Sdougm if (subgroup != NULL) 1259a3351425Sdougm *subgroup++ = '\0'; 1260a3351425Sdougm } 126157b448deSdougm } 1262a3351425Sdougm /* 1263a3351425Sdougm * We want to find the, possibly, named group. If 1264a3351425Sdougm * group is not NULL, then lookup the name. If it is 1265a3351425Sdougm * NULL, we only do the find if groupname is also 1266a3351425Sdougm * NULL. This allows lookup of the "first" group in 1267a3351425Sdougm * the internal list. 1268a3351425Sdougm */ 1269a3351425Sdougm if (group != NULL || groupname == NULL) 1270a3351425Sdougm node = find_group_by_name(impl_handle->tree, 1271a3351425Sdougm (xmlChar *)group); 1272a3351425Sdougm 127357b448deSdougm /* if a subgroup, find it before returning */ 127457b448deSdougm if (subgroup != NULL && node != NULL) 127557b448deSdougm node = find_group_by_name(node, (xmlChar *)subgroup); 12766185db85Sdougm } 12776185db85Sdougm if (node != NULL && (char *)group != NULL) 127857b448deSdougm (void) sa_get_instance(impl_handle->scfhandle, (char *)group); 12796185db85Sdougm if (group != NULL) 128057b448deSdougm free(group); 12816185db85Sdougm return ((sa_group_t)(node)); 12826185db85Sdougm } 12836185db85Sdougm 12846185db85Sdougm /* 12856185db85Sdougm * sa_get_next_group(group) 12866185db85Sdougm * Return the "next" group after the specified group from 12876185db85Sdougm * the internal group list. NULL if there are no more. 12886185db85Sdougm */ 12896185db85Sdougm sa_group_t 12906185db85Sdougm sa_get_next_group(sa_group_t group) 12916185db85Sdougm { 12926185db85Sdougm xmlNodePtr ngroup = NULL; 12936185db85Sdougm if (group != NULL) { 129457b448deSdougm for (ngroup = ((xmlNodePtr)group)->next; ngroup != NULL; 12956185db85Sdougm ngroup = ngroup->next) { 129657b448deSdougm if (xmlStrcmp(ngroup->name, (xmlChar *)"group") == 0) 129757b448deSdougm break; 129857b448deSdougm } 12996185db85Sdougm } 13006185db85Sdougm return ((sa_group_t)ngroup); 13016185db85Sdougm } 13026185db85Sdougm 13036185db85Sdougm /* 13046185db85Sdougm * sa_get_share(group, sharepath) 13056185db85Sdougm * Return the share object for the share specified. The share 13066185db85Sdougm * must be in the specified group. Return NULL if not found. 13076185db85Sdougm */ 13086185db85Sdougm sa_share_t 13096185db85Sdougm sa_get_share(sa_group_t group, char *sharepath) 13106185db85Sdougm { 13116185db85Sdougm xmlNodePtr node = NULL; 13126185db85Sdougm xmlChar *path; 13136185db85Sdougm 13146185db85Sdougm /* 13156185db85Sdougm * For future scalability, this should end up building a cache 13166185db85Sdougm * since it will get called regularly by the mountd and info 13176185db85Sdougm * services. 13186185db85Sdougm */ 13196185db85Sdougm if (group != NULL) { 132057b448deSdougm for (node = ((xmlNodePtr)group)->children; node != NULL; 13216185db85Sdougm node = node->next) { 132257b448deSdougm if (xmlStrcmp(node->name, (xmlChar *)"share") == 0) { 132357b448deSdougm if (sharepath == NULL) { 132457b448deSdougm break; 132557b448deSdougm } else { 132657b448deSdougm /* is it the correct share? */ 132757b448deSdougm path = xmlGetProp(node, 132857b448deSdougm (xmlChar *)"path"); 132957b448deSdougm if (path != NULL && 133057b448deSdougm xmlStrcmp(path, 133157b448deSdougm (xmlChar *)sharepath) == 0) { 133257b448deSdougm xmlFree(path); 133357b448deSdougm break; 133457b448deSdougm } 133557b448deSdougm xmlFree(path); 133657b448deSdougm } 13376185db85Sdougm } 13386185db85Sdougm } 13396185db85Sdougm } 13406185db85Sdougm return ((sa_share_t)node); 13416185db85Sdougm } 13426185db85Sdougm 13436185db85Sdougm /* 13446185db85Sdougm * sa_get_next_share(share) 13456185db85Sdougm * Return the next share following the specified share 13466185db85Sdougm * from the internal list of shares. Returns NULL if there 13476185db85Sdougm * are no more shares. The list is relative to the same 13486185db85Sdougm * group. 13496185db85Sdougm */ 13506185db85Sdougm sa_share_t 13516185db85Sdougm sa_get_next_share(sa_share_t share) 13526185db85Sdougm { 13536185db85Sdougm xmlNodePtr node = NULL; 13546185db85Sdougm 13556185db85Sdougm if (share != NULL) { 135657b448deSdougm for (node = ((xmlNodePtr)share)->next; node != NULL; 13576185db85Sdougm node = node->next) { 135857b448deSdougm if (xmlStrcmp(node->name, (xmlChar *)"share") == 0) { 135957b448deSdougm break; 136057b448deSdougm } 13616185db85Sdougm } 13626185db85Sdougm } 13636185db85Sdougm return ((sa_share_t)node); 13646185db85Sdougm } 13656185db85Sdougm 13666185db85Sdougm /* 13676185db85Sdougm * _sa_get_child_node(node, type) 13686185db85Sdougm * 13696185db85Sdougm * find the child node of the specified node that has "type". This is 13706185db85Sdougm * used to implement several internal functions. 13716185db85Sdougm */ 13726185db85Sdougm 13736185db85Sdougm static xmlNodePtr 13746185db85Sdougm _sa_get_child_node(xmlNodePtr node, xmlChar *type) 13756185db85Sdougm { 13766185db85Sdougm xmlNodePtr child; 13776185db85Sdougm for (child = node->xmlChildrenNode; child != NULL; 13786185db85Sdougm child = child->next) 137957b448deSdougm if (xmlStrcmp(child->name, type) == 0) 138057b448deSdougm return (child); 13816185db85Sdougm return ((xmlNodePtr)NULL); 13826185db85Sdougm } 13836185db85Sdougm 13846185db85Sdougm /* 13856185db85Sdougm * find_share(group, path) 13866185db85Sdougm * 13876185db85Sdougm * Search all the shares in the specified group for one that has the 13886185db85Sdougm * specified path. 13896185db85Sdougm */ 13906185db85Sdougm 13916185db85Sdougm static sa_share_t 13926185db85Sdougm find_share(sa_group_t group, char *sharepath) 13936185db85Sdougm { 13946185db85Sdougm sa_share_t share; 13956185db85Sdougm char *path; 13966185db85Sdougm 13976185db85Sdougm for (share = sa_get_share(group, NULL); share != NULL; 13986185db85Sdougm share = sa_get_next_share(share)) { 139957b448deSdougm path = sa_get_share_attr(share, "path"); 140057b448deSdougm if (path != NULL && strcmp(path, sharepath) == 0) { 140157b448deSdougm sa_free_attr_string(path); 140257b448deSdougm break; 140357b448deSdougm } 140457b448deSdougm if (path != NULL) 140557b448deSdougm sa_free_attr_string(path); 14066185db85Sdougm } 14076185db85Sdougm return (share); 14086185db85Sdougm } 14096185db85Sdougm 14106185db85Sdougm /* 14116185db85Sdougm * sa_get_sub_group(group) 14126185db85Sdougm * 14136185db85Sdougm * Get the first sub-group of group. The sa_get_next_group() function 14146185db85Sdougm * can be used to get the rest. This is currently only used for ZFS 14156185db85Sdougm * sub-groups but could be used to implement a more general mechanism. 14166185db85Sdougm */ 14176185db85Sdougm 14186185db85Sdougm sa_group_t 14196185db85Sdougm sa_get_sub_group(sa_group_t group) 14206185db85Sdougm { 14216185db85Sdougm return ((sa_group_t)_sa_get_child_node((xmlNodePtr)group, 142257b448deSdougm (xmlChar *)"group")); 14236185db85Sdougm } 14246185db85Sdougm 14256185db85Sdougm /* 14266185db85Sdougm * sa_find_share(sharepath) 14276185db85Sdougm * Finds a share regardless of group. In the future, this 14286185db85Sdougm * function should utilize a cache and hash table of some kind. 14296185db85Sdougm * The current assumption is that a path will only be shared 14306185db85Sdougm * once. In the future, this may change as implementation of 14316185db85Sdougm * resource names comes into being. 14326185db85Sdougm */ 14336185db85Sdougm sa_share_t 1434549ec3ffSdougm sa_find_share(sa_handle_t handle, char *sharepath) 14356185db85Sdougm { 14366185db85Sdougm sa_group_t group; 14376185db85Sdougm sa_group_t zgroup; 14386185db85Sdougm sa_share_t share = NULL; 14396185db85Sdougm int done = 0; 14406185db85Sdougm 1441549ec3ffSdougm for (group = sa_get_group(handle, NULL); group != NULL && !done; 144257b448deSdougm group = sa_get_next_group(group)) { 144357b448deSdougm if (is_zfs_group(group)) { 144457b448deSdougm for (zgroup = 144557b448deSdougm (sa_group_t)_sa_get_child_node((xmlNodePtr)group, 144657b448deSdougm (xmlChar *)"group"); 144757b448deSdougm zgroup != NULL; 144857b448deSdougm zgroup = sa_get_next_group(zgroup)) { 144957b448deSdougm share = find_share(zgroup, sharepath); 145057b448deSdougm if (share != NULL) 145157b448deSdougm break; 145257b448deSdougm } 145357b448deSdougm } else { 145457b448deSdougm share = find_share(group, sharepath); 14556185db85Sdougm } 145657b448deSdougm if (share != NULL) 145757b448deSdougm break; 14586185db85Sdougm } 14596185db85Sdougm return (share); 14606185db85Sdougm } 14616185db85Sdougm 14626185db85Sdougm /* 1463f345c0beSdougm * sa_check_path(group, path, strictness) 14646185db85Sdougm * 1465da6c28aaSamw * Check that path is a valid path relative to the group. Currently, 14666185db85Sdougm * we are ignoring the group and checking only the NFS rules. Later, 14676185db85Sdougm * we may want to use the group to then check against the protocols 1468f345c0beSdougm * enabled on the group. The strictness values mean: 1469f345c0beSdougm * SA_CHECK_NORMAL == only check newpath against shares that are active 1470f345c0beSdougm * SA_CHECK_STRICT == check newpath against both active shares and those 1471f345c0beSdougm * stored in the repository 14726185db85Sdougm */ 14736185db85Sdougm 14746185db85Sdougm int 1475f345c0beSdougm sa_check_path(sa_group_t group, char *path, int strictness) 14766185db85Sdougm { 1477549ec3ffSdougm sa_handle_t handle; 1478549ec3ffSdougm 1479549ec3ffSdougm handle = sa_find_group_handle(group); 14809fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States if (handle == NULL) 14819fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States return (SA_BAD_PATH); 14829fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States 1483549ec3ffSdougm return (validpath(handle, path, strictness)); 14846185db85Sdougm } 14856185db85Sdougm 14866185db85Sdougm /* 1487da6c28aaSamw * mark_excluded_protos(group, share, flags) 1488da6c28aaSamw * 1489da6c28aaSamw * Walk through all the protocols enabled for the group and check to 1490da6c28aaSamw * see if the share has any of them should be in the exclude list 1491da6c28aaSamw * based on the featureset of the protocol. If there are any, add the 1492da6c28aaSamw * "exclude" property to the share. 1493da6c28aaSamw */ 1494da6c28aaSamw static void 1495da6c28aaSamw mark_excluded_protos(sa_group_t group, xmlNodePtr share, uint64_t flags) 1496da6c28aaSamw { 1497da6c28aaSamw sa_optionset_t optionset; 1498da6c28aaSamw char exclude_list[SA_STRSIZE]; 1499da6c28aaSamw char *sep = ""; 1500da6c28aaSamw 1501da6c28aaSamw exclude_list[0] = '\0'; 1502da6c28aaSamw for (optionset = sa_get_optionset(group, NULL); 1503da6c28aaSamw optionset != NULL; 1504da6c28aaSamw optionset = sa_get_next_optionset(optionset)) { 1505da6c28aaSamw char *value; 1506da6c28aaSamw uint64_t features; 1507da6c28aaSamw value = sa_get_optionset_attr(optionset, "type"); 1508da6c28aaSamw if (value == NULL) 1509da6c28aaSamw continue; 1510da6c28aaSamw features = sa_proto_get_featureset(value); 1511da6c28aaSamw if (!(features & flags)) { 1512da6c28aaSamw (void) strlcat(exclude_list, sep, 1513da6c28aaSamw sizeof (exclude_list)); 1514da6c28aaSamw (void) strlcat(exclude_list, value, 1515da6c28aaSamw sizeof (exclude_list)); 1516da6c28aaSamw sep = ","; 1517da6c28aaSamw } 1518fe1c642dSBill Krier sa_free_attr_string(value); 1519da6c28aaSamw } 1520da6c28aaSamw if (exclude_list[0] != '\0') 15214bff34e3Sthurlow (void) xmlSetProp(share, (xmlChar *)"exclude", 1522da6c28aaSamw (xmlChar *)exclude_list); 1523da6c28aaSamw } 1524da6c28aaSamw 1525da6c28aaSamw /* 1526da6c28aaSamw * get_all_features(group) 1527da6c28aaSamw * 1528da6c28aaSamw * Walk through all the protocols on the group and collect all 1529da6c28aaSamw * possible enabled features. This is the OR of all the featuresets. 1530da6c28aaSamw */ 1531da6c28aaSamw static uint64_t 1532da6c28aaSamw get_all_features(sa_group_t group) 1533da6c28aaSamw { 1534da6c28aaSamw sa_optionset_t optionset; 1535da6c28aaSamw uint64_t features = 0; 1536da6c28aaSamw 1537da6c28aaSamw for (optionset = sa_get_optionset(group, NULL); 1538da6c28aaSamw optionset != NULL; 1539da6c28aaSamw optionset = sa_get_next_optionset(optionset)) { 1540da6c28aaSamw char *value; 1541da6c28aaSamw value = sa_get_optionset_attr(optionset, "type"); 1542da6c28aaSamw if (value == NULL) 1543da6c28aaSamw continue; 1544da6c28aaSamw features |= sa_proto_get_featureset(value); 1545da6c28aaSamw sa_free_attr_string(value); 1546da6c28aaSamw } 1547da6c28aaSamw return (features); 1548da6c28aaSamw } 1549da6c28aaSamw 1550da6c28aaSamw 1551da6c28aaSamw /* 1552da6c28aaSamw * _sa_add_share(group, sharepath, persist, *error, flags) 15536185db85Sdougm * 1554da6c28aaSamw * Common code for all types of add_share. sa_add_share() is the 15556185db85Sdougm * public API, we also need to be able to do this when parsing legacy 15566185db85Sdougm * files and construction of the internal configuration while 1557da6c28aaSamw * extracting config info from SMF. "flags" indicates if some 1558da6c28aaSamw * protocols need relaxed rules while other don't. These values are 1559da6c28aaSamw * the featureset values defined in libshare.h. 15606185db85Sdougm */ 15616185db85Sdougm 15626185db85Sdougm sa_share_t 1563da6c28aaSamw _sa_add_share(sa_group_t group, char *sharepath, int persist, int *error, 1564da6c28aaSamw uint64_t flags) 15656185db85Sdougm { 15666185db85Sdougm xmlNodePtr node = NULL; 15676185db85Sdougm int err; 15686185db85Sdougm 15696185db85Sdougm err = SA_OK; /* assume success */ 15706185db85Sdougm 157157b448deSdougm node = xmlNewChild((xmlNodePtr)group, NULL, (xmlChar *)"share", NULL); 1572da6c28aaSamw if (node == NULL) { 1573da6c28aaSamw if (error != NULL) 1574da6c28aaSamw *error = SA_NO_MEMORY; 1575da6c28aaSamw return (node); 1576da6c28aaSamw } 1577da6c28aaSamw 15784bff34e3Sthurlow (void) xmlSetProp(node, (xmlChar *)"path", (xmlChar *)sharepath); 15794bff34e3Sthurlow (void) xmlSetProp(node, (xmlChar *)"type", 1580da6c28aaSamw persist ? (xmlChar *)"persist" : (xmlChar *)"transient"); 1581da6c28aaSamw if (flags != 0) 1582da6c28aaSamw mark_excluded_protos(group, node, flags); 1583da6c28aaSamw if (persist != SA_SHARE_TRANSIENT) { 1584da6c28aaSamw /* 1585da6c28aaSamw * persistent shares come in two flavors: SMF and 1586da6c28aaSamw * ZFS. Sort this one out based on target group and 1587da6c28aaSamw * path type. Both NFS and SMB are supported. First, 1588da6c28aaSamw * check to see if the protocol is enabled on the 1589da6c28aaSamw * subgroup and then setup the share appropriately. 1590da6c28aaSamw */ 1591da6c28aaSamw if (sa_group_is_zfs(group) && 1592da6c28aaSamw sa_path_is_zfs(sharepath)) { 1593da6c28aaSamw if (sa_get_optionset(group, "nfs") != NULL) 159457b448deSdougm err = sa_zfs_set_sharenfs(group, sharepath, 1); 1595da6c28aaSamw else if (sa_get_optionset(group, "smb") != NULL) 1596da6c28aaSamw err = sa_zfs_set_sharesmb(group, sharepath, 1); 1597da6c28aaSamw } else { 1598da6c28aaSamw sa_handle_impl_t impl_handle; 1599da6c28aaSamw impl_handle = 1600da6c28aaSamw (sa_handle_impl_t)sa_find_group_handle(group); 1601da6c28aaSamw if (impl_handle != NULL) { 1602da6c28aaSamw err = sa_commit_share(impl_handle->scfhandle, 1603da6c28aaSamw group, (sa_share_t)node); 160457b448deSdougm } else { 1605da6c28aaSamw err = SA_SYSTEM_ERR; 160657b448deSdougm } 160757b448deSdougm } 16086185db85Sdougm } 1609da6c28aaSamw if (err == SA_NO_PERMISSION && persist & SA_SHARE_PARSER) 1610da6c28aaSamw /* called by the dfstab parser so could be a show */ 1611da6c28aaSamw err = SA_OK; 1612da6c28aaSamw 1613da6c28aaSamw if (err != SA_OK) { 1614da6c28aaSamw /* 1615da6c28aaSamw * we couldn't commit to the repository so undo 1616da6c28aaSamw * our internal state to reflect reality. 1617da6c28aaSamw */ 1618da6c28aaSamw xmlUnlinkNode(node); 1619da6c28aaSamw xmlFreeNode(node); 1620da6c28aaSamw node = NULL; 1621da6c28aaSamw } 1622da6c28aaSamw 16236185db85Sdougm if (error != NULL) 162457b448deSdougm *error = err; 1625da6c28aaSamw 16266185db85Sdougm return (node); 16276185db85Sdougm } 16286185db85Sdougm 16296185db85Sdougm /* 16306185db85Sdougm * sa_add_share(group, sharepath, persist, *error) 16316185db85Sdougm * 16326185db85Sdougm * Add a new share object to the specified group. The share will 16336185db85Sdougm * have the specified sharepath and will only be constructed if 16346185db85Sdougm * it is a valid path to be shared. NULL is returned on error 16356185db85Sdougm * and a detailed error value will be returned via the error 16366185db85Sdougm * pointer. 16376185db85Sdougm */ 16386185db85Sdougm sa_share_t 16396185db85Sdougm sa_add_share(sa_group_t group, char *sharepath, int persist, int *error) 16406185db85Sdougm { 16416185db85Sdougm xmlNodePtr node = NULL; 1642f345c0beSdougm int strictness = SA_CHECK_NORMAL; 1643549ec3ffSdougm sa_handle_t handle; 1644da6c28aaSamw uint64_t special = 0; 1645da6c28aaSamw uint64_t features; 1646f345c0beSdougm 1647f345c0beSdougm /* 1648f345c0beSdougm * If the share is to be permanent, use strict checking so a 1649f345c0beSdougm * bad config doesn't get created. Transient shares only need 1650f345c0beSdougm * to check against the currently active 1651f345c0beSdougm * shares. SA_SHARE_PARSER is a modifier used internally to 1652f345c0beSdougm * indicate that we are being called by the dfstab parser and 1653f345c0beSdougm * that we need strict checking in all cases. Normally persist 1654f345c0beSdougm * is in integer value but SA_SHARE_PARSER may be or'd into 1655f345c0beSdougm * it as an override. 1656f345c0beSdougm */ 1657f345c0beSdougm if (persist & SA_SHARE_PARSER || persist == SA_SHARE_PERMANENT) 165857b448deSdougm strictness = SA_CHECK_STRICT; 16596185db85Sdougm 1660549ec3ffSdougm handle = sa_find_group_handle(group); 1661549ec3ffSdougm 1662da6c28aaSamw /* 1663da6c28aaSamw * need to determine if the share is valid. The rules are: 1664da6c28aaSamw * - The path must not already exist 1665da6c28aaSamw * - The path must not be a subdir or parent dir of an 1666da6c28aaSamw * existing path unless at least one protocol allows it. 1667da6c28aaSamw * The sub/parent check is done in sa_check_path(). 1668da6c28aaSamw */ 1669da6c28aaSamw 1670da6c28aaSamw if (sa_find_share(handle, sharepath) == NULL) { 1671da6c28aaSamw *error = sa_check_path(group, sharepath, strictness); 1672da6c28aaSamw features = get_all_features(group); 1673da6c28aaSamw switch (*error) { 1674da6c28aaSamw case SA_PATH_IS_SUBDIR: 1675da6c28aaSamw if (features & SA_FEATURE_ALLOWSUBDIRS) 1676da6c28aaSamw special |= SA_FEATURE_ALLOWSUBDIRS; 1677da6c28aaSamw break; 1678da6c28aaSamw case SA_PATH_IS_PARENTDIR: 1679da6c28aaSamw if (features & SA_FEATURE_ALLOWPARDIRS) 1680da6c28aaSamw special |= SA_FEATURE_ALLOWPARDIRS; 1681da6c28aaSamw break; 1682da6c28aaSamw } 1683da6c28aaSamw if (*error == SA_OK || special != SA_FEATURE_NONE) 1684da6c28aaSamw node = _sa_add_share(group, sharepath, persist, 1685da6c28aaSamw error, special); 1686da6c28aaSamw } else { 168757b448deSdougm *error = SA_DUPLICATE_NAME; 1688da6c28aaSamw } 16896185db85Sdougm 16906185db85Sdougm return ((sa_share_t)node); 16916185db85Sdougm } 16926185db85Sdougm 16936185db85Sdougm /* 16946185db85Sdougm * sa_enable_share(share, protocol) 16956185db85Sdougm * Enable the specified share to the specified protocol. 16966185db85Sdougm * If protocol is NULL, then all protocols. 16976185db85Sdougm */ 16986185db85Sdougm int 16996185db85Sdougm sa_enable_share(sa_share_t share, char *protocol) 17006185db85Sdougm { 17016185db85Sdougm char *sharepath; 17026185db85Sdougm struct stat st; 1703da6c28aaSamw int err = SA_OK; 1704da6c28aaSamw int ret; 17056185db85Sdougm 17066185db85Sdougm sharepath = sa_get_share_attr(share, "path"); 1707da6c28aaSamw if (sharepath == NULL) 1708da6c28aaSamw return (SA_NO_MEMORY); 17096185db85Sdougm if (stat(sharepath, &st) < 0) { 171057b448deSdougm err = SA_NO_SUCH_PATH; 17116185db85Sdougm } else { 171257b448deSdougm /* tell the server about the share */ 171357b448deSdougm if (protocol != NULL) { 1714da6c28aaSamw if (excluded_protocol(share, protocol)) 1715da6c28aaSamw goto done; 1716da6c28aaSamw 171757b448deSdougm /* lookup protocol specific handler */ 171857b448deSdougm err = sa_proto_share(protocol, share); 171957b448deSdougm if (err == SA_OK) 1720da6c28aaSamw (void) sa_set_share_attr(share, 1721da6c28aaSamw "shared", "true"); 172257b448deSdougm } else { 1723da6c28aaSamw /* Tell all protocols about the share */ 1724da6c28aaSamw sa_group_t group; 1725da6c28aaSamw sa_optionset_t optionset; 1726da6c28aaSamw 1727da6c28aaSamw group = sa_get_parent_group(share); 1728da6c28aaSamw 1729da6c28aaSamw for (optionset = sa_get_optionset(group, NULL); 1730da6c28aaSamw optionset != NULL; 1731da6c28aaSamw optionset = sa_get_next_optionset(optionset)) { 1732da6c28aaSamw char *proto; 1733da6c28aaSamw proto = sa_get_optionset_attr(optionset, 1734da6c28aaSamw "type"); 1735da6c28aaSamw if (proto != NULL) { 1736da6c28aaSamw if (!excluded_protocol(share, proto)) { 1737da6c28aaSamw ret = sa_proto_share(proto, 1738da6c28aaSamw share); 1739da6c28aaSamw if (ret != SA_OK) 1740da6c28aaSamw err = ret; 1741da6c28aaSamw } 1742da6c28aaSamw sa_free_attr_string(proto); 1743da6c28aaSamw } 1744da6c28aaSamw } 174557b448deSdougm (void) sa_set_share_attr(share, "shared", "true"); 174657b448deSdougm } 17476185db85Sdougm } 1748da6c28aaSamw done: 17496185db85Sdougm if (sharepath != NULL) 175057b448deSdougm sa_free_attr_string(sharepath); 17516185db85Sdougm return (err); 17526185db85Sdougm } 17536185db85Sdougm 17546185db85Sdougm /* 17556185db85Sdougm * sa_disable_share(share, protocol) 1756da6c28aaSamw * Disable the specified share to the specified protocol. If 1757da6c28aaSamw * protocol is NULL, then all protocols that are enabled for the 1758da6c28aaSamw * share should be disabled. 17596185db85Sdougm */ 17606185db85Sdougm int 17616185db85Sdougm sa_disable_share(sa_share_t share, char *protocol) 17626185db85Sdougm { 17636185db85Sdougm char *path; 1764da6c28aaSamw int err = SA_OK; 17656185db85Sdougm int ret = SA_OK; 17666185db85Sdougm 17676185db85Sdougm path = sa_get_share_attr(share, "path"); 17686185db85Sdougm 17696185db85Sdougm if (protocol != NULL) { 1770ecd6cf80Smarks ret = sa_proto_unshare(share, protocol, path); 17716185db85Sdougm } else { 177257b448deSdougm /* need to do all protocols */ 1773da6c28aaSamw sa_group_t group; 1774da6c28aaSamw sa_optionset_t optionset; 1775da6c28aaSamw 1776da6c28aaSamw group = sa_get_parent_group(share); 1777da6c28aaSamw 1778da6c28aaSamw /* Tell all protocols about the share */ 1779da6c28aaSamw for (optionset = sa_get_optionset(group, NULL); 1780da6c28aaSamw optionset != NULL; 1781da6c28aaSamw optionset = sa_get_next_optionset(optionset)) { 1782da6c28aaSamw char *proto; 1783da6c28aaSamw 1784da6c28aaSamw proto = sa_get_optionset_attr(optionset, "type"); 1785da6c28aaSamw if (proto != NULL) { 1786da6c28aaSamw err = sa_proto_unshare(share, proto, path); 1787da6c28aaSamw if (err != SA_OK) 1788da6c28aaSamw ret = err; 1789da6c28aaSamw sa_free_attr_string(proto); 1790da6c28aaSamw } 1791da6c28aaSamw } 17926185db85Sdougm } 17936185db85Sdougm if (ret == SA_OK) 17946185db85Sdougm (void) sa_set_share_attr(share, "shared", NULL); 17956185db85Sdougm if (path != NULL) 179657b448deSdougm sa_free_attr_string(path); 17976185db85Sdougm return (ret); 17986185db85Sdougm } 17996185db85Sdougm 18006185db85Sdougm /* 18016185db85Sdougm * sa_remove_share(share) 18026185db85Sdougm * 18036185db85Sdougm * remove the specified share from its containing group. 18046185db85Sdougm * Remove from the SMF or ZFS configuration space. 18056185db85Sdougm */ 18066185db85Sdougm 18076185db85Sdougm int 18086185db85Sdougm sa_remove_share(sa_share_t share) 18096185db85Sdougm { 18106185db85Sdougm sa_group_t group; 18116185db85Sdougm int ret = SA_OK; 18126185db85Sdougm char *type; 18136185db85Sdougm int transient = 0; 18146185db85Sdougm char *groupname; 18156185db85Sdougm char *zfs; 18166185db85Sdougm 18176185db85Sdougm type = sa_get_share_attr(share, "type"); 18186185db85Sdougm group = sa_get_parent_group(share); 18196185db85Sdougm zfs = sa_get_group_attr(group, "zfs"); 18206185db85Sdougm groupname = sa_get_group_attr(group, "name"); 18216185db85Sdougm if (type != NULL && strcmp(type, "persist") != 0) 182257b448deSdougm transient = 1; 18236185db85Sdougm if (type != NULL) 182457b448deSdougm sa_free_attr_string(type); 18256185db85Sdougm 18266185db85Sdougm /* remove the node from its group then free the memory */ 18276185db85Sdougm 18286185db85Sdougm /* 18296185db85Sdougm * need to test if "busy" 18306185db85Sdougm */ 18316185db85Sdougm /* only do SMF action if permanent */ 18326185db85Sdougm if (!transient || zfs != NULL) { 183357b448deSdougm /* remove from legacy dfstab as well as possible SMF */ 1834da6c28aaSamw ret = sa_delete_legacy(share, NULL); 183557b448deSdougm if (ret == SA_OK) { 183657b448deSdougm if (!sa_group_is_zfs(group)) { 183757b448deSdougm sa_handle_impl_t impl_handle; 183857b448deSdougm impl_handle = (sa_handle_impl_t) 183957b448deSdougm sa_find_group_handle(group); 184057b448deSdougm if (impl_handle != NULL) { 184157b448deSdougm ret = sa_delete_share( 184257b448deSdougm impl_handle->scfhandle, group, 184357b448deSdougm share); 184457b448deSdougm } else { 184557b448deSdougm ret = SA_SYSTEM_ERR; 184657b448deSdougm } 184757b448deSdougm } else { 184857b448deSdougm char *sharepath = sa_get_share_attr(share, 184957b448deSdougm "path"); 185057b448deSdougm if (sharepath != NULL) { 185157b448deSdougm ret = sa_zfs_set_sharenfs(group, 185257b448deSdougm sharepath, 0); 185357b448deSdougm sa_free_attr_string(sharepath); 185457b448deSdougm } 185557b448deSdougm } 18566185db85Sdougm } 18576185db85Sdougm } 18586185db85Sdougm if (groupname != NULL) 185957b448deSdougm sa_free_attr_string(groupname); 18606185db85Sdougm if (zfs != NULL) 186157b448deSdougm sa_free_attr_string(zfs); 18626185db85Sdougm 18636185db85Sdougm xmlUnlinkNode((xmlNodePtr)share); 18646185db85Sdougm xmlFreeNode((xmlNodePtr)share); 18656185db85Sdougm return (ret); 18666185db85Sdougm } 18676185db85Sdougm 18686185db85Sdougm /* 18696185db85Sdougm * sa_move_share(group, share) 18706185db85Sdougm * 18716185db85Sdougm * move the specified share to the specified group. Update SMF 18726185db85Sdougm * appropriately. 18736185db85Sdougm */ 18746185db85Sdougm 18756185db85Sdougm int 18766185db85Sdougm sa_move_share(sa_group_t group, sa_share_t share) 18776185db85Sdougm { 18786185db85Sdougm sa_group_t oldgroup; 18796185db85Sdougm int ret = SA_OK; 18806185db85Sdougm 18816185db85Sdougm /* remove the node from its group then free the memory */ 18826185db85Sdougm 18836185db85Sdougm oldgroup = sa_get_parent_group(share); 18846185db85Sdougm if (oldgroup != group) { 188557b448deSdougm sa_handle_impl_t impl_handle; 188657b448deSdougm xmlUnlinkNode((xmlNodePtr)share); 18876185db85Sdougm /* 188857b448deSdougm * now that the share isn't in its old group, add to 188957b448deSdougm * the new one 18906185db85Sdougm */ 18914bff34e3Sthurlow (void) xmlAddChild((xmlNodePtr)group, (xmlNodePtr)share); 189257b448deSdougm /* need to deal with SMF */ 189357b448deSdougm impl_handle = (sa_handle_impl_t)sa_find_group_handle(group); 189457b448deSdougm if (impl_handle != NULL) { 189557b448deSdougm /* 189657b448deSdougm * need to remove from old group first and then add to 189757b448deSdougm * new group. Ideally, we would do the other order but 189857b448deSdougm * need to avoid having the share in two groups at the 189957b448deSdougm * same time. 190057b448deSdougm */ 190157b448deSdougm ret = sa_delete_share(impl_handle->scfhandle, oldgroup, 190257b448deSdougm share); 190357b448deSdougm if (ret == SA_OK) 190457b448deSdougm ret = sa_commit_share(impl_handle->scfhandle, 190557b448deSdougm group, share); 190657b448deSdougm } else { 190757b448deSdougm ret = SA_SYSTEM_ERR; 190857b448deSdougm } 19096185db85Sdougm } 19106185db85Sdougm return (ret); 19116185db85Sdougm } 19126185db85Sdougm 19136185db85Sdougm /* 19146185db85Sdougm * sa_get_parent_group(share) 19156185db85Sdougm * 1916da6c28aaSamw * Return the containing group for the share. If a group was actually 19176185db85Sdougm * passed in, we don't want a parent so return NULL. 19186185db85Sdougm */ 19196185db85Sdougm 19206185db85Sdougm sa_group_t 19216185db85Sdougm sa_get_parent_group(sa_share_t share) 19226185db85Sdougm { 19236185db85Sdougm xmlNodePtr node = NULL; 19246185db85Sdougm if (share != NULL) { 192557b448deSdougm node = ((xmlNodePtr)share)->parent; 19266185db85Sdougm /* 19276185db85Sdougm * make sure parent is a group and not sharecfg since 19286185db85Sdougm * we may be cheating and passing in a group. 19296185db85Sdougm * Eventually, groups of groups might come into being. 19306185db85Sdougm */ 193157b448deSdougm if (node == NULL || 193257b448deSdougm xmlStrcmp(node->name, (xmlChar *)"sharecfg") == 0) 193357b448deSdougm node = NULL; 19346185db85Sdougm } 19356185db85Sdougm return ((sa_group_t)node); 19366185db85Sdougm } 19376185db85Sdougm 19386185db85Sdougm /* 1939549ec3ffSdougm * _sa_create_group(impl_handle, groupname) 19406185db85Sdougm * 19416185db85Sdougm * Create a group in the document. The caller will need to deal with 19426185db85Sdougm * configuration store and activation. 19436185db85Sdougm */ 19446185db85Sdougm 19456185db85Sdougm sa_group_t 1946549ec3ffSdougm _sa_create_group(sa_handle_impl_t impl_handle, char *groupname) 19476185db85Sdougm { 19486185db85Sdougm xmlNodePtr node = NULL; 19496185db85Sdougm 19506185db85Sdougm if (sa_valid_group_name(groupname)) { 195157b448deSdougm node = xmlNewChild(impl_handle->tree, NULL, (xmlChar *)"group", 195257b448deSdougm NULL); 195357b448deSdougm if (node != NULL) { 19544bff34e3Sthurlow (void) xmlSetProp(node, (xmlChar *)"name", 195557b448deSdougm (xmlChar *)groupname); 19564bff34e3Sthurlow (void) xmlSetProp(node, (xmlChar *)"state", 195757b448deSdougm (xmlChar *)"enabled"); 195857b448deSdougm } 19596185db85Sdougm } 19606185db85Sdougm return ((sa_group_t)node); 19616185db85Sdougm } 19626185db85Sdougm 19636185db85Sdougm /* 19646185db85Sdougm * _sa_create_zfs_group(group, groupname) 19656185db85Sdougm * 19666185db85Sdougm * Create a ZFS subgroup under the specified group. This may 19676185db85Sdougm * eventually form the basis of general sub-groups, but is currently 19686185db85Sdougm * restricted to ZFS. 19696185db85Sdougm */ 19706185db85Sdougm sa_group_t 19716185db85Sdougm _sa_create_zfs_group(sa_group_t group, char *groupname) 19726185db85Sdougm { 19736185db85Sdougm xmlNodePtr node = NULL; 19746185db85Sdougm 197557b448deSdougm node = xmlNewChild((xmlNodePtr)group, NULL, (xmlChar *)"group", NULL); 19766185db85Sdougm if (node != NULL) { 19774bff34e3Sthurlow (void) xmlSetProp(node, (xmlChar *)"name", 19784bff34e3Sthurlow (xmlChar *)groupname); 19794bff34e3Sthurlow (void) xmlSetProp(node, (xmlChar *)"state", 19804bff34e3Sthurlow (xmlChar *)"enabled"); 19816185db85Sdougm } 19826185db85Sdougm 19836185db85Sdougm return ((sa_group_t)node); 19846185db85Sdougm } 19856185db85Sdougm 19866185db85Sdougm /* 19876185db85Sdougm * sa_create_group(groupname, *error) 19886185db85Sdougm * 19896185db85Sdougm * Create a new group with groupname. Need to validate that it is a 19906185db85Sdougm * legal name for SMF and the construct the SMF service instance of 19916185db85Sdougm * svc:/network/shares/group to implement the group. All necessary 19926185db85Sdougm * operational properties must be added to the group at this point 19936185db85Sdougm * (via the SMF transaction model). 19946185db85Sdougm */ 19956185db85Sdougm sa_group_t 1996549ec3ffSdougm sa_create_group(sa_handle_t handle, char *groupname, int *error) 19976185db85Sdougm { 19986185db85Sdougm xmlNodePtr node = NULL; 19996185db85Sdougm sa_group_t group; 20006185db85Sdougm int ret; 200157b448deSdougm char rbacstr[SA_STRSIZE]; 2002549ec3ffSdougm sa_handle_impl_t impl_handle = (sa_handle_impl_t)handle; 20036185db85Sdougm 20046185db85Sdougm ret = SA_OK; 20056185db85Sdougm 2006549ec3ffSdougm if (impl_handle == NULL || impl_handle->scfhandle == NULL) { 200757b448deSdougm ret = SA_SYSTEM_ERR; 200857b448deSdougm goto err; 20096185db85Sdougm } 20106185db85Sdougm 2011549ec3ffSdougm group = sa_get_group(handle, groupname); 20126185db85Sdougm if (group != NULL) { 201357b448deSdougm ret = SA_DUPLICATE_NAME; 20146185db85Sdougm } else { 201557b448deSdougm if (sa_valid_group_name(groupname)) { 201657b448deSdougm node = xmlNewChild(impl_handle->tree, NULL, 201757b448deSdougm (xmlChar *)"group", NULL); 201857b448deSdougm if (node != NULL) { 20194bff34e3Sthurlow (void) xmlSetProp(node, (xmlChar *)"name", 202057b448deSdougm (xmlChar *)groupname); 202157b448deSdougm /* default to the group being enabled */ 20224bff34e3Sthurlow (void) xmlSetProp(node, (xmlChar *)"state", 202357b448deSdougm (xmlChar *)"enabled"); 202457b448deSdougm ret = sa_create_instance(impl_handle->scfhandle, 202557b448deSdougm groupname); 202657b448deSdougm if (ret == SA_OK) { 202757b448deSdougm ret = sa_start_transaction( 202857b448deSdougm impl_handle->scfhandle, 202957b448deSdougm "operation"); 203057b448deSdougm } 203157b448deSdougm if (ret == SA_OK) { 203257b448deSdougm ret = sa_set_property( 203357b448deSdougm impl_handle->scfhandle, 203457b448deSdougm "state", "enabled"); 203557b448deSdougm if (ret == SA_OK) { 203657b448deSdougm ret = sa_end_transaction( 20375b6e0c46Sdougm impl_handle->scfhandle, 20385b6e0c46Sdougm impl_handle); 203957b448deSdougm } else { 204057b448deSdougm sa_abort_transaction( 204157b448deSdougm impl_handle->scfhandle); 204257b448deSdougm } 204357b448deSdougm } 204457b448deSdougm if (ret == SA_OK) { 204557b448deSdougm /* initialize the RBAC strings */ 204657b448deSdougm ret = sa_start_transaction( 204757b448deSdougm impl_handle->scfhandle, 204857b448deSdougm "general"); 204957b448deSdougm if (ret == SA_OK) { 205057b448deSdougm (void) snprintf(rbacstr, 205157b448deSdougm sizeof (rbacstr), "%s.%s", 205257b448deSdougm SA_RBAC_MANAGE, groupname); 205357b448deSdougm ret = sa_set_property( 205457b448deSdougm impl_handle->scfhandle, 20556185db85Sdougm "action_authorization", 20566185db85Sdougm rbacstr); 205757b448deSdougm } 205857b448deSdougm if (ret == SA_OK) { 205957b448deSdougm (void) snprintf(rbacstr, 206057b448deSdougm sizeof (rbacstr), "%s.%s", 206157b448deSdougm SA_RBAC_VALUE, groupname); 206257b448deSdougm ret = sa_set_property( 206357b448deSdougm impl_handle->scfhandle, 20646185db85Sdougm "value_authorization", 20656185db85Sdougm rbacstr); 206657b448deSdougm } 206757b448deSdougm if (ret == SA_OK) { 206857b448deSdougm ret = sa_end_transaction( 20695b6e0c46Sdougm impl_handle->scfhandle, 20705b6e0c46Sdougm impl_handle); 207157b448deSdougm } else { 207257b448deSdougm sa_abort_transaction( 207357b448deSdougm impl_handle->scfhandle); 207457b448deSdougm } 207557b448deSdougm } 207657b448deSdougm if (ret != SA_OK) { 207757b448deSdougm /* 207857b448deSdougm * Couldn't commit the group 207957b448deSdougm * so we need to undo 208057b448deSdougm * internally. 208157b448deSdougm */ 208257b448deSdougm xmlUnlinkNode(node); 208357b448deSdougm xmlFreeNode(node); 208457b448deSdougm node = NULL; 208557b448deSdougm } 20866185db85Sdougm } else { 208757b448deSdougm ret = SA_NO_MEMORY; 20886185db85Sdougm } 20896185db85Sdougm } else { 209057b448deSdougm ret = SA_INVALID_NAME; 20916185db85Sdougm } 20926185db85Sdougm } 20936185db85Sdougm err: 20946185db85Sdougm if (error != NULL) 209557b448deSdougm *error = ret; 20966185db85Sdougm return ((sa_group_t)node); 20976185db85Sdougm } 20986185db85Sdougm 20996185db85Sdougm /* 21006185db85Sdougm * sa_remove_group(group) 21016185db85Sdougm * 21026185db85Sdougm * Remove the specified group. This deletes from the SMF repository. 21036185db85Sdougm * All property groups and properties are removed. 21046185db85Sdougm */ 21056185db85Sdougm 21066185db85Sdougm int 21076185db85Sdougm sa_remove_group(sa_group_t group) 21086185db85Sdougm { 21096185db85Sdougm char *name; 21106185db85Sdougm int ret = SA_OK; 2111549ec3ffSdougm sa_handle_impl_t impl_handle; 21126185db85Sdougm 2113549ec3ffSdougm impl_handle = (sa_handle_impl_t)sa_find_group_handle(group); 2114549ec3ffSdougm if (impl_handle != NULL) { 211557b448deSdougm name = sa_get_group_attr(group, "name"); 211657b448deSdougm if (name != NULL) { 211757b448deSdougm ret = sa_delete_instance(impl_handle->scfhandle, name); 211857b448deSdougm sa_free_attr_string(name); 211957b448deSdougm } 212057b448deSdougm xmlUnlinkNode((xmlNodePtr)group); /* make sure unlinked */ 212157b448deSdougm xmlFreeNode((xmlNodePtr)group); /* now it is gone */ 2122549ec3ffSdougm } else { 212357b448deSdougm ret = SA_SYSTEM_ERR; 21246185db85Sdougm } 21256185db85Sdougm return (ret); 21266185db85Sdougm } 21276185db85Sdougm 21286185db85Sdougm /* 21296185db85Sdougm * sa_update_config() 21306185db85Sdougm * 21316185db85Sdougm * Used to update legacy files that need to be updated in bulk 21326185db85Sdougm * Currently, this is a placeholder and will go away in a future 21336185db85Sdougm * release. 21346185db85Sdougm */ 21356185db85Sdougm 21366185db85Sdougm int 2137549ec3ffSdougm sa_update_config(sa_handle_t handle) 21386185db85Sdougm { 21396185db85Sdougm /* 21406185db85Sdougm * do legacy files first so we can tell when they change. 21416185db85Sdougm * This will go away when we start updating individual records 21426185db85Sdougm * rather than the whole file. 21436185db85Sdougm */ 2144549ec3ffSdougm update_legacy_config(handle); 21456185db85Sdougm return (SA_OK); 21466185db85Sdougm } 21476185db85Sdougm 21486185db85Sdougm /* 21496185db85Sdougm * get_node_attr(node, tag) 21506185db85Sdougm * 2151da6c28aaSamw * Get the specified tag(attribute) if it exists on the node. This is 21526185db85Sdougm * used internally by a number of attribute oriented functions. 21536185db85Sdougm */ 21546185db85Sdougm 21556185db85Sdougm static char * 21566185db85Sdougm get_node_attr(void *nodehdl, char *tag) 21576185db85Sdougm { 21586185db85Sdougm xmlNodePtr node = (xmlNodePtr)nodehdl; 21596185db85Sdougm xmlChar *name = NULL; 21606185db85Sdougm 216157b448deSdougm if (node != NULL) 21626185db85Sdougm name = xmlGetProp(node, (xmlChar *)tag); 21636185db85Sdougm return ((char *)name); 21646185db85Sdougm } 21656185db85Sdougm 21666185db85Sdougm /* 2167fe1c642dSBill Krier * set_node_attr(node, tag) 21686185db85Sdougm * 2169da6c28aaSamw * Set the specified tag(attribute) to the specified value This is 21706185db85Sdougm * used internally by a number of attribute oriented functions. It 21716185db85Sdougm * doesn't update the repository, only the internal document state. 21726185db85Sdougm */ 21736185db85Sdougm 21746185db85Sdougm void 21756185db85Sdougm set_node_attr(void *nodehdl, char *tag, char *value) 21766185db85Sdougm { 21776185db85Sdougm xmlNodePtr node = (xmlNodePtr)nodehdl; 21786185db85Sdougm if (node != NULL && tag != NULL) { 217957b448deSdougm if (value != NULL) 21804bff34e3Sthurlow (void) xmlSetProp(node, (xmlChar *)tag, 21814bff34e3Sthurlow (xmlChar *)value); 218257b448deSdougm else 21834bff34e3Sthurlow (void) xmlUnsetProp(node, (xmlChar *)tag); 21846185db85Sdougm } 21856185db85Sdougm } 21866185db85Sdougm 21876185db85Sdougm /* 21886185db85Sdougm * sa_get_group_attr(group, tag) 21896185db85Sdougm * 21906185db85Sdougm * Get the specied attribute, if defined, for the group. 21916185db85Sdougm */ 21926185db85Sdougm 21936185db85Sdougm char * 21946185db85Sdougm sa_get_group_attr(sa_group_t group, char *tag) 21956185db85Sdougm { 21966185db85Sdougm return (get_node_attr((void *)group, tag)); 21976185db85Sdougm } 21986185db85Sdougm 21996185db85Sdougm /* 22006185db85Sdougm * sa_set_group_attr(group, tag, value) 22016185db85Sdougm * 22026185db85Sdougm * set the specified tag/attribute on the group using value as its 22036185db85Sdougm * value. 22046185db85Sdougm * 22056185db85Sdougm * This will result in setting the property in the SMF repository as 22066185db85Sdougm * well as in the internal document. 22076185db85Sdougm */ 22086185db85Sdougm 22096185db85Sdougm int 22106185db85Sdougm sa_set_group_attr(sa_group_t group, char *tag, char *value) 22116185db85Sdougm { 22126185db85Sdougm int ret; 22136185db85Sdougm char *groupname; 2214549ec3ffSdougm sa_handle_impl_t impl_handle; 22156185db85Sdougm 2216da6c28aaSamw /* 2217da6c28aaSamw * ZFS group/subgroup doesn't need the handle so shortcut. 2218da6c28aaSamw */ 2219da6c28aaSamw if (sa_group_is_zfs(group)) { 2220da6c28aaSamw set_node_attr((void *)group, tag, value); 2221da6c28aaSamw return (SA_OK); 2222da6c28aaSamw } 2223da6c28aaSamw 2224549ec3ffSdougm impl_handle = (sa_handle_impl_t)sa_find_group_handle(group); 2225549ec3ffSdougm if (impl_handle != NULL) { 222657b448deSdougm groupname = sa_get_group_attr(group, "name"); 222757b448deSdougm ret = sa_get_instance(impl_handle->scfhandle, groupname); 2228549ec3ffSdougm if (ret == SA_OK) { 222957b448deSdougm set_node_attr((void *)group, tag, value); 223057b448deSdougm ret = sa_start_transaction(impl_handle->scfhandle, 223157b448deSdougm "operation"); 223257b448deSdougm if (ret == SA_OK) { 223357b448deSdougm ret = sa_set_property(impl_handle->scfhandle, 223457b448deSdougm tag, value); 223557b448deSdougm if (ret == SA_OK) 2236573b0c00Sdougm ret = sa_end_transaction( 22375b6e0c46Sdougm impl_handle->scfhandle, 22385b6e0c46Sdougm impl_handle); 223957b448deSdougm else 224057b448deSdougm sa_abort_transaction( 224157b448deSdougm impl_handle->scfhandle); 224257b448deSdougm } 2243573b0c00Sdougm if (ret == SA_SYSTEM_ERR) 2244573b0c00Sdougm ret = SA_NO_PERMISSION; 22456185db85Sdougm } 224657b448deSdougm if (groupname != NULL) 224757b448deSdougm sa_free_attr_string(groupname); 2248549ec3ffSdougm } else { 224957b448deSdougm ret = SA_SYSTEM_ERR; 22506185db85Sdougm } 22516185db85Sdougm return (ret); 22526185db85Sdougm } 22536185db85Sdougm 22546185db85Sdougm /* 22556185db85Sdougm * sa_get_share_attr(share, tag) 22566185db85Sdougm * 22576185db85Sdougm * Return the value of the tag/attribute set on the specified 22586185db85Sdougm * share. Returns NULL if the tag doesn't exist. 22596185db85Sdougm */ 22606185db85Sdougm 22616185db85Sdougm char * 22626185db85Sdougm sa_get_share_attr(sa_share_t share, char *tag) 22636185db85Sdougm { 22646185db85Sdougm return (get_node_attr((void *)share, tag)); 22656185db85Sdougm } 22666185db85Sdougm 22676185db85Sdougm /* 22686185db85Sdougm * _sa_set_share_description(share, description) 22696185db85Sdougm * 2270da6c28aaSamw * Add a description tag with text contents to the specified share. A 2271da6c28aaSamw * separate XML tag is used rather than a property. This can also be 2272da6c28aaSamw * used with resources. 22736185db85Sdougm */ 22746185db85Sdougm 22756185db85Sdougm xmlNodePtr 2276da6c28aaSamw _sa_set_share_description(void *share, char *content) 22776185db85Sdougm { 22786185db85Sdougm xmlNodePtr node; 227957b448deSdougm node = xmlNewChild((xmlNodePtr)share, NULL, (xmlChar *)"description", 228057b448deSdougm NULL); 22816185db85Sdougm xmlNodeSetContent(node, (xmlChar *)content); 22826185db85Sdougm return (node); 22836185db85Sdougm } 22846185db85Sdougm 22856185db85Sdougm /* 22866185db85Sdougm * sa_set_share_attr(share, tag, value) 22876185db85Sdougm * 22886185db85Sdougm * Set the share attribute specified by tag to the specified value. In 22896185db85Sdougm * the case of "resource", enforce a no duplicates in a group rule. If 22906185db85Sdougm * the share is not transient, commit the changes to the repository 22916185db85Sdougm * else just update the share internally. 22926185db85Sdougm */ 22936185db85Sdougm 22946185db85Sdougm int 22956185db85Sdougm sa_set_share_attr(sa_share_t share, char *tag, char *value) 22966185db85Sdougm { 22976185db85Sdougm sa_group_t group; 22986185db85Sdougm sa_share_t resource; 22996185db85Sdougm int ret = SA_OK; 23006185db85Sdougm 23016185db85Sdougm group = sa_get_parent_group(share); 23026185db85Sdougm 23036185db85Sdougm /* 23046185db85Sdougm * There are some attributes that may have specific 23056185db85Sdougm * restrictions on them. Initially, only "resource" has 23066185db85Sdougm * special meaning that needs to be checked. Only one instance 23076185db85Sdougm * of a resource name may exist within a group. 23086185db85Sdougm */ 23096185db85Sdougm 23106185db85Sdougm if (strcmp(tag, "resource") == 0) { 231157b448deSdougm resource = sa_get_resource(group, value); 231257b448deSdougm if (resource != share && resource != NULL) 231357b448deSdougm ret = SA_DUPLICATE_NAME; 23146185db85Sdougm } 23156185db85Sdougm if (ret == SA_OK) { 231657b448deSdougm set_node_attr((void *)share, tag, value); 231757b448deSdougm if (group != NULL) { 231857b448deSdougm char *type; 231957b448deSdougm /* we can probably optimize this some */ 232057b448deSdougm type = sa_get_share_attr(share, "type"); 232157b448deSdougm if (type == NULL || strcmp(type, "transient") != 0) { 232257b448deSdougm sa_handle_impl_t impl_handle; 232357b448deSdougm impl_handle = 232457b448deSdougm (sa_handle_impl_t)sa_find_group_handle( 232557b448deSdougm group); 232657b448deSdougm if (impl_handle != NULL) { 232757b448deSdougm ret = sa_commit_share( 232857b448deSdougm impl_handle->scfhandle, group, 232957b448deSdougm share); 233057b448deSdougm } else { 233157b448deSdougm ret = SA_SYSTEM_ERR; 233257b448deSdougm } 233357b448deSdougm } 233457b448deSdougm if (type != NULL) 233557b448deSdougm sa_free_attr_string(type); 2336549ec3ffSdougm } 23376185db85Sdougm } 23386185db85Sdougm return (ret); 23396185db85Sdougm } 23406185db85Sdougm 23416185db85Sdougm /* 23426185db85Sdougm * sa_get_property_attr(prop, tag) 23436185db85Sdougm * 23446185db85Sdougm * Get the value of the specified property attribute. Standard 23456185db85Sdougm * attributes are "type" and "value". 23466185db85Sdougm */ 23476185db85Sdougm 23486185db85Sdougm char * 23496185db85Sdougm sa_get_property_attr(sa_property_t prop, char *tag) 23506185db85Sdougm { 23516185db85Sdougm return (get_node_attr((void *)prop, tag)); 23526185db85Sdougm } 23536185db85Sdougm 23546185db85Sdougm /* 23556185db85Sdougm * sa_get_optionset_attr(prop, tag) 23566185db85Sdougm * 23576185db85Sdougm * Get the value of the specified property attribute. Standard 23586185db85Sdougm * attribute is "type". 23596185db85Sdougm */ 23606185db85Sdougm 23616185db85Sdougm char * 23626185db85Sdougm sa_get_optionset_attr(sa_property_t optionset, char *tag) 23636185db85Sdougm { 23646185db85Sdougm return (get_node_attr((void *)optionset, tag)); 23656185db85Sdougm 23666185db85Sdougm } 23676185db85Sdougm 23686185db85Sdougm /* 23696185db85Sdougm * sa_set_optionset_attr(optionset, tag, value) 23706185db85Sdougm * 23716185db85Sdougm * Set the specified attribute(tag) to the specified value on the 23726185db85Sdougm * optionset. 23736185db85Sdougm */ 23746185db85Sdougm 23756185db85Sdougm void 23766185db85Sdougm sa_set_optionset_attr(sa_group_t optionset, char *tag, char *value) 23776185db85Sdougm { 23786185db85Sdougm set_node_attr((void *)optionset, tag, value); 23796185db85Sdougm } 23806185db85Sdougm 23816185db85Sdougm /* 23826185db85Sdougm * sa_free_attr_string(string) 23836185db85Sdougm * 23846185db85Sdougm * Free the string that was returned in one of the sa_get_*_attr() 23856185db85Sdougm * functions. 23866185db85Sdougm */ 23876185db85Sdougm 23886185db85Sdougm void 23896185db85Sdougm sa_free_attr_string(char *string) 23906185db85Sdougm { 23916185db85Sdougm xmlFree((xmlChar *)string); 23926185db85Sdougm } 23936185db85Sdougm 23946185db85Sdougm /* 23956185db85Sdougm * sa_get_optionset(group, proto) 23966185db85Sdougm * 23976185db85Sdougm * Return the optionset, if it exists, that is associated with the 23986185db85Sdougm * specified protocol. 23996185db85Sdougm */ 24006185db85Sdougm 24016185db85Sdougm sa_optionset_t 24026185db85Sdougm sa_get_optionset(void *group, char *proto) 24036185db85Sdougm { 24046185db85Sdougm xmlNodePtr node; 24056185db85Sdougm xmlChar *value = NULL; 24066185db85Sdougm 24076185db85Sdougm for (node = ((xmlNodePtr)group)->children; node != NULL; 240857b448deSdougm node = node->next) { 24096185db85Sdougm if (xmlStrcmp(node->name, (xmlChar *)"optionset") == 0) { 241057b448deSdougm value = xmlGetProp(node, (xmlChar *)"type"); 241157b448deSdougm if (proto != NULL) { 241257b448deSdougm if (value != NULL && 241357b448deSdougm xmlStrcmp(value, (xmlChar *)proto) == 0) { 241457b448deSdougm break; 241557b448deSdougm } 241657b448deSdougm if (value != NULL) { 241757b448deSdougm xmlFree(value); 241857b448deSdougm value = NULL; 241957b448deSdougm } 242057b448deSdougm } else { 242157b448deSdougm break; 24226185db85Sdougm } 24236185db85Sdougm } 24246185db85Sdougm } 24256185db85Sdougm if (value != NULL) 242657b448deSdougm xmlFree(value); 24276185db85Sdougm return ((sa_optionset_t)node); 24286185db85Sdougm } 24296185db85Sdougm 24306185db85Sdougm /* 24316185db85Sdougm * sa_get_next_optionset(optionset) 24326185db85Sdougm * 24336185db85Sdougm * Return the next optionset in the group. NULL if this was the last. 24346185db85Sdougm */ 24356185db85Sdougm 24366185db85Sdougm sa_optionset_t 24376185db85Sdougm sa_get_next_optionset(sa_optionset_t optionset) 24386185db85Sdougm { 24396185db85Sdougm xmlNodePtr node; 24406185db85Sdougm 24416185db85Sdougm for (node = ((xmlNodePtr)optionset)->next; node != NULL; 244257b448deSdougm node = node->next) { 24436185db85Sdougm if (xmlStrcmp(node->name, (xmlChar *)"optionset") == 0) { 24446185db85Sdougm break; 24456185db85Sdougm } 24466185db85Sdougm } 24476185db85Sdougm return ((sa_optionset_t)node); 24486185db85Sdougm } 24496185db85Sdougm 24506185db85Sdougm /* 24516185db85Sdougm * sa_get_security(group, sectype, proto) 24526185db85Sdougm * 24536185db85Sdougm * Return the security optionset. The internal name is a hold over 24546185db85Sdougm * from the implementation and will be changed before the API is 24556185db85Sdougm * finalized. This is really a named optionset that can be negotiated 24566185db85Sdougm * as a group of properties (like NFS security options). 24576185db85Sdougm */ 24586185db85Sdougm 24596185db85Sdougm sa_security_t 24606185db85Sdougm sa_get_security(sa_group_t group, char *sectype, char *proto) 24616185db85Sdougm { 24626185db85Sdougm xmlNodePtr node; 24636185db85Sdougm xmlChar *value = NULL; 24646185db85Sdougm 24656185db85Sdougm for (node = ((xmlNodePtr)group)->children; node != NULL; 246657b448deSdougm node = node->next) { 246757b448deSdougm if (xmlStrcmp(node->name, (xmlChar *)"security") == 0) { 246857b448deSdougm if (proto != NULL) { 246957b448deSdougm value = xmlGetProp(node, (xmlChar *)"type"); 247057b448deSdougm if (value == NULL || 247157b448deSdougm (value != NULL && 247257b448deSdougm xmlStrcmp(value, (xmlChar *)proto) != 0)) { 247357b448deSdougm /* it doesn't match so continue */ 247457b448deSdougm xmlFree(value); 247557b448deSdougm value = NULL; 247657b448deSdougm continue; 247757b448deSdougm } 247857b448deSdougm } 247957b448deSdougm if (value != NULL) { 248057b448deSdougm xmlFree(value); 248157b448deSdougm value = NULL; 248257b448deSdougm } 248357b448deSdougm /* potential match */ 248457b448deSdougm if (sectype != NULL) { 248557b448deSdougm value = xmlGetProp(node, (xmlChar *)"sectype"); 248657b448deSdougm if (value != NULL && 248757b448deSdougm xmlStrcmp(value, (xmlChar *)sectype) == 0) { 248857b448deSdougm break; 248957b448deSdougm } 249057b448deSdougm } else { 249157b448deSdougm break; 249257b448deSdougm } 24936185db85Sdougm } 24946185db85Sdougm if (value != NULL) { 249557b448deSdougm xmlFree(value); 249657b448deSdougm value = NULL; 24976185db85Sdougm } 24986185db85Sdougm } 24996185db85Sdougm if (value != NULL) 250057b448deSdougm xmlFree(value); 25016185db85Sdougm return ((sa_security_t)node); 25026185db85Sdougm } 25036185db85Sdougm 25046185db85Sdougm /* 25056185db85Sdougm * sa_get_next_security(security) 25066185db85Sdougm * 25076185db85Sdougm * Get the next security optionset if one exists. 25086185db85Sdougm */ 25096185db85Sdougm 25106185db85Sdougm sa_security_t 25116185db85Sdougm sa_get_next_security(sa_security_t security) 25126185db85Sdougm { 25136185db85Sdougm xmlNodePtr node; 25146185db85Sdougm 25156185db85Sdougm for (node = ((xmlNodePtr)security)->next; node != NULL; 251657b448deSdougm node = node->next) { 25176185db85Sdougm if (xmlStrcmp(node->name, (xmlChar *)"security") == 0) { 25186185db85Sdougm break; 25196185db85Sdougm } 25206185db85Sdougm } 25216185db85Sdougm return ((sa_security_t)node); 25226185db85Sdougm } 25236185db85Sdougm 25246185db85Sdougm /* 25256185db85Sdougm * sa_get_property(optionset, prop) 25266185db85Sdougm * 25276185db85Sdougm * Get the property object with the name specified in prop from the 25286185db85Sdougm * optionset. 25296185db85Sdougm */ 25306185db85Sdougm 25316185db85Sdougm sa_property_t 25326185db85Sdougm sa_get_property(sa_optionset_t optionset, char *prop) 25336185db85Sdougm { 25346185db85Sdougm xmlNodePtr node = (xmlNodePtr)optionset; 25356185db85Sdougm xmlChar *value = NULL; 25366185db85Sdougm 25376185db85Sdougm if (optionset == NULL) 253857b448deSdougm return (NULL); 25396185db85Sdougm 25406185db85Sdougm for (node = node->children; node != NULL; 254157b448deSdougm node = node->next) { 254257b448deSdougm if (xmlStrcmp(node->name, (xmlChar *)"option") == 0) { 254357b448deSdougm if (prop == NULL) 254457b448deSdougm break; 254557b448deSdougm value = xmlGetProp(node, (xmlChar *)"type"); 254657b448deSdougm if (value != NULL && 254757b448deSdougm xmlStrcmp(value, (xmlChar *)prop) == 0) { 254857b448deSdougm break; 254957b448deSdougm } 255057b448deSdougm if (value != NULL) { 255157b448deSdougm xmlFree(value); 255257b448deSdougm value = NULL; 255357b448deSdougm } 25546185db85Sdougm } 25556185db85Sdougm } 25566185db85Sdougm if (value != NULL) 25576185db85Sdougm xmlFree(value); 25586185db85Sdougm if (node != NULL && xmlStrcmp(node->name, (xmlChar *)"option") != 0) { 255957b448deSdougm /* 256057b448deSdougm * avoid a non option node -- it is possible to be a 256157b448deSdougm * text node 256257b448deSdougm */ 256357b448deSdougm node = NULL; 25646185db85Sdougm } 25656185db85Sdougm return ((sa_property_t)node); 25666185db85Sdougm } 25676185db85Sdougm 25686185db85Sdougm /* 25696185db85Sdougm * sa_get_next_property(property) 25706185db85Sdougm * 25716185db85Sdougm * Get the next property following the specified property. NULL if 25726185db85Sdougm * this was the last. 25736185db85Sdougm */ 25746185db85Sdougm 25756185db85Sdougm sa_property_t 25766185db85Sdougm sa_get_next_property(sa_property_t property) 25776185db85Sdougm { 25786185db85Sdougm xmlNodePtr node; 25796185db85Sdougm 25806185db85Sdougm for (node = ((xmlNodePtr)property)->next; node != NULL; 258157b448deSdougm node = node->next) { 25826185db85Sdougm if (xmlStrcmp(node->name, (xmlChar *)"option") == 0) { 25836185db85Sdougm break; 25846185db85Sdougm } 25856185db85Sdougm } 25866185db85Sdougm return ((sa_property_t)node); 25876185db85Sdougm } 25886185db85Sdougm 25896185db85Sdougm /* 25906185db85Sdougm * sa_set_share_description(share, content) 25916185db85Sdougm * 25926185db85Sdougm * Set the description of share to content. 25936185db85Sdougm */ 25946185db85Sdougm 25956185db85Sdougm int 25966185db85Sdougm sa_set_share_description(sa_share_t share, char *content) 25976185db85Sdougm { 25986185db85Sdougm xmlNodePtr node; 25996185db85Sdougm sa_group_t group; 26006185db85Sdougm int ret = SA_OK; 26016185db85Sdougm 26026185db85Sdougm for (node = ((xmlNodePtr)share)->children; node != NULL; 260357b448deSdougm node = node->next) { 26046185db85Sdougm if (xmlStrcmp(node->name, (xmlChar *)"description") == 0) { 26056185db85Sdougm break; 26066185db85Sdougm } 26076185db85Sdougm } 26086185db85Sdougm /* no existing description but want to add */ 26096185db85Sdougm if (node == NULL && content != NULL) { 26106185db85Sdougm /* add a description */ 261157b448deSdougm node = _sa_set_share_description(share, content); 26126185db85Sdougm } else if (node != NULL && content != NULL) { 26136185db85Sdougm /* update a description */ 26146185db85Sdougm xmlNodeSetContent(node, (xmlChar *)content); 26156185db85Sdougm } else if (node != NULL && content == NULL) { 26166185db85Sdougm /* remove an existing description */ 26176185db85Sdougm xmlUnlinkNode(node); 26186185db85Sdougm xmlFreeNode(node); 26196185db85Sdougm } 2620da6c28aaSamw group = sa_get_parent_group(share); 2621148c5f43SAlan Wright if (group != NULL && 2622148c5f43SAlan Wright sa_is_persistent(share) && (!sa_group_is_zfs(group))) { 262357b448deSdougm sa_handle_impl_t impl_handle; 262457b448deSdougm impl_handle = (sa_handle_impl_t)sa_find_group_handle(group); 262557b448deSdougm if (impl_handle != NULL) { 262657b448deSdougm ret = sa_commit_share(impl_handle->scfhandle, group, 262757b448deSdougm share); 262857b448deSdougm } else { 262957b448deSdougm ret = SA_SYSTEM_ERR; 263057b448deSdougm } 2631549ec3ffSdougm } 26326185db85Sdougm return (ret); 26336185db85Sdougm } 26346185db85Sdougm 26356185db85Sdougm /* 26366185db85Sdougm * fixproblemchars(string) 26376185db85Sdougm * 26386185db85Sdougm * don't want any newline or tab characters in the text since these 26396185db85Sdougm * could break display of data and legacy file formats. 26406185db85Sdougm */ 26416185db85Sdougm static void 26426185db85Sdougm fixproblemchars(char *str) 26436185db85Sdougm { 26446185db85Sdougm int c; 26456185db85Sdougm for (c = *str; c != '\0'; c = *++str) { 264657b448deSdougm if (c == '\t' || c == '\n') 264757b448deSdougm *str = ' '; 264857b448deSdougm else if (c == '"') 264957b448deSdougm *str = '\''; 26506185db85Sdougm } 26516185db85Sdougm } 26526185db85Sdougm 26536185db85Sdougm /* 26546185db85Sdougm * sa_get_share_description(share) 26556185db85Sdougm * 26566185db85Sdougm * Return the description text for the specified share if it 26576185db85Sdougm * exists. NULL if no description exists. 26586185db85Sdougm */ 26596185db85Sdougm 26606185db85Sdougm char * 26616185db85Sdougm sa_get_share_description(sa_share_t share) 26626185db85Sdougm { 26636185db85Sdougm xmlChar *description = NULL; 26646185db85Sdougm xmlNodePtr node; 26656185db85Sdougm 26666185db85Sdougm for (node = ((xmlNodePtr)share)->children; node != NULL; 266757b448deSdougm node = node->next) { 266857b448deSdougm if (xmlStrcmp(node->name, (xmlChar *)"description") == 0) { 266957b448deSdougm break; 267057b448deSdougm } 26716185db85Sdougm } 26726185db85Sdougm if (node != NULL) { 2673da6c28aaSamw description = xmlNodeGetContent(node); 267457b448deSdougm fixproblemchars((char *)description); 26756185db85Sdougm } 26766185db85Sdougm return ((char *)description); 26776185db85Sdougm } 26786185db85Sdougm 26796185db85Sdougm /* 26806185db85Sdougm * sa_free(share_description(description) 26816185db85Sdougm * 26826185db85Sdougm * Free the description string. 26836185db85Sdougm */ 26846185db85Sdougm 26856185db85Sdougm void 26866185db85Sdougm sa_free_share_description(char *description) 26876185db85Sdougm { 26886185db85Sdougm xmlFree((xmlChar *)description); 26896185db85Sdougm } 26906185db85Sdougm 26916185db85Sdougm /* 26926185db85Sdougm * sa_create_optionset(group, proto) 26936185db85Sdougm * 26946185db85Sdougm * Create an optionset for the specified protocol in the specied 26956185db85Sdougm * group. This is manifested as a property group within SMF. 26966185db85Sdougm */ 26976185db85Sdougm 26986185db85Sdougm sa_optionset_t 26996185db85Sdougm sa_create_optionset(sa_group_t group, char *proto) 27006185db85Sdougm { 27016185db85Sdougm sa_optionset_t optionset; 27026185db85Sdougm sa_group_t parent = group; 2703da6c28aaSamw sa_share_t share = NULL; 2704da6c28aaSamw int err = SA_OK; 2705da6c28aaSamw char *id = NULL; 27066185db85Sdougm 27076185db85Sdougm optionset = sa_get_optionset(group, proto); 27086185db85Sdougm if (optionset != NULL) { 27096185db85Sdougm /* can't have a duplicate protocol */ 271057b448deSdougm optionset = NULL; 27116185db85Sdougm } else { 2712da6c28aaSamw /* 2713da6c28aaSamw * Account for resource names being slightly 2714da6c28aaSamw * different. 2715da6c28aaSamw */ 2716da6c28aaSamw if (sa_is_share(group)) { 2717da6c28aaSamw /* 2718da6c28aaSamw * Transient shares do not have an "id" so not an 2719da6c28aaSamw * error to not find one. 2720da6c28aaSamw */ 2721da6c28aaSamw id = sa_get_share_attr((sa_share_t)group, "id"); 2722da6c28aaSamw } else if (sa_is_resource(group)) { 2723da6c28aaSamw share = sa_get_resource_parent( 2724da6c28aaSamw (sa_resource_t)group); 2725da6c28aaSamw id = sa_get_resource_attr(share, "id"); 2726da6c28aaSamw 2727da6c28aaSamw /* id can be NULL if the group is transient (ZFS) */ 2728da6c28aaSamw if (id == NULL && sa_is_persistent(group)) 2729da6c28aaSamw err = SA_NO_MEMORY; 2730da6c28aaSamw } 2731da6c28aaSamw if (err == SA_NO_MEMORY) { 2732da6c28aaSamw /* 2733da6c28aaSamw * Couldn't get the id for the share or 2734da6c28aaSamw * resource. While this could be a 2735da6c28aaSamw * configuration issue, it is most likely an 2736da6c28aaSamw * out of memory. In any case, fail the create. 2737da6c28aaSamw */ 2738da6c28aaSamw return (NULL); 2739da6c28aaSamw } 2740da6c28aaSamw 274157b448deSdougm optionset = (sa_optionset_t)xmlNewChild((xmlNodePtr)group, 274257b448deSdougm NULL, (xmlChar *)"optionset", NULL); 27436185db85Sdougm /* 27446185db85Sdougm * only put to repository if on a group and we were 27456185db85Sdougm * able to create an optionset. 27466185db85Sdougm */ 274757b448deSdougm if (optionset != NULL) { 274857b448deSdougm char oname[SA_STRSIZE]; 274957b448deSdougm char *groupname; 27506185db85Sdougm 2751da6c28aaSamw /* 2752da6c28aaSamw * Need to get parent group in all cases, but also get 2753da6c28aaSamw * the share if this is a resource. 2754da6c28aaSamw */ 2755da6c28aaSamw if (sa_is_share(group)) { 275657b448deSdougm parent = sa_get_parent_group((sa_share_t)group); 2757da6c28aaSamw } else if (sa_is_resource(group)) { 2758da6c28aaSamw share = sa_get_resource_parent( 2759da6c28aaSamw (sa_resource_t)group); 2760da6c28aaSamw parent = sa_get_parent_group(share); 2761da6c28aaSamw } 27626185db85Sdougm 276357b448deSdougm sa_set_optionset_attr(optionset, "type", proto); 27646185db85Sdougm 276557b448deSdougm (void) sa_optionset_name(optionset, oname, 276657b448deSdougm sizeof (oname), id); 276757b448deSdougm groupname = sa_get_group_attr(parent, "name"); 2768da6c28aaSamw if (groupname != NULL && sa_is_persistent(group)) { 276957b448deSdougm sa_handle_impl_t impl_handle; 2770da6c28aaSamw impl_handle = 2771da6c28aaSamw (sa_handle_impl_t)sa_find_group_handle( 2772da6c28aaSamw group); 277357b448deSdougm assert(impl_handle != NULL); 277457b448deSdougm if (impl_handle != NULL) { 277557b448deSdougm (void) sa_get_instance( 2776da6c28aaSamw impl_handle->scfhandle, groupname); 277757b448deSdougm (void) sa_create_pgroup( 277857b448deSdougm impl_handle->scfhandle, oname); 277957b448deSdougm } 278057b448deSdougm } 278157b448deSdougm if (groupname != NULL) 278257b448deSdougm sa_free_attr_string(groupname); 27836185db85Sdougm } 27846185db85Sdougm } 2785da6c28aaSamw 2786da6c28aaSamw if (id != NULL) 2787da6c28aaSamw sa_free_attr_string(id); 27886185db85Sdougm return (optionset); 27896185db85Sdougm } 27906185db85Sdougm 27916185db85Sdougm /* 27926185db85Sdougm * sa_get_property_parent(property) 27936185db85Sdougm * 27946185db85Sdougm * Given a property, return the object it is a property of. This will 27956185db85Sdougm * be an optionset of some type. 27966185db85Sdougm */ 27976185db85Sdougm 27986185db85Sdougm static sa_optionset_t 27996185db85Sdougm sa_get_property_parent(sa_property_t property) 28006185db85Sdougm { 28016185db85Sdougm xmlNodePtr node = NULL; 28026185db85Sdougm 280357b448deSdougm if (property != NULL) 280457b448deSdougm node = ((xmlNodePtr)property)->parent; 28056185db85Sdougm return ((sa_optionset_t)node); 28066185db85Sdougm } 28076185db85Sdougm 28086185db85Sdougm /* 28096185db85Sdougm * sa_get_optionset_parent(optionset) 28106185db85Sdougm * 28116185db85Sdougm * Return the parent of the specified optionset. This could be a group 28126185db85Sdougm * or a share. 28136185db85Sdougm */ 28146185db85Sdougm 28156185db85Sdougm static sa_group_t 28166185db85Sdougm sa_get_optionset_parent(sa_optionset_t optionset) 28176185db85Sdougm { 28186185db85Sdougm xmlNodePtr node = NULL; 28196185db85Sdougm 282057b448deSdougm if (optionset != NULL) 282157b448deSdougm node = ((xmlNodePtr)optionset)->parent; 28226185db85Sdougm return ((sa_group_t)node); 28236185db85Sdougm } 28246185db85Sdougm 28256185db85Sdougm /* 28266185db85Sdougm * zfs_needs_update(share) 28276185db85Sdougm * 28286185db85Sdougm * In order to avoid making multiple updates to a ZFS share when 28296185db85Sdougm * setting properties, the share attribute "changed" will be set to 2830da6c28aaSamw * true when a property is added or modified. When done adding 28316185db85Sdougm * properties, we can then detect that an update is needed. We then 28326185db85Sdougm * clear the state here to detect additional changes. 28336185db85Sdougm */ 28346185db85Sdougm 28356185db85Sdougm static int 28366185db85Sdougm zfs_needs_update(sa_share_t share) 28376185db85Sdougm { 28386185db85Sdougm char *attr; 28396185db85Sdougm int result = 0; 28406185db85Sdougm 28416185db85Sdougm attr = sa_get_share_attr(share, "changed"); 28426185db85Sdougm if (attr != NULL) { 284357b448deSdougm sa_free_attr_string(attr); 28446185db85Sdougm result = 1; 28456185db85Sdougm } 28466185db85Sdougm set_node_attr((void *)share, "changed", NULL); 28476185db85Sdougm return (result); 28486185db85Sdougm } 28496185db85Sdougm 28506185db85Sdougm /* 28516185db85Sdougm * zfs_set_update(share) 28526185db85Sdougm * 28536185db85Sdougm * Set the changed attribute of the share to true. 28546185db85Sdougm */ 28556185db85Sdougm 28566185db85Sdougm static void 28576185db85Sdougm zfs_set_update(sa_share_t share) 28586185db85Sdougm { 28596185db85Sdougm set_node_attr((void *)share, "changed", "true"); 28606185db85Sdougm } 28616185db85Sdougm 28626185db85Sdougm /* 28636185db85Sdougm * sa_commit_properties(optionset, clear) 28646185db85Sdougm * 28656185db85Sdougm * Check if SMF or ZFS config and either update or abort the pending 28666185db85Sdougm * changes. 28676185db85Sdougm */ 28686185db85Sdougm 28696185db85Sdougm int 28706185db85Sdougm sa_commit_properties(sa_optionset_t optionset, int clear) 28716185db85Sdougm { 28726185db85Sdougm sa_group_t group; 28736185db85Sdougm sa_group_t parent; 28746185db85Sdougm int zfs = 0; 28756185db85Sdougm int needsupdate = 0; 28766185db85Sdougm int ret = SA_OK; 2877549ec3ffSdougm sa_handle_impl_t impl_handle; 28786185db85Sdougm 28796185db85Sdougm group = sa_get_optionset_parent(optionset); 28806185db85Sdougm if (group != NULL && (sa_is_share(group) || is_zfs_group(group))) { 288157b448deSdougm /* only update ZFS if on a share */ 288257b448deSdougm parent = sa_get_parent_group(group); 288357b448deSdougm zfs++; 288457b448deSdougm if (parent != NULL && is_zfs_group(parent)) 288557b448deSdougm needsupdate = zfs_needs_update(group); 288657b448deSdougm else 288757b448deSdougm zfs = 0; 28886185db85Sdougm } 28896185db85Sdougm if (zfs) { 289057b448deSdougm if (!clear && needsupdate) 289157b448deSdougm ret = sa_zfs_update((sa_share_t)group); 28926185db85Sdougm } else { 289357b448deSdougm impl_handle = (sa_handle_impl_t)sa_find_group_handle(group); 289457b448deSdougm if (impl_handle != NULL) { 289557b448deSdougm if (clear) { 289657b448deSdougm (void) sa_abort_transaction( 289757b448deSdougm impl_handle->scfhandle); 289857b448deSdougm } else { 289957b448deSdougm ret = sa_end_transaction( 29005b6e0c46Sdougm impl_handle->scfhandle, impl_handle); 290157b448deSdougm } 290257b448deSdougm } else { 290357b448deSdougm ret = SA_SYSTEM_ERR; 290457b448deSdougm } 29056185db85Sdougm } 29066185db85Sdougm return (ret); 29076185db85Sdougm } 29086185db85Sdougm 29096185db85Sdougm /* 29106185db85Sdougm * sa_destroy_optionset(optionset) 29116185db85Sdougm * 2912da6c28aaSamw * Remove the optionset from its group. Update the repository to 29136185db85Sdougm * reflect this change. 29146185db85Sdougm */ 29156185db85Sdougm 29166185db85Sdougm int 29176185db85Sdougm sa_destroy_optionset(sa_optionset_t optionset) 29186185db85Sdougm { 291957b448deSdougm char name[SA_STRSIZE]; 29206185db85Sdougm int len; 29216185db85Sdougm int ret; 29226185db85Sdougm char *id = NULL; 29236185db85Sdougm sa_group_t group; 29246185db85Sdougm int ispersist = 1; 29256185db85Sdougm 29266185db85Sdougm /* now delete the prop group */ 29276185db85Sdougm group = sa_get_optionset_parent(optionset); 2928da6c28aaSamw if (group != NULL) { 2929da6c28aaSamw if (sa_is_resource(group)) { 2930da6c28aaSamw sa_resource_t resource = group; 2931da6c28aaSamw sa_share_t share = sa_get_resource_parent(resource); 2932da6c28aaSamw group = sa_get_parent_group(share); 2933da6c28aaSamw id = sa_get_share_attr(share, "id"); 2934da6c28aaSamw } else if (sa_is_share(group)) { 2935da6c28aaSamw id = sa_get_share_attr((sa_share_t)group, "id"); 2936da6c28aaSamw } 2937da6c28aaSamw ispersist = sa_is_persistent(group); 29386185db85Sdougm } 29396185db85Sdougm if (ispersist) { 294057b448deSdougm sa_handle_impl_t impl_handle; 294157b448deSdougm len = sa_optionset_name(optionset, name, sizeof (name), id); 294257b448deSdougm impl_handle = (sa_handle_impl_t)sa_find_group_handle(group); 294357b448deSdougm if (impl_handle != NULL) { 294457b448deSdougm if (len > 0) { 294557b448deSdougm ret = sa_delete_pgroup(impl_handle->scfhandle, 294657b448deSdougm name); 294757b448deSdougm } 294857b448deSdougm } else { 294957b448deSdougm ret = SA_SYSTEM_ERR; 2950549ec3ffSdougm } 29516185db85Sdougm } 29526185db85Sdougm xmlUnlinkNode((xmlNodePtr)optionset); 29536185db85Sdougm xmlFreeNode((xmlNodePtr)optionset); 29546185db85Sdougm if (id != NULL) 295557b448deSdougm sa_free_attr_string(id); 29566185db85Sdougm return (ret); 29576185db85Sdougm } 29586185db85Sdougm 29596185db85Sdougm /* private to the implementation */ 29606185db85Sdougm int 29616185db85Sdougm _sa_remove_optionset(sa_optionset_t optionset) 29626185db85Sdougm { 29636185db85Sdougm int ret = SA_OK; 29646185db85Sdougm 29656185db85Sdougm xmlUnlinkNode((xmlNodePtr)optionset); 29666185db85Sdougm xmlFreeNode((xmlNodePtr)optionset); 29676185db85Sdougm return (ret); 29686185db85Sdougm } 29696185db85Sdougm 29706185db85Sdougm /* 29716185db85Sdougm * sa_create_security(group, sectype, proto) 29726185db85Sdougm * 29736185db85Sdougm * Create a security optionset (one that has a type name and a 29746185db85Sdougm * proto). Security is left over from a pure NFS implementation. The 29756185db85Sdougm * naming will change in the future when the API is released. 29766185db85Sdougm */ 29776185db85Sdougm sa_security_t 29786185db85Sdougm sa_create_security(sa_group_t group, char *sectype, char *proto) 29796185db85Sdougm { 29806185db85Sdougm sa_security_t security; 29816185db85Sdougm char *id = NULL; 29826185db85Sdougm sa_group_t parent; 29836185db85Sdougm char *groupname = NULL; 29846185db85Sdougm 29856185db85Sdougm if (group != NULL && sa_is_share(group)) { 298657b448deSdougm id = sa_get_share_attr((sa_share_t)group, "id"); 298757b448deSdougm parent = sa_get_parent_group(group); 298857b448deSdougm if (parent != NULL) 298957b448deSdougm groupname = sa_get_group_attr(parent, "name"); 29906185db85Sdougm } else if (group != NULL) { 299157b448deSdougm groupname = sa_get_group_attr(group, "name"); 29926185db85Sdougm } 29936185db85Sdougm 29946185db85Sdougm security = sa_get_security(group, sectype, proto); 29956185db85Sdougm if (security != NULL) { 29966185db85Sdougm /* can't have a duplicate security option */ 29976185db85Sdougm security = NULL; 29986185db85Sdougm } else { 29996185db85Sdougm security = (sa_security_t)xmlNewChild((xmlNodePtr)group, 300057b448deSdougm NULL, (xmlChar *)"security", NULL); 30016185db85Sdougm if (security != NULL) { 300257b448deSdougm char oname[SA_STRSIZE]; 30036185db85Sdougm sa_set_security_attr(security, "type", proto); 30046185db85Sdougm 30056185db85Sdougm sa_set_security_attr(security, "sectype", sectype); 30066185db85Sdougm (void) sa_security_name(security, oname, 300757b448deSdougm sizeof (oname), id); 3008da6c28aaSamw if (groupname != NULL && sa_is_persistent(group)) { 300957b448deSdougm sa_handle_impl_t impl_handle; 301057b448deSdougm impl_handle = 301157b448deSdougm (sa_handle_impl_t)sa_find_group_handle( 301257b448deSdougm group); 301357b448deSdougm if (impl_handle != NULL) { 301457b448deSdougm (void) sa_get_instance( 301557b448deSdougm impl_handle->scfhandle, groupname); 301657b448deSdougm (void) sa_create_pgroup( 301757b448deSdougm impl_handle->scfhandle, oname); 301857b448deSdougm } 30196185db85Sdougm } 30206185db85Sdougm } 30216185db85Sdougm } 3022fe1c642dSBill Krier if (id != NULL) 3023fe1c642dSBill Krier sa_free_attr_string(id); 30246185db85Sdougm if (groupname != NULL) 302557b448deSdougm sa_free_attr_string(groupname); 30266185db85Sdougm return (security); 30276185db85Sdougm } 30286185db85Sdougm 30296185db85Sdougm /* 30306185db85Sdougm * sa_destroy_security(security) 30316185db85Sdougm * 30326185db85Sdougm * Remove the specified optionset from the document and the 30336185db85Sdougm * configuration. 30346185db85Sdougm */ 30356185db85Sdougm 30366185db85Sdougm int 30376185db85Sdougm sa_destroy_security(sa_security_t security) 30386185db85Sdougm { 303957b448deSdougm char name[SA_STRSIZE]; 30406185db85Sdougm int len; 30416185db85Sdougm int ret = SA_OK; 30426185db85Sdougm char *id = NULL; 30436185db85Sdougm sa_group_t group; 30446185db85Sdougm int iszfs = 0; 30456185db85Sdougm int ispersist = 1; 30466185db85Sdougm 30476185db85Sdougm group = sa_get_optionset_parent(security); 30486185db85Sdougm 30496185db85Sdougm if (group != NULL) 305057b448deSdougm iszfs = sa_group_is_zfs(group); 30516185db85Sdougm 30526185db85Sdougm if (group != NULL && !iszfs) { 305357b448deSdougm if (sa_is_share(group)) 3054da6c28aaSamw ispersist = sa_is_persistent(group); 305557b448deSdougm id = sa_get_share_attr((sa_share_t)group, "id"); 30566185db85Sdougm } 30576185db85Sdougm if (ispersist) { 305857b448deSdougm len = sa_security_name(security, name, sizeof (name), id); 305957b448deSdougm if (!iszfs && len > 0) { 306057b448deSdougm sa_handle_impl_t impl_handle; 306157b448deSdougm impl_handle = 306257b448deSdougm (sa_handle_impl_t)sa_find_group_handle(group); 306357b448deSdougm if (impl_handle != NULL) { 306457b448deSdougm ret = sa_delete_pgroup(impl_handle->scfhandle, 306557b448deSdougm name); 306657b448deSdougm } else { 306757b448deSdougm ret = SA_SYSTEM_ERR; 306857b448deSdougm } 3069549ec3ffSdougm } 30706185db85Sdougm } 30716185db85Sdougm xmlUnlinkNode((xmlNodePtr)security); 30726185db85Sdougm xmlFreeNode((xmlNodePtr)security); 307357b448deSdougm if (iszfs) 307457b448deSdougm ret = sa_zfs_update(group); 30756185db85Sdougm if (id != NULL) 307657b448deSdougm sa_free_attr_string(id); 30776185db85Sdougm return (ret); 30786185db85Sdougm } 30796185db85Sdougm 30806185db85Sdougm /* 30816185db85Sdougm * sa_get_security_attr(optionset, tag) 30826185db85Sdougm * 30836185db85Sdougm * Return the specified attribute value from the optionset. 30846185db85Sdougm */ 30856185db85Sdougm 30866185db85Sdougm char * 30876185db85Sdougm sa_get_security_attr(sa_property_t optionset, char *tag) 30886185db85Sdougm { 30896185db85Sdougm return (get_node_attr((void *)optionset, tag)); 30906185db85Sdougm 30916185db85Sdougm } 30926185db85Sdougm 30936185db85Sdougm /* 30946185db85Sdougm * sa_set_security_attr(optionset, tag, value) 30956185db85Sdougm * 30966185db85Sdougm * Set the optioset attribute specied by tag to the specified value. 30976185db85Sdougm */ 30986185db85Sdougm 30996185db85Sdougm void 31006185db85Sdougm sa_set_security_attr(sa_group_t optionset, char *tag, char *value) 31016185db85Sdougm { 31026185db85Sdougm set_node_attr((void *)optionset, tag, value); 31036185db85Sdougm } 31046185db85Sdougm 31056185db85Sdougm /* 31066185db85Sdougm * is_nodetype(node, type) 31076185db85Sdougm * 31086185db85Sdougm * Check to see if node is of the type specified. 31096185db85Sdougm */ 31106185db85Sdougm 31116185db85Sdougm static int 31126185db85Sdougm is_nodetype(void *node, char *type) 31136185db85Sdougm { 31146185db85Sdougm return (strcmp((char *)((xmlNodePtr)node)->name, type) == 0); 31156185db85Sdougm } 31166185db85Sdougm 311757b448deSdougm /* 311857b448deSdougm * add_or_update() 311957b448deSdougm * 312057b448deSdougm * Add or update a property. Pulled out of sa_set_prop_by_prop for 312157b448deSdougm * readability. 312257b448deSdougm */ 312357b448deSdougm static int 312457b448deSdougm add_or_update(scfutilhandle_t *scf_handle, int type, scf_value_t *value, 312557b448deSdougm scf_transaction_entry_t *entry, char *name, char *valstr) 312657b448deSdougm { 312757b448deSdougm int ret = SA_SYSTEM_ERR; 312857b448deSdougm 312957b448deSdougm if (value != NULL) { 313057b448deSdougm if (type == SA_PROP_OP_ADD) 313157b448deSdougm ret = scf_transaction_property_new(scf_handle->trans, 313257b448deSdougm entry, name, SCF_TYPE_ASTRING); 313357b448deSdougm else 313457b448deSdougm ret = scf_transaction_property_change(scf_handle->trans, 313557b448deSdougm entry, name, SCF_TYPE_ASTRING); 313657b448deSdougm if (ret == 0) { 313757b448deSdougm ret = scf_value_set_astring(value, valstr); 313857b448deSdougm if (ret == 0) 313957b448deSdougm ret = scf_entry_add_value(entry, value); 314057b448deSdougm if (ret == 0) 314157b448deSdougm return (ret); 314257b448deSdougm scf_value_destroy(value); 314357b448deSdougm } else { 314457b448deSdougm scf_entry_destroy(entry); 314557b448deSdougm } 314657b448deSdougm } 314757b448deSdougm return (SA_SYSTEM_ERR); 314857b448deSdougm } 314957b448deSdougm 31506185db85Sdougm /* 31516185db85Sdougm * sa_set_prop_by_prop(optionset, group, prop, type) 31526185db85Sdougm * 31536185db85Sdougm * Add/remove/update the specified property prop into the optionset or 31546185db85Sdougm * share. If a share, sort out which property group based on GUID. In 31556185db85Sdougm * all cases, the appropriate transaction is set (or ZFS share is 31566185db85Sdougm * marked as needing an update) 31576185db85Sdougm */ 31586185db85Sdougm 31596185db85Sdougm static int 31606185db85Sdougm sa_set_prop_by_prop(sa_optionset_t optionset, sa_group_t group, 31618a981c33SDaniel Hoffman sa_property_t prop, int type) 31626185db85Sdougm { 31636185db85Sdougm char *name; 31646185db85Sdougm char *valstr; 31656185db85Sdougm int ret = SA_OK; 31666185db85Sdougm scf_transaction_entry_t *entry; 31676185db85Sdougm scf_value_t *value; 31686185db85Sdougm int opttype; /* 1 == optionset, 0 == security */ 31696185db85Sdougm char *id = NULL; 31706185db85Sdougm int iszfs = 0; 31716185db85Sdougm sa_group_t parent = NULL; 3172da6c28aaSamw sa_share_t share = NULL; 3173549ec3ffSdougm sa_handle_impl_t impl_handle; 3174549ec3ffSdougm scfutilhandle_t *scf_handle; 31756185db85Sdougm 3176da6c28aaSamw if (!sa_is_persistent(group)) { 31776185db85Sdougm /* 31786185db85Sdougm * if the group/share is not persistent we don't need 31796185db85Sdougm * to do anything here 31806185db85Sdougm */ 318157b448deSdougm return (SA_OK); 31826185db85Sdougm } 3183549ec3ffSdougm impl_handle = (sa_handle_impl_t)sa_find_group_handle(group); 318457b448deSdougm if (impl_handle == NULL || impl_handle->scfhandle == NULL) 318557b448deSdougm return (SA_SYSTEM_ERR); 3186549ec3ffSdougm scf_handle = impl_handle->scfhandle; 31876185db85Sdougm name = sa_get_property_attr(prop, "type"); 31886185db85Sdougm valstr = sa_get_property_attr(prop, "value"); 31896185db85Sdougm entry = scf_entry_create(scf_handle->handle); 31906185db85Sdougm opttype = is_nodetype((void *)optionset, "optionset"); 31916185db85Sdougm 3192da6c28aaSamw /* 3193da6c28aaSamw * Check for share vs. resource since they need slightly 3194da6c28aaSamw * different treatment given the hierarchy. 3195da6c28aaSamw */ 31966185db85Sdougm if (valstr != NULL && entry != NULL) { 319757b448deSdougm if (sa_is_share(group)) { 319857b448deSdougm parent = sa_get_parent_group(group); 3199da6c28aaSamw share = (sa_share_t)group; 320057b448deSdougm if (parent != NULL) 320157b448deSdougm iszfs = is_zfs_group(parent); 3202da6c28aaSamw } else if (sa_is_resource(group)) { 3203da6c28aaSamw share = sa_get_parent_group(group); 3204da6c28aaSamw if (share != NULL) 3205da6c28aaSamw parent = sa_get_parent_group(share); 320657b448deSdougm } else { 320757b448deSdougm iszfs = is_zfs_group(group); 32086185db85Sdougm } 320957b448deSdougm if (!iszfs) { 321057b448deSdougm if (scf_handle->trans == NULL) { 321157b448deSdougm char oname[SA_STRSIZE]; 321257b448deSdougm char *groupname = NULL; 3213da6c28aaSamw if (share != NULL) { 3214da6c28aaSamw if (parent != NULL) 321557b448deSdougm groupname = 321657b448deSdougm sa_get_group_attr(parent, 321757b448deSdougm "name"); 3218da6c28aaSamw id = sa_get_share_attr( 3219da6c28aaSamw (sa_share_t)share, "id"); 3220549ec3ffSdougm } else { 322157b448deSdougm groupname = sa_get_group_attr(group, 322257b448deSdougm "name"); 32236185db85Sdougm } 322457b448deSdougm if (groupname != NULL) { 322557b448deSdougm ret = sa_get_instance(scf_handle, 322657b448deSdougm groupname); 322757b448deSdougm sa_free_attr_string(groupname); 322857b448deSdougm } 322957b448deSdougm if (opttype) 323057b448deSdougm (void) sa_optionset_name(optionset, 323157b448deSdougm oname, sizeof (oname), id); 323257b448deSdougm else 323357b448deSdougm (void) sa_security_name(optionset, 323457b448deSdougm oname, sizeof (oname), id); 323557b448deSdougm ret = sa_start_transaction(scf_handle, oname); 3236fe1c642dSBill Krier if (id != NULL) 3237fe1c642dSBill Krier sa_free_attr_string(id); 32386185db85Sdougm } 323957b448deSdougm if (ret == SA_OK) { 324057b448deSdougm switch (type) { 324157b448deSdougm case SA_PROP_OP_REMOVE: 324257b448deSdougm ret = scf_transaction_property_delete( 324357b448deSdougm scf_handle->trans, entry, name); 324457b448deSdougm break; 324557b448deSdougm case SA_PROP_OP_ADD: 324657b448deSdougm case SA_PROP_OP_UPDATE: 324757b448deSdougm value = scf_value_create( 324857b448deSdougm scf_handle->handle); 324957b448deSdougm ret = add_or_update(scf_handle, type, 325057b448deSdougm value, entry, name, valstr); 325157b448deSdougm break; 325257b448deSdougm } 325357b448deSdougm } 325457b448deSdougm } else { 325557b448deSdougm /* 325657b448deSdougm * ZFS update. The calling function would have updated 325757b448deSdougm * the internal XML structure. Just need to flag it as 325857b448deSdougm * changed for ZFS. 325957b448deSdougm */ 326057b448deSdougm zfs_set_update((sa_share_t)group); 326157b448deSdougm } 32626185db85Sdougm } 32636185db85Sdougm 32646185db85Sdougm if (name != NULL) 326557b448deSdougm sa_free_attr_string(name); 32666185db85Sdougm if (valstr != NULL) 326757b448deSdougm sa_free_attr_string(valstr); 32686185db85Sdougm else if (entry != NULL) 326957b448deSdougm scf_entry_destroy(entry); 32706185db85Sdougm 32716185db85Sdougm if (ret == -1) 327257b448deSdougm ret = SA_SYSTEM_ERR; 32736185db85Sdougm 32746185db85Sdougm return (ret); 32756185db85Sdougm } 32766185db85Sdougm 32776185db85Sdougm /* 32784bff34e3Sthurlow * sa_create_section(name, value) 32794bff34e3Sthurlow * 32804bff34e3Sthurlow * Create a new section with the specified name and extra data. 32814bff34e3Sthurlow */ 32824bff34e3Sthurlow 32834bff34e3Sthurlow sa_property_t 32844bff34e3Sthurlow sa_create_section(char *name, char *extra) 32854bff34e3Sthurlow { 32864bff34e3Sthurlow xmlNodePtr node; 32874bff34e3Sthurlow 32884bff34e3Sthurlow node = xmlNewNode(NULL, (xmlChar *)"section"); 32894bff34e3Sthurlow if (node != NULL) { 32904bff34e3Sthurlow if (name != NULL) 32914bff34e3Sthurlow (void) xmlSetProp(node, (xmlChar *)"name", 32924bff34e3Sthurlow (xmlChar *)name); 32934bff34e3Sthurlow if (extra != NULL) 32944bff34e3Sthurlow (void) xmlSetProp(node, (xmlChar *)"extra", 32954bff34e3Sthurlow (xmlChar *)extra); 32964bff34e3Sthurlow } 32974bff34e3Sthurlow return ((sa_property_t)node); 32984bff34e3Sthurlow } 32994bff34e3Sthurlow 33004bff34e3Sthurlow void 33014bff34e3Sthurlow sa_set_section_attr(sa_property_t sect, char *name, char *value) 33024bff34e3Sthurlow { 33034bff34e3Sthurlow (void) xmlSetProp(sect, (xmlChar *)name, (xmlChar *)value); 33044bff34e3Sthurlow } 33054bff34e3Sthurlow 33064bff34e3Sthurlow /* 33074bff34e3Sthurlow * sa_create_property(section, name, value) 33086185db85Sdougm * 33096185db85Sdougm * Create a new property with the specified name and value. 33106185db85Sdougm */ 33116185db85Sdougm 33126185db85Sdougm sa_property_t 33136185db85Sdougm sa_create_property(char *name, char *value) 33146185db85Sdougm { 33156185db85Sdougm xmlNodePtr node; 33166185db85Sdougm 33176185db85Sdougm node = xmlNewNode(NULL, (xmlChar *)"option"); 33186185db85Sdougm if (node != NULL) { 33194bff34e3Sthurlow (void) xmlSetProp(node, (xmlChar *)"type", (xmlChar *)name); 33204bff34e3Sthurlow (void) xmlSetProp(node, (xmlChar *)"value", (xmlChar *)value); 33216185db85Sdougm } 33226185db85Sdougm return ((sa_property_t)node); 33236185db85Sdougm } 33246185db85Sdougm 33256185db85Sdougm /* 33266185db85Sdougm * sa_add_property(object, property) 33276185db85Sdougm * 33286185db85Sdougm * Add the specified property to the object. Issue the appropriate 33296185db85Sdougm * transaction or mark a ZFS object as needing an update. 33306185db85Sdougm */ 33316185db85Sdougm 33326185db85Sdougm int 33336185db85Sdougm sa_add_property(void *object, sa_property_t property) 33346185db85Sdougm { 33356185db85Sdougm int ret = SA_OK; 33366185db85Sdougm sa_group_t parent; 33376185db85Sdougm sa_group_t group; 33386185db85Sdougm char *proto; 33396185db85Sdougm 33406185db85Sdougm if (property != NULL) { 33413b61b335Sdougm sa_handle_t handle; 3342687915e9Sdougm handle = sa_find_group_handle((sa_group_t)object); 33433b61b335Sdougm /* It is legitimate to not find a handle */ 3344687915e9Sdougm proto = sa_get_optionset_attr(object, "type"); 3345687915e9Sdougm if ((ret = sa_valid_property(handle, object, proto, 3346687915e9Sdougm property)) == SA_OK) { 334757b448deSdougm property = (sa_property_t)xmlAddChild( 334857b448deSdougm (xmlNodePtr)object, (xmlNodePtr)property); 334957b448deSdougm } else { 335057b448deSdougm if (proto != NULL) 335157b448deSdougm sa_free_attr_string(proto); 335257b448deSdougm return (ret); 335357b448deSdougm } 3354687915e9Sdougm if (proto != NULL) 3355687915e9Sdougm sa_free_attr_string(proto); 33566185db85Sdougm } 33576185db85Sdougm 33586185db85Sdougm 33596185db85Sdougm parent = sa_get_parent_group(object); 3360da6c28aaSamw if (!sa_is_persistent(parent)) 336157b448deSdougm return (ret); 33626185db85Sdougm 3363da6c28aaSamw if (sa_is_resource(parent)) { 3364da6c28aaSamw /* 3365da6c28aaSamw * Resources are children of share. Need to go up two 3366da6c28aaSamw * levels to find the group but the parent needs to be 3367da6c28aaSamw * the share at this point in order to get the "id". 3368da6c28aaSamw */ 3369da6c28aaSamw parent = sa_get_parent_group(parent); 337057b448deSdougm group = sa_get_parent_group(parent); 3371da6c28aaSamw } else if (sa_is_share(parent)) { 3372da6c28aaSamw group = sa_get_parent_group(parent); 3373da6c28aaSamw } else { 337457b448deSdougm group = parent; 3375da6c28aaSamw } 3376549ec3ffSdougm 337757b448deSdougm if (property == NULL) { 337857b448deSdougm ret = SA_NO_MEMORY; 337957b448deSdougm } else { 338057b448deSdougm char oname[SA_STRSIZE]; 338157b448deSdougm 338257b448deSdougm if (!is_zfs_group(group)) { 338357b448deSdougm char *id = NULL; 338457b448deSdougm sa_handle_impl_t impl_handle; 338557b448deSdougm scfutilhandle_t *scf_handle; 338657b448deSdougm 338757b448deSdougm impl_handle = (sa_handle_impl_t)sa_find_group_handle( 338857b448deSdougm group); 338957b448deSdougm if (impl_handle == NULL || 339057b448deSdougm impl_handle->scfhandle == NULL) 339157b448deSdougm ret = SA_SYSTEM_ERR; 339257b448deSdougm if (ret == SA_OK) { 339357b448deSdougm scf_handle = impl_handle->scfhandle; 339457b448deSdougm if (sa_is_share((sa_group_t)parent)) { 339557b448deSdougm id = sa_get_share_attr( 339657b448deSdougm (sa_share_t)parent, "id"); 339757b448deSdougm } 339857b448deSdougm if (scf_handle->trans == NULL) { 339957b448deSdougm if (is_nodetype(object, "optionset")) { 340057b448deSdougm (void) sa_optionset_name( 340157b448deSdougm (sa_optionset_t)object, 340257b448deSdougm oname, sizeof (oname), id); 340357b448deSdougm } else { 340457b448deSdougm (void) sa_security_name( 340557b448deSdougm (sa_optionset_t)object, 340657b448deSdougm oname, sizeof (oname), id); 340757b448deSdougm } 340857b448deSdougm ret = sa_start_transaction(scf_handle, 340957b448deSdougm oname); 341057b448deSdougm } 341157b448deSdougm if (ret == SA_OK) { 341257b448deSdougm char *name; 341357b448deSdougm char *value; 341457b448deSdougm name = sa_get_property_attr(property, 341557b448deSdougm "type"); 341657b448deSdougm value = sa_get_property_attr(property, 341757b448deSdougm "value"); 341857b448deSdougm if (name != NULL && value != NULL) { 341957b448deSdougm if (scf_handle->scf_state == 342057b448deSdougm SCH_STATE_INIT) { 342157b448deSdougm ret = sa_set_property( 342257b448deSdougm scf_handle, name, 342357b448deSdougm value); 342457b448deSdougm } 342557b448deSdougm } else { 342657b448deSdougm ret = SA_CONFIG_ERR; 342757b448deSdougm } 342857b448deSdougm if (name != NULL) 342957b448deSdougm sa_free_attr_string( 343057b448deSdougm name); 343157b448deSdougm if (value != NULL) 343257b448deSdougm sa_free_attr_string(value); 343357b448deSdougm } 343457b448deSdougm if (id != NULL) 343557b448deSdougm sa_free_attr_string(id); 343657b448deSdougm } 343757b448deSdougm } else { 343857b448deSdougm /* 343957b448deSdougm * ZFS is a special case. We do want 344057b448deSdougm * to allow editing property/security 344157b448deSdougm * lists since we can have a better 344257b448deSdougm * syntax and we also want to keep 344357b448deSdougm * things consistent when possible. 344457b448deSdougm * 344557b448deSdougm * Right now, we defer until the 344657b448deSdougm * sa_commit_properties so we can get 344757b448deSdougm * them all at once. We do need to 344857b448deSdougm * mark the share as "changed" 344957b448deSdougm */ 345057b448deSdougm zfs_set_update((sa_share_t)parent); 34516185db85Sdougm } 34526185db85Sdougm } 34536185db85Sdougm return (ret); 34546185db85Sdougm } 34556185db85Sdougm 34566185db85Sdougm /* 34576185db85Sdougm * sa_remove_property(property) 34586185db85Sdougm * 34596185db85Sdougm * Remove the specied property from its containing object. Update the 34606185db85Sdougm * repository as appropriate. 34616185db85Sdougm */ 34626185db85Sdougm 34636185db85Sdougm int 34646185db85Sdougm sa_remove_property(sa_property_t property) 34656185db85Sdougm { 34666185db85Sdougm int ret = SA_OK; 34676185db85Sdougm 34686185db85Sdougm if (property != NULL) { 34696185db85Sdougm sa_optionset_t optionset; 34706185db85Sdougm sa_group_t group; 34716185db85Sdougm optionset = sa_get_property_parent(property); 34726185db85Sdougm if (optionset != NULL) { 347357b448deSdougm group = sa_get_optionset_parent(optionset); 347457b448deSdougm if (group != NULL) { 347557b448deSdougm ret = sa_set_prop_by_prop(optionset, group, 347657b448deSdougm property, SA_PROP_OP_REMOVE); 347757b448deSdougm } 34786185db85Sdougm } 34796185db85Sdougm xmlUnlinkNode((xmlNodePtr)property); 34806185db85Sdougm xmlFreeNode((xmlNodePtr)property); 34816185db85Sdougm } else { 348257b448deSdougm ret = SA_NO_SUCH_PROP; 34836185db85Sdougm } 34846185db85Sdougm return (ret); 34856185db85Sdougm } 34866185db85Sdougm 34876185db85Sdougm /* 34886185db85Sdougm * sa_update_property(property, value) 34896185db85Sdougm * 34906185db85Sdougm * Update the specified property to the new value. If value is NULL, 34916185db85Sdougm * we currently treat this as a remove. 34926185db85Sdougm */ 34936185db85Sdougm 34946185db85Sdougm int 34956185db85Sdougm sa_update_property(sa_property_t property, char *value) 34966185db85Sdougm { 34976185db85Sdougm int ret = SA_OK; 34986185db85Sdougm if (value == NULL) { 34996185db85Sdougm return (sa_remove_property(property)); 35006185db85Sdougm } else { 35016185db85Sdougm sa_optionset_t optionset; 35026185db85Sdougm sa_group_t group; 35036185db85Sdougm set_node_attr((void *)property, "value", value); 35046185db85Sdougm optionset = sa_get_property_parent(property); 35056185db85Sdougm if (optionset != NULL) { 350657b448deSdougm group = sa_get_optionset_parent(optionset); 350757b448deSdougm if (group != NULL) { 350857b448deSdougm ret = sa_set_prop_by_prop(optionset, group, 350957b448deSdougm property, SA_PROP_OP_UPDATE); 351057b448deSdougm } 35116185db85Sdougm } else { 351257b448deSdougm ret = SA_NO_SUCH_PROP; 35136185db85Sdougm } 35146185db85Sdougm } 35156185db85Sdougm return (ret); 35166185db85Sdougm } 35176185db85Sdougm 35184bff34e3Sthurlow /* 35194bff34e3Sthurlow * sa_get_protocol_section(propset, prop) 35204bff34e3Sthurlow * 35214bff34e3Sthurlow * Get the specified protocol specific section. These are global to 35224bff34e3Sthurlow * the protocol and not specific to a group or share. 35234bff34e3Sthurlow */ 35244bff34e3Sthurlow 35254bff34e3Sthurlow sa_protocol_properties_t 35264bff34e3Sthurlow sa_get_protocol_section(sa_protocol_properties_t propset, char *section) 35274bff34e3Sthurlow { 35284bff34e3Sthurlow xmlNodePtr node = (xmlNodePtr)propset; 35294bff34e3Sthurlow xmlChar *value = NULL; 35304bff34e3Sthurlow char *proto; 35314bff34e3Sthurlow 35324bff34e3Sthurlow proto = sa_get_optionset_attr(propset, "type"); 35339c9af259SGordon Ross if ((sa_proto_get_featureset(proto) & SA_FEATURE_HAS_SECTIONS) == 0) { 35349c9af259SGordon Ross if (proto != NULL) 35359c9af259SGordon Ross sa_free_attr_string(proto); 35364bff34e3Sthurlow return (propset); 35379c9af259SGordon Ross } 35384bff34e3Sthurlow 35394bff34e3Sthurlow for (node = node->children; node != NULL; 35404bff34e3Sthurlow node = node->next) { 35414bff34e3Sthurlow if (xmlStrcmp(node->name, (xmlChar *)"section") == 0) { 35424bff34e3Sthurlow if (section == NULL) 35434bff34e3Sthurlow break; 35444bff34e3Sthurlow value = xmlGetProp(node, (xmlChar *)"name"); 35454bff34e3Sthurlow if (value != NULL && 35464bff34e3Sthurlow xmlStrcasecmp(value, (xmlChar *)section) == 0) { 35474bff34e3Sthurlow break; 35484bff34e3Sthurlow } 35494bff34e3Sthurlow if (value != NULL) { 35504bff34e3Sthurlow xmlFree(value); 35514bff34e3Sthurlow value = NULL; 35524bff34e3Sthurlow } 35534bff34e3Sthurlow } 35544bff34e3Sthurlow } 35554bff34e3Sthurlow if (value != NULL) 35564bff34e3Sthurlow xmlFree(value); 35579c9af259SGordon Ross if (proto != NULL) 35589c9af259SGordon Ross sa_free_attr_string(proto); 35594bff34e3Sthurlow if (node != NULL && xmlStrcmp(node->name, (xmlChar *)"section") != 0) { 35604bff34e3Sthurlow /* 35614bff34e3Sthurlow * avoid a non option node -- it is possible to be a 35624bff34e3Sthurlow * text node 35634bff34e3Sthurlow */ 35644bff34e3Sthurlow node = NULL; 35654bff34e3Sthurlow } 35664bff34e3Sthurlow return ((sa_protocol_properties_t)node); 35674bff34e3Sthurlow } 35684bff34e3Sthurlow 35694bff34e3Sthurlow /* 35704bff34e3Sthurlow * sa_get_next_protocol_section(prop, find) 35714bff34e3Sthurlow * 35724bff34e3Sthurlow * Get the next protocol specific section in the list. 35734bff34e3Sthurlow */ 35744bff34e3Sthurlow 35754bff34e3Sthurlow sa_property_t 35764bff34e3Sthurlow sa_get_next_protocol_section(sa_property_t prop, char *find) 35774bff34e3Sthurlow { 35784bff34e3Sthurlow xmlNodePtr node; 35794bff34e3Sthurlow xmlChar *value = NULL; 35804bff34e3Sthurlow char *proto; 35814bff34e3Sthurlow 35824bff34e3Sthurlow proto = sa_get_optionset_attr(prop, "type"); 35839c9af259SGordon Ross if ((sa_proto_get_featureset(proto) & SA_FEATURE_HAS_SECTIONS) == 0) { 35849c9af259SGordon Ross if (proto != NULL) 35859c9af259SGordon Ross sa_free_attr_string(proto); 35864bff34e3Sthurlow return ((sa_property_t)NULL); 35879c9af259SGordon Ross } 35884bff34e3Sthurlow 35894bff34e3Sthurlow for (node = ((xmlNodePtr)prop)->next; node != NULL; 35904bff34e3Sthurlow node = node->next) { 35914bff34e3Sthurlow if (xmlStrcmp(node->name, (xmlChar *)"section") == 0) { 35924bff34e3Sthurlow if (find == NULL) 35934bff34e3Sthurlow break; 35944bff34e3Sthurlow value = xmlGetProp(node, (xmlChar *)"name"); 35954bff34e3Sthurlow if (value != NULL && 35964bff34e3Sthurlow xmlStrcasecmp(value, (xmlChar *)find) == 0) { 35974bff34e3Sthurlow break; 35984bff34e3Sthurlow } 35994bff34e3Sthurlow if (value != NULL) { 36004bff34e3Sthurlow xmlFree(value); 36014bff34e3Sthurlow value = NULL; 36024bff34e3Sthurlow } 36034bff34e3Sthurlow 36044bff34e3Sthurlow } 36054bff34e3Sthurlow } 36064bff34e3Sthurlow if (value != NULL) 36074bff34e3Sthurlow xmlFree(value); 36089c9af259SGordon Ross if (proto != NULL) 36099c9af259SGordon Ross sa_free_attr_string(proto); 36104bff34e3Sthurlow return ((sa_property_t)node); 36114bff34e3Sthurlow } 36124bff34e3Sthurlow 36136185db85Sdougm /* 36146185db85Sdougm * sa_get_protocol_property(propset, prop) 36156185db85Sdougm * 36166185db85Sdougm * Get the specified protocol specific property. These are global to 36176185db85Sdougm * the protocol and not specific to a group or share. 36186185db85Sdougm */ 36196185db85Sdougm 36206185db85Sdougm sa_property_t 36216185db85Sdougm sa_get_protocol_property(sa_protocol_properties_t propset, char *prop) 36226185db85Sdougm { 36236185db85Sdougm xmlNodePtr node = (xmlNodePtr)propset; 36246185db85Sdougm xmlChar *value = NULL; 36256185db85Sdougm 36264bff34e3Sthurlow if (propset == NULL) 36274bff34e3Sthurlow return (NULL); 36284bff34e3Sthurlow 36296185db85Sdougm for (node = node->children; node != NULL; 363057b448deSdougm node = node->next) { 363157b448deSdougm if (xmlStrcmp(node->name, (xmlChar *)"option") == 0) { 363257b448deSdougm if (prop == NULL) 363357b448deSdougm break; 363457b448deSdougm value = xmlGetProp(node, (xmlChar *)"type"); 363557b448deSdougm if (value != NULL && 363657b448deSdougm xmlStrcasecmp(value, (xmlChar *)prop) == 0) { 363757b448deSdougm break; 363857b448deSdougm } 363957b448deSdougm if (value != NULL) { 364057b448deSdougm xmlFree(value); 364157b448deSdougm value = NULL; 364257b448deSdougm } 36436185db85Sdougm } 36446185db85Sdougm } 36456185db85Sdougm if (value != NULL) 36466185db85Sdougm xmlFree(value); 36476185db85Sdougm if (node != NULL && xmlStrcmp(node->name, (xmlChar *)"option") != 0) { 364857b448deSdougm /* 364957b448deSdougm * avoid a non option node -- it is possible to be a 365057b448deSdougm * text node 365157b448deSdougm */ 365257b448deSdougm node = NULL; 36536185db85Sdougm } 36546185db85Sdougm return ((sa_property_t)node); 36556185db85Sdougm } 36566185db85Sdougm 36576185db85Sdougm /* 36586185db85Sdougm * sa_get_next_protocol_property(prop) 36596185db85Sdougm * 36606185db85Sdougm * Get the next protocol specific property in the list. 36616185db85Sdougm */ 36626185db85Sdougm 36636185db85Sdougm sa_property_t 36644bff34e3Sthurlow sa_get_next_protocol_property(sa_property_t prop, char *find) 36656185db85Sdougm { 36666185db85Sdougm xmlNodePtr node; 36674bff34e3Sthurlow xmlChar *value = NULL; 36686185db85Sdougm 36696185db85Sdougm for (node = ((xmlNodePtr)prop)->next; node != NULL; 367057b448deSdougm node = node->next) { 36716185db85Sdougm if (xmlStrcmp(node->name, (xmlChar *)"option") == 0) { 36724bff34e3Sthurlow if (find == NULL) 36734bff34e3Sthurlow break; 36744bff34e3Sthurlow value = xmlGetProp(node, (xmlChar *)"type"); 36754bff34e3Sthurlow if (value != NULL && 36764bff34e3Sthurlow xmlStrcasecmp(value, (xmlChar *)find) == 0) { 36774bff34e3Sthurlow break; 36784bff34e3Sthurlow } 36794bff34e3Sthurlow if (value != NULL) { 36804bff34e3Sthurlow xmlFree(value); 36814bff34e3Sthurlow value = NULL; 36824bff34e3Sthurlow } 36834bff34e3Sthurlow 36846185db85Sdougm } 36856185db85Sdougm } 36864bff34e3Sthurlow if (value != NULL) 36874bff34e3Sthurlow xmlFree(value); 36886185db85Sdougm return ((sa_property_t)node); 36896185db85Sdougm } 36906185db85Sdougm 36916185db85Sdougm /* 36926185db85Sdougm * sa_set_protocol_property(prop, value) 36936185db85Sdougm * 36946185db85Sdougm * Set the specified property to have the new value. The protocol 36956185db85Sdougm * specific plugin will then be called to update the property. 36966185db85Sdougm */ 36976185db85Sdougm 36986185db85Sdougm int 36994bff34e3Sthurlow sa_set_protocol_property(sa_property_t prop, char *section, char *value) 37006185db85Sdougm { 37016185db85Sdougm sa_protocol_properties_t propset; 37026185db85Sdougm char *proto; 37036185db85Sdougm int ret = SA_INVALID_PROTOCOL; 37046185db85Sdougm 37056185db85Sdougm propset = ((xmlNodePtr)prop)->parent; 37066185db85Sdougm if (propset != NULL) { 370757b448deSdougm proto = sa_get_optionset_attr(propset, "type"); 370857b448deSdougm if (proto != NULL) { 37094bff34e3Sthurlow if (section != NULL) 37104bff34e3Sthurlow set_node_attr((xmlNodePtr)prop, "section", 37114bff34e3Sthurlow section); 371257b448deSdougm set_node_attr((xmlNodePtr)prop, "value", value); 371357b448deSdougm ret = sa_proto_set_property(proto, prop); 371457b448deSdougm sa_free_attr_string(proto); 371557b448deSdougm } 37166185db85Sdougm } 37176185db85Sdougm return (ret); 37186185db85Sdougm } 37196185db85Sdougm 37206185db85Sdougm /* 37216185db85Sdougm * sa_add_protocol_property(propset, prop) 37226185db85Sdougm * 3723da6c28aaSamw * Add a new property to the protocol specific property set. 37246185db85Sdougm */ 37256185db85Sdougm 37266185db85Sdougm int 37276185db85Sdougm sa_add_protocol_property(sa_protocol_properties_t propset, sa_property_t prop) 37286185db85Sdougm { 37296185db85Sdougm xmlNodePtr node; 37306185db85Sdougm 37316185db85Sdougm /* should check for legitimacy */ 37326185db85Sdougm node = xmlAddChild((xmlNodePtr)propset, (xmlNodePtr)prop); 37336185db85Sdougm if (node != NULL) 373457b448deSdougm return (SA_OK); 37356185db85Sdougm return (SA_NO_MEMORY); 37366185db85Sdougm } 37376185db85Sdougm 37386185db85Sdougm /* 37396185db85Sdougm * sa_create_protocol_properties(proto) 37406185db85Sdougm * 3741da6c28aaSamw * Create a protocol specific property set. 37426185db85Sdougm */ 37436185db85Sdougm 37446185db85Sdougm sa_protocol_properties_t 37456185db85Sdougm sa_create_protocol_properties(char *proto) 37466185db85Sdougm { 37476185db85Sdougm xmlNodePtr node; 374857b448deSdougm 37496185db85Sdougm node = xmlNewNode(NULL, (xmlChar *)"propertyset"); 375057b448deSdougm if (node != NULL) 37514bff34e3Sthurlow (void) xmlSetProp(node, (xmlChar *)"type", (xmlChar *)proto); 37526185db85Sdougm return (node); 37536185db85Sdougm } 3754da6c28aaSamw 3755da6c28aaSamw /* 3756da6c28aaSamw * sa_get_share_resource(share, resource) 3757da6c28aaSamw * 3758da6c28aaSamw * Get the named resource from the share, if it exists. If resource is 3759da6c28aaSamw * NULL, get the first resource. 3760da6c28aaSamw */ 3761da6c28aaSamw 3762da6c28aaSamw sa_resource_t 3763da6c28aaSamw sa_get_share_resource(sa_share_t share, char *resource) 3764da6c28aaSamw { 3765da6c28aaSamw xmlNodePtr node = NULL; 3766da6c28aaSamw xmlChar *name; 3767da6c28aaSamw 3768da6c28aaSamw if (share != NULL) { 3769da6c28aaSamw for (node = ((xmlNodePtr)share)->children; node != NULL; 3770da6c28aaSamw node = node->next) { 3771da6c28aaSamw if (xmlStrcmp(node->name, (xmlChar *)"resource") == 0) { 3772da6c28aaSamw if (resource == NULL) { 3773da6c28aaSamw /* 3774da6c28aaSamw * We are looking for the first 3775da6c28aaSamw * resource node and not a names 3776da6c28aaSamw * resource. 3777da6c28aaSamw */ 3778da6c28aaSamw break; 3779da6c28aaSamw } else { 3780da6c28aaSamw /* is it the correct share? */ 3781da6c28aaSamw name = xmlGetProp(node, 3782da6c28aaSamw (xmlChar *)"name"); 3783da6c28aaSamw if (name != NULL && 3784da6c28aaSamw xmlStrcasecmp(name, 3785da6c28aaSamw (xmlChar *)resource) == 0) { 3786da6c28aaSamw xmlFree(name); 3787da6c28aaSamw break; 3788da6c28aaSamw } 3789da6c28aaSamw xmlFree(name); 3790da6c28aaSamw } 3791da6c28aaSamw } 3792da6c28aaSamw } 3793da6c28aaSamw } 3794da6c28aaSamw return ((sa_resource_t)node); 3795da6c28aaSamw } 3796da6c28aaSamw 3797da6c28aaSamw /* 3798da6c28aaSamw * sa_get_next_resource(resource) 3799da6c28aaSamw * Return the next share following the specified share 3800da6c28aaSamw * from the internal list of shares. Returns NULL if there 3801da6c28aaSamw * are no more shares. The list is relative to the same 3802da6c28aaSamw * group. 3803da6c28aaSamw */ 3804da6c28aaSamw sa_share_t 3805da6c28aaSamw sa_get_next_resource(sa_resource_t resource) 3806da6c28aaSamw { 3807da6c28aaSamw xmlNodePtr node = NULL; 3808da6c28aaSamw 3809da6c28aaSamw if (resource != NULL) { 3810da6c28aaSamw for (node = ((xmlNodePtr)resource)->next; node != NULL; 3811da6c28aaSamw node = node->next) { 3812da6c28aaSamw if (xmlStrcmp(node->name, (xmlChar *)"resource") == 0) 3813da6c28aaSamw break; 3814da6c28aaSamw } 3815da6c28aaSamw } 3816da6c28aaSamw return ((sa_share_t)node); 3817da6c28aaSamw } 3818da6c28aaSamw 3819da6c28aaSamw /* 3820da6c28aaSamw * _sa_get_next_resource_index(share) 3821da6c28aaSamw * 3822da6c28aaSamw * get the next resource index number (one greater then current largest) 3823da6c28aaSamw */ 3824da6c28aaSamw 3825da6c28aaSamw static int 3826da6c28aaSamw _sa_get_next_resource_index(sa_share_t share) 3827da6c28aaSamw { 3828da6c28aaSamw sa_resource_t resource; 3829da6c28aaSamw int index = 0; 3830da6c28aaSamw char *id; 3831da6c28aaSamw 3832da6c28aaSamw for (resource = sa_get_share_resource(share, NULL); 3833da6c28aaSamw resource != NULL; 3834da6c28aaSamw resource = sa_get_next_resource(resource)) { 3835da6c28aaSamw id = get_node_attr((void *)resource, "id"); 3836da6c28aaSamw if (id != NULL) { 3837da6c28aaSamw int val; 3838da6c28aaSamw val = atoi(id); 3839da6c28aaSamw if (val > index) 3840da6c28aaSamw index = val; 3841da6c28aaSamw sa_free_attr_string(id); 3842da6c28aaSamw } 3843da6c28aaSamw } 3844da6c28aaSamw return (index + 1); 3845da6c28aaSamw } 3846da6c28aaSamw 3847da6c28aaSamw 3848da6c28aaSamw /* 3849da6c28aaSamw * sa_add_resource(share, resource, persist, &err) 3850da6c28aaSamw * 3851da6c28aaSamw * Adds a new resource name associated with share. The resource name 3852da6c28aaSamw * must be unique in the system and will be case insensitive (eventually). 3853da6c28aaSamw */ 3854da6c28aaSamw 3855da6c28aaSamw sa_resource_t 3856da6c28aaSamw sa_add_resource(sa_share_t share, char *resource, int persist, int *error) 3857da6c28aaSamw { 3858da6c28aaSamw xmlNodePtr node; 3859da6c28aaSamw int err = SA_OK; 3860da6c28aaSamw sa_resource_t res; 3861da6c28aaSamw sa_group_t group; 3862da6c28aaSamw sa_handle_t handle; 3863da6c28aaSamw char istring[8]; /* just big enough for an integer value */ 3864da6c28aaSamw int index; 3865da6c28aaSamw 3866da6c28aaSamw group = sa_get_parent_group(share); 3867da6c28aaSamw handle = sa_find_group_handle(group); 3868da6c28aaSamw res = sa_find_resource(handle, resource); 3869da6c28aaSamw if (res != NULL) { 3870da6c28aaSamw err = SA_DUPLICATE_NAME; 3871da6c28aaSamw res = NULL; 3872da6c28aaSamw } else { 3873da6c28aaSamw node = xmlNewChild((xmlNodePtr)share, NULL, 3874da6c28aaSamw (xmlChar *)"resource", NULL); 3875da6c28aaSamw if (node != NULL) { 38764bff34e3Sthurlow (void) xmlSetProp(node, (xmlChar *)"name", 3877da6c28aaSamw (xmlChar *)resource); 38784bff34e3Sthurlow (void) xmlSetProp(node, (xmlChar *)"type", persist ? 3879da6c28aaSamw (xmlChar *)"persist" : (xmlChar *)"transient"); 3880da6c28aaSamw if (persist != SA_SHARE_TRANSIENT) { 3881da6c28aaSamw index = _sa_get_next_resource_index(share); 3882da6c28aaSamw (void) snprintf(istring, sizeof (istring), "%d", 3883da6c28aaSamw index); 38844bff34e3Sthurlow (void) xmlSetProp(node, (xmlChar *)"id", 3885da6c28aaSamw (xmlChar *)istring); 38861f713840SDoug McCallum 38871f713840SDoug McCallum if (!sa_is_persistent((sa_group_t)share)) 38881f713840SDoug McCallum goto done; 38891f713840SDoug McCallum 38901f713840SDoug McCallum if (!sa_group_is_zfs(group)) { 3891da6c28aaSamw /* ZFS doesn't use resource names */ 3892da6c28aaSamw sa_handle_impl_t ihandle; 38931f713840SDoug McCallum 3894da6c28aaSamw ihandle = (sa_handle_impl_t) 3895da6c28aaSamw sa_find_group_handle( 3896da6c28aaSamw group); 3897da6c28aaSamw if (ihandle != NULL) 3898da6c28aaSamw err = sa_commit_share( 3899da6c28aaSamw ihandle->scfhandle, group, 3900da6c28aaSamw share); 3901da6c28aaSamw else 3902da6c28aaSamw err = SA_SYSTEM_ERR; 39031f713840SDoug McCallum } else { 39041f713840SDoug McCallum err = sa_zfs_update((sa_share_t)group); 3905da6c28aaSamw } 3906da6c28aaSamw } 3907da6c28aaSamw } 3908da6c28aaSamw } 39091f713840SDoug McCallum done: 3910da6c28aaSamw if (error != NULL) 3911da6c28aaSamw *error = err; 3912da6c28aaSamw return ((sa_resource_t)node); 3913da6c28aaSamw } 3914da6c28aaSamw 3915da6c28aaSamw /* 3916da6c28aaSamw * sa_remove_resource(resource) 3917da6c28aaSamw * 3918da6c28aaSamw * Remove the resource name from the share (and the system) 3919da6c28aaSamw */ 3920da6c28aaSamw 3921da6c28aaSamw int 3922da6c28aaSamw sa_remove_resource(sa_resource_t resource) 3923da6c28aaSamw { 3924da6c28aaSamw sa_share_t share; 3925da6c28aaSamw sa_group_t group; 3926da6c28aaSamw char *type; 3927da6c28aaSamw int ret = SA_OK; 39281f713840SDoug McCallum boolean_t transient = B_FALSE; 392955bf511dSas sa_optionset_t opt; 3930da6c28aaSamw 3931da6c28aaSamw share = sa_get_resource_parent(resource); 3932da6c28aaSamw type = sa_get_share_attr(share, "type"); 3933da6c28aaSamw group = sa_get_parent_group(share); 3934da6c28aaSamw 3935da6c28aaSamw 3936da6c28aaSamw if (type != NULL) { 3937da6c28aaSamw if (strcmp(type, "persist") != 0) 39381f713840SDoug McCallum transient = B_TRUE; 3939da6c28aaSamw sa_free_attr_string(type); 3940da6c28aaSamw } 3941da6c28aaSamw 394255bf511dSas /* Disable the resource for all protocols. */ 394355bf511dSas (void) sa_disable_resource(resource, NULL); 394455bf511dSas 394555bf511dSas /* Remove any optionsets from the resource. */ 394655bf511dSas for (opt = sa_get_optionset(resource, NULL); 394755bf511dSas opt != NULL; 394855bf511dSas opt = sa_get_next_optionset(opt)) 394955bf511dSas (void) sa_destroy_optionset(opt); 395055bf511dSas 3951da6c28aaSamw /* Remove from the share */ 3952da6c28aaSamw xmlUnlinkNode((xmlNode *)resource); 3953da6c28aaSamw xmlFreeNode((xmlNode *)resource); 3954da6c28aaSamw 3955da6c28aaSamw /* only do SMF action if permanent and not ZFS */ 39561f713840SDoug McCallum if (transient) 39571f713840SDoug McCallum return (ret); 39581f713840SDoug McCallum 39591f713840SDoug McCallum if (!sa_group_is_zfs(group)) { 3960da6c28aaSamw sa_handle_impl_t ihandle; 3961da6c28aaSamw ihandle = (sa_handle_impl_t)sa_find_group_handle(group); 3962da6c28aaSamw if (ihandle != NULL) 3963da6c28aaSamw ret = sa_commit_share(ihandle->scfhandle, group, share); 3964da6c28aaSamw else 3965da6c28aaSamw ret = SA_SYSTEM_ERR; 39661f713840SDoug McCallum } else { 39671f713840SDoug McCallum ret = sa_zfs_update((sa_share_t)group); 3968da6c28aaSamw } 3969743a77edSAlan Wright 3970da6c28aaSamw return (ret); 3971da6c28aaSamw } 3972da6c28aaSamw 3973da6c28aaSamw /* 3974743a77edSAlan Wright * proto_rename_resource(handle, group, resource, newname) 3975da6c28aaSamw * 3976da6c28aaSamw * Helper function for sa_rename_resource that notifies the protocol 3977da6c28aaSamw * of a resource name change prior to a config repository update. 3978da6c28aaSamw */ 3979da6c28aaSamw static int 3980da6c28aaSamw proto_rename_resource(sa_handle_t handle, sa_group_t group, 3981da6c28aaSamw sa_resource_t resource, char *newname) 3982da6c28aaSamw { 3983da6c28aaSamw sa_optionset_t optionset; 3984da6c28aaSamw int ret = SA_OK; 3985da6c28aaSamw int err; 3986da6c28aaSamw 3987da6c28aaSamw for (optionset = sa_get_optionset(group, NULL); 3988da6c28aaSamw optionset != NULL; 3989da6c28aaSamw optionset = sa_get_next_optionset(optionset)) { 3990da6c28aaSamw char *type; 3991da6c28aaSamw type = sa_get_optionset_attr(optionset, "type"); 3992da6c28aaSamw if (type != NULL) { 3993da6c28aaSamw err = sa_proto_rename_resource(handle, type, resource, 3994da6c28aaSamw newname); 3995da6c28aaSamw if (err != SA_OK) 3996da6c28aaSamw ret = err; 3997da6c28aaSamw sa_free_attr_string(type); 3998da6c28aaSamw } 3999da6c28aaSamw } 4000da6c28aaSamw return (ret); 4001da6c28aaSamw } 4002da6c28aaSamw 4003da6c28aaSamw /* 4004da6c28aaSamw * sa_rename_resource(resource, newname) 4005da6c28aaSamw * 4006da6c28aaSamw * Rename the resource to the new name, if it is unique. 4007da6c28aaSamw */ 4008da6c28aaSamw 4009da6c28aaSamw int 4010da6c28aaSamw sa_rename_resource(sa_resource_t resource, char *newname) 4011da6c28aaSamw { 4012da6c28aaSamw sa_share_t share; 4013da6c28aaSamw sa_group_t group = NULL; 4014da6c28aaSamw sa_resource_t target; 4015da6c28aaSamw int ret = SA_CONFIG_ERR; 4016da6c28aaSamw sa_handle_t handle = NULL; 4017da6c28aaSamw 4018da6c28aaSamw share = sa_get_resource_parent(resource); 4019da6c28aaSamw if (share == NULL) 4020da6c28aaSamw return (ret); 4021da6c28aaSamw 4022da6c28aaSamw group = sa_get_parent_group(share); 4023da6c28aaSamw if (group == NULL) 4024da6c28aaSamw return (ret); 4025da6c28aaSamw 4026da6c28aaSamw handle = (sa_handle_impl_t)sa_find_group_handle(group); 4027da6c28aaSamw if (handle == NULL) 4028da6c28aaSamw return (ret); 4029da6c28aaSamw 4030da6c28aaSamw target = sa_find_resource(handle, newname); 4031da6c28aaSamw if (target != NULL) { 4032da6c28aaSamw ret = SA_DUPLICATE_NAME; 4033da6c28aaSamw } else { 4034da6c28aaSamw /* 4035da6c28aaSamw * Everything appears to be valid at this 4036da6c28aaSamw * point. Change the name of the active share and then 4037da6c28aaSamw * update the share in the appropriate repository. 4038da6c28aaSamw */ 4039da6c28aaSamw ret = proto_rename_resource(handle, group, resource, newname); 4040da6c28aaSamw set_node_attr(resource, "name", newname); 40411f713840SDoug McCallum 40421f713840SDoug McCallum if (!sa_is_persistent((sa_group_t)share)) 40431f713840SDoug McCallum return (ret); 40441f713840SDoug McCallum 40451f713840SDoug McCallum if (!sa_group_is_zfs(group)) { 4046da6c28aaSamw sa_handle_impl_t ihandle = (sa_handle_impl_t)handle; 4047da6c28aaSamw ret = sa_commit_share(ihandle->scfhandle, group, 4048da6c28aaSamw share); 40491f713840SDoug McCallum } else { 40501f713840SDoug McCallum ret = sa_zfs_update((sa_share_t)group); 4051da6c28aaSamw } 4052da6c28aaSamw } 4053da6c28aaSamw return (ret); 4054da6c28aaSamw } 4055da6c28aaSamw 4056da6c28aaSamw /* 4057da6c28aaSamw * sa_get_resource_attr(resource, tag) 4058da6c28aaSamw * 4059da6c28aaSamw * Get the named attribute of the resource. "name" and "id" are 4060da6c28aaSamw * currently defined. NULL if tag not defined. 4061da6c28aaSamw */ 4062da6c28aaSamw 4063da6c28aaSamw char * 4064da6c28aaSamw sa_get_resource_attr(sa_resource_t resource, char *tag) 4065da6c28aaSamw { 4066da6c28aaSamw return (get_node_attr((void *)resource, tag)); 4067da6c28aaSamw } 4068da6c28aaSamw 4069da6c28aaSamw /* 4070da6c28aaSamw * sa_set_resource_attr(resource, tag, value) 4071da6c28aaSamw * 4072da6c28aaSamw * Get the named attribute of the resource. "name" and "id" are 4073da6c28aaSamw * currently defined. NULL if tag not defined. Currently we don't do 4074da6c28aaSamw * much, but additional checking may be needed in the future. 4075da6c28aaSamw */ 4076da6c28aaSamw 4077da6c28aaSamw int 4078da6c28aaSamw sa_set_resource_attr(sa_resource_t resource, char *tag, char *value) 4079da6c28aaSamw { 4080da6c28aaSamw set_node_attr((void *)resource, tag, value); 4081da6c28aaSamw return (SA_OK); 4082da6c28aaSamw } 4083da6c28aaSamw 4084da6c28aaSamw /* 4085da6c28aaSamw * sa_get_resource_parent(resource_t) 4086da6c28aaSamw * 4087da6c28aaSamw * Returns the share associated with the resource. 4088da6c28aaSamw */ 4089da6c28aaSamw 4090da6c28aaSamw sa_share_t 4091da6c28aaSamw sa_get_resource_parent(sa_resource_t resource) 4092da6c28aaSamw { 4093da6c28aaSamw sa_share_t share = NULL; 4094da6c28aaSamw 4095da6c28aaSamw if (resource != NULL) 4096da6c28aaSamw share = (sa_share_t)((xmlNodePtr)resource)->parent; 4097da6c28aaSamw return (share); 4098da6c28aaSamw } 4099da6c28aaSamw 4100da6c28aaSamw /* 4101da6c28aaSamw * find_resource(group, name) 4102da6c28aaSamw * 4103da6c28aaSamw * Find the resource within the group. 4104da6c28aaSamw */ 4105da6c28aaSamw 4106da6c28aaSamw static sa_resource_t 4107da6c28aaSamw find_resource(sa_group_t group, char *resname) 4108da6c28aaSamw { 4109da6c28aaSamw sa_share_t share; 4110da6c28aaSamw sa_resource_t resource = NULL; 4111da6c28aaSamw char *name; 4112da6c28aaSamw 4113da6c28aaSamw /* Iterate over all the shares and resources in the group. */ 4114da6c28aaSamw for (share = sa_get_share(group, NULL); 4115da6c28aaSamw share != NULL && resource == NULL; 4116da6c28aaSamw share = sa_get_next_share(share)) { 4117da6c28aaSamw for (resource = sa_get_share_resource(share, NULL); 4118da6c28aaSamw resource != NULL; 4119da6c28aaSamw resource = sa_get_next_resource(resource)) { 4120da6c28aaSamw name = sa_get_resource_attr(resource, "name"); 4121da6c28aaSamw if (name != NULL && xmlStrcasecmp((xmlChar*)name, 4122da6c28aaSamw (xmlChar*)resname) == 0) { 4123da6c28aaSamw sa_free_attr_string(name); 4124da6c28aaSamw break; 4125da6c28aaSamw } 4126da6c28aaSamw if (name != NULL) { 4127da6c28aaSamw sa_free_attr_string(name); 4128da6c28aaSamw } 4129da6c28aaSamw } 4130da6c28aaSamw } 4131da6c28aaSamw return (resource); 4132da6c28aaSamw } 4133da6c28aaSamw 4134da6c28aaSamw /* 4135da6c28aaSamw * sa_find_resource(name) 4136da6c28aaSamw * 4137da6c28aaSamw * Find the named resource in the system. 4138da6c28aaSamw */ 4139da6c28aaSamw 4140da6c28aaSamw sa_resource_t 4141da6c28aaSamw sa_find_resource(sa_handle_t handle, char *name) 4142da6c28aaSamw { 4143da6c28aaSamw sa_group_t group; 4144da6c28aaSamw sa_group_t zgroup; 4145da6c28aaSamw sa_resource_t resource = NULL; 4146da6c28aaSamw 4147da6c28aaSamw /* 4148da6c28aaSamw * Iterate over all groups and zfs subgroups and check for 4149da6c28aaSamw * resource name in them. 4150da6c28aaSamw */ 4151da6c28aaSamw for (group = sa_get_group(handle, NULL); group != NULL; 4152da6c28aaSamw group = sa_get_next_group(group)) { 4153da6c28aaSamw 4154da6c28aaSamw if (is_zfs_group(group)) { 4155da6c28aaSamw for (zgroup = 4156da6c28aaSamw (sa_group_t)_sa_get_child_node((xmlNodePtr)group, 4157da6c28aaSamw (xmlChar *)"group"); 4158da6c28aaSamw zgroup != NULL && resource == NULL; 4159da6c28aaSamw zgroup = sa_get_next_group(zgroup)) { 4160da6c28aaSamw resource = find_resource(zgroup, name); 4161da6c28aaSamw } 4162da6c28aaSamw } else { 4163da6c28aaSamw resource = find_resource(group, name); 4164da6c28aaSamw } 4165da6c28aaSamw if (resource != NULL) 4166da6c28aaSamw break; 4167da6c28aaSamw } 4168da6c28aaSamw return (resource); 4169da6c28aaSamw } 4170da6c28aaSamw 4171da6c28aaSamw /* 4172da6c28aaSamw * sa_get_resource(group, resource) 4173da6c28aaSamw * 4174da6c28aaSamw * Search all the shares in the specified group for a share with a 4175da6c28aaSamw * resource name matching the one specified. 4176da6c28aaSamw * 4177da6c28aaSamw * In the future, it may be advantageous to allow group to be NULL and 4178da6c28aaSamw * search all groups but that isn't needed at present. 4179da6c28aaSamw */ 4180da6c28aaSamw 4181da6c28aaSamw sa_resource_t 4182da6c28aaSamw sa_get_resource(sa_group_t group, char *resource) 4183da6c28aaSamw { 4184da6c28aaSamw sa_share_t share = NULL; 4185da6c28aaSamw sa_resource_t res = NULL; 4186da6c28aaSamw 4187da6c28aaSamw if (resource != NULL) { 4188da6c28aaSamw for (share = sa_get_share(group, NULL); 4189da6c28aaSamw share != NULL && res == NULL; 4190da6c28aaSamw share = sa_get_next_share(share)) { 4191da6c28aaSamw res = sa_get_share_resource(share, resource); 4192da6c28aaSamw } 4193da6c28aaSamw } 4194da6c28aaSamw return (res); 4195da6c28aaSamw } 4196da6c28aaSamw 4197f85463f2Sdougm /* 4198f85463f2Sdougm * get_protocol_list(optionset, object) 4199f85463f2Sdougm * 4200f85463f2Sdougm * Get the protocol optionset list for the object and add them as 4201f85463f2Sdougm * properties to optionset. 4202f85463f2Sdougm */ 4203f85463f2Sdougm static int 4204f85463f2Sdougm get_protocol_list(sa_optionset_t optionset, void *object) 4205f85463f2Sdougm { 4206f85463f2Sdougm sa_property_t prop; 4207f85463f2Sdougm sa_optionset_t opts; 4208f85463f2Sdougm int ret = SA_OK; 4209f85463f2Sdougm 4210f85463f2Sdougm for (opts = sa_get_optionset(object, NULL); 4211f85463f2Sdougm opts != NULL; 4212f85463f2Sdougm opts = sa_get_next_optionset(opts)) { 4213f85463f2Sdougm char *type; 4214f85463f2Sdougm type = sa_get_optionset_attr(opts, "type"); 4215f85463f2Sdougm /* 4216f85463f2Sdougm * It is possible to have a non-protocol optionset. We 4217f85463f2Sdougm * skip any of those found. 4218f85463f2Sdougm */ 4219f85463f2Sdougm if (type == NULL) 4220f85463f2Sdougm continue; 4221f85463f2Sdougm prop = sa_create_property(type, "true"); 4222f85463f2Sdougm sa_free_attr_string(type); 4223f85463f2Sdougm if (prop != NULL) 4224f85463f2Sdougm prop = (sa_property_t)xmlAddChild((xmlNodePtr)optionset, 4225f85463f2Sdougm (xmlNodePtr)prop); 4226f85463f2Sdougm /* If prop is NULL, don't bother continuing */ 4227f85463f2Sdougm if (prop == NULL) { 4228f85463f2Sdougm ret = SA_NO_MEMORY; 4229f85463f2Sdougm break; 4230f85463f2Sdougm } 4231f85463f2Sdougm } 4232f85463f2Sdougm return (ret); 4233f85463f2Sdougm } 4234f85463f2Sdougm 4235f85463f2Sdougm /* 4236f85463f2Sdougm * sa_free_protoset(optionset) 4237f85463f2Sdougm * 4238f85463f2Sdougm * Free the protocol property optionset. 4239f85463f2Sdougm */ 4240f85463f2Sdougm static void 4241f85463f2Sdougm sa_free_protoset(sa_optionset_t optionset) 4242f85463f2Sdougm { 4243f85463f2Sdougm if (optionset != NULL) { 4244f85463f2Sdougm xmlUnlinkNode((xmlNodePtr) optionset); 4245f85463f2Sdougm xmlFreeNode((xmlNodePtr) optionset); 4246f85463f2Sdougm } 4247f85463f2Sdougm } 4248f85463f2Sdougm 4249f85463f2Sdougm /* 4250f85463f2Sdougm * sa_optionset_t sa_get_active_protocols(object) 4251f85463f2Sdougm * 4252f85463f2Sdougm * Return a list of the protocols that are active for the object. 4253f85463f2Sdougm * This is currently an internal helper function, but could be 4254f85463f2Sdougm * made visible if there is enough demand for it. 4255f85463f2Sdougm * 4256f85463f2Sdougm * The function finds the parent group and extracts the protocol 4257f85463f2Sdougm * optionsets creating a new optionset with the protocols as properties. 4258f85463f2Sdougm * 4259f85463f2Sdougm * The caller must free the returned optionset. 4260f85463f2Sdougm */ 4261f85463f2Sdougm 4262f85463f2Sdougm static sa_optionset_t 4263f85463f2Sdougm sa_get_active_protocols(void *object) 4264f85463f2Sdougm { 4265f85463f2Sdougm sa_optionset_t options; 4266f85463f2Sdougm sa_share_t share = NULL; 4267f85463f2Sdougm sa_group_t group = NULL; 4268f85463f2Sdougm sa_resource_t resource = NULL; 4269f85463f2Sdougm int ret = SA_OK; 4270f85463f2Sdougm 4271f85463f2Sdougm if (object == NULL) 4272f85463f2Sdougm return (NULL); 4273f85463f2Sdougm options = (sa_optionset_t)xmlNewNode(NULL, (xmlChar *)"optionset"); 4274f85463f2Sdougm if (options == NULL) 4275f85463f2Sdougm return (NULL); 4276f85463f2Sdougm 4277f85463f2Sdougm /* 4278f85463f2Sdougm * Find the objects up the tree that might have protocols 4279f85463f2Sdougm * enabled on them. 4280f85463f2Sdougm */ 4281f85463f2Sdougm if (sa_is_resource(object)) { 4282f85463f2Sdougm resource = (sa_resource_t)object; 4283f85463f2Sdougm share = sa_get_resource_parent(resource); 4284f85463f2Sdougm group = sa_get_parent_group(share); 4285f85463f2Sdougm } else if (sa_is_share(object)) { 4286f85463f2Sdougm share = (sa_share_t)object; 4287f85463f2Sdougm group = sa_get_parent_group(share); 4288f85463f2Sdougm } else { 4289f85463f2Sdougm group = (sa_group_t)group; 4290f85463f2Sdougm } 4291f85463f2Sdougm if (resource != NULL) 4292f85463f2Sdougm ret = get_protocol_list(options, resource); 4293f85463f2Sdougm if (ret == SA_OK && share != NULL) 4294f85463f2Sdougm ret = get_protocol_list(options, share); 4295f85463f2Sdougm if (ret == SA_OK && group != NULL) 4296f85463f2Sdougm ret = get_protocol_list(options, group); 4297f85463f2Sdougm 4298f85463f2Sdougm /* 4299f85463f2Sdougm * If there was an error, we won't have a complete list so 4300f85463f2Sdougm * abandon everything. The caller will have to deal with the 4301f85463f2Sdougm * issue. 4302f85463f2Sdougm */ 4303f85463f2Sdougm if (ret != SA_OK) { 4304f85463f2Sdougm sa_free_protoset(options); 4305f85463f2Sdougm options = NULL; 4306f85463f2Sdougm } 4307f85463f2Sdougm return (options); 4308f85463f2Sdougm } 4309f85463f2Sdougm 4310da6c28aaSamw /* 4311da6c28aaSamw * sa_enable_resource, protocol) 4312da6c28aaSamw * Disable the specified share to the specified protocol. 4313da6c28aaSamw * If protocol is NULL, then all protocols. 4314da6c28aaSamw */ 4315da6c28aaSamw int 4316da6c28aaSamw sa_enable_resource(sa_resource_t resource, char *protocol) 4317da6c28aaSamw { 4318da6c28aaSamw int ret = SA_OK; 4319da6c28aaSamw 4320da6c28aaSamw if (protocol != NULL) { 4321da6c28aaSamw ret = sa_proto_share_resource(protocol, resource); 4322da6c28aaSamw } else { 4323f85463f2Sdougm sa_optionset_t protoset; 4324f85463f2Sdougm sa_property_t prop; 4325f85463f2Sdougm char *proto; 4326f85463f2Sdougm int err; 4327f85463f2Sdougm 4328da6c28aaSamw /* need to do all protocols */ 4329f85463f2Sdougm protoset = sa_get_active_protocols(resource); 4330f85463f2Sdougm if (protoset == NULL) 4331f85463f2Sdougm return (SA_NO_MEMORY); 4332f85463f2Sdougm for (prop = sa_get_property(protoset, NULL); 4333f85463f2Sdougm prop != NULL; 4334f85463f2Sdougm prop = sa_get_next_property(prop)) { 4335f85463f2Sdougm proto = sa_get_property_attr(prop, "type"); 4336f85463f2Sdougm if (proto == NULL) { 4337f85463f2Sdougm ret = SA_NO_MEMORY; 4338f85463f2Sdougm continue; 4339da6c28aaSamw } 4340f85463f2Sdougm err = sa_proto_share_resource(proto, resource); 4341f85463f2Sdougm if (err != SA_OK) 4342f85463f2Sdougm ret = err; 4343f85463f2Sdougm sa_free_attr_string(proto); 4344da6c28aaSamw } 4345f85463f2Sdougm sa_free_protoset(protoset); 4346da6c28aaSamw } 4347da6c28aaSamw if (ret == SA_OK) 4348da6c28aaSamw (void) sa_set_resource_attr(resource, "shared", NULL); 4349da6c28aaSamw 4350da6c28aaSamw return (ret); 4351da6c28aaSamw } 4352da6c28aaSamw 4353da6c28aaSamw /* 4354da6c28aaSamw * sa_disable_resource(resource, protocol) 4355da6c28aaSamw * 4356da6c28aaSamw * Disable the specified share for the specified protocol. If 4357da6c28aaSamw * protocol is NULL, then all protocols. If the underlying 4358da6c28aaSamw * protocol doesn't implement disable at the resource level, we 4359da6c28aaSamw * disable at the share level. 4360da6c28aaSamw */ 4361da6c28aaSamw int 4362da6c28aaSamw sa_disable_resource(sa_resource_t resource, char *protocol) 4363da6c28aaSamw { 4364da6c28aaSamw int ret = SA_OK; 4365da6c28aaSamw 4366da6c28aaSamw if (protocol != NULL) { 4367da6c28aaSamw ret = sa_proto_unshare_resource(protocol, resource); 4368da6c28aaSamw if (ret == SA_NOT_IMPLEMENTED) { 4369da6c28aaSamw sa_share_t parent; 4370da6c28aaSamw /* 4371da6c28aaSamw * The protocol doesn't implement unshare 4372da6c28aaSamw * resource. That implies that resource names are 4373da6c28aaSamw * simple aliases for this protocol so we need to 4374da6c28aaSamw * unshare the share. 4375da6c28aaSamw */ 4376da6c28aaSamw parent = sa_get_resource_parent(resource); 4377da6c28aaSamw if (parent != NULL) 4378da6c28aaSamw ret = sa_disable_share(parent, protocol); 4379da6c28aaSamw else 4380da6c28aaSamw ret = SA_CONFIG_ERR; 4381da6c28aaSamw } 4382da6c28aaSamw } else { 4383f85463f2Sdougm sa_optionset_t protoset; 4384f85463f2Sdougm sa_property_t prop; 4385f85463f2Sdougm char *proto; 4386f85463f2Sdougm int err; 4387f85463f2Sdougm 4388da6c28aaSamw /* need to do all protocols */ 4389f85463f2Sdougm protoset = sa_get_active_protocols(resource); 4390f85463f2Sdougm if (protoset == NULL) 4391f85463f2Sdougm return (SA_NO_MEMORY); 4392f85463f2Sdougm for (prop = sa_get_property(protoset, NULL); 4393f85463f2Sdougm prop != NULL; 4394f85463f2Sdougm prop = sa_get_next_property(prop)) { 4395f85463f2Sdougm proto = sa_get_property_attr(prop, "type"); 4396f85463f2Sdougm if (proto == NULL) { 4397f85463f2Sdougm ret = SA_NO_MEMORY; 4398f85463f2Sdougm continue; 4399da6c28aaSamw } 4400f85463f2Sdougm err = sa_proto_unshare_resource(proto, resource); 4401f85463f2Sdougm if (err == SA_NOT_SUPPORTED) { 4402f85463f2Sdougm sa_share_t parent; 4403f85463f2Sdougm parent = sa_get_resource_parent(resource); 4404f85463f2Sdougm if (parent != NULL) 4405f85463f2Sdougm err = sa_disable_share(parent, proto); 4406f85463f2Sdougm else 4407f85463f2Sdougm err = SA_CONFIG_ERR; 4408f85463f2Sdougm } 4409f85463f2Sdougm if (err != SA_OK) 4410f85463f2Sdougm ret = err; 4411f85463f2Sdougm sa_free_attr_string(proto); 4412da6c28aaSamw } 4413f85463f2Sdougm sa_free_protoset(protoset); 4414da6c28aaSamw } 4415da6c28aaSamw if (ret == SA_OK) 4416da6c28aaSamw (void) sa_set_resource_attr(resource, "shared", NULL); 4417da6c28aaSamw 4418da6c28aaSamw return (ret); 4419da6c28aaSamw } 4420da6c28aaSamw 4421da6c28aaSamw /* 4422da6c28aaSamw * sa_set_resource_description(resource, content) 4423da6c28aaSamw * 4424da6c28aaSamw * Set the description of share to content. 4425da6c28aaSamw */ 4426da6c28aaSamw 4427da6c28aaSamw int 4428da6c28aaSamw sa_set_resource_description(sa_resource_t resource, char *content) 4429da6c28aaSamw { 4430da6c28aaSamw xmlNodePtr node; 4431da6c28aaSamw sa_group_t group; 4432da6c28aaSamw sa_share_t share; 4433da6c28aaSamw int ret = SA_OK; 4434da6c28aaSamw 4435da6c28aaSamw for (node = ((xmlNodePtr)resource)->children; 4436da6c28aaSamw node != NULL; 4437da6c28aaSamw node = node->next) { 4438da6c28aaSamw if (xmlStrcmp(node->name, (xmlChar *)"description") == 0) { 4439da6c28aaSamw break; 4440da6c28aaSamw } 4441da6c28aaSamw } 4442da6c28aaSamw 4443da6c28aaSamw /* no existing description but want to add */ 4444da6c28aaSamw if (node == NULL && content != NULL) { 4445da6c28aaSamw /* add a description */ 4446da6c28aaSamw node = _sa_set_share_description(resource, content); 4447da6c28aaSamw } else if (node != NULL && content != NULL) { 4448da6c28aaSamw /* update a description */ 4449da6c28aaSamw xmlNodeSetContent(node, (xmlChar *)content); 4450da6c28aaSamw } else if (node != NULL && content == NULL) { 4451da6c28aaSamw /* remove an existing description */ 4452da6c28aaSamw xmlUnlinkNode(node); 4453da6c28aaSamw xmlFreeNode(node); 4454da6c28aaSamw } 4455148c5f43SAlan Wright 4456da6c28aaSamw share = sa_get_resource_parent(resource); 4457da6c28aaSamw group = sa_get_parent_group(share); 4458148c5f43SAlan Wright if (group != NULL && 4459148c5f43SAlan Wright sa_is_persistent(share) && (!sa_group_is_zfs(group))) { 4460da6c28aaSamw sa_handle_impl_t impl_handle; 4461da6c28aaSamw impl_handle = (sa_handle_impl_t)sa_find_group_handle(group); 4462da6c28aaSamw if (impl_handle != NULL) 4463da6c28aaSamw ret = sa_commit_share(impl_handle->scfhandle, 4464da6c28aaSamw group, share); 4465da6c28aaSamw else 4466da6c28aaSamw ret = SA_SYSTEM_ERR; 4467da6c28aaSamw } 4468da6c28aaSamw return (ret); 4469da6c28aaSamw } 4470da6c28aaSamw 4471da6c28aaSamw /* 4472da6c28aaSamw * sa_get_resource_description(share) 4473da6c28aaSamw * 4474da6c28aaSamw * Return the description text for the specified share if it 4475da6c28aaSamw * exists. NULL if no description exists. 4476da6c28aaSamw */ 4477da6c28aaSamw 4478da6c28aaSamw char * 4479da6c28aaSamw sa_get_resource_description(sa_resource_t resource) 4480da6c28aaSamw { 4481da6c28aaSamw xmlChar *description = NULL; 4482da6c28aaSamw xmlNodePtr node; 4483da6c28aaSamw 4484da6c28aaSamw for (node = ((xmlNodePtr)resource)->children; node != NULL; 4485da6c28aaSamw node = node->next) { 4486da6c28aaSamw if (xmlStrcmp(node->name, (xmlChar *)"description") == 0) 4487da6c28aaSamw break; 4488da6c28aaSamw } 4489da6c28aaSamw if (node != NULL) { 4490da6c28aaSamw description = xmlNodeGetContent(node); 4491da6c28aaSamw fixproblemchars((char *)description); 4492da6c28aaSamw } 4493da6c28aaSamw return ((char *)description); 4494da6c28aaSamw } 4495