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 /* 23f345c0beSdougm * Copyright 2007 Sun Microsystems, Inc. All rights reserved. 246185db85Sdougm * Use is subject to license terms. 256185db85Sdougm */ 266185db85Sdougm 276185db85Sdougm #pragma ident "%Z%%M% %I% %E% SMI" 286185db85Sdougm 296185db85Sdougm /* 306185db85Sdougm * Share control API 316185db85Sdougm */ 326185db85Sdougm #include <stdio.h> 336185db85Sdougm #include <string.h> 346185db85Sdougm #include <ctype.h> 356185db85Sdougm #include <sys/types.h> 366185db85Sdougm #include <sys/stat.h> 37a99982a7Sdougm #include <fcntl.h> 386185db85Sdougm #include <unistd.h> 396185db85Sdougm #include <libxml/parser.h> 406185db85Sdougm #include <libxml/tree.h> 416185db85Sdougm #include "libshare.h" 426185db85Sdougm #include "libshare_impl.h" 436185db85Sdougm #include <libscf.h> 446185db85Sdougm #include "scfutil.h" 456185db85Sdougm #include <ctype.h> 466185db85Sdougm #include <libintl.h> 47549ec3ffSdougm #include <thread.h> 48549ec3ffSdougm #include <synch.h> 496185db85Sdougm 506185db85Sdougm #if _NOT_SMF 516185db85Sdougm #define CONFIG_FILE "/var/tmp/share.cfg" 526185db85Sdougm #define CONFIG_FILE_TMP "/var/tmp/share.cfg.tmp" 536185db85Sdougm #endif 546185db85Sdougm #define TSTAMP(tm) (uint64_t)(((uint64_t)tm.tv_sec << 32) | \ 556185db85Sdougm (tm.tv_nsec & 0xffffffff)) 566185db85Sdougm 57a99982a7Sdougm #define DFS_LOCK_FILE "/etc/dfs/fstypes" 5857b448deSdougm #define SA_STRSIZE 256 /* max string size for names */ 59a99982a7Sdougm 60*da6c28aaSamw /* 61*da6c28aaSamw * internal object type values returned by sa_get_object_type() 62*da6c28aaSamw */ 63*da6c28aaSamw #define SA_TYPE_UNKNOWN 0 64*da6c28aaSamw #define SA_TYPE_GROUP 1 65*da6c28aaSamw #define SA_TYPE_SHARE 2 66*da6c28aaSamw #define SA_TYPE_RESOURCE 3 67*da6c28aaSamw #define SA_TYPE_OPTIONSET 4 68*da6c28aaSamw #define SA_TYPE_ALTSPACE 5 69*da6c28aaSamw 706185db85Sdougm /* 716185db85Sdougm * internal data structures 726185db85Sdougm */ 736185db85Sdougm 746185db85Sdougm extern struct sa_proto_plugin *sap_proto_list; 756185db85Sdougm 766185db85Sdougm /* current SMF/SVC repository handle */ 77549ec3ffSdougm extern void getlegacyconfig(sa_handle_t, char *, xmlNodePtr *); 78549ec3ffSdougm extern int gettransients(sa_handle_impl_t, xmlNodePtr *); 796185db85Sdougm extern int sa_valid_property(void *, char *, sa_property_t); 806185db85Sdougm extern char *sa_fstype(char *); 816185db85Sdougm extern int sa_is_share(void *); 82*da6c28aaSamw extern int sa_is_resource(void *); 836185db85Sdougm extern ssize_t scf_max_name_len; /* defined in scfutil during initialization */ 846185db85Sdougm extern int sa_group_is_zfs(sa_group_t); 856185db85Sdougm extern int sa_path_is_zfs(char *); 866185db85Sdougm extern int sa_zfs_set_sharenfs(sa_group_t, char *, int); 87*da6c28aaSamw extern int sa_zfs_set_sharesmb(sa_group_t, char *, int); 88549ec3ffSdougm extern void update_legacy_config(sa_handle_t); 896185db85Sdougm extern int issubdir(char *, char *); 9057b448deSdougm extern int sa_zfs_init(sa_handle_impl_t); 91549ec3ffSdougm extern void sa_zfs_fini(sa_handle_impl_t); 92a99982a7Sdougm extern void sablocksigs(sigset_t *); 93a99982a7Sdougm extern void saunblocksigs(sigset_t *); 94*da6c28aaSamw static sa_group_t sa_get_optionset_parent(sa_optionset_t); 95*da6c28aaSamw static char *get_node_attr(void *, char *); 966185db85Sdougm 97549ec3ffSdougm /* 98549ec3ffSdougm * Data structures for finding/managing the document root to access 99549ec3ffSdougm * handle mapping. The list isn't expected to grow very large so a 100549ec3ffSdougm * simple list is acceptable. The purpose is to provide a way to start 101549ec3ffSdougm * with a group or share and find the library handle needed for 102549ec3ffSdougm * various operations. 103549ec3ffSdougm */ 104549ec3ffSdougm mutex_t sa_global_lock; 105549ec3ffSdougm struct doc2handle { 106549ec3ffSdougm struct doc2handle *next; 107549ec3ffSdougm xmlNodePtr root; 108549ec3ffSdougm sa_handle_impl_t handle; 109549ec3ffSdougm }; 110549ec3ffSdougm 11157b448deSdougm /* definitions used in a couple of property functions */ 11257b448deSdougm #define SA_PROP_OP_REMOVE 1 11357b448deSdougm #define SA_PROP_OP_ADD 2 11457b448deSdougm #define SA_PROP_OP_UPDATE 3 11557b448deSdougm 116549ec3ffSdougm static struct doc2handle *sa_global_handles = NULL; 1176185db85Sdougm 1186185db85Sdougm /* helper functions */ 1196185db85Sdougm 120549ec3ffSdougm /* 121549ec3ffSdougm * sa_errorstr(err) 122549ec3ffSdougm * 123549ec3ffSdougm * convert an error value to an error string 124549ec3ffSdougm */ 125549ec3ffSdougm 1266185db85Sdougm char * 1276185db85Sdougm sa_errorstr(int err) 1286185db85Sdougm { 1296185db85Sdougm static char errstr[32]; 1306185db85Sdougm char *ret = NULL; 1316185db85Sdougm 1326185db85Sdougm switch (err) { 1336185db85Sdougm case SA_OK: 13457b448deSdougm ret = dgettext(TEXT_DOMAIN, "ok"); 13557b448deSdougm break; 1366185db85Sdougm case SA_NO_SUCH_PATH: 13757b448deSdougm ret = dgettext(TEXT_DOMAIN, "path doesn't exist"); 13857b448deSdougm break; 1396185db85Sdougm case SA_NO_MEMORY: 14057b448deSdougm ret = dgettext(TEXT_DOMAIN, "no memory"); 14157b448deSdougm break; 1426185db85Sdougm case SA_DUPLICATE_NAME: 14357b448deSdougm ret = dgettext(TEXT_DOMAIN, "name in use"); 14457b448deSdougm break; 1456185db85Sdougm case SA_BAD_PATH: 14657b448deSdougm ret = dgettext(TEXT_DOMAIN, "bad path"); 14757b448deSdougm break; 1486185db85Sdougm case SA_NO_SUCH_GROUP: 14957b448deSdougm ret = dgettext(TEXT_DOMAIN, "no such group"); 15057b448deSdougm break; 1516185db85Sdougm case SA_CONFIG_ERR: 15257b448deSdougm ret = dgettext(TEXT_DOMAIN, "configuration error"); 15357b448deSdougm break; 1546185db85Sdougm case SA_SYSTEM_ERR: 15557b448deSdougm ret = dgettext(TEXT_DOMAIN, "system error"); 15657b448deSdougm break; 1576185db85Sdougm case SA_SYNTAX_ERR: 15857b448deSdougm ret = dgettext(TEXT_DOMAIN, "syntax error"); 15957b448deSdougm break; 1606185db85Sdougm case SA_NO_PERMISSION: 16157b448deSdougm ret = dgettext(TEXT_DOMAIN, "no permission"); 16257b448deSdougm break; 1636185db85Sdougm case SA_BUSY: 16457b448deSdougm ret = dgettext(TEXT_DOMAIN, "busy"); 16557b448deSdougm break; 1666185db85Sdougm case SA_NO_SUCH_PROP: 16757b448deSdougm ret = dgettext(TEXT_DOMAIN, "no such property"); 16857b448deSdougm break; 1696185db85Sdougm case SA_INVALID_NAME: 17057b448deSdougm ret = dgettext(TEXT_DOMAIN, "invalid name"); 17157b448deSdougm break; 1726185db85Sdougm case SA_INVALID_PROTOCOL: 17357b448deSdougm ret = dgettext(TEXT_DOMAIN, "invalid protocol"); 17457b448deSdougm break; 1756185db85Sdougm case SA_NOT_ALLOWED: 17657b448deSdougm ret = dgettext(TEXT_DOMAIN, "operation not allowed"); 17757b448deSdougm break; 1786185db85Sdougm case SA_BAD_VALUE: 17957b448deSdougm ret = dgettext(TEXT_DOMAIN, "bad property value"); 18057b448deSdougm break; 1816185db85Sdougm case SA_INVALID_SECURITY: 18257b448deSdougm ret = dgettext(TEXT_DOMAIN, "invalid security type"); 18357b448deSdougm break; 1846185db85Sdougm case SA_NO_SUCH_SECURITY: 18557b448deSdougm ret = dgettext(TEXT_DOMAIN, "security type not found"); 18657b448deSdougm break; 1876185db85Sdougm case SA_VALUE_CONFLICT: 18857b448deSdougm ret = dgettext(TEXT_DOMAIN, "property value conflict"); 18957b448deSdougm break; 1906185db85Sdougm case SA_NOT_IMPLEMENTED: 19157b448deSdougm ret = dgettext(TEXT_DOMAIN, "not implemented"); 19257b448deSdougm break; 1936185db85Sdougm case SA_INVALID_PATH: 19457b448deSdougm ret = dgettext(TEXT_DOMAIN, "invalid path"); 19557b448deSdougm break; 1966185db85Sdougm case SA_NOT_SUPPORTED: 19757b448deSdougm ret = dgettext(TEXT_DOMAIN, "operation not supported"); 19857b448deSdougm break; 1996185db85Sdougm case SA_PROP_SHARE_ONLY: 20057b448deSdougm ret = dgettext(TEXT_DOMAIN, "property not valid for group"); 20157b448deSdougm break; 2026185db85Sdougm case SA_NOT_SHARED: 20357b448deSdougm ret = dgettext(TEXT_DOMAIN, "not shared"); 20457b448deSdougm break; 205*da6c28aaSamw case SA_NO_SUCH_RESOURCE: 206*da6c28aaSamw ret = dgettext(TEXT_DOMAIN, "no such resource"); 207*da6c28aaSamw break; 208*da6c28aaSamw case SA_RESOURCE_REQUIRED: 209*da6c28aaSamw ret = dgettext(TEXT_DOMAIN, "resource name required"); 210*da6c28aaSamw break; 211*da6c28aaSamw case SA_MULTIPLE_ERROR: 212*da6c28aaSamw ret = dgettext(TEXT_DOMAIN, "errors from multiple protocols"); 213*da6c28aaSamw break; 214*da6c28aaSamw case SA_PATH_IS_SUBDIR: 215*da6c28aaSamw ret = dgettext(TEXT_DOMAIN, "path is a subpath of share"); 216*da6c28aaSamw break; 217*da6c28aaSamw case SA_PATH_IS_PARENTDIR: 218*da6c28aaSamw ret = dgettext(TEXT_DOMAIN, "path is parent of a share"); 219*da6c28aaSamw break; 2206185db85Sdougm default: 22157b448deSdougm (void) snprintf(errstr, sizeof (errstr), 22257b448deSdougm dgettext(TEXT_DOMAIN, "unknown %d"), err); 22357b448deSdougm ret = errstr; 2246185db85Sdougm } 2256185db85Sdougm return (ret); 2266185db85Sdougm } 2276185db85Sdougm 228549ec3ffSdougm /* 229549ec3ffSdougm * Document root to active handle mapping functions. These are only 230549ec3ffSdougm * used internally. A mutex is used to prevent access while the list 231549ec3ffSdougm * is changing. In general, the list will be relatively short - one 232549ec3ffSdougm * item per thread that has called sa_init(). 233549ec3ffSdougm */ 234549ec3ffSdougm 235549ec3ffSdougm sa_handle_impl_t 236549ec3ffSdougm get_handle_for_root(xmlNodePtr root) 237549ec3ffSdougm { 238549ec3ffSdougm struct doc2handle *item; 239549ec3ffSdougm 240549ec3ffSdougm (void) mutex_lock(&sa_global_lock); 241549ec3ffSdougm for (item = sa_global_handles; item != NULL; item = item->next) { 24257b448deSdougm if (item->root == root) 24357b448deSdougm break; 244549ec3ffSdougm } 245549ec3ffSdougm (void) mutex_unlock(&sa_global_lock); 246549ec3ffSdougm if (item != NULL) 24757b448deSdougm return (item->handle); 248549ec3ffSdougm return (NULL); 249549ec3ffSdougm } 250549ec3ffSdougm 251549ec3ffSdougm static int 252549ec3ffSdougm add_handle_for_root(xmlNodePtr root, sa_handle_impl_t handle) 253549ec3ffSdougm { 254549ec3ffSdougm struct doc2handle *item; 255549ec3ffSdougm int ret = SA_NO_MEMORY; 256549ec3ffSdougm 257549ec3ffSdougm item = (struct doc2handle *)calloc(sizeof (struct doc2handle), 1); 258549ec3ffSdougm if (item != NULL) { 25957b448deSdougm item->root = root; 26057b448deSdougm item->handle = handle; 26157b448deSdougm (void) mutex_lock(&sa_global_lock); 26257b448deSdougm item->next = sa_global_handles; 26357b448deSdougm sa_global_handles = item; 26457b448deSdougm (void) mutex_unlock(&sa_global_lock); 26557b448deSdougm ret = SA_OK; 266549ec3ffSdougm } 267549ec3ffSdougm return (ret); 268549ec3ffSdougm } 269549ec3ffSdougm 270549ec3ffSdougm /* 271549ec3ffSdougm * remove_handle_for_root(root) 272549ec3ffSdougm * 273549ec3ffSdougm * Walks the list of handles and removes the one for this "root" from 274549ec3ffSdougm * the list. It is up to the caller to free the data. 275549ec3ffSdougm */ 276549ec3ffSdougm 277549ec3ffSdougm static void 278549ec3ffSdougm remove_handle_for_root(xmlNodePtr root) 279549ec3ffSdougm { 280549ec3ffSdougm struct doc2handle *item, *prev; 281549ec3ffSdougm 282549ec3ffSdougm (void) mutex_lock(&sa_global_lock); 283549ec3ffSdougm for (prev = NULL, item = sa_global_handles; item != NULL; 28457b448deSdougm item = item->next) { 28557b448deSdougm if (item->root == root) { 28657b448deSdougm /* first in the list */ 28757b448deSdougm if (prev == NULL) 28857b448deSdougm sa_global_handles = sa_global_handles->next; 28957b448deSdougm else 29057b448deSdougm prev->next = item->next; 29157b448deSdougm /* Item is out of the list so free the list structure */ 29257b448deSdougm free(item); 29357b448deSdougm break; 294549ec3ffSdougm } 29557b448deSdougm prev = item; 296549ec3ffSdougm } 297549ec3ffSdougm (void) mutex_unlock(&sa_global_lock); 298549ec3ffSdougm } 299549ec3ffSdougm 300549ec3ffSdougm /* 301549ec3ffSdougm * sa_find_group_handle(sa_group_t group) 302549ec3ffSdougm * 303549ec3ffSdougm * Find the sa_handle_t for the configuration associated with this 304549ec3ffSdougm * group. 305549ec3ffSdougm */ 306549ec3ffSdougm sa_handle_t 307549ec3ffSdougm sa_find_group_handle(sa_group_t group) 308549ec3ffSdougm { 309549ec3ffSdougm xmlNodePtr node = (xmlNodePtr)group; 310549ec3ffSdougm sa_handle_t handle; 311549ec3ffSdougm 312549ec3ffSdougm while (node != NULL) { 31357b448deSdougm if (strcmp((char *)(node->name), "sharecfg") == 0) { 31457b448deSdougm /* have the root so get the handle */ 31557b448deSdougm handle = (sa_handle_t)get_handle_for_root(node); 31657b448deSdougm return (handle); 31757b448deSdougm } 31857b448deSdougm node = node->parent; 319549ec3ffSdougm } 320549ec3ffSdougm return (NULL); 321549ec3ffSdougm } 322549ec3ffSdougm 3236185db85Sdougm /* 3246185db85Sdougm * set_legacy_timestamp(root, path, timevalue) 3256185db85Sdougm * 3266185db85Sdougm * add the current timestamp value to the configuration for use in 3276185db85Sdougm * determining when to update the legacy files. For SMF, this 3286185db85Sdougm * property is kept in default/operation/legacy_timestamp 3296185db85Sdougm */ 3306185db85Sdougm 3316185db85Sdougm static void 3326185db85Sdougm set_legacy_timestamp(xmlNodePtr root, char *path, uint64_t tval) 3336185db85Sdougm { 3346185db85Sdougm xmlNodePtr node; 3356185db85Sdougm xmlChar *lpath = NULL; 336549ec3ffSdougm sa_handle_impl_t handle; 337549ec3ffSdougm 338549ec3ffSdougm /* Have to have a handle or else we weren't initialized. */ 339549ec3ffSdougm handle = get_handle_for_root(root); 340549ec3ffSdougm if (handle == NULL) 34157b448deSdougm return; 3426185db85Sdougm 3436185db85Sdougm for (node = root->xmlChildrenNode; node != NULL; 34457b448deSdougm node = node->next) { 34557b448deSdougm if (xmlStrcmp(node->name, (xmlChar *)"legacy") == 0) { 34657b448deSdougm /* a possible legacy node for this path */ 34757b448deSdougm lpath = xmlGetProp(node, (xmlChar *)"path"); 34857b448deSdougm if (lpath != NULL && 34957b448deSdougm xmlStrcmp(lpath, (xmlChar *)path) == 0) { 35057b448deSdougm xmlFree(lpath); 35157b448deSdougm break; 35257b448deSdougm } 35357b448deSdougm if (lpath != NULL) 35457b448deSdougm xmlFree(lpath); 3556185db85Sdougm } 3566185db85Sdougm } 3576185db85Sdougm if (node == NULL) { 35857b448deSdougm /* need to create the first legacy timestamp node */ 35957b448deSdougm node = xmlNewChild(root, NULL, (xmlChar *)"legacy", NULL); 3606185db85Sdougm } 3616185db85Sdougm if (node != NULL) { 36257b448deSdougm char tstring[32]; 36357b448deSdougm int ret; 36457b448deSdougm 36557b448deSdougm (void) snprintf(tstring, sizeof (tstring), "%lld", tval); 36657b448deSdougm xmlSetProp(node, (xmlChar *)"timestamp", (xmlChar *)tstring); 36757b448deSdougm xmlSetProp(node, (xmlChar *)"path", (xmlChar *)path); 36857b448deSdougm /* now commit to SMF */ 36957b448deSdougm ret = sa_get_instance(handle->scfhandle, "default"); 3706185db85Sdougm if (ret == SA_OK) { 37157b448deSdougm ret = sa_start_transaction(handle->scfhandle, 37257b448deSdougm "operation"); 37357b448deSdougm if (ret == SA_OK) { 37457b448deSdougm ret = sa_set_property(handle->scfhandle, 37557b448deSdougm "legacy-timestamp", tstring); 37657b448deSdougm if (ret == SA_OK) { 37757b448deSdougm (void) sa_end_transaction( 37857b448deSdougm handle->scfhandle); 37957b448deSdougm } else { 38057b448deSdougm sa_abort_transaction(handle->scfhandle); 38157b448deSdougm } 38257b448deSdougm } 3836185db85Sdougm } 3846185db85Sdougm } 3856185db85Sdougm } 3866185db85Sdougm 3876185db85Sdougm /* 3886185db85Sdougm * is_shared(share) 3896185db85Sdougm * 3906185db85Sdougm * determine if the specified share is currently shared or not. 3916185db85Sdougm */ 3926185db85Sdougm static int 3936185db85Sdougm is_shared(sa_share_t share) 3946185db85Sdougm { 3956185db85Sdougm char *shared; 3966185db85Sdougm int result = 0; /* assume not */ 3976185db85Sdougm 3986185db85Sdougm shared = sa_get_share_attr(share, "shared"); 3996185db85Sdougm if (shared != NULL) { 40057b448deSdougm if (strcmp(shared, "true") == 0) 40157b448deSdougm result = 1; 40257b448deSdougm sa_free_attr_string(shared); 4036185db85Sdougm } 4046185db85Sdougm return (result); 4056185db85Sdougm } 4066185db85Sdougm 407*da6c28aaSamw /* 408*da6c28aaSamw * excluded_protocol(share, proto) 409*da6c28aaSamw * 410*da6c28aaSamw * Returns B_TRUE if the specified protocol appears in the "exclude" 411*da6c28aaSamw * property. This is used to prevent sharing special case shares 412*da6c28aaSamw * (e.g. subdirs when SMB wants a subdir and NFS doesn't. B_FALSE is 413*da6c28aaSamw * returned if the protocol isn't in the list. 414*da6c28aaSamw */ 415*da6c28aaSamw static boolean_t 416*da6c28aaSamw excluded_protocol(sa_share_t share, char *proto) 417*da6c28aaSamw { 418*da6c28aaSamw char *protolist; 419*da6c28aaSamw char *str; 420*da6c28aaSamw char *token; 421*da6c28aaSamw 422*da6c28aaSamw protolist = sa_get_share_attr(share, "exclude"); 423*da6c28aaSamw if (protolist != NULL) { 424*da6c28aaSamw str = protolist; 425*da6c28aaSamw while ((token = strtok(str, ",")) != NULL) { 426*da6c28aaSamw if (strcmp(token, proto) == 0) { 427*da6c28aaSamw sa_free_attr_string(protolist); 428*da6c28aaSamw return (B_TRUE); 429*da6c28aaSamw } 430*da6c28aaSamw str = NULL; 431*da6c28aaSamw } 432*da6c28aaSamw sa_free_attr_string(protolist); 433*da6c28aaSamw } 434*da6c28aaSamw return (B_FALSE); 435*da6c28aaSamw } 436*da6c28aaSamw 4376185db85Sdougm /* 438a99982a7Sdougm * checksubdirgroup(group, newpath, strictness) 439f345c0beSdougm * 440a99982a7Sdougm * check all the specified newpath against all the paths in the 441a99982a7Sdougm * group. This is a helper function for checksubdir to make it easier 442a99982a7Sdougm * to also check ZFS subgroups. 443a99982a7Sdougm * The strictness values mean: 444f345c0beSdougm * SA_CHECK_NORMAL == only check newpath against shares that are active 445f345c0beSdougm * SA_CHECK_STRICT == check newpath against both active shares and those 446f345c0beSdougm * stored in the repository 4476185db85Sdougm */ 4486185db85Sdougm static int 449a99982a7Sdougm checksubdirgroup(sa_group_t group, char *newpath, int strictness) 4506185db85Sdougm { 4516185db85Sdougm sa_share_t share; 452a99982a7Sdougm char *path; 453a99982a7Sdougm int issub = SA_OK; 454*da6c28aaSamw int subdir; 455*da6c28aaSamw int parent; 456*da6c28aaSamw 457*da6c28aaSamw if (newpath == NULL) 458*da6c28aaSamw return (SA_INVALID_PATH); 4596185db85Sdougm 460a99982a7Sdougm for (share = sa_get_share(group, NULL); share != NULL; 461a99982a7Sdougm share = sa_get_next_share(share)) { 4626185db85Sdougm /* 4636185db85Sdougm * The original behavior of share never checked 4646185db85Sdougm * against the permanent configuration 4656185db85Sdougm * (/etc/dfs/dfstab). PIT has a number of cases where 4666185db85Sdougm * it depends on this older behavior even though it 4676185db85Sdougm * could be considered incorrect. We may tighten this 4686185db85Sdougm * up in the future. 4696185db85Sdougm */ 47057b448deSdougm if (strictness == SA_CHECK_NORMAL && !is_shared(share)) 47157b448deSdougm continue; 4726185db85Sdougm 47357b448deSdougm path = sa_get_share_attr(share, "path"); 474f345c0beSdougm /* 475f345c0beSdougm * If path is NULL, then a share is in the process of 476f345c0beSdougm * construction or someone has modified the property 477a99982a7Sdougm * group inappropriately. It should be 478a99982a7Sdougm * ignored. issubdir() comes from the original share 479a99982a7Sdougm * implementation and does the difficult part of 480a99982a7Sdougm * checking subdirectories. 481f345c0beSdougm */ 48257b448deSdougm if (path == NULL) 48357b448deSdougm continue; 484*da6c28aaSamw 485*da6c28aaSamw if (strcmp(path, newpath) == 0) { 48657b448deSdougm issub = SA_INVALID_PATH; 487*da6c28aaSamw } else { 488*da6c28aaSamw subdir = issubdir(newpath, path); 489*da6c28aaSamw parent = issubdir(path, newpath); 490*da6c28aaSamw if (subdir || parent) { 491*da6c28aaSamw sa_free_attr_string(path); 492*da6c28aaSamw path = NULL; 493*da6c28aaSamw return (subdir ? 494*da6c28aaSamw SA_PATH_IS_SUBDIR : SA_PATH_IS_PARENTDIR); 495*da6c28aaSamw } 49657b448deSdougm } 4976185db85Sdougm sa_free_attr_string(path); 4986185db85Sdougm path = NULL; 499a99982a7Sdougm } 500a99982a7Sdougm return (issub); 501a99982a7Sdougm } 502a99982a7Sdougm 503a99982a7Sdougm /* 504a99982a7Sdougm * checksubdir(newpath, strictness) 505a99982a7Sdougm * 506a99982a7Sdougm * checksubdir determines if the specified path (newpath) is a 507a99982a7Sdougm * subdirectory of another share. It calls checksubdirgroup() to do 508a99982a7Sdougm * the complicated work. The strictness parameter determines how 509a99982a7Sdougm * strict a check to make against the path. The strictness values 510a99982a7Sdougm * mean: SA_CHECK_NORMAL == only check newpath against shares that are 511a99982a7Sdougm * active SA_CHECK_STRICT == check newpath against both active shares 512a99982a7Sdougm * and those * stored in the repository 513a99982a7Sdougm */ 514a99982a7Sdougm static int 515549ec3ffSdougm checksubdir(sa_handle_t handle, char *newpath, int strictness) 516a99982a7Sdougm { 517a99982a7Sdougm sa_group_t group; 518*da6c28aaSamw int issub = SA_OK; 519a99982a7Sdougm char *path = NULL; 520a99982a7Sdougm 521*da6c28aaSamw for (group = sa_get_group(handle, NULL); 522*da6c28aaSamw group != NULL && issub == SA_OK; 523*da6c28aaSamw group = sa_get_next_group(group)) { 52457b448deSdougm if (sa_group_is_zfs(group)) { 52557b448deSdougm sa_group_t subgroup; 52657b448deSdougm for (subgroup = sa_get_sub_group(group); 527*da6c28aaSamw subgroup != NULL && issub == SA_OK; 52857b448deSdougm subgroup = sa_get_next_group(subgroup)) 52957b448deSdougm issub = checksubdirgroup(subgroup, newpath, 53057b448deSdougm strictness); 53157b448deSdougm } else { 53257b448deSdougm issub = checksubdirgroup(group, newpath, strictness); 53357b448deSdougm } 5346185db85Sdougm } 5356185db85Sdougm if (path != NULL) 53657b448deSdougm sa_free_attr_string(path); 5376185db85Sdougm return (issub); 5386185db85Sdougm } 5396185db85Sdougm 5406185db85Sdougm /* 541f345c0beSdougm * validpath(path, strictness) 5426185db85Sdougm * determine if the provided path is valid for a share. It shouldn't 5436185db85Sdougm * be a sub-dir of an already shared path or the parent directory of a 5446185db85Sdougm * share path. 5456185db85Sdougm */ 5466185db85Sdougm static int 547549ec3ffSdougm validpath(sa_handle_t handle, char *path, int strictness) 5486185db85Sdougm { 5496185db85Sdougm int error = SA_OK; 5506185db85Sdougm struct stat st; 5516185db85Sdougm sa_share_t share; 5526185db85Sdougm char *fstype; 5536185db85Sdougm 55457b448deSdougm if (*path != '/') 55557b448deSdougm return (SA_BAD_PATH); 55657b448deSdougm 5576185db85Sdougm if (stat(path, &st) < 0) { 55857b448deSdougm error = SA_NO_SUCH_PATH; 5596185db85Sdougm } else { 56057b448deSdougm share = sa_find_share(handle, path); 56157b448deSdougm if (share != NULL) 56257b448deSdougm error = SA_DUPLICATE_NAME; 56357b448deSdougm 56457b448deSdougm if (error == SA_OK) { 56557b448deSdougm /* 56657b448deSdougm * check for special case with file system 56757b448deSdougm * that might have restrictions. For now, ZFS 56857b448deSdougm * is the only case since it has its own idea 56957b448deSdougm * of how to configure shares. We do this 57057b448deSdougm * before subdir checking since things like 57157b448deSdougm * ZFS will do that for us. This should also 57257b448deSdougm * be done via plugin interface. 57357b448deSdougm */ 57457b448deSdougm fstype = sa_fstype(path); 57557b448deSdougm if (fstype != NULL && strcmp(fstype, "zfs") == 0) { 57657b448deSdougm if (sa_zfs_is_shared(handle, path)) 57757b448deSdougm error = SA_INVALID_NAME; 57857b448deSdougm } 57957b448deSdougm if (fstype != NULL) 58057b448deSdougm sa_free_fstype(fstype); 5816185db85Sdougm } 58257b448deSdougm if (error == SA_OK) 58357b448deSdougm error = checksubdir(handle, path, strictness); 5846185db85Sdougm } 5856185db85Sdougm return (error); 5866185db85Sdougm } 5876185db85Sdougm 5886185db85Sdougm /* 5896185db85Sdougm * check to see if group/share is persistent. 590*da6c28aaSamw * 591*da6c28aaSamw * "group" can be either an sa_group_t or an sa_share_t. (void *) 592*da6c28aaSamw * works since both thse types are also void *. 5936185db85Sdougm */ 594*da6c28aaSamw int 595*da6c28aaSamw sa_is_persistent(void *group) 5966185db85Sdougm { 5976185db85Sdougm char *type; 5986185db85Sdougm int persist = 1; 5996185db85Sdougm 600*da6c28aaSamw type = sa_get_group_attr((sa_group_t)group, "type"); 6016185db85Sdougm if (type != NULL && strcmp(type, "transient") == 0) 60257b448deSdougm persist = 0; 6036185db85Sdougm if (type != NULL) 60457b448deSdougm sa_free_attr_string(type); 6056185db85Sdougm return (persist); 6066185db85Sdougm } 6076185db85Sdougm 6086185db85Sdougm /* 6096185db85Sdougm * sa_valid_group_name(name) 6106185db85Sdougm * 6116185db85Sdougm * check that the "name" contains only valid characters and otherwise 6126185db85Sdougm * fits the required naming conventions. Valid names must start with 6136185db85Sdougm * an alphabetic and the remainder may consist of only alphanumeric 6146185db85Sdougm * plus the '-' and '_' characters. This name limitation comes from 6156185db85Sdougm * inherent limitations in SMF. 6166185db85Sdougm */ 6176185db85Sdougm 6186185db85Sdougm int 6196185db85Sdougm sa_valid_group_name(char *name) 6206185db85Sdougm { 6216185db85Sdougm int ret = 1; 6226185db85Sdougm ssize_t len; 6236185db85Sdougm 6246185db85Sdougm if (name != NULL && isalpha(*name)) { 62557b448deSdougm char c; 62657b448deSdougm len = strlen(name); 62757b448deSdougm if (len < (scf_max_name_len - sizeof ("group:"))) { 62857b448deSdougm for (c = *name++; c != '\0' && ret != 0; c = *name++) { 62957b448deSdougm if (!isalnum(c) && c != '-' && c != '_') 63057b448deSdougm ret = 0; 63157b448deSdougm } 63257b448deSdougm } else { 6336185db85Sdougm ret = 0; 6346185db85Sdougm } 6356185db85Sdougm } else { 63657b448deSdougm ret = 0; 6376185db85Sdougm } 6386185db85Sdougm return (ret); 6396185db85Sdougm } 6406185db85Sdougm 6416185db85Sdougm 6426185db85Sdougm /* 6436185db85Sdougm * is_zfs_group(group) 6446185db85Sdougm * Determine if the specified group is a ZFS sharenfs group 6456185db85Sdougm */ 6466185db85Sdougm static int 6476185db85Sdougm is_zfs_group(sa_group_t group) 6486185db85Sdougm { 6496185db85Sdougm int ret = 0; 6506185db85Sdougm xmlNodePtr parent; 6516185db85Sdougm xmlChar *zfs; 6526185db85Sdougm 65357b448deSdougm if (strcmp((char *)((xmlNodePtr)group)->name, "share") == 0) 65457b448deSdougm parent = (xmlNodePtr)sa_get_parent_group(group); 65557b448deSdougm else 65657b448deSdougm parent = (xmlNodePtr)group; 6576185db85Sdougm zfs = xmlGetProp(parent, (xmlChar *)"zfs"); 6586185db85Sdougm if (zfs != NULL) { 65957b448deSdougm xmlFree(zfs); 66057b448deSdougm ret = 1; 6616185db85Sdougm } 6626185db85Sdougm return (ret); 6636185db85Sdougm } 6646185db85Sdougm 665*da6c28aaSamw /* 666*da6c28aaSamw * sa_get_object_type(object) 667*da6c28aaSamw * 668*da6c28aaSamw * This function returns a numeric value representing the object 669*da6c28aaSamw * type. This allows using simpler checks when doing type specific 670*da6c28aaSamw * operations. 671*da6c28aaSamw */ 672*da6c28aaSamw 673*da6c28aaSamw static int 674*da6c28aaSamw sa_get_object_type(void *object) 675*da6c28aaSamw { 676*da6c28aaSamw xmlNodePtr node = (xmlNodePtr)object; 677*da6c28aaSamw int type; 678*da6c28aaSamw 679*da6c28aaSamw if (xmlStrcmp(node->name, (xmlChar *)"group") == 0) 680*da6c28aaSamw type = SA_TYPE_GROUP; 681*da6c28aaSamw else if (xmlStrcmp(node->name, (xmlChar *)"share") == 0) 682*da6c28aaSamw type = SA_TYPE_SHARE; 683*da6c28aaSamw else if (xmlStrcmp(node->name, (xmlChar *)"resource") == 0) 684*da6c28aaSamw type = SA_TYPE_RESOURCE; 685*da6c28aaSamw else if (xmlStrcmp(node->name, (xmlChar *)"optionset") == 0) 686*da6c28aaSamw type = SA_TYPE_OPTIONSET; 687*da6c28aaSamw else if (xmlStrcmp(node->name, (xmlChar *)"security") == 0) 688*da6c28aaSamw type = SA_TYPE_ALTSPACE; 689*da6c28aaSamw else 690*da6c28aaSamw assert(0); 691*da6c28aaSamw return (type); 692*da6c28aaSamw } 693*da6c28aaSamw 6946185db85Sdougm /* 6956185db85Sdougm * sa_optionset_name(optionset, oname, len, id) 6966185db85Sdougm * return the SMF name for the optionset. If id is not NULL, it 6976185db85Sdougm * will have the GUID value for a share and should be used 6986185db85Sdougm * instead of the keyword "optionset" which is used for 6996185db85Sdougm * groups. If the optionset doesn't have a protocol type 7006185db85Sdougm * associated with it, "default" is used. This shouldn't happen 7016185db85Sdougm * at this point but may be desirable in the future if there are 7026185db85Sdougm * protocol independent properties added. The name is returned in 7036185db85Sdougm * oname. 7046185db85Sdougm */ 7056185db85Sdougm 7066185db85Sdougm static int 7076185db85Sdougm sa_optionset_name(sa_optionset_t optionset, char *oname, size_t len, char *id) 7086185db85Sdougm { 7096185db85Sdougm char *proto; 710*da6c28aaSamw void *parent; 711*da6c28aaSamw int ptype; 7126185db85Sdougm 7136185db85Sdougm if (id == NULL) 71457b448deSdougm id = "optionset"; 7156185db85Sdougm 716*da6c28aaSamw parent = sa_get_optionset_parent(optionset); 717*da6c28aaSamw if (parent != NULL) { 718*da6c28aaSamw ptype = sa_get_object_type(parent); 719*da6c28aaSamw proto = sa_get_optionset_attr(optionset, "type"); 720*da6c28aaSamw if (ptype != SA_TYPE_RESOURCE) { 721*da6c28aaSamw len = snprintf(oname, len, "%s_%s", id, 722*da6c28aaSamw proto ? proto : "default"); 723*da6c28aaSamw } else { 724*da6c28aaSamw char *index; 725*da6c28aaSamw index = get_node_attr((void *)parent, "id"); 726*da6c28aaSamw if (index != NULL) 727*da6c28aaSamw len = snprintf(oname, len, "%s_%s_%s", id, 728*da6c28aaSamw proto ? proto : "default", index); 729*da6c28aaSamw else 730*da6c28aaSamw len = 0; 731*da6c28aaSamw } 7326185db85Sdougm 733*da6c28aaSamw if (proto != NULL) 734*da6c28aaSamw sa_free_attr_string(proto); 735*da6c28aaSamw } else { 736*da6c28aaSamw len = 0; 737*da6c28aaSamw } 7386185db85Sdougm return (len); 7396185db85Sdougm } 7406185db85Sdougm 7416185db85Sdougm /* 7426185db85Sdougm * sa_security_name(optionset, oname, len, id) 7436185db85Sdougm * 7446185db85Sdougm * return the SMF name for the security. If id is not NULL, it will 7456185db85Sdougm * have the GUID value for a share and should be used instead of the 7466185db85Sdougm * keyword "optionset" which is used for groups. If the optionset 7476185db85Sdougm * doesn't have a protocol type associated with it, "default" is 7486185db85Sdougm * used. This shouldn't happen at this point but may be desirable in 7496185db85Sdougm * the future if there are protocol independent properties added. The 7506185db85Sdougm * name is returned in oname. The security type is also encoded into 7516185db85Sdougm * the name. In the future, this wil *be handled a bit differently. 7526185db85Sdougm */ 7536185db85Sdougm 7546185db85Sdougm static int 7556185db85Sdougm sa_security_name(sa_security_t security, char *oname, size_t len, char *id) 7566185db85Sdougm { 7576185db85Sdougm char *proto; 7586185db85Sdougm char *sectype; 7596185db85Sdougm 7606185db85Sdougm if (id == NULL) 76157b448deSdougm id = "optionset"; 7626185db85Sdougm 7636185db85Sdougm proto = sa_get_security_attr(security, "type"); 7646185db85Sdougm sectype = sa_get_security_attr(security, "sectype"); 76557b448deSdougm len = snprintf(oname, len, "%s_%s_%s", id, proto ? proto : "default", 76657b448deSdougm sectype ? sectype : "default"); 7676185db85Sdougm if (proto != NULL) 76857b448deSdougm sa_free_attr_string(proto); 7696185db85Sdougm if (sectype != NULL) 77057b448deSdougm sa_free_attr_string(sectype); 7716185db85Sdougm return (len); 7726185db85Sdougm } 7736185db85Sdougm 77457b448deSdougm /* 77557b448deSdougm * verifydefgroupopts(handle) 77657b448deSdougm * 77757b448deSdougm * Make sure a "default" group exists and has default protocols enabled. 77857b448deSdougm */ 77957b448deSdougm static void 78057b448deSdougm verifydefgroupopts(sa_handle_t handle) 78157b448deSdougm { 78257b448deSdougm sa_group_t defgrp; 78357b448deSdougm sa_optionset_t opt; 784*da6c28aaSamw 78557b448deSdougm defgrp = sa_get_group(handle, "default"); 78657b448deSdougm if (defgrp != NULL) { 78757b448deSdougm opt = sa_get_optionset(defgrp, NULL); 78857b448deSdougm /* 78957b448deSdougm * NFS is the default for default group 79057b448deSdougm */ 79157b448deSdougm if (opt == NULL) 79257b448deSdougm opt = sa_create_optionset(defgrp, "nfs"); 79357b448deSdougm } 79457b448deSdougm } 79557b448deSdougm 7966185db85Sdougm /* 797f345c0beSdougm * sa_init(init_service) 7986185db85Sdougm * Initialize the API 7996185db85Sdougm * find all the shared objects 8006185db85Sdougm * init the tables with all objects 8016185db85Sdougm * read in the current configuration 8026185db85Sdougm */ 8036185db85Sdougm 80457b448deSdougm #define GETPROP(prop) scf_simple_prop_next_astring(prop) 80557b448deSdougm #define CHECKTSTAMP(st, tval) stat(SA_LEGACY_DFSTAB, &st) >= 0 && \ 80657b448deSdougm tval != TSTAMP(st.st_ctim) 80757b448deSdougm 808549ec3ffSdougm sa_handle_t 8096185db85Sdougm sa_init(int init_service) 8106185db85Sdougm { 8116185db85Sdougm struct stat st; 8126185db85Sdougm int legacy = 0; 8136185db85Sdougm uint64_t tval = 0; 814a99982a7Sdougm int lockfd; 815a99982a7Sdougm sigset_t old; 816a99982a7Sdougm int updatelegacy = B_FALSE; 817a99982a7Sdougm scf_simple_prop_t *prop; 818549ec3ffSdougm sa_handle_impl_t handle; 819549ec3ffSdougm int err; 820549ec3ffSdougm 821549ec3ffSdougm handle = calloc(sizeof (struct sa_handle_impl), 1); 8226185db85Sdougm 823549ec3ffSdougm if (handle != NULL) { 82457b448deSdougm /* get protocol specific structures */ 82557b448deSdougm (void) proto_plugin_init(); 82657b448deSdougm if (init_service & SA_INIT_SHARE_API) { 827a99982a7Sdougm /* 82857b448deSdougm * initialize access into libzfs. We use this 82957b448deSdougm * when collecting info about ZFS datasets and 83057b448deSdougm * shares. 831a99982a7Sdougm */ 83257b448deSdougm if (sa_zfs_init(handle) == B_FALSE) { 83357b448deSdougm free(handle); 83457b448deSdougm (void) proto_plugin_fini(); 83557b448deSdougm return (NULL); 83657b448deSdougm } 837a99982a7Sdougm /* 83857b448deSdougm * since we want to use SMF, initialize an svc handle 83957b448deSdougm * and find out what is there. 840a99982a7Sdougm */ 84157b448deSdougm handle->scfhandle = sa_scf_init(handle); 84257b448deSdougm if (handle->scfhandle != NULL) { 84357b448deSdougm /* 84457b448deSdougm * Need to lock the extraction of the 84557b448deSdougm * configuration if the dfstab file has 84657b448deSdougm * changed. Lock everything now and release if 84757b448deSdougm * not needed. Use a file that isn't being 84857b448deSdougm * manipulated by other parts of the system in 84957b448deSdougm * order to not interfere with locking. Using 85057b448deSdougm * dfstab doesn't work. 85157b448deSdougm */ 85257b448deSdougm sablocksigs(&old); 85357b448deSdougm lockfd = open(DFS_LOCK_FILE, O_RDWR); 85457b448deSdougm if (lockfd >= 0) { 85557b448deSdougm extern int errno; 85657b448deSdougm errno = 0; 85757b448deSdougm (void) lockf(lockfd, F_LOCK, 0); 85857b448deSdougm /* 85957b448deSdougm * Check whether we are going to need 86057b448deSdougm * to merge any dfstab changes. This 86157b448deSdougm * is done by comparing the value of 86257b448deSdougm * legacy-timestamp with the current 86357b448deSdougm * st_ctim of the file. If they are 86457b448deSdougm * different, an update is needed and 86557b448deSdougm * the file must remain locked until 86657b448deSdougm * the merge is done in order to 86757b448deSdougm * prevent multiple startups from 86857b448deSdougm * changing the SMF repository at the 86957b448deSdougm * same time. The first to get the 87057b448deSdougm * lock will make any changes before 87157b448deSdougm * the others can read the repository. 87257b448deSdougm */ 87357b448deSdougm prop = scf_simple_prop_get 87457b448deSdougm (handle->scfhandle->handle, 87557b448deSdougm (const char *)SA_SVC_FMRI_BASE 87657b448deSdougm ":default", "operation", 87757b448deSdougm "legacy-timestamp"); 87857b448deSdougm if (prop != NULL) { 87957b448deSdougm char *i64; 88057b448deSdougm i64 = GETPROP(prop); 88157b448deSdougm if (i64 != NULL) 88257b448deSdougm tval = strtoull(i64, 88357b448deSdougm NULL, 0); 88457b448deSdougm if (CHECKTSTAMP(st, tval)) 88557b448deSdougm updatelegacy = B_TRUE; 88657b448deSdougm scf_simple_prop_free(prop); 88757b448deSdougm } else { 88857b448deSdougm /* 88957b448deSdougm * We haven't set the 89057b448deSdougm * timestamp before so do it. 89157b448deSdougm */ 89257b448deSdougm updatelegacy = B_TRUE; 89357b448deSdougm } 89457b448deSdougm } 89557b448deSdougm if (updatelegacy == B_FALSE) { 89657b448deSdougm /* Don't need the lock anymore */ 89757b448deSdougm (void) lockf(lockfd, F_ULOCK, 0); 89857b448deSdougm (void) close(lockfd); 89957b448deSdougm } 9001d1813a7Sdougm 90157b448deSdougm /* 90257b448deSdougm * It is essential that the document tree and 90357b448deSdougm * the internal list of roots to handles be 90457b448deSdougm * setup before anything that might try to 90557b448deSdougm * create a new object is called. The document 90657b448deSdougm * tree is the combination of handle->doc and 90757b448deSdougm * handle->tree. This allows searches, 90857b448deSdougm * etc. when all you have is an object in the 90957b448deSdougm * tree. 91057b448deSdougm */ 91157b448deSdougm handle->doc = xmlNewDoc((xmlChar *)"1.0"); 91257b448deSdougm handle->tree = xmlNewNode(NULL, 91357b448deSdougm (xmlChar *)"sharecfg"); 91457b448deSdougm if (handle->doc != NULL && 91557b448deSdougm handle->tree != NULL) { 91657b448deSdougm xmlDocSetRootElement(handle->doc, 91757b448deSdougm handle->tree); 91857b448deSdougm err = add_handle_for_root(handle->tree, 91957b448deSdougm handle); 92057b448deSdougm if (err == SA_OK) 92157b448deSdougm err = sa_get_config( 92257b448deSdougm handle->scfhandle, 9231d1813a7Sdougm handle->tree, handle); 92457b448deSdougm } else { 92557b448deSdougm if (handle->doc != NULL) 92657b448deSdougm xmlFreeDoc(handle->doc); 92757b448deSdougm if (handle->tree != NULL) 92857b448deSdougm xmlFreeNode(handle->tree); 92957b448deSdougm err = SA_NO_MEMORY; 93057b448deSdougm } 93157b448deSdougm 93257b448deSdougm saunblocksigs(&old); 93357b448deSdougm 93457b448deSdougm if (err != SA_OK) { 93557b448deSdougm /* 93657b448deSdougm * If we couldn't add the tree handle 93757b448deSdougm * to the list, then things are going 93857b448deSdougm * to fail badly. Might as well undo 93957b448deSdougm * everything now and fail the 94057b448deSdougm * sa_init(). 94157b448deSdougm */ 94257b448deSdougm sa_fini(handle); 94357b448deSdougm return (NULL); 94457b448deSdougm } 9451d1813a7Sdougm 94657b448deSdougm if (tval == 0) { 94757b448deSdougm /* 94857b448deSdougm * first time so make sure 94957b448deSdougm * default is setup 95057b448deSdougm */ 95157b448deSdougm verifydefgroupopts(handle); 95257b448deSdougm } 953549ec3ffSdougm 954546405c3Sdougm if (updatelegacy == B_TRUE) { 955546405c3Sdougm sablocksigs(&old); 956546405c3Sdougm getlegacyconfig((sa_handle_t)handle, 957546405c3Sdougm SA_LEGACY_DFSTAB, &handle->tree); 958546405c3Sdougm if (stat(SA_LEGACY_DFSTAB, &st) >= 0) 959546405c3Sdougm set_legacy_timestamp( 960546405c3Sdougm handle->tree, 961546405c3Sdougm SA_LEGACY_DFSTAB, 962546405c3Sdougm TSTAMP(st.st_ctim)); 963546405c3Sdougm saunblocksigs(&old); 964546405c3Sdougm /* 965546405c3Sdougm * Safe to unlock now to allow 966546405c3Sdougm * others to run 967546405c3Sdougm */ 968546405c3Sdougm (void) lockf(lockfd, F_ULOCK, 0); 969546405c3Sdougm (void) close(lockfd); 970546405c3Sdougm } 971546405c3Sdougm legacy |= sa_get_zfs_shares(handle, "zfs"); 972546405c3Sdougm legacy |= gettransients(handle, &handle->tree); 9736185db85Sdougm } 9746185db85Sdougm } 9756185db85Sdougm } 976549ec3ffSdougm return ((sa_handle_t)handle); 9776185db85Sdougm } 9786185db85Sdougm 9796185db85Sdougm /* 980549ec3ffSdougm * sa_fini(handle) 9816185db85Sdougm * Uninitialize the API structures including the configuration 9821cea05afSdougm * data structures and ZFS related data. 9836185db85Sdougm */ 9846185db85Sdougm 9856185db85Sdougm void 986549ec3ffSdougm sa_fini(sa_handle_t handle) 9876185db85Sdougm { 988549ec3ffSdougm sa_handle_impl_t impl_handle = (sa_handle_impl_t)handle; 989549ec3ffSdougm 990549ec3ffSdougm if (impl_handle != NULL) { 991549ec3ffSdougm /* 992549ec3ffSdougm * Free the config trees and any other data structures 993549ec3ffSdougm * used in the handle. 994549ec3ffSdougm */ 995549ec3ffSdougm if (impl_handle->doc != NULL) 996549ec3ffSdougm xmlFreeDoc(impl_handle->doc); 997549ec3ffSdougm sa_scf_fini(impl_handle->scfhandle); 998549ec3ffSdougm sa_zfs_fini(impl_handle); 999549ec3ffSdougm 1000549ec3ffSdougm /* Remove and free the entry in the global list. */ 1001549ec3ffSdougm remove_handle_for_root(impl_handle->tree); 1002549ec3ffSdougm 1003549ec3ffSdougm /* Make sure we free the handle */ 1004549ec3ffSdougm free(impl_handle); 1005549ec3ffSdougm 1006549ec3ffSdougm /* 1007549ec3ffSdougm * If this was the last handle to release, unload the 1008549ec3ffSdougm * plugins that were loaded. 1009549ec3ffSdougm */ 1010549ec3ffSdougm if (sa_global_handles == NULL) 101157b448deSdougm (void) proto_plugin_fini(); 1012549ec3ffSdougm 10136185db85Sdougm } 10146185db85Sdougm } 10156185db85Sdougm 10166185db85Sdougm /* 10176185db85Sdougm * sa_get_protocols(char **protocol) 10186185db85Sdougm * Get array of protocols that are supported 10196185db85Sdougm * Returns pointer to an allocated and NULL terminated 10206185db85Sdougm * array of strings. Caller must free. 10216185db85Sdougm * This really should be determined dynamically. 10226185db85Sdougm * If there aren't any defined, return -1. 10236185db85Sdougm * Use free() to return memory. 10246185db85Sdougm */ 10256185db85Sdougm 10266185db85Sdougm int 10276185db85Sdougm sa_get_protocols(char ***protocols) 10286185db85Sdougm { 10296185db85Sdougm int numproto = -1; 10306185db85Sdougm 10316185db85Sdougm if (protocols != NULL) { 103257b448deSdougm struct sa_proto_plugin *plug; 103357b448deSdougm for (numproto = 0, plug = sap_proto_list; plug != NULL; 10346185db85Sdougm plug = plug->plugin_next) { 103557b448deSdougm numproto++; 103657b448deSdougm } 103757b448deSdougm 103857b448deSdougm *protocols = calloc(numproto + 1, sizeof (char *)); 103957b448deSdougm if (*protocols != NULL) { 104057b448deSdougm int ret = 0; 104157b448deSdougm for (plug = sap_proto_list; plug != NULL; 104257b448deSdougm plug = plug->plugin_next) { 104357b448deSdougm /* faking for now */ 104457b448deSdougm (*protocols)[ret++] = 104557b448deSdougm plug->plugin_ops->sa_protocol; 104657b448deSdougm } 104757b448deSdougm } else { 104857b448deSdougm numproto = -1; 10496185db85Sdougm } 10506185db85Sdougm } 10516185db85Sdougm return (numproto); 10526185db85Sdougm } 10536185db85Sdougm 10546185db85Sdougm /* 10556185db85Sdougm * find_group_by_name(node, group) 10566185db85Sdougm * 10576185db85Sdougm * search the XML document subtree specified by node to find the group 10586185db85Sdougm * specified by group. Searching subtree allows subgroups to be 10596185db85Sdougm * searched for. 10606185db85Sdougm */ 10616185db85Sdougm 10626185db85Sdougm static xmlNodePtr 10636185db85Sdougm find_group_by_name(xmlNodePtr node, xmlChar *group) 10646185db85Sdougm { 10656185db85Sdougm xmlChar *name = NULL; 10666185db85Sdougm 10676185db85Sdougm for (node = node->xmlChildrenNode; node != NULL; 10686185db85Sdougm node = node->next) { 106957b448deSdougm if (xmlStrcmp(node->name, (xmlChar *)"group") == 0) { 107057b448deSdougm /* if no groupname, return the first found */ 107157b448deSdougm if (group == NULL) 107257b448deSdougm break; 107357b448deSdougm name = xmlGetProp(node, (xmlChar *)"name"); 107457b448deSdougm if (name != NULL && xmlStrcmp(name, group) == 0) 107557b448deSdougm break; 107657b448deSdougm if (name != NULL) { 107757b448deSdougm xmlFree(name); 107857b448deSdougm name = NULL; 107957b448deSdougm } 10806185db85Sdougm } 10816185db85Sdougm } 10826185db85Sdougm if (name != NULL) 108357b448deSdougm xmlFree(name); 10846185db85Sdougm return (node); 10856185db85Sdougm } 10866185db85Sdougm 10876185db85Sdougm /* 10886185db85Sdougm * sa_get_group(groupname) 10896185db85Sdougm * Return the "group" specified. If groupname is NULL, 10906185db85Sdougm * return the first group of the list of groups. 10916185db85Sdougm */ 10926185db85Sdougm sa_group_t 1093549ec3ffSdougm sa_get_group(sa_handle_t handle, char *groupname) 10946185db85Sdougm { 10956185db85Sdougm xmlNodePtr node = NULL; 10966185db85Sdougm char *subgroup = NULL; 10976185db85Sdougm char *group = NULL; 1098549ec3ffSdougm sa_handle_impl_t impl_handle = (sa_handle_impl_t)handle; 10996185db85Sdougm 1100549ec3ffSdougm if (impl_handle != NULL && impl_handle->tree != NULL) { 110157b448deSdougm if (groupname != NULL) { 110257b448deSdougm group = strdup(groupname); 1103a3351425Sdougm if (group != NULL) { 1104a3351425Sdougm subgroup = strchr(group, '/'); 1105a3351425Sdougm if (subgroup != NULL) 1106a3351425Sdougm *subgroup++ = '\0'; 1107a3351425Sdougm } 110857b448deSdougm } 1109a3351425Sdougm /* 1110a3351425Sdougm * We want to find the, possibly, named group. If 1111a3351425Sdougm * group is not NULL, then lookup the name. If it is 1112a3351425Sdougm * NULL, we only do the find if groupname is also 1113a3351425Sdougm * NULL. This allows lookup of the "first" group in 1114a3351425Sdougm * the internal list. 1115a3351425Sdougm */ 1116a3351425Sdougm if (group != NULL || groupname == NULL) 1117a3351425Sdougm node = find_group_by_name(impl_handle->tree, 1118a3351425Sdougm (xmlChar *)group); 1119a3351425Sdougm 112057b448deSdougm /* if a subgroup, find it before returning */ 112157b448deSdougm if (subgroup != NULL && node != NULL) 112257b448deSdougm node = find_group_by_name(node, (xmlChar *)subgroup); 11236185db85Sdougm } 11246185db85Sdougm if (node != NULL && (char *)group != NULL) 112557b448deSdougm (void) sa_get_instance(impl_handle->scfhandle, (char *)group); 11266185db85Sdougm if (group != NULL) 112757b448deSdougm free(group); 11286185db85Sdougm return ((sa_group_t)(node)); 11296185db85Sdougm } 11306185db85Sdougm 11316185db85Sdougm /* 11326185db85Sdougm * sa_get_next_group(group) 11336185db85Sdougm * Return the "next" group after the specified group from 11346185db85Sdougm * the internal group list. NULL if there are no more. 11356185db85Sdougm */ 11366185db85Sdougm sa_group_t 11376185db85Sdougm sa_get_next_group(sa_group_t group) 11386185db85Sdougm { 11396185db85Sdougm xmlNodePtr ngroup = NULL; 11406185db85Sdougm if (group != NULL) { 114157b448deSdougm for (ngroup = ((xmlNodePtr)group)->next; ngroup != NULL; 11426185db85Sdougm ngroup = ngroup->next) { 114357b448deSdougm if (xmlStrcmp(ngroup->name, (xmlChar *)"group") == 0) 114457b448deSdougm break; 114557b448deSdougm } 11466185db85Sdougm } 11476185db85Sdougm return ((sa_group_t)ngroup); 11486185db85Sdougm } 11496185db85Sdougm 11506185db85Sdougm /* 11516185db85Sdougm * sa_get_share(group, sharepath) 11526185db85Sdougm * Return the share object for the share specified. The share 11536185db85Sdougm * must be in the specified group. Return NULL if not found. 11546185db85Sdougm */ 11556185db85Sdougm sa_share_t 11566185db85Sdougm sa_get_share(sa_group_t group, char *sharepath) 11576185db85Sdougm { 11586185db85Sdougm xmlNodePtr node = NULL; 11596185db85Sdougm xmlChar *path; 11606185db85Sdougm 11616185db85Sdougm /* 11626185db85Sdougm * For future scalability, this should end up building a cache 11636185db85Sdougm * since it will get called regularly by the mountd and info 11646185db85Sdougm * services. 11656185db85Sdougm */ 11666185db85Sdougm if (group != NULL) { 116757b448deSdougm for (node = ((xmlNodePtr)group)->children; node != NULL; 11686185db85Sdougm node = node->next) { 116957b448deSdougm if (xmlStrcmp(node->name, (xmlChar *)"share") == 0) { 117057b448deSdougm if (sharepath == NULL) { 117157b448deSdougm break; 117257b448deSdougm } else { 117357b448deSdougm /* is it the correct share? */ 117457b448deSdougm path = xmlGetProp(node, 117557b448deSdougm (xmlChar *)"path"); 117657b448deSdougm if (path != NULL && 117757b448deSdougm xmlStrcmp(path, 117857b448deSdougm (xmlChar *)sharepath) == 0) { 117957b448deSdougm xmlFree(path); 118057b448deSdougm break; 118157b448deSdougm } 118257b448deSdougm xmlFree(path); 118357b448deSdougm } 11846185db85Sdougm } 11856185db85Sdougm } 11866185db85Sdougm } 11876185db85Sdougm return ((sa_share_t)node); 11886185db85Sdougm } 11896185db85Sdougm 11906185db85Sdougm /* 11916185db85Sdougm * sa_get_next_share(share) 11926185db85Sdougm * Return the next share following the specified share 11936185db85Sdougm * from the internal list of shares. Returns NULL if there 11946185db85Sdougm * are no more shares. The list is relative to the same 11956185db85Sdougm * group. 11966185db85Sdougm */ 11976185db85Sdougm sa_share_t 11986185db85Sdougm sa_get_next_share(sa_share_t share) 11996185db85Sdougm { 12006185db85Sdougm xmlNodePtr node = NULL; 12016185db85Sdougm 12026185db85Sdougm if (share != NULL) { 120357b448deSdougm for (node = ((xmlNodePtr)share)->next; node != NULL; 12046185db85Sdougm node = node->next) { 120557b448deSdougm if (xmlStrcmp(node->name, (xmlChar *)"share") == 0) { 120657b448deSdougm break; 120757b448deSdougm } 12086185db85Sdougm } 12096185db85Sdougm } 12106185db85Sdougm return ((sa_share_t)node); 12116185db85Sdougm } 12126185db85Sdougm 12136185db85Sdougm /* 12146185db85Sdougm * _sa_get_child_node(node, type) 12156185db85Sdougm * 12166185db85Sdougm * find the child node of the specified node that has "type". This is 12176185db85Sdougm * used to implement several internal functions. 12186185db85Sdougm */ 12196185db85Sdougm 12206185db85Sdougm static xmlNodePtr 12216185db85Sdougm _sa_get_child_node(xmlNodePtr node, xmlChar *type) 12226185db85Sdougm { 12236185db85Sdougm xmlNodePtr child; 12246185db85Sdougm for (child = node->xmlChildrenNode; child != NULL; 12256185db85Sdougm child = child->next) 122657b448deSdougm if (xmlStrcmp(child->name, type) == 0) 122757b448deSdougm return (child); 12286185db85Sdougm return ((xmlNodePtr)NULL); 12296185db85Sdougm } 12306185db85Sdougm 12316185db85Sdougm /* 12326185db85Sdougm * find_share(group, path) 12336185db85Sdougm * 12346185db85Sdougm * Search all the shares in the specified group for one that has the 12356185db85Sdougm * specified path. 12366185db85Sdougm */ 12376185db85Sdougm 12386185db85Sdougm static sa_share_t 12396185db85Sdougm find_share(sa_group_t group, char *sharepath) 12406185db85Sdougm { 12416185db85Sdougm sa_share_t share; 12426185db85Sdougm char *path; 12436185db85Sdougm 12446185db85Sdougm for (share = sa_get_share(group, NULL); share != NULL; 12456185db85Sdougm share = sa_get_next_share(share)) { 124657b448deSdougm path = sa_get_share_attr(share, "path"); 124757b448deSdougm if (path != NULL && strcmp(path, sharepath) == 0) { 124857b448deSdougm sa_free_attr_string(path); 124957b448deSdougm break; 125057b448deSdougm } 125157b448deSdougm if (path != NULL) 125257b448deSdougm sa_free_attr_string(path); 12536185db85Sdougm } 12546185db85Sdougm return (share); 12556185db85Sdougm } 12566185db85Sdougm 12576185db85Sdougm /* 12586185db85Sdougm * sa_get_sub_group(group) 12596185db85Sdougm * 12606185db85Sdougm * Get the first sub-group of group. The sa_get_next_group() function 12616185db85Sdougm * can be used to get the rest. This is currently only used for ZFS 12626185db85Sdougm * sub-groups but could be used to implement a more general mechanism. 12636185db85Sdougm */ 12646185db85Sdougm 12656185db85Sdougm sa_group_t 12666185db85Sdougm sa_get_sub_group(sa_group_t group) 12676185db85Sdougm { 12686185db85Sdougm return ((sa_group_t)_sa_get_child_node((xmlNodePtr)group, 126957b448deSdougm (xmlChar *)"group")); 12706185db85Sdougm } 12716185db85Sdougm 12726185db85Sdougm /* 12736185db85Sdougm * sa_find_share(sharepath) 12746185db85Sdougm * Finds a share regardless of group. In the future, this 12756185db85Sdougm * function should utilize a cache and hash table of some kind. 12766185db85Sdougm * The current assumption is that a path will only be shared 12776185db85Sdougm * once. In the future, this may change as implementation of 12786185db85Sdougm * resource names comes into being. 12796185db85Sdougm */ 12806185db85Sdougm sa_share_t 1281549ec3ffSdougm sa_find_share(sa_handle_t handle, char *sharepath) 12826185db85Sdougm { 12836185db85Sdougm sa_group_t group; 12846185db85Sdougm sa_group_t zgroup; 12856185db85Sdougm sa_share_t share = NULL; 12866185db85Sdougm int done = 0; 12876185db85Sdougm 1288549ec3ffSdougm for (group = sa_get_group(handle, NULL); group != NULL && !done; 128957b448deSdougm group = sa_get_next_group(group)) { 129057b448deSdougm if (is_zfs_group(group)) { 129157b448deSdougm for (zgroup = 129257b448deSdougm (sa_group_t)_sa_get_child_node((xmlNodePtr)group, 129357b448deSdougm (xmlChar *)"group"); 129457b448deSdougm zgroup != NULL; 129557b448deSdougm zgroup = sa_get_next_group(zgroup)) { 129657b448deSdougm share = find_share(zgroup, sharepath); 129757b448deSdougm if (share != NULL) 129857b448deSdougm break; 129957b448deSdougm } 130057b448deSdougm } else { 130157b448deSdougm share = find_share(group, sharepath); 13026185db85Sdougm } 130357b448deSdougm if (share != NULL) 130457b448deSdougm break; 13056185db85Sdougm } 13066185db85Sdougm return (share); 13076185db85Sdougm } 13086185db85Sdougm 13096185db85Sdougm /* 1310f345c0beSdougm * sa_check_path(group, path, strictness) 13116185db85Sdougm * 1312*da6c28aaSamw * Check that path is a valid path relative to the group. Currently, 13136185db85Sdougm * we are ignoring the group and checking only the NFS rules. Later, 13146185db85Sdougm * we may want to use the group to then check against the protocols 1315f345c0beSdougm * enabled on the group. The strictness values mean: 1316f345c0beSdougm * SA_CHECK_NORMAL == only check newpath against shares that are active 1317f345c0beSdougm * SA_CHECK_STRICT == check newpath against both active shares and those 1318f345c0beSdougm * stored in the repository 13196185db85Sdougm */ 13206185db85Sdougm 13216185db85Sdougm int 1322f345c0beSdougm sa_check_path(sa_group_t group, char *path, int strictness) 13236185db85Sdougm { 1324549ec3ffSdougm sa_handle_t handle; 1325549ec3ffSdougm 1326549ec3ffSdougm handle = sa_find_group_handle(group); 1327549ec3ffSdougm return (validpath(handle, path, strictness)); 13286185db85Sdougm } 13296185db85Sdougm 13306185db85Sdougm /* 1331*da6c28aaSamw * mark_excluded_protos(group, share, flags) 1332*da6c28aaSamw * 1333*da6c28aaSamw * Walk through all the protocols enabled for the group and check to 1334*da6c28aaSamw * see if the share has any of them should be in the exclude list 1335*da6c28aaSamw * based on the featureset of the protocol. If there are any, add the 1336*da6c28aaSamw * "exclude" property to the share. 1337*da6c28aaSamw */ 1338*da6c28aaSamw static void 1339*da6c28aaSamw mark_excluded_protos(sa_group_t group, xmlNodePtr share, uint64_t flags) 1340*da6c28aaSamw { 1341*da6c28aaSamw sa_optionset_t optionset; 1342*da6c28aaSamw char exclude_list[SA_STRSIZE]; 1343*da6c28aaSamw char *sep = ""; 1344*da6c28aaSamw 1345*da6c28aaSamw exclude_list[0] = '\0'; 1346*da6c28aaSamw for (optionset = sa_get_optionset(group, NULL); 1347*da6c28aaSamw optionset != NULL; 1348*da6c28aaSamw optionset = sa_get_next_optionset(optionset)) { 1349*da6c28aaSamw char *value; 1350*da6c28aaSamw uint64_t features; 1351*da6c28aaSamw value = sa_get_optionset_attr(optionset, "type"); 1352*da6c28aaSamw if (value == NULL) 1353*da6c28aaSamw continue; 1354*da6c28aaSamw features = sa_proto_get_featureset(value); 1355*da6c28aaSamw sa_free_attr_string(value); 1356*da6c28aaSamw if (!(features & flags)) { 1357*da6c28aaSamw (void) strlcat(exclude_list, sep, 1358*da6c28aaSamw sizeof (exclude_list)); 1359*da6c28aaSamw (void) strlcat(exclude_list, value, 1360*da6c28aaSamw sizeof (exclude_list)); 1361*da6c28aaSamw sep = ","; 1362*da6c28aaSamw } 1363*da6c28aaSamw } 1364*da6c28aaSamw if (exclude_list[0] != '\0') 1365*da6c28aaSamw xmlSetProp(share, (xmlChar *)"exclude", 1366*da6c28aaSamw (xmlChar *)exclude_list); 1367*da6c28aaSamw } 1368*da6c28aaSamw 1369*da6c28aaSamw /* 1370*da6c28aaSamw * get_all_features(group) 1371*da6c28aaSamw * 1372*da6c28aaSamw * Walk through all the protocols on the group and collect all 1373*da6c28aaSamw * possible enabled features. This is the OR of all the featuresets. 1374*da6c28aaSamw */ 1375*da6c28aaSamw static uint64_t 1376*da6c28aaSamw get_all_features(sa_group_t group) 1377*da6c28aaSamw { 1378*da6c28aaSamw sa_optionset_t optionset; 1379*da6c28aaSamw uint64_t features = 0; 1380*da6c28aaSamw 1381*da6c28aaSamw for (optionset = sa_get_optionset(group, NULL); 1382*da6c28aaSamw optionset != NULL; 1383*da6c28aaSamw optionset = sa_get_next_optionset(optionset)) { 1384*da6c28aaSamw char *value; 1385*da6c28aaSamw value = sa_get_optionset_attr(optionset, "type"); 1386*da6c28aaSamw if (value == NULL) 1387*da6c28aaSamw continue; 1388*da6c28aaSamw features |= sa_proto_get_featureset(value); 1389*da6c28aaSamw sa_free_attr_string(value); 1390*da6c28aaSamw } 1391*da6c28aaSamw return (features); 1392*da6c28aaSamw } 1393*da6c28aaSamw 1394*da6c28aaSamw 1395*da6c28aaSamw /* 1396*da6c28aaSamw * _sa_add_share(group, sharepath, persist, *error, flags) 13976185db85Sdougm * 1398*da6c28aaSamw * Common code for all types of add_share. sa_add_share() is the 13996185db85Sdougm * public API, we also need to be able to do this when parsing legacy 14006185db85Sdougm * files and construction of the internal configuration while 1401*da6c28aaSamw * extracting config info from SMF. "flags" indicates if some 1402*da6c28aaSamw * protocols need relaxed rules while other don't. These values are 1403*da6c28aaSamw * the featureset values defined in libshare.h. 14046185db85Sdougm */ 14056185db85Sdougm 14066185db85Sdougm sa_share_t 1407*da6c28aaSamw _sa_add_share(sa_group_t group, char *sharepath, int persist, int *error, 1408*da6c28aaSamw uint64_t flags) 14096185db85Sdougm { 14106185db85Sdougm xmlNodePtr node = NULL; 14116185db85Sdougm int err; 14126185db85Sdougm 14136185db85Sdougm err = SA_OK; /* assume success */ 14146185db85Sdougm 141557b448deSdougm node = xmlNewChild((xmlNodePtr)group, NULL, (xmlChar *)"share", NULL); 1416*da6c28aaSamw if (node == NULL) { 1417*da6c28aaSamw if (error != NULL) 1418*da6c28aaSamw *error = SA_NO_MEMORY; 1419*da6c28aaSamw return (node); 1420*da6c28aaSamw } 1421*da6c28aaSamw 1422*da6c28aaSamw xmlSetProp(node, (xmlChar *)"path", (xmlChar *)sharepath); 1423*da6c28aaSamw xmlSetProp(node, (xmlChar *)"type", 1424*da6c28aaSamw persist ? (xmlChar *)"persist" : (xmlChar *)"transient"); 1425*da6c28aaSamw if (flags != 0) 1426*da6c28aaSamw mark_excluded_protos(group, node, flags); 1427*da6c28aaSamw if (persist != SA_SHARE_TRANSIENT) { 1428*da6c28aaSamw /* 1429*da6c28aaSamw * persistent shares come in two flavors: SMF and 1430*da6c28aaSamw * ZFS. Sort this one out based on target group and 1431*da6c28aaSamw * path type. Both NFS and SMB are supported. First, 1432*da6c28aaSamw * check to see if the protocol is enabled on the 1433*da6c28aaSamw * subgroup and then setup the share appropriately. 1434*da6c28aaSamw */ 1435*da6c28aaSamw if (sa_group_is_zfs(group) && 1436*da6c28aaSamw sa_path_is_zfs(sharepath)) { 1437*da6c28aaSamw if (sa_get_optionset(group, "nfs") != NULL) 143857b448deSdougm err = sa_zfs_set_sharenfs(group, sharepath, 1); 1439*da6c28aaSamw else if (sa_get_optionset(group, "smb") != NULL) 1440*da6c28aaSamw err = sa_zfs_set_sharesmb(group, sharepath, 1); 1441*da6c28aaSamw } else { 1442*da6c28aaSamw sa_handle_impl_t impl_handle; 1443*da6c28aaSamw impl_handle = 1444*da6c28aaSamw (sa_handle_impl_t)sa_find_group_handle(group); 1445*da6c28aaSamw if (impl_handle != NULL) { 1446*da6c28aaSamw err = sa_commit_share(impl_handle->scfhandle, 1447*da6c28aaSamw group, (sa_share_t)node); 144857b448deSdougm } else { 1449*da6c28aaSamw err = SA_SYSTEM_ERR; 145057b448deSdougm } 145157b448deSdougm } 14526185db85Sdougm } 1453*da6c28aaSamw if (err == SA_NO_PERMISSION && persist & SA_SHARE_PARSER) 1454*da6c28aaSamw /* called by the dfstab parser so could be a show */ 1455*da6c28aaSamw err = SA_OK; 1456*da6c28aaSamw 1457*da6c28aaSamw if (err != SA_OK) { 1458*da6c28aaSamw /* 1459*da6c28aaSamw * we couldn't commit to the repository so undo 1460*da6c28aaSamw * our internal state to reflect reality. 1461*da6c28aaSamw */ 1462*da6c28aaSamw xmlUnlinkNode(node); 1463*da6c28aaSamw xmlFreeNode(node); 1464*da6c28aaSamw node = NULL; 1465*da6c28aaSamw } 1466*da6c28aaSamw 14676185db85Sdougm if (error != NULL) 146857b448deSdougm *error = err; 1469*da6c28aaSamw 14706185db85Sdougm return (node); 14716185db85Sdougm } 14726185db85Sdougm 14736185db85Sdougm /* 14746185db85Sdougm * sa_add_share(group, sharepath, persist, *error) 14756185db85Sdougm * 14766185db85Sdougm * Add a new share object to the specified group. The share will 14776185db85Sdougm * have the specified sharepath and will only be constructed if 14786185db85Sdougm * it is a valid path to be shared. NULL is returned on error 14796185db85Sdougm * and a detailed error value will be returned via the error 14806185db85Sdougm * pointer. 14816185db85Sdougm */ 14826185db85Sdougm sa_share_t 14836185db85Sdougm sa_add_share(sa_group_t group, char *sharepath, int persist, int *error) 14846185db85Sdougm { 14856185db85Sdougm xmlNodePtr node = NULL; 1486f345c0beSdougm int strictness = SA_CHECK_NORMAL; 1487549ec3ffSdougm sa_handle_t handle; 1488*da6c28aaSamw uint64_t special = 0; 1489*da6c28aaSamw uint64_t features; 1490f345c0beSdougm 1491f345c0beSdougm /* 1492f345c0beSdougm * If the share is to be permanent, use strict checking so a 1493f345c0beSdougm * bad config doesn't get created. Transient shares only need 1494f345c0beSdougm * to check against the currently active 1495f345c0beSdougm * shares. SA_SHARE_PARSER is a modifier used internally to 1496f345c0beSdougm * indicate that we are being called by the dfstab parser and 1497f345c0beSdougm * that we need strict checking in all cases. Normally persist 1498f345c0beSdougm * is in integer value but SA_SHARE_PARSER may be or'd into 1499f345c0beSdougm * it as an override. 1500f345c0beSdougm */ 1501f345c0beSdougm if (persist & SA_SHARE_PARSER || persist == SA_SHARE_PERMANENT) 150257b448deSdougm strictness = SA_CHECK_STRICT; 15036185db85Sdougm 1504549ec3ffSdougm handle = sa_find_group_handle(group); 1505549ec3ffSdougm 1506*da6c28aaSamw /* 1507*da6c28aaSamw * need to determine if the share is valid. The rules are: 1508*da6c28aaSamw * - The path must not already exist 1509*da6c28aaSamw * - The path must not be a subdir or parent dir of an 1510*da6c28aaSamw * existing path unless at least one protocol allows it. 1511*da6c28aaSamw * The sub/parent check is done in sa_check_path(). 1512*da6c28aaSamw */ 1513*da6c28aaSamw 1514*da6c28aaSamw if (sa_find_share(handle, sharepath) == NULL) { 1515*da6c28aaSamw *error = sa_check_path(group, sharepath, strictness); 1516*da6c28aaSamw features = get_all_features(group); 1517*da6c28aaSamw switch (*error) { 1518*da6c28aaSamw case SA_PATH_IS_SUBDIR: 1519*da6c28aaSamw if (features & SA_FEATURE_ALLOWSUBDIRS) 1520*da6c28aaSamw special |= SA_FEATURE_ALLOWSUBDIRS; 1521*da6c28aaSamw break; 1522*da6c28aaSamw case SA_PATH_IS_PARENTDIR: 1523*da6c28aaSamw if (features & SA_FEATURE_ALLOWPARDIRS) 1524*da6c28aaSamw special |= SA_FEATURE_ALLOWPARDIRS; 1525*da6c28aaSamw break; 1526*da6c28aaSamw } 1527*da6c28aaSamw if (*error == SA_OK || special != SA_FEATURE_NONE) 1528*da6c28aaSamw node = _sa_add_share(group, sharepath, persist, 1529*da6c28aaSamw error, special); 1530*da6c28aaSamw } else { 153157b448deSdougm *error = SA_DUPLICATE_NAME; 1532*da6c28aaSamw } 15336185db85Sdougm 15346185db85Sdougm return ((sa_share_t)node); 15356185db85Sdougm } 15366185db85Sdougm 15376185db85Sdougm /* 15386185db85Sdougm * sa_enable_share(share, protocol) 15396185db85Sdougm * Enable the specified share to the specified protocol. 15406185db85Sdougm * If protocol is NULL, then all protocols. 15416185db85Sdougm */ 15426185db85Sdougm int 15436185db85Sdougm sa_enable_share(sa_share_t share, char *protocol) 15446185db85Sdougm { 15456185db85Sdougm char *sharepath; 15466185db85Sdougm struct stat st; 1547*da6c28aaSamw int err = SA_OK; 1548*da6c28aaSamw int ret; 15496185db85Sdougm 15506185db85Sdougm sharepath = sa_get_share_attr(share, "path"); 1551*da6c28aaSamw if (sharepath == NULL) 1552*da6c28aaSamw return (SA_NO_MEMORY); 15536185db85Sdougm if (stat(sharepath, &st) < 0) { 155457b448deSdougm err = SA_NO_SUCH_PATH; 15556185db85Sdougm } else { 155657b448deSdougm /* tell the server about the share */ 155757b448deSdougm if (protocol != NULL) { 1558*da6c28aaSamw if (excluded_protocol(share, protocol)) 1559*da6c28aaSamw goto done; 1560*da6c28aaSamw 156157b448deSdougm /* lookup protocol specific handler */ 156257b448deSdougm err = sa_proto_share(protocol, share); 156357b448deSdougm if (err == SA_OK) 1564*da6c28aaSamw (void) sa_set_share_attr(share, 1565*da6c28aaSamw "shared", "true"); 156657b448deSdougm } else { 1567*da6c28aaSamw /* Tell all protocols about the share */ 1568*da6c28aaSamw sa_group_t group; 1569*da6c28aaSamw sa_optionset_t optionset; 1570*da6c28aaSamw 1571*da6c28aaSamw group = sa_get_parent_group(share); 1572*da6c28aaSamw 1573*da6c28aaSamw for (optionset = sa_get_optionset(group, NULL); 1574*da6c28aaSamw optionset != NULL; 1575*da6c28aaSamw optionset = sa_get_next_optionset(optionset)) { 1576*da6c28aaSamw char *proto; 1577*da6c28aaSamw proto = sa_get_optionset_attr(optionset, 1578*da6c28aaSamw "type"); 1579*da6c28aaSamw if (proto != NULL) { 1580*da6c28aaSamw if (!excluded_protocol(share, proto)) { 1581*da6c28aaSamw ret = sa_proto_share(proto, 1582*da6c28aaSamw share); 1583*da6c28aaSamw if (ret != SA_OK) 1584*da6c28aaSamw err = ret; 1585*da6c28aaSamw } 1586*da6c28aaSamw sa_free_attr_string(proto); 1587*da6c28aaSamw } 1588*da6c28aaSamw } 158957b448deSdougm (void) sa_set_share_attr(share, "shared", "true"); 159057b448deSdougm } 15916185db85Sdougm } 1592*da6c28aaSamw done: 15936185db85Sdougm if (sharepath != NULL) 159457b448deSdougm sa_free_attr_string(sharepath); 15956185db85Sdougm return (err); 15966185db85Sdougm } 15976185db85Sdougm 15986185db85Sdougm /* 15996185db85Sdougm * sa_disable_share(share, protocol) 1600*da6c28aaSamw * Disable the specified share to the specified protocol. If 1601*da6c28aaSamw * protocol is NULL, then all protocols that are enabled for the 1602*da6c28aaSamw * share should be disabled. 16036185db85Sdougm */ 16046185db85Sdougm int 16056185db85Sdougm sa_disable_share(sa_share_t share, char *protocol) 16066185db85Sdougm { 16076185db85Sdougm char *path; 1608*da6c28aaSamw int err = SA_OK; 16096185db85Sdougm int ret = SA_OK; 16106185db85Sdougm 16116185db85Sdougm path = sa_get_share_attr(share, "path"); 16126185db85Sdougm 16136185db85Sdougm if (protocol != NULL) { 1614ecd6cf80Smarks ret = sa_proto_unshare(share, protocol, path); 16156185db85Sdougm } else { 161657b448deSdougm /* need to do all protocols */ 1617*da6c28aaSamw sa_group_t group; 1618*da6c28aaSamw sa_optionset_t optionset; 1619*da6c28aaSamw 1620*da6c28aaSamw group = sa_get_parent_group(share); 1621*da6c28aaSamw 1622*da6c28aaSamw /* Tell all protocols about the share */ 1623*da6c28aaSamw for (optionset = sa_get_optionset(group, NULL); 1624*da6c28aaSamw optionset != NULL; 1625*da6c28aaSamw optionset = sa_get_next_optionset(optionset)) { 1626*da6c28aaSamw char *proto; 1627*da6c28aaSamw 1628*da6c28aaSamw proto = sa_get_optionset_attr(optionset, "type"); 1629*da6c28aaSamw if (proto != NULL) { 1630*da6c28aaSamw err = sa_proto_unshare(share, proto, path); 1631*da6c28aaSamw if (err != SA_OK) 1632*da6c28aaSamw ret = err; 1633*da6c28aaSamw sa_free_attr_string(proto); 1634*da6c28aaSamw } 1635*da6c28aaSamw } 16366185db85Sdougm } 16376185db85Sdougm if (ret == SA_OK) 16386185db85Sdougm (void) sa_set_share_attr(share, "shared", NULL); 16396185db85Sdougm if (path != NULL) 164057b448deSdougm sa_free_attr_string(path); 16416185db85Sdougm return (ret); 16426185db85Sdougm } 16436185db85Sdougm 16446185db85Sdougm /* 16456185db85Sdougm * sa_remove_share(share) 16466185db85Sdougm * 16476185db85Sdougm * remove the specified share from its containing group. 16486185db85Sdougm * Remove from the SMF or ZFS configuration space. 16496185db85Sdougm */ 16506185db85Sdougm 16516185db85Sdougm int 16526185db85Sdougm sa_remove_share(sa_share_t share) 16536185db85Sdougm { 16546185db85Sdougm sa_group_t group; 16556185db85Sdougm int ret = SA_OK; 16566185db85Sdougm char *type; 16576185db85Sdougm int transient = 0; 16586185db85Sdougm char *groupname; 16596185db85Sdougm char *zfs; 16606185db85Sdougm 16616185db85Sdougm type = sa_get_share_attr(share, "type"); 16626185db85Sdougm group = sa_get_parent_group(share); 16636185db85Sdougm zfs = sa_get_group_attr(group, "zfs"); 16646185db85Sdougm groupname = sa_get_group_attr(group, "name"); 16656185db85Sdougm if (type != NULL && strcmp(type, "persist") != 0) 166657b448deSdougm transient = 1; 16676185db85Sdougm if (type != NULL) 166857b448deSdougm sa_free_attr_string(type); 16696185db85Sdougm 16706185db85Sdougm /* remove the node from its group then free the memory */ 16716185db85Sdougm 16726185db85Sdougm /* 16736185db85Sdougm * need to test if "busy" 16746185db85Sdougm */ 16756185db85Sdougm /* only do SMF action if permanent */ 16766185db85Sdougm if (!transient || zfs != NULL) { 167757b448deSdougm /* remove from legacy dfstab as well as possible SMF */ 1678*da6c28aaSamw ret = sa_delete_legacy(share, NULL); 167957b448deSdougm if (ret == SA_OK) { 168057b448deSdougm if (!sa_group_is_zfs(group)) { 168157b448deSdougm sa_handle_impl_t impl_handle; 168257b448deSdougm impl_handle = (sa_handle_impl_t) 168357b448deSdougm sa_find_group_handle(group); 168457b448deSdougm if (impl_handle != NULL) { 168557b448deSdougm ret = sa_delete_share( 168657b448deSdougm impl_handle->scfhandle, group, 168757b448deSdougm share); 168857b448deSdougm } else { 168957b448deSdougm ret = SA_SYSTEM_ERR; 169057b448deSdougm } 169157b448deSdougm } else { 169257b448deSdougm char *sharepath = sa_get_share_attr(share, 169357b448deSdougm "path"); 169457b448deSdougm if (sharepath != NULL) { 169557b448deSdougm ret = sa_zfs_set_sharenfs(group, 169657b448deSdougm sharepath, 0); 169757b448deSdougm sa_free_attr_string(sharepath); 169857b448deSdougm } 169957b448deSdougm } 17006185db85Sdougm } 17016185db85Sdougm } 17026185db85Sdougm if (groupname != NULL) 170357b448deSdougm sa_free_attr_string(groupname); 17046185db85Sdougm if (zfs != NULL) 170557b448deSdougm sa_free_attr_string(zfs); 17066185db85Sdougm 17076185db85Sdougm xmlUnlinkNode((xmlNodePtr)share); 17086185db85Sdougm xmlFreeNode((xmlNodePtr)share); 17096185db85Sdougm return (ret); 17106185db85Sdougm } 17116185db85Sdougm 17126185db85Sdougm /* 17136185db85Sdougm * sa_move_share(group, share) 17146185db85Sdougm * 17156185db85Sdougm * move the specified share to the specified group. Update SMF 17166185db85Sdougm * appropriately. 17176185db85Sdougm */ 17186185db85Sdougm 17196185db85Sdougm int 17206185db85Sdougm sa_move_share(sa_group_t group, sa_share_t share) 17216185db85Sdougm { 17226185db85Sdougm sa_group_t oldgroup; 17236185db85Sdougm int ret = SA_OK; 17246185db85Sdougm 17256185db85Sdougm /* remove the node from its group then free the memory */ 17266185db85Sdougm 17276185db85Sdougm oldgroup = sa_get_parent_group(share); 17286185db85Sdougm if (oldgroup != group) { 172957b448deSdougm sa_handle_impl_t impl_handle; 173057b448deSdougm xmlUnlinkNode((xmlNodePtr)share); 17316185db85Sdougm /* 173257b448deSdougm * now that the share isn't in its old group, add to 173357b448deSdougm * the new one 17346185db85Sdougm */ 173557b448deSdougm xmlAddChild((xmlNodePtr)group, (xmlNodePtr)share); 173657b448deSdougm /* need to deal with SMF */ 173757b448deSdougm impl_handle = (sa_handle_impl_t)sa_find_group_handle(group); 173857b448deSdougm if (impl_handle != NULL) { 173957b448deSdougm /* 174057b448deSdougm * need to remove from old group first and then add to 174157b448deSdougm * new group. Ideally, we would do the other order but 174257b448deSdougm * need to avoid having the share in two groups at the 174357b448deSdougm * same time. 174457b448deSdougm */ 174557b448deSdougm ret = sa_delete_share(impl_handle->scfhandle, oldgroup, 174657b448deSdougm share); 174757b448deSdougm if (ret == SA_OK) 174857b448deSdougm ret = sa_commit_share(impl_handle->scfhandle, 174957b448deSdougm group, share); 175057b448deSdougm } else { 175157b448deSdougm ret = SA_SYSTEM_ERR; 175257b448deSdougm } 17536185db85Sdougm } 17546185db85Sdougm return (ret); 17556185db85Sdougm } 17566185db85Sdougm 17576185db85Sdougm /* 17586185db85Sdougm * sa_get_parent_group(share) 17596185db85Sdougm * 1760*da6c28aaSamw * Return the containing group for the share. If a group was actually 17616185db85Sdougm * passed in, we don't want a parent so return NULL. 17626185db85Sdougm */ 17636185db85Sdougm 17646185db85Sdougm sa_group_t 17656185db85Sdougm sa_get_parent_group(sa_share_t share) 17666185db85Sdougm { 17676185db85Sdougm xmlNodePtr node = NULL; 17686185db85Sdougm if (share != NULL) { 176957b448deSdougm node = ((xmlNodePtr)share)->parent; 17706185db85Sdougm /* 17716185db85Sdougm * make sure parent is a group and not sharecfg since 17726185db85Sdougm * we may be cheating and passing in a group. 17736185db85Sdougm * Eventually, groups of groups might come into being. 17746185db85Sdougm */ 177557b448deSdougm if (node == NULL || 177657b448deSdougm xmlStrcmp(node->name, (xmlChar *)"sharecfg") == 0) 177757b448deSdougm node = NULL; 17786185db85Sdougm } 17796185db85Sdougm return ((sa_group_t)node); 17806185db85Sdougm } 17816185db85Sdougm 17826185db85Sdougm /* 1783549ec3ffSdougm * _sa_create_group(impl_handle, groupname) 17846185db85Sdougm * 17856185db85Sdougm * Create a group in the document. The caller will need to deal with 17866185db85Sdougm * configuration store and activation. 17876185db85Sdougm */ 17886185db85Sdougm 17896185db85Sdougm sa_group_t 1790549ec3ffSdougm _sa_create_group(sa_handle_impl_t impl_handle, char *groupname) 17916185db85Sdougm { 17926185db85Sdougm xmlNodePtr node = NULL; 17936185db85Sdougm 17946185db85Sdougm if (sa_valid_group_name(groupname)) { 179557b448deSdougm node = xmlNewChild(impl_handle->tree, NULL, (xmlChar *)"group", 179657b448deSdougm NULL); 179757b448deSdougm if (node != NULL) { 179857b448deSdougm xmlSetProp(node, (xmlChar *)"name", 179957b448deSdougm (xmlChar *)groupname); 180057b448deSdougm xmlSetProp(node, (xmlChar *)"state", 180157b448deSdougm (xmlChar *)"enabled"); 180257b448deSdougm } 18036185db85Sdougm } 18046185db85Sdougm return ((sa_group_t)node); 18056185db85Sdougm } 18066185db85Sdougm 18076185db85Sdougm /* 18086185db85Sdougm * _sa_create_zfs_group(group, groupname) 18096185db85Sdougm * 18106185db85Sdougm * Create a ZFS subgroup under the specified group. This may 18116185db85Sdougm * eventually form the basis of general sub-groups, but is currently 18126185db85Sdougm * restricted to ZFS. 18136185db85Sdougm */ 18146185db85Sdougm sa_group_t 18156185db85Sdougm _sa_create_zfs_group(sa_group_t group, char *groupname) 18166185db85Sdougm { 18176185db85Sdougm xmlNodePtr node = NULL; 18186185db85Sdougm 181957b448deSdougm node = xmlNewChild((xmlNodePtr)group, NULL, (xmlChar *)"group", NULL); 18206185db85Sdougm if (node != NULL) { 18216185db85Sdougm xmlSetProp(node, (xmlChar *)"name", (xmlChar *)groupname); 18226185db85Sdougm xmlSetProp(node, (xmlChar *)"state", (xmlChar *)"enabled"); 18236185db85Sdougm } 18246185db85Sdougm 18256185db85Sdougm return ((sa_group_t)node); 18266185db85Sdougm } 18276185db85Sdougm 18286185db85Sdougm /* 18296185db85Sdougm * sa_create_group(groupname, *error) 18306185db85Sdougm * 18316185db85Sdougm * Create a new group with groupname. Need to validate that it is a 18326185db85Sdougm * legal name for SMF and the construct the SMF service instance of 18336185db85Sdougm * svc:/network/shares/group to implement the group. All necessary 18346185db85Sdougm * operational properties must be added to the group at this point 18356185db85Sdougm * (via the SMF transaction model). 18366185db85Sdougm */ 18376185db85Sdougm sa_group_t 1838549ec3ffSdougm sa_create_group(sa_handle_t handle, char *groupname, int *error) 18396185db85Sdougm { 18406185db85Sdougm xmlNodePtr node = NULL; 18416185db85Sdougm sa_group_t group; 18426185db85Sdougm int ret; 184357b448deSdougm char rbacstr[SA_STRSIZE]; 1844549ec3ffSdougm sa_handle_impl_t impl_handle = (sa_handle_impl_t)handle; 18456185db85Sdougm 18466185db85Sdougm ret = SA_OK; 18476185db85Sdougm 1848549ec3ffSdougm if (impl_handle == NULL || impl_handle->scfhandle == NULL) { 184957b448deSdougm ret = SA_SYSTEM_ERR; 185057b448deSdougm goto err; 18516185db85Sdougm } 18526185db85Sdougm 1853549ec3ffSdougm group = sa_get_group(handle, groupname); 18546185db85Sdougm if (group != NULL) { 185557b448deSdougm ret = SA_DUPLICATE_NAME; 18566185db85Sdougm } else { 185757b448deSdougm if (sa_valid_group_name(groupname)) { 185857b448deSdougm node = xmlNewChild(impl_handle->tree, NULL, 185957b448deSdougm (xmlChar *)"group", NULL); 186057b448deSdougm if (node != NULL) { 186157b448deSdougm xmlSetProp(node, (xmlChar *)"name", 186257b448deSdougm (xmlChar *)groupname); 186357b448deSdougm /* default to the group being enabled */ 186457b448deSdougm xmlSetProp(node, (xmlChar *)"state", 186557b448deSdougm (xmlChar *)"enabled"); 186657b448deSdougm ret = sa_create_instance(impl_handle->scfhandle, 186757b448deSdougm groupname); 186857b448deSdougm if (ret == SA_OK) { 186957b448deSdougm ret = sa_start_transaction( 187057b448deSdougm impl_handle->scfhandle, 187157b448deSdougm "operation"); 187257b448deSdougm } 187357b448deSdougm if (ret == SA_OK) { 187457b448deSdougm ret = sa_set_property( 187557b448deSdougm impl_handle->scfhandle, 187657b448deSdougm "state", "enabled"); 187757b448deSdougm if (ret == SA_OK) { 187857b448deSdougm ret = sa_end_transaction( 187957b448deSdougm impl_handle->scfhandle); 188057b448deSdougm } else { 188157b448deSdougm sa_abort_transaction( 188257b448deSdougm impl_handle->scfhandle); 188357b448deSdougm } 188457b448deSdougm } 188557b448deSdougm if (ret == SA_OK) { 188657b448deSdougm /* initialize the RBAC strings */ 188757b448deSdougm ret = sa_start_transaction( 188857b448deSdougm impl_handle->scfhandle, 188957b448deSdougm "general"); 189057b448deSdougm if (ret == SA_OK) { 189157b448deSdougm (void) snprintf(rbacstr, 189257b448deSdougm sizeof (rbacstr), "%s.%s", 189357b448deSdougm SA_RBAC_MANAGE, groupname); 189457b448deSdougm ret = sa_set_property( 189557b448deSdougm impl_handle->scfhandle, 18966185db85Sdougm "action_authorization", 18976185db85Sdougm rbacstr); 189857b448deSdougm } 189957b448deSdougm if (ret == SA_OK) { 190057b448deSdougm (void) snprintf(rbacstr, 190157b448deSdougm sizeof (rbacstr), "%s.%s", 190257b448deSdougm SA_RBAC_VALUE, groupname); 190357b448deSdougm ret = sa_set_property( 190457b448deSdougm impl_handle->scfhandle, 19056185db85Sdougm "value_authorization", 19066185db85Sdougm rbacstr); 190757b448deSdougm } 190857b448deSdougm if (ret == SA_OK) { 190957b448deSdougm ret = sa_end_transaction( 191057b448deSdougm impl_handle->scfhandle); 191157b448deSdougm } else { 191257b448deSdougm sa_abort_transaction( 191357b448deSdougm impl_handle->scfhandle); 191457b448deSdougm } 191557b448deSdougm } 191657b448deSdougm if (ret != SA_OK) { 191757b448deSdougm /* 191857b448deSdougm * Couldn't commit the group 191957b448deSdougm * so we need to undo 192057b448deSdougm * internally. 192157b448deSdougm */ 192257b448deSdougm xmlUnlinkNode(node); 192357b448deSdougm xmlFreeNode(node); 192457b448deSdougm node = NULL; 192557b448deSdougm } 19266185db85Sdougm } else { 192757b448deSdougm ret = SA_NO_MEMORY; 19286185db85Sdougm } 19296185db85Sdougm } else { 193057b448deSdougm ret = SA_INVALID_NAME; 19316185db85Sdougm } 19326185db85Sdougm } 19336185db85Sdougm err: 19346185db85Sdougm if (error != NULL) 193557b448deSdougm *error = ret; 19366185db85Sdougm return ((sa_group_t)node); 19376185db85Sdougm } 19386185db85Sdougm 19396185db85Sdougm /* 19406185db85Sdougm * sa_remove_group(group) 19416185db85Sdougm * 19426185db85Sdougm * Remove the specified group. This deletes from the SMF repository. 19436185db85Sdougm * All property groups and properties are removed. 19446185db85Sdougm */ 19456185db85Sdougm 19466185db85Sdougm int 19476185db85Sdougm sa_remove_group(sa_group_t group) 19486185db85Sdougm { 19496185db85Sdougm char *name; 19506185db85Sdougm int ret = SA_OK; 1951549ec3ffSdougm sa_handle_impl_t impl_handle; 19526185db85Sdougm 1953549ec3ffSdougm impl_handle = (sa_handle_impl_t)sa_find_group_handle(group); 1954549ec3ffSdougm if (impl_handle != NULL) { 195557b448deSdougm name = sa_get_group_attr(group, "name"); 195657b448deSdougm if (name != NULL) { 195757b448deSdougm ret = sa_delete_instance(impl_handle->scfhandle, name); 195857b448deSdougm sa_free_attr_string(name); 195957b448deSdougm } 196057b448deSdougm xmlUnlinkNode((xmlNodePtr)group); /* make sure unlinked */ 196157b448deSdougm xmlFreeNode((xmlNodePtr)group); /* now it is gone */ 1962549ec3ffSdougm } else { 196357b448deSdougm ret = SA_SYSTEM_ERR; 19646185db85Sdougm } 19656185db85Sdougm return (ret); 19666185db85Sdougm } 19676185db85Sdougm 19686185db85Sdougm /* 19696185db85Sdougm * sa_update_config() 19706185db85Sdougm * 19716185db85Sdougm * Used to update legacy files that need to be updated in bulk 19726185db85Sdougm * Currently, this is a placeholder and will go away in a future 19736185db85Sdougm * release. 19746185db85Sdougm */ 19756185db85Sdougm 19766185db85Sdougm int 1977549ec3ffSdougm sa_update_config(sa_handle_t handle) 19786185db85Sdougm { 19796185db85Sdougm /* 19806185db85Sdougm * do legacy files first so we can tell when they change. 19816185db85Sdougm * This will go away when we start updating individual records 19826185db85Sdougm * rather than the whole file. 19836185db85Sdougm */ 1984549ec3ffSdougm update_legacy_config(handle); 19856185db85Sdougm return (SA_OK); 19866185db85Sdougm } 19876185db85Sdougm 19886185db85Sdougm /* 19896185db85Sdougm * get_node_attr(node, tag) 19906185db85Sdougm * 1991*da6c28aaSamw * Get the specified tag(attribute) if it exists on the node. This is 19926185db85Sdougm * used internally by a number of attribute oriented functions. 19936185db85Sdougm */ 19946185db85Sdougm 19956185db85Sdougm static char * 19966185db85Sdougm get_node_attr(void *nodehdl, char *tag) 19976185db85Sdougm { 19986185db85Sdougm xmlNodePtr node = (xmlNodePtr)nodehdl; 19996185db85Sdougm xmlChar *name = NULL; 20006185db85Sdougm 200157b448deSdougm if (node != NULL) 20026185db85Sdougm name = xmlGetProp(node, (xmlChar *)tag); 20036185db85Sdougm return ((char *)name); 20046185db85Sdougm } 20056185db85Sdougm 20066185db85Sdougm /* 20076185db85Sdougm * get_node_attr(node, tag) 20086185db85Sdougm * 2009*da6c28aaSamw * Set the specified tag(attribute) to the specified value This is 20106185db85Sdougm * used internally by a number of attribute oriented functions. It 20116185db85Sdougm * doesn't update the repository, only the internal document state. 20126185db85Sdougm */ 20136185db85Sdougm 20146185db85Sdougm void 20156185db85Sdougm set_node_attr(void *nodehdl, char *tag, char *value) 20166185db85Sdougm { 20176185db85Sdougm xmlNodePtr node = (xmlNodePtr)nodehdl; 20186185db85Sdougm if (node != NULL && tag != NULL) { 201957b448deSdougm if (value != NULL) 20206185db85Sdougm xmlSetProp(node, (xmlChar *)tag, (xmlChar *)value); 202157b448deSdougm else 20226185db85Sdougm xmlUnsetProp(node, (xmlChar *)tag); 20236185db85Sdougm } 20246185db85Sdougm } 20256185db85Sdougm 20266185db85Sdougm /* 20276185db85Sdougm * sa_get_group_attr(group, tag) 20286185db85Sdougm * 20296185db85Sdougm * Get the specied attribute, if defined, for the group. 20306185db85Sdougm */ 20316185db85Sdougm 20326185db85Sdougm char * 20336185db85Sdougm sa_get_group_attr(sa_group_t group, char *tag) 20346185db85Sdougm { 20356185db85Sdougm return (get_node_attr((void *)group, tag)); 20366185db85Sdougm } 20376185db85Sdougm 20386185db85Sdougm /* 20396185db85Sdougm * sa_set_group_attr(group, tag, value) 20406185db85Sdougm * 20416185db85Sdougm * set the specified tag/attribute on the group using value as its 20426185db85Sdougm * value. 20436185db85Sdougm * 20446185db85Sdougm * This will result in setting the property in the SMF repository as 20456185db85Sdougm * well as in the internal document. 20466185db85Sdougm */ 20476185db85Sdougm 20486185db85Sdougm int 20496185db85Sdougm sa_set_group_attr(sa_group_t group, char *tag, char *value) 20506185db85Sdougm { 20516185db85Sdougm int ret; 20526185db85Sdougm char *groupname; 2053549ec3ffSdougm sa_handle_impl_t impl_handle; 20546185db85Sdougm 2055*da6c28aaSamw /* 2056*da6c28aaSamw * ZFS group/subgroup doesn't need the handle so shortcut. 2057*da6c28aaSamw */ 2058*da6c28aaSamw if (sa_group_is_zfs(group)) { 2059*da6c28aaSamw set_node_attr((void *)group, tag, value); 2060*da6c28aaSamw return (SA_OK); 2061*da6c28aaSamw } 2062*da6c28aaSamw 2063549ec3ffSdougm impl_handle = (sa_handle_impl_t)sa_find_group_handle(group); 2064549ec3ffSdougm if (impl_handle != NULL) { 206557b448deSdougm groupname = sa_get_group_attr(group, "name"); 206657b448deSdougm ret = sa_get_instance(impl_handle->scfhandle, groupname); 2067549ec3ffSdougm if (ret == SA_OK) { 206857b448deSdougm set_node_attr((void *)group, tag, value); 206957b448deSdougm ret = sa_start_transaction(impl_handle->scfhandle, 207057b448deSdougm "operation"); 207157b448deSdougm if (ret == SA_OK) { 207257b448deSdougm ret = sa_set_property(impl_handle->scfhandle, 207357b448deSdougm tag, value); 207457b448deSdougm if (ret == SA_OK) 207557b448deSdougm (void) sa_end_transaction( 207657b448deSdougm impl_handle->scfhandle); 207757b448deSdougm else 207857b448deSdougm sa_abort_transaction( 207957b448deSdougm impl_handle->scfhandle); 208057b448deSdougm } 20816185db85Sdougm } 208257b448deSdougm if (groupname != NULL) 208357b448deSdougm sa_free_attr_string(groupname); 2084549ec3ffSdougm } else { 208557b448deSdougm ret = SA_SYSTEM_ERR; 20866185db85Sdougm } 20876185db85Sdougm return (ret); 20886185db85Sdougm } 20896185db85Sdougm 20906185db85Sdougm /* 20916185db85Sdougm * sa_get_share_attr(share, tag) 20926185db85Sdougm * 20936185db85Sdougm * Return the value of the tag/attribute set on the specified 20946185db85Sdougm * share. Returns NULL if the tag doesn't exist. 20956185db85Sdougm */ 20966185db85Sdougm 20976185db85Sdougm char * 20986185db85Sdougm sa_get_share_attr(sa_share_t share, char *tag) 20996185db85Sdougm { 21006185db85Sdougm return (get_node_attr((void *)share, tag)); 21016185db85Sdougm } 21026185db85Sdougm 21036185db85Sdougm /* 21046185db85Sdougm * _sa_set_share_description(share, description) 21056185db85Sdougm * 2106*da6c28aaSamw * Add a description tag with text contents to the specified share. A 2107*da6c28aaSamw * separate XML tag is used rather than a property. This can also be 2108*da6c28aaSamw * used with resources. 21096185db85Sdougm */ 21106185db85Sdougm 21116185db85Sdougm xmlNodePtr 2112*da6c28aaSamw _sa_set_share_description(void *share, char *content) 21136185db85Sdougm { 21146185db85Sdougm xmlNodePtr node; 211557b448deSdougm node = xmlNewChild((xmlNodePtr)share, NULL, (xmlChar *)"description", 211657b448deSdougm NULL); 21176185db85Sdougm xmlNodeSetContent(node, (xmlChar *)content); 21186185db85Sdougm return (node); 21196185db85Sdougm } 21206185db85Sdougm 21216185db85Sdougm /* 21226185db85Sdougm * sa_set_share_attr(share, tag, value) 21236185db85Sdougm * 21246185db85Sdougm * Set the share attribute specified by tag to the specified value. In 21256185db85Sdougm * the case of "resource", enforce a no duplicates in a group rule. If 21266185db85Sdougm * the share is not transient, commit the changes to the repository 21276185db85Sdougm * else just update the share internally. 21286185db85Sdougm */ 21296185db85Sdougm 21306185db85Sdougm int 21316185db85Sdougm sa_set_share_attr(sa_share_t share, char *tag, char *value) 21326185db85Sdougm { 21336185db85Sdougm sa_group_t group; 21346185db85Sdougm sa_share_t resource; 21356185db85Sdougm int ret = SA_OK; 21366185db85Sdougm 21376185db85Sdougm group = sa_get_parent_group(share); 21386185db85Sdougm 21396185db85Sdougm /* 21406185db85Sdougm * There are some attributes that may have specific 21416185db85Sdougm * restrictions on them. Initially, only "resource" has 21426185db85Sdougm * special meaning that needs to be checked. Only one instance 21436185db85Sdougm * of a resource name may exist within a group. 21446185db85Sdougm */ 21456185db85Sdougm 21466185db85Sdougm if (strcmp(tag, "resource") == 0) { 214757b448deSdougm resource = sa_get_resource(group, value); 214857b448deSdougm if (resource != share && resource != NULL) 214957b448deSdougm ret = SA_DUPLICATE_NAME; 21506185db85Sdougm } 21516185db85Sdougm if (ret == SA_OK) { 215257b448deSdougm set_node_attr((void *)share, tag, value); 215357b448deSdougm if (group != NULL) { 215457b448deSdougm char *type; 215557b448deSdougm /* we can probably optimize this some */ 215657b448deSdougm type = sa_get_share_attr(share, "type"); 215757b448deSdougm if (type == NULL || strcmp(type, "transient") != 0) { 215857b448deSdougm sa_handle_impl_t impl_handle; 215957b448deSdougm impl_handle = 216057b448deSdougm (sa_handle_impl_t)sa_find_group_handle( 216157b448deSdougm group); 216257b448deSdougm if (impl_handle != NULL) { 216357b448deSdougm ret = sa_commit_share( 216457b448deSdougm impl_handle->scfhandle, group, 216557b448deSdougm share); 216657b448deSdougm } else { 216757b448deSdougm ret = SA_SYSTEM_ERR; 216857b448deSdougm } 216957b448deSdougm } 217057b448deSdougm if (type != NULL) 217157b448deSdougm sa_free_attr_string(type); 2172549ec3ffSdougm } 21736185db85Sdougm } 21746185db85Sdougm return (ret); 21756185db85Sdougm } 21766185db85Sdougm 21776185db85Sdougm /* 21786185db85Sdougm * sa_get_property_attr(prop, tag) 21796185db85Sdougm * 21806185db85Sdougm * Get the value of the specified property attribute. Standard 21816185db85Sdougm * attributes are "type" and "value". 21826185db85Sdougm */ 21836185db85Sdougm 21846185db85Sdougm char * 21856185db85Sdougm sa_get_property_attr(sa_property_t prop, char *tag) 21866185db85Sdougm { 21876185db85Sdougm return (get_node_attr((void *)prop, tag)); 21886185db85Sdougm } 21896185db85Sdougm 21906185db85Sdougm /* 21916185db85Sdougm * sa_get_optionset_attr(prop, tag) 21926185db85Sdougm * 21936185db85Sdougm * Get the value of the specified property attribute. Standard 21946185db85Sdougm * attribute is "type". 21956185db85Sdougm */ 21966185db85Sdougm 21976185db85Sdougm char * 21986185db85Sdougm sa_get_optionset_attr(sa_property_t optionset, char *tag) 21996185db85Sdougm { 22006185db85Sdougm return (get_node_attr((void *)optionset, tag)); 22016185db85Sdougm 22026185db85Sdougm } 22036185db85Sdougm 22046185db85Sdougm /* 22056185db85Sdougm * sa_set_optionset_attr(optionset, tag, value) 22066185db85Sdougm * 22076185db85Sdougm * Set the specified attribute(tag) to the specified value on the 22086185db85Sdougm * optionset. 22096185db85Sdougm */ 22106185db85Sdougm 22116185db85Sdougm void 22126185db85Sdougm sa_set_optionset_attr(sa_group_t optionset, char *tag, char *value) 22136185db85Sdougm { 22146185db85Sdougm set_node_attr((void *)optionset, tag, value); 22156185db85Sdougm } 22166185db85Sdougm 22176185db85Sdougm /* 22186185db85Sdougm * sa_free_attr_string(string) 22196185db85Sdougm * 22206185db85Sdougm * Free the string that was returned in one of the sa_get_*_attr() 22216185db85Sdougm * functions. 22226185db85Sdougm */ 22236185db85Sdougm 22246185db85Sdougm void 22256185db85Sdougm sa_free_attr_string(char *string) 22266185db85Sdougm { 22276185db85Sdougm xmlFree((xmlChar *)string); 22286185db85Sdougm } 22296185db85Sdougm 22306185db85Sdougm /* 22316185db85Sdougm * sa_get_optionset(group, proto) 22326185db85Sdougm * 22336185db85Sdougm * Return the optionset, if it exists, that is associated with the 22346185db85Sdougm * specified protocol. 22356185db85Sdougm */ 22366185db85Sdougm 22376185db85Sdougm sa_optionset_t 22386185db85Sdougm sa_get_optionset(void *group, char *proto) 22396185db85Sdougm { 22406185db85Sdougm xmlNodePtr node; 22416185db85Sdougm xmlChar *value = NULL; 22426185db85Sdougm 22436185db85Sdougm for (node = ((xmlNodePtr)group)->children; node != NULL; 224457b448deSdougm node = node->next) { 22456185db85Sdougm if (xmlStrcmp(node->name, (xmlChar *)"optionset") == 0) { 224657b448deSdougm value = xmlGetProp(node, (xmlChar *)"type"); 224757b448deSdougm if (proto != NULL) { 224857b448deSdougm if (value != NULL && 224957b448deSdougm xmlStrcmp(value, (xmlChar *)proto) == 0) { 225057b448deSdougm break; 225157b448deSdougm } 225257b448deSdougm if (value != NULL) { 225357b448deSdougm xmlFree(value); 225457b448deSdougm value = NULL; 225557b448deSdougm } 225657b448deSdougm } else { 225757b448deSdougm break; 22586185db85Sdougm } 22596185db85Sdougm } 22606185db85Sdougm } 22616185db85Sdougm if (value != NULL) 226257b448deSdougm xmlFree(value); 22636185db85Sdougm return ((sa_optionset_t)node); 22646185db85Sdougm } 22656185db85Sdougm 22666185db85Sdougm /* 22676185db85Sdougm * sa_get_next_optionset(optionset) 22686185db85Sdougm * 22696185db85Sdougm * Return the next optionset in the group. NULL if this was the last. 22706185db85Sdougm */ 22716185db85Sdougm 22726185db85Sdougm sa_optionset_t 22736185db85Sdougm sa_get_next_optionset(sa_optionset_t optionset) 22746185db85Sdougm { 22756185db85Sdougm xmlNodePtr node; 22766185db85Sdougm 22776185db85Sdougm for (node = ((xmlNodePtr)optionset)->next; node != NULL; 227857b448deSdougm node = node->next) { 22796185db85Sdougm if (xmlStrcmp(node->name, (xmlChar *)"optionset") == 0) { 22806185db85Sdougm break; 22816185db85Sdougm } 22826185db85Sdougm } 22836185db85Sdougm return ((sa_optionset_t)node); 22846185db85Sdougm } 22856185db85Sdougm 22866185db85Sdougm /* 22876185db85Sdougm * sa_get_security(group, sectype, proto) 22886185db85Sdougm * 22896185db85Sdougm * Return the security optionset. The internal name is a hold over 22906185db85Sdougm * from the implementation and will be changed before the API is 22916185db85Sdougm * finalized. This is really a named optionset that can be negotiated 22926185db85Sdougm * as a group of properties (like NFS security options). 22936185db85Sdougm */ 22946185db85Sdougm 22956185db85Sdougm sa_security_t 22966185db85Sdougm sa_get_security(sa_group_t group, char *sectype, char *proto) 22976185db85Sdougm { 22986185db85Sdougm xmlNodePtr node; 22996185db85Sdougm xmlChar *value = NULL; 23006185db85Sdougm 23016185db85Sdougm for (node = ((xmlNodePtr)group)->children; node != NULL; 230257b448deSdougm node = node->next) { 230357b448deSdougm if (xmlStrcmp(node->name, (xmlChar *)"security") == 0) { 230457b448deSdougm if (proto != NULL) { 230557b448deSdougm value = xmlGetProp(node, (xmlChar *)"type"); 230657b448deSdougm if (value == NULL || 230757b448deSdougm (value != NULL && 230857b448deSdougm xmlStrcmp(value, (xmlChar *)proto) != 0)) { 230957b448deSdougm /* it doesn't match so continue */ 231057b448deSdougm xmlFree(value); 231157b448deSdougm value = NULL; 231257b448deSdougm continue; 231357b448deSdougm } 231457b448deSdougm } 231557b448deSdougm if (value != NULL) { 231657b448deSdougm xmlFree(value); 231757b448deSdougm value = NULL; 231857b448deSdougm } 231957b448deSdougm /* potential match */ 232057b448deSdougm if (sectype != NULL) { 232157b448deSdougm value = xmlGetProp(node, (xmlChar *)"sectype"); 232257b448deSdougm if (value != NULL && 232357b448deSdougm xmlStrcmp(value, (xmlChar *)sectype) == 0) { 232457b448deSdougm break; 232557b448deSdougm } 232657b448deSdougm } else { 232757b448deSdougm break; 232857b448deSdougm } 23296185db85Sdougm } 23306185db85Sdougm if (value != NULL) { 233157b448deSdougm xmlFree(value); 233257b448deSdougm value = NULL; 23336185db85Sdougm } 23346185db85Sdougm } 23356185db85Sdougm if (value != NULL) 233657b448deSdougm xmlFree(value); 23376185db85Sdougm return ((sa_security_t)node); 23386185db85Sdougm } 23396185db85Sdougm 23406185db85Sdougm /* 23416185db85Sdougm * sa_get_next_security(security) 23426185db85Sdougm * 23436185db85Sdougm * Get the next security optionset if one exists. 23446185db85Sdougm */ 23456185db85Sdougm 23466185db85Sdougm sa_security_t 23476185db85Sdougm sa_get_next_security(sa_security_t security) 23486185db85Sdougm { 23496185db85Sdougm xmlNodePtr node; 23506185db85Sdougm 23516185db85Sdougm for (node = ((xmlNodePtr)security)->next; node != NULL; 235257b448deSdougm node = node->next) { 23536185db85Sdougm if (xmlStrcmp(node->name, (xmlChar *)"security") == 0) { 23546185db85Sdougm break; 23556185db85Sdougm } 23566185db85Sdougm } 23576185db85Sdougm return ((sa_security_t)node); 23586185db85Sdougm } 23596185db85Sdougm 23606185db85Sdougm /* 23616185db85Sdougm * sa_get_property(optionset, prop) 23626185db85Sdougm * 23636185db85Sdougm * Get the property object with the name specified in prop from the 23646185db85Sdougm * optionset. 23656185db85Sdougm */ 23666185db85Sdougm 23676185db85Sdougm sa_property_t 23686185db85Sdougm sa_get_property(sa_optionset_t optionset, char *prop) 23696185db85Sdougm { 23706185db85Sdougm xmlNodePtr node = (xmlNodePtr)optionset; 23716185db85Sdougm xmlChar *value = NULL; 23726185db85Sdougm 23736185db85Sdougm if (optionset == NULL) 237457b448deSdougm return (NULL); 23756185db85Sdougm 23766185db85Sdougm for (node = node->children; node != NULL; 237757b448deSdougm node = node->next) { 237857b448deSdougm if (xmlStrcmp(node->name, (xmlChar *)"option") == 0) { 237957b448deSdougm if (prop == NULL) 238057b448deSdougm break; 238157b448deSdougm value = xmlGetProp(node, (xmlChar *)"type"); 238257b448deSdougm if (value != NULL && 238357b448deSdougm xmlStrcmp(value, (xmlChar *)prop) == 0) { 238457b448deSdougm break; 238557b448deSdougm } 238657b448deSdougm if (value != NULL) { 238757b448deSdougm xmlFree(value); 238857b448deSdougm value = NULL; 238957b448deSdougm } 23906185db85Sdougm } 23916185db85Sdougm } 23926185db85Sdougm if (value != NULL) 23936185db85Sdougm xmlFree(value); 23946185db85Sdougm if (node != NULL && xmlStrcmp(node->name, (xmlChar *)"option") != 0) { 239557b448deSdougm /* 239657b448deSdougm * avoid a non option node -- it is possible to be a 239757b448deSdougm * text node 239857b448deSdougm */ 239957b448deSdougm node = NULL; 24006185db85Sdougm } 24016185db85Sdougm return ((sa_property_t)node); 24026185db85Sdougm } 24036185db85Sdougm 24046185db85Sdougm /* 24056185db85Sdougm * sa_get_next_property(property) 24066185db85Sdougm * 24076185db85Sdougm * Get the next property following the specified property. NULL if 24086185db85Sdougm * this was the last. 24096185db85Sdougm */ 24106185db85Sdougm 24116185db85Sdougm sa_property_t 24126185db85Sdougm sa_get_next_property(sa_property_t property) 24136185db85Sdougm { 24146185db85Sdougm xmlNodePtr node; 24156185db85Sdougm 24166185db85Sdougm for (node = ((xmlNodePtr)property)->next; node != NULL; 241757b448deSdougm node = node->next) { 24186185db85Sdougm if (xmlStrcmp(node->name, (xmlChar *)"option") == 0) { 24196185db85Sdougm break; 24206185db85Sdougm } 24216185db85Sdougm } 24226185db85Sdougm return ((sa_property_t)node); 24236185db85Sdougm } 24246185db85Sdougm 24256185db85Sdougm /* 24266185db85Sdougm * sa_set_share_description(share, content) 24276185db85Sdougm * 24286185db85Sdougm * Set the description of share to content. 24296185db85Sdougm */ 24306185db85Sdougm 24316185db85Sdougm int 24326185db85Sdougm sa_set_share_description(sa_share_t share, char *content) 24336185db85Sdougm { 24346185db85Sdougm xmlNodePtr node; 24356185db85Sdougm sa_group_t group; 24366185db85Sdougm int ret = SA_OK; 24376185db85Sdougm 24386185db85Sdougm for (node = ((xmlNodePtr)share)->children; node != NULL; 243957b448deSdougm node = node->next) { 24406185db85Sdougm if (xmlStrcmp(node->name, (xmlChar *)"description") == 0) { 24416185db85Sdougm break; 24426185db85Sdougm } 24436185db85Sdougm } 24446185db85Sdougm /* no existing description but want to add */ 24456185db85Sdougm if (node == NULL && content != NULL) { 24466185db85Sdougm /* add a description */ 244757b448deSdougm node = _sa_set_share_description(share, content); 24486185db85Sdougm } else if (node != NULL && content != NULL) { 24496185db85Sdougm /* update a description */ 24506185db85Sdougm xmlNodeSetContent(node, (xmlChar *)content); 24516185db85Sdougm } else if (node != NULL && content == NULL) { 24526185db85Sdougm /* remove an existing description */ 24536185db85Sdougm xmlUnlinkNode(node); 24546185db85Sdougm xmlFreeNode(node); 24556185db85Sdougm } 2456*da6c28aaSamw group = sa_get_parent_group(share); 2457*da6c28aaSamw if (group != NULL && sa_is_persistent(share)) { 245857b448deSdougm sa_handle_impl_t impl_handle; 245957b448deSdougm impl_handle = (sa_handle_impl_t)sa_find_group_handle(group); 246057b448deSdougm if (impl_handle != NULL) { 246157b448deSdougm ret = sa_commit_share(impl_handle->scfhandle, group, 246257b448deSdougm share); 246357b448deSdougm } else { 246457b448deSdougm ret = SA_SYSTEM_ERR; 246557b448deSdougm } 2466549ec3ffSdougm } 24676185db85Sdougm return (ret); 24686185db85Sdougm } 24696185db85Sdougm 24706185db85Sdougm /* 24716185db85Sdougm * fixproblemchars(string) 24726185db85Sdougm * 24736185db85Sdougm * don't want any newline or tab characters in the text since these 24746185db85Sdougm * could break display of data and legacy file formats. 24756185db85Sdougm */ 24766185db85Sdougm static void 24776185db85Sdougm fixproblemchars(char *str) 24786185db85Sdougm { 24796185db85Sdougm int c; 24806185db85Sdougm for (c = *str; c != '\0'; c = *++str) { 248157b448deSdougm if (c == '\t' || c == '\n') 248257b448deSdougm *str = ' '; 248357b448deSdougm else if (c == '"') 248457b448deSdougm *str = '\''; 24856185db85Sdougm } 24866185db85Sdougm } 24876185db85Sdougm 24886185db85Sdougm /* 24896185db85Sdougm * sa_get_share_description(share) 24906185db85Sdougm * 24916185db85Sdougm * Return the description text for the specified share if it 24926185db85Sdougm * exists. NULL if no description exists. 24936185db85Sdougm */ 24946185db85Sdougm 24956185db85Sdougm char * 24966185db85Sdougm sa_get_share_description(sa_share_t share) 24976185db85Sdougm { 24986185db85Sdougm xmlChar *description = NULL; 24996185db85Sdougm xmlNodePtr node; 25006185db85Sdougm 25016185db85Sdougm for (node = ((xmlNodePtr)share)->children; node != NULL; 250257b448deSdougm node = node->next) { 250357b448deSdougm if (xmlStrcmp(node->name, (xmlChar *)"description") == 0) { 250457b448deSdougm break; 250557b448deSdougm } 25066185db85Sdougm } 25076185db85Sdougm if (node != NULL) { 2508*da6c28aaSamw description = xmlNodeGetContent(node); 250957b448deSdougm fixproblemchars((char *)description); 25106185db85Sdougm } 25116185db85Sdougm return ((char *)description); 25126185db85Sdougm } 25136185db85Sdougm 25146185db85Sdougm /* 25156185db85Sdougm * sa_free(share_description(description) 25166185db85Sdougm * 25176185db85Sdougm * Free the description string. 25186185db85Sdougm */ 25196185db85Sdougm 25206185db85Sdougm void 25216185db85Sdougm sa_free_share_description(char *description) 25226185db85Sdougm { 25236185db85Sdougm xmlFree((xmlChar *)description); 25246185db85Sdougm } 25256185db85Sdougm 25266185db85Sdougm /* 25276185db85Sdougm * sa_create_optionset(group, proto) 25286185db85Sdougm * 25296185db85Sdougm * Create an optionset for the specified protocol in the specied 25306185db85Sdougm * group. This is manifested as a property group within SMF. 25316185db85Sdougm */ 25326185db85Sdougm 25336185db85Sdougm sa_optionset_t 25346185db85Sdougm sa_create_optionset(sa_group_t group, char *proto) 25356185db85Sdougm { 25366185db85Sdougm sa_optionset_t optionset; 25376185db85Sdougm sa_group_t parent = group; 2538*da6c28aaSamw sa_share_t share = NULL; 2539*da6c28aaSamw int err = SA_OK; 2540*da6c28aaSamw char *id = NULL; 25416185db85Sdougm 25426185db85Sdougm optionset = sa_get_optionset(group, proto); 25436185db85Sdougm if (optionset != NULL) { 25446185db85Sdougm /* can't have a duplicate protocol */ 254557b448deSdougm optionset = NULL; 25466185db85Sdougm } else { 2547*da6c28aaSamw /* 2548*da6c28aaSamw * Account for resource names being slightly 2549*da6c28aaSamw * different. 2550*da6c28aaSamw */ 2551*da6c28aaSamw if (sa_is_share(group)) { 2552*da6c28aaSamw /* 2553*da6c28aaSamw * Transient shares do not have an "id" so not an 2554*da6c28aaSamw * error to not find one. 2555*da6c28aaSamw */ 2556*da6c28aaSamw id = sa_get_share_attr((sa_share_t)group, "id"); 2557*da6c28aaSamw } else if (sa_is_resource(group)) { 2558*da6c28aaSamw share = sa_get_resource_parent( 2559*da6c28aaSamw (sa_resource_t)group); 2560*da6c28aaSamw id = sa_get_resource_attr(share, "id"); 2561*da6c28aaSamw 2562*da6c28aaSamw /* id can be NULL if the group is transient (ZFS) */ 2563*da6c28aaSamw if (id == NULL && sa_is_persistent(group)) 2564*da6c28aaSamw err = SA_NO_MEMORY; 2565*da6c28aaSamw } 2566*da6c28aaSamw if (err == SA_NO_MEMORY) { 2567*da6c28aaSamw /* 2568*da6c28aaSamw * Couldn't get the id for the share or 2569*da6c28aaSamw * resource. While this could be a 2570*da6c28aaSamw * configuration issue, it is most likely an 2571*da6c28aaSamw * out of memory. In any case, fail the create. 2572*da6c28aaSamw */ 2573*da6c28aaSamw return (NULL); 2574*da6c28aaSamw } 2575*da6c28aaSamw 257657b448deSdougm optionset = (sa_optionset_t)xmlNewChild((xmlNodePtr)group, 257757b448deSdougm NULL, (xmlChar *)"optionset", NULL); 25786185db85Sdougm /* 25796185db85Sdougm * only put to repository if on a group and we were 25806185db85Sdougm * able to create an optionset. 25816185db85Sdougm */ 258257b448deSdougm if (optionset != NULL) { 258357b448deSdougm char oname[SA_STRSIZE]; 258457b448deSdougm char *groupname; 25856185db85Sdougm 2586*da6c28aaSamw /* 2587*da6c28aaSamw * Need to get parent group in all cases, but also get 2588*da6c28aaSamw * the share if this is a resource. 2589*da6c28aaSamw */ 2590*da6c28aaSamw if (sa_is_share(group)) { 259157b448deSdougm parent = sa_get_parent_group((sa_share_t)group); 2592*da6c28aaSamw } else if (sa_is_resource(group)) { 2593*da6c28aaSamw share = sa_get_resource_parent( 2594*da6c28aaSamw (sa_resource_t)group); 2595*da6c28aaSamw parent = sa_get_parent_group(share); 2596*da6c28aaSamw } 25976185db85Sdougm 259857b448deSdougm sa_set_optionset_attr(optionset, "type", proto); 25996185db85Sdougm 260057b448deSdougm (void) sa_optionset_name(optionset, oname, 260157b448deSdougm sizeof (oname), id); 260257b448deSdougm groupname = sa_get_group_attr(parent, "name"); 2603*da6c28aaSamw if (groupname != NULL && sa_is_persistent(group)) { 260457b448deSdougm sa_handle_impl_t impl_handle; 2605*da6c28aaSamw impl_handle = 2606*da6c28aaSamw (sa_handle_impl_t)sa_find_group_handle( 2607*da6c28aaSamw group); 260857b448deSdougm assert(impl_handle != NULL); 260957b448deSdougm if (impl_handle != NULL) { 261057b448deSdougm (void) sa_get_instance( 2611*da6c28aaSamw impl_handle->scfhandle, groupname); 261257b448deSdougm (void) sa_create_pgroup( 261357b448deSdougm impl_handle->scfhandle, oname); 261457b448deSdougm } 261557b448deSdougm } 261657b448deSdougm if (groupname != NULL) 261757b448deSdougm sa_free_attr_string(groupname); 26186185db85Sdougm } 26196185db85Sdougm } 2620*da6c28aaSamw 2621*da6c28aaSamw if (id != NULL) 2622*da6c28aaSamw sa_free_attr_string(id); 26236185db85Sdougm return (optionset); 26246185db85Sdougm } 26256185db85Sdougm 26266185db85Sdougm /* 26276185db85Sdougm * sa_get_property_parent(property) 26286185db85Sdougm * 26296185db85Sdougm * Given a property, return the object it is a property of. This will 26306185db85Sdougm * be an optionset of some type. 26316185db85Sdougm */ 26326185db85Sdougm 26336185db85Sdougm static sa_optionset_t 26346185db85Sdougm sa_get_property_parent(sa_property_t property) 26356185db85Sdougm { 26366185db85Sdougm xmlNodePtr node = NULL; 26376185db85Sdougm 263857b448deSdougm if (property != NULL) 263957b448deSdougm node = ((xmlNodePtr)property)->parent; 26406185db85Sdougm return ((sa_optionset_t)node); 26416185db85Sdougm } 26426185db85Sdougm 26436185db85Sdougm /* 26446185db85Sdougm * sa_get_optionset_parent(optionset) 26456185db85Sdougm * 26466185db85Sdougm * Return the parent of the specified optionset. This could be a group 26476185db85Sdougm * or a share. 26486185db85Sdougm */ 26496185db85Sdougm 26506185db85Sdougm static sa_group_t 26516185db85Sdougm sa_get_optionset_parent(sa_optionset_t optionset) 26526185db85Sdougm { 26536185db85Sdougm xmlNodePtr node = NULL; 26546185db85Sdougm 265557b448deSdougm if (optionset != NULL) 265657b448deSdougm node = ((xmlNodePtr)optionset)->parent; 26576185db85Sdougm return ((sa_group_t)node); 26586185db85Sdougm } 26596185db85Sdougm 26606185db85Sdougm /* 26616185db85Sdougm * zfs_needs_update(share) 26626185db85Sdougm * 26636185db85Sdougm * In order to avoid making multiple updates to a ZFS share when 26646185db85Sdougm * setting properties, the share attribute "changed" will be set to 2665*da6c28aaSamw * true when a property is added or modified. When done adding 26666185db85Sdougm * properties, we can then detect that an update is needed. We then 26676185db85Sdougm * clear the state here to detect additional changes. 26686185db85Sdougm */ 26696185db85Sdougm 26706185db85Sdougm static int 26716185db85Sdougm zfs_needs_update(sa_share_t share) 26726185db85Sdougm { 26736185db85Sdougm char *attr; 26746185db85Sdougm int result = 0; 26756185db85Sdougm 26766185db85Sdougm attr = sa_get_share_attr(share, "changed"); 26776185db85Sdougm if (attr != NULL) { 267857b448deSdougm sa_free_attr_string(attr); 26796185db85Sdougm result = 1; 26806185db85Sdougm } 26816185db85Sdougm set_node_attr((void *)share, "changed", NULL); 26826185db85Sdougm return (result); 26836185db85Sdougm } 26846185db85Sdougm 26856185db85Sdougm /* 26866185db85Sdougm * zfs_set_update(share) 26876185db85Sdougm * 26886185db85Sdougm * Set the changed attribute of the share to true. 26896185db85Sdougm */ 26906185db85Sdougm 26916185db85Sdougm static void 26926185db85Sdougm zfs_set_update(sa_share_t share) 26936185db85Sdougm { 26946185db85Sdougm set_node_attr((void *)share, "changed", "true"); 26956185db85Sdougm } 26966185db85Sdougm 26976185db85Sdougm /* 26986185db85Sdougm * sa_commit_properties(optionset, clear) 26996185db85Sdougm * 27006185db85Sdougm * Check if SMF or ZFS config and either update or abort the pending 27016185db85Sdougm * changes. 27026185db85Sdougm */ 27036185db85Sdougm 27046185db85Sdougm int 27056185db85Sdougm sa_commit_properties(sa_optionset_t optionset, int clear) 27066185db85Sdougm { 27076185db85Sdougm sa_group_t group; 27086185db85Sdougm sa_group_t parent; 27096185db85Sdougm int zfs = 0; 27106185db85Sdougm int needsupdate = 0; 27116185db85Sdougm int ret = SA_OK; 2712549ec3ffSdougm sa_handle_impl_t impl_handle; 27136185db85Sdougm 27146185db85Sdougm group = sa_get_optionset_parent(optionset); 27156185db85Sdougm if (group != NULL && (sa_is_share(group) || is_zfs_group(group))) { 271657b448deSdougm /* only update ZFS if on a share */ 271757b448deSdougm parent = sa_get_parent_group(group); 271857b448deSdougm zfs++; 271957b448deSdougm if (parent != NULL && is_zfs_group(parent)) 272057b448deSdougm needsupdate = zfs_needs_update(group); 272157b448deSdougm else 272257b448deSdougm zfs = 0; 27236185db85Sdougm } 27246185db85Sdougm if (zfs) { 272557b448deSdougm if (!clear && needsupdate) 272657b448deSdougm ret = sa_zfs_update((sa_share_t)group); 27276185db85Sdougm } else { 272857b448deSdougm impl_handle = (sa_handle_impl_t)sa_find_group_handle(group); 272957b448deSdougm if (impl_handle != NULL) { 273057b448deSdougm if (clear) { 273157b448deSdougm (void) sa_abort_transaction( 273257b448deSdougm impl_handle->scfhandle); 273357b448deSdougm } else { 273457b448deSdougm ret = sa_end_transaction( 273557b448deSdougm impl_handle->scfhandle); 273657b448deSdougm } 273757b448deSdougm } else { 273857b448deSdougm ret = SA_SYSTEM_ERR; 273957b448deSdougm } 27406185db85Sdougm } 27416185db85Sdougm return (ret); 27426185db85Sdougm } 27436185db85Sdougm 27446185db85Sdougm /* 27456185db85Sdougm * sa_destroy_optionset(optionset) 27466185db85Sdougm * 2747*da6c28aaSamw * Remove the optionset from its group. Update the repository to 27486185db85Sdougm * reflect this change. 27496185db85Sdougm */ 27506185db85Sdougm 27516185db85Sdougm int 27526185db85Sdougm sa_destroy_optionset(sa_optionset_t optionset) 27536185db85Sdougm { 275457b448deSdougm char name[SA_STRSIZE]; 27556185db85Sdougm int len; 27566185db85Sdougm int ret; 27576185db85Sdougm char *id = NULL; 27586185db85Sdougm sa_group_t group; 27596185db85Sdougm int ispersist = 1; 27606185db85Sdougm 27616185db85Sdougm /* now delete the prop group */ 27626185db85Sdougm group = sa_get_optionset_parent(optionset); 2763*da6c28aaSamw if (group != NULL) { 2764*da6c28aaSamw if (sa_is_resource(group)) { 2765*da6c28aaSamw sa_resource_t resource = group; 2766*da6c28aaSamw sa_share_t share = sa_get_resource_parent(resource); 2767*da6c28aaSamw group = sa_get_parent_group(share); 2768*da6c28aaSamw id = sa_get_share_attr(share, "id"); 2769*da6c28aaSamw } else if (sa_is_share(group)) { 2770*da6c28aaSamw id = sa_get_share_attr((sa_share_t)group, "id"); 2771*da6c28aaSamw } 2772*da6c28aaSamw ispersist = sa_is_persistent(group); 27736185db85Sdougm } 27746185db85Sdougm if (ispersist) { 277557b448deSdougm sa_handle_impl_t impl_handle; 277657b448deSdougm len = sa_optionset_name(optionset, name, sizeof (name), id); 277757b448deSdougm impl_handle = (sa_handle_impl_t)sa_find_group_handle(group); 277857b448deSdougm if (impl_handle != NULL) { 277957b448deSdougm if (len > 0) { 278057b448deSdougm ret = sa_delete_pgroup(impl_handle->scfhandle, 278157b448deSdougm name); 278257b448deSdougm } 278357b448deSdougm } else { 278457b448deSdougm ret = SA_SYSTEM_ERR; 2785549ec3ffSdougm } 27866185db85Sdougm } 27876185db85Sdougm xmlUnlinkNode((xmlNodePtr)optionset); 27886185db85Sdougm xmlFreeNode((xmlNodePtr)optionset); 27896185db85Sdougm if (id != NULL) 279057b448deSdougm sa_free_attr_string(id); 27916185db85Sdougm return (ret); 27926185db85Sdougm } 27936185db85Sdougm 27946185db85Sdougm /* private to the implementation */ 27956185db85Sdougm int 27966185db85Sdougm _sa_remove_optionset(sa_optionset_t optionset) 27976185db85Sdougm { 27986185db85Sdougm int ret = SA_OK; 27996185db85Sdougm 28006185db85Sdougm xmlUnlinkNode((xmlNodePtr)optionset); 28016185db85Sdougm xmlFreeNode((xmlNodePtr)optionset); 28026185db85Sdougm return (ret); 28036185db85Sdougm } 28046185db85Sdougm 28056185db85Sdougm /* 28066185db85Sdougm * sa_create_security(group, sectype, proto) 28076185db85Sdougm * 28086185db85Sdougm * Create a security optionset (one that has a type name and a 28096185db85Sdougm * proto). Security is left over from a pure NFS implementation. The 28106185db85Sdougm * naming will change in the future when the API is released. 28116185db85Sdougm */ 28126185db85Sdougm sa_security_t 28136185db85Sdougm sa_create_security(sa_group_t group, char *sectype, char *proto) 28146185db85Sdougm { 28156185db85Sdougm sa_security_t security; 28166185db85Sdougm char *id = NULL; 28176185db85Sdougm sa_group_t parent; 28186185db85Sdougm char *groupname = NULL; 28196185db85Sdougm 28206185db85Sdougm if (group != NULL && sa_is_share(group)) { 282157b448deSdougm id = sa_get_share_attr((sa_share_t)group, "id"); 282257b448deSdougm parent = sa_get_parent_group(group); 282357b448deSdougm if (parent != NULL) 282457b448deSdougm groupname = sa_get_group_attr(parent, "name"); 28256185db85Sdougm } else if (group != NULL) { 282657b448deSdougm groupname = sa_get_group_attr(group, "name"); 28276185db85Sdougm } 28286185db85Sdougm 28296185db85Sdougm security = sa_get_security(group, sectype, proto); 28306185db85Sdougm if (security != NULL) { 28316185db85Sdougm /* can't have a duplicate security option */ 28326185db85Sdougm security = NULL; 28336185db85Sdougm } else { 28346185db85Sdougm security = (sa_security_t)xmlNewChild((xmlNodePtr)group, 283557b448deSdougm NULL, (xmlChar *)"security", NULL); 28366185db85Sdougm if (security != NULL) { 283757b448deSdougm char oname[SA_STRSIZE]; 28386185db85Sdougm sa_set_security_attr(security, "type", proto); 28396185db85Sdougm 28406185db85Sdougm sa_set_security_attr(security, "sectype", sectype); 28416185db85Sdougm (void) sa_security_name(security, oname, 284257b448deSdougm sizeof (oname), id); 2843*da6c28aaSamw if (groupname != NULL && sa_is_persistent(group)) { 284457b448deSdougm sa_handle_impl_t impl_handle; 284557b448deSdougm impl_handle = 284657b448deSdougm (sa_handle_impl_t)sa_find_group_handle( 284757b448deSdougm group); 284857b448deSdougm if (impl_handle != NULL) { 284957b448deSdougm (void) sa_get_instance( 285057b448deSdougm impl_handle->scfhandle, groupname); 285157b448deSdougm (void) sa_create_pgroup( 285257b448deSdougm impl_handle->scfhandle, oname); 285357b448deSdougm } 28546185db85Sdougm } 28556185db85Sdougm } 28566185db85Sdougm } 28576185db85Sdougm if (groupname != NULL) 285857b448deSdougm sa_free_attr_string(groupname); 28596185db85Sdougm return (security); 28606185db85Sdougm } 28616185db85Sdougm 28626185db85Sdougm /* 28636185db85Sdougm * sa_destroy_security(security) 28646185db85Sdougm * 28656185db85Sdougm * Remove the specified optionset from the document and the 28666185db85Sdougm * configuration. 28676185db85Sdougm */ 28686185db85Sdougm 28696185db85Sdougm int 28706185db85Sdougm sa_destroy_security(sa_security_t security) 28716185db85Sdougm { 287257b448deSdougm char name[SA_STRSIZE]; 28736185db85Sdougm int len; 28746185db85Sdougm int ret = SA_OK; 28756185db85Sdougm char *id = NULL; 28766185db85Sdougm sa_group_t group; 28776185db85Sdougm int iszfs = 0; 28786185db85Sdougm int ispersist = 1; 28796185db85Sdougm 28806185db85Sdougm group = sa_get_optionset_parent(security); 28816185db85Sdougm 28826185db85Sdougm if (group != NULL) 288357b448deSdougm iszfs = sa_group_is_zfs(group); 28846185db85Sdougm 28856185db85Sdougm if (group != NULL && !iszfs) { 288657b448deSdougm if (sa_is_share(group)) 2887*da6c28aaSamw ispersist = sa_is_persistent(group); 288857b448deSdougm id = sa_get_share_attr((sa_share_t)group, "id"); 28896185db85Sdougm } 28906185db85Sdougm if (ispersist) { 289157b448deSdougm len = sa_security_name(security, name, sizeof (name), id); 289257b448deSdougm if (!iszfs && len > 0) { 289357b448deSdougm sa_handle_impl_t impl_handle; 289457b448deSdougm impl_handle = 289557b448deSdougm (sa_handle_impl_t)sa_find_group_handle(group); 289657b448deSdougm if (impl_handle != NULL) { 289757b448deSdougm ret = sa_delete_pgroup(impl_handle->scfhandle, 289857b448deSdougm name); 289957b448deSdougm } else { 290057b448deSdougm ret = SA_SYSTEM_ERR; 290157b448deSdougm } 2902549ec3ffSdougm } 29036185db85Sdougm } 29046185db85Sdougm xmlUnlinkNode((xmlNodePtr)security); 29056185db85Sdougm xmlFreeNode((xmlNodePtr)security); 290657b448deSdougm if (iszfs) 290757b448deSdougm ret = sa_zfs_update(group); 29086185db85Sdougm if (id != NULL) 290957b448deSdougm sa_free_attr_string(id); 29106185db85Sdougm return (ret); 29116185db85Sdougm } 29126185db85Sdougm 29136185db85Sdougm /* 29146185db85Sdougm * sa_get_security_attr(optionset, tag) 29156185db85Sdougm * 29166185db85Sdougm * Return the specified attribute value from the optionset. 29176185db85Sdougm */ 29186185db85Sdougm 29196185db85Sdougm char * 29206185db85Sdougm sa_get_security_attr(sa_property_t optionset, char *tag) 29216185db85Sdougm { 29226185db85Sdougm return (get_node_attr((void *)optionset, tag)); 29236185db85Sdougm 29246185db85Sdougm } 29256185db85Sdougm 29266185db85Sdougm /* 29276185db85Sdougm * sa_set_security_attr(optionset, tag, value) 29286185db85Sdougm * 29296185db85Sdougm * Set the optioset attribute specied by tag to the specified value. 29306185db85Sdougm */ 29316185db85Sdougm 29326185db85Sdougm void 29336185db85Sdougm sa_set_security_attr(sa_group_t optionset, char *tag, char *value) 29346185db85Sdougm { 29356185db85Sdougm set_node_attr((void *)optionset, tag, value); 29366185db85Sdougm } 29376185db85Sdougm 29386185db85Sdougm /* 29396185db85Sdougm * is_nodetype(node, type) 29406185db85Sdougm * 29416185db85Sdougm * Check to see if node is of the type specified. 29426185db85Sdougm */ 29436185db85Sdougm 29446185db85Sdougm static int 29456185db85Sdougm is_nodetype(void *node, char *type) 29466185db85Sdougm { 29476185db85Sdougm return (strcmp((char *)((xmlNodePtr)node)->name, type) == 0); 29486185db85Sdougm } 29496185db85Sdougm 295057b448deSdougm /* 295157b448deSdougm * add_or_update() 295257b448deSdougm * 295357b448deSdougm * Add or update a property. Pulled out of sa_set_prop_by_prop for 295457b448deSdougm * readability. 295557b448deSdougm */ 295657b448deSdougm static int 295757b448deSdougm add_or_update(scfutilhandle_t *scf_handle, int type, scf_value_t *value, 295857b448deSdougm scf_transaction_entry_t *entry, char *name, char *valstr) 295957b448deSdougm { 296057b448deSdougm int ret = SA_SYSTEM_ERR; 296157b448deSdougm 296257b448deSdougm if (value != NULL) { 296357b448deSdougm if (type == SA_PROP_OP_ADD) 296457b448deSdougm ret = scf_transaction_property_new(scf_handle->trans, 296557b448deSdougm entry, name, SCF_TYPE_ASTRING); 296657b448deSdougm else 296757b448deSdougm ret = scf_transaction_property_change(scf_handle->trans, 296857b448deSdougm entry, name, SCF_TYPE_ASTRING); 296957b448deSdougm if (ret == 0) { 297057b448deSdougm ret = scf_value_set_astring(value, valstr); 297157b448deSdougm if (ret == 0) 297257b448deSdougm ret = scf_entry_add_value(entry, value); 297357b448deSdougm if (ret == 0) 297457b448deSdougm return (ret); 297557b448deSdougm scf_value_destroy(value); 297657b448deSdougm } else { 297757b448deSdougm scf_entry_destroy(entry); 297857b448deSdougm } 297957b448deSdougm } 298057b448deSdougm return (SA_SYSTEM_ERR); 298157b448deSdougm } 298257b448deSdougm 29836185db85Sdougm /* 29846185db85Sdougm * sa_set_prop_by_prop(optionset, group, prop, type) 29856185db85Sdougm * 29866185db85Sdougm * Add/remove/update the specified property prop into the optionset or 29876185db85Sdougm * share. If a share, sort out which property group based on GUID. In 29886185db85Sdougm * all cases, the appropriate transaction is set (or ZFS share is 29896185db85Sdougm * marked as needing an update) 29906185db85Sdougm */ 29916185db85Sdougm 29926185db85Sdougm static int 29936185db85Sdougm sa_set_prop_by_prop(sa_optionset_t optionset, sa_group_t group, 29946185db85Sdougm sa_property_t prop, int type) 29956185db85Sdougm { 29966185db85Sdougm char *name; 29976185db85Sdougm char *valstr; 29986185db85Sdougm int ret = SA_OK; 29996185db85Sdougm scf_transaction_entry_t *entry; 30006185db85Sdougm scf_value_t *value; 30016185db85Sdougm int opttype; /* 1 == optionset, 0 == security */ 30026185db85Sdougm char *id = NULL; 30036185db85Sdougm int iszfs = 0; 30046185db85Sdougm sa_group_t parent = NULL; 3005*da6c28aaSamw sa_share_t share = NULL; 3006549ec3ffSdougm sa_handle_impl_t impl_handle; 3007549ec3ffSdougm scfutilhandle_t *scf_handle; 30086185db85Sdougm 3009*da6c28aaSamw if (!sa_is_persistent(group)) { 30106185db85Sdougm /* 30116185db85Sdougm * if the group/share is not persistent we don't need 30126185db85Sdougm * to do anything here 30136185db85Sdougm */ 301457b448deSdougm return (SA_OK); 30156185db85Sdougm } 3016549ec3ffSdougm impl_handle = (sa_handle_impl_t)sa_find_group_handle(group); 301757b448deSdougm if (impl_handle == NULL || impl_handle->scfhandle == NULL) 301857b448deSdougm return (SA_SYSTEM_ERR); 3019549ec3ffSdougm scf_handle = impl_handle->scfhandle; 30206185db85Sdougm name = sa_get_property_attr(prop, "type"); 30216185db85Sdougm valstr = sa_get_property_attr(prop, "value"); 30226185db85Sdougm entry = scf_entry_create(scf_handle->handle); 30236185db85Sdougm opttype = is_nodetype((void *)optionset, "optionset"); 30246185db85Sdougm 3025*da6c28aaSamw /* 3026*da6c28aaSamw * Check for share vs. resource since they need slightly 3027*da6c28aaSamw * different treatment given the hierarchy. 3028*da6c28aaSamw */ 30296185db85Sdougm if (valstr != NULL && entry != NULL) { 303057b448deSdougm if (sa_is_share(group)) { 303157b448deSdougm parent = sa_get_parent_group(group); 3032*da6c28aaSamw share = (sa_share_t)group; 303357b448deSdougm if (parent != NULL) 303457b448deSdougm iszfs = is_zfs_group(parent); 3035*da6c28aaSamw } else if (sa_is_resource(group)) { 3036*da6c28aaSamw share = sa_get_parent_group(group); 3037*da6c28aaSamw if (share != NULL) 3038*da6c28aaSamw parent = sa_get_parent_group(share); 303957b448deSdougm } else { 304057b448deSdougm iszfs = is_zfs_group(group); 30416185db85Sdougm } 304257b448deSdougm if (!iszfs) { 304357b448deSdougm if (scf_handle->trans == NULL) { 304457b448deSdougm char oname[SA_STRSIZE]; 304557b448deSdougm char *groupname = NULL; 3046*da6c28aaSamw if (share != NULL) { 3047*da6c28aaSamw if (parent != NULL) 304857b448deSdougm groupname = 304957b448deSdougm sa_get_group_attr(parent, 305057b448deSdougm "name"); 3051*da6c28aaSamw id = sa_get_share_attr( 3052*da6c28aaSamw (sa_share_t)share, "id"); 3053549ec3ffSdougm } else { 305457b448deSdougm groupname = sa_get_group_attr(group, 305557b448deSdougm "name"); 30566185db85Sdougm } 305757b448deSdougm if (groupname != NULL) { 305857b448deSdougm ret = sa_get_instance(scf_handle, 305957b448deSdougm groupname); 306057b448deSdougm sa_free_attr_string(groupname); 306157b448deSdougm } 306257b448deSdougm if (opttype) 306357b448deSdougm (void) sa_optionset_name(optionset, 306457b448deSdougm oname, sizeof (oname), id); 306557b448deSdougm else 306657b448deSdougm (void) sa_security_name(optionset, 306757b448deSdougm oname, sizeof (oname), id); 306857b448deSdougm ret = sa_start_transaction(scf_handle, oname); 30696185db85Sdougm } 307057b448deSdougm if (ret == SA_OK) { 307157b448deSdougm switch (type) { 307257b448deSdougm case SA_PROP_OP_REMOVE: 307357b448deSdougm ret = scf_transaction_property_delete( 307457b448deSdougm scf_handle->trans, entry, name); 307557b448deSdougm break; 307657b448deSdougm case SA_PROP_OP_ADD: 307757b448deSdougm case SA_PROP_OP_UPDATE: 307857b448deSdougm value = scf_value_create( 307957b448deSdougm scf_handle->handle); 308057b448deSdougm ret = add_or_update(scf_handle, type, 308157b448deSdougm value, entry, name, valstr); 308257b448deSdougm break; 308357b448deSdougm } 308457b448deSdougm } 308557b448deSdougm } else { 308657b448deSdougm /* 308757b448deSdougm * ZFS update. The calling function would have updated 308857b448deSdougm * the internal XML structure. Just need to flag it as 308957b448deSdougm * changed for ZFS. 309057b448deSdougm */ 309157b448deSdougm zfs_set_update((sa_share_t)group); 309257b448deSdougm } 30936185db85Sdougm } 30946185db85Sdougm 30956185db85Sdougm if (name != NULL) 309657b448deSdougm sa_free_attr_string(name); 30976185db85Sdougm if (valstr != NULL) 309857b448deSdougm sa_free_attr_string(valstr); 30996185db85Sdougm else if (entry != NULL) 310057b448deSdougm scf_entry_destroy(entry); 31016185db85Sdougm 31026185db85Sdougm if (ret == -1) 310357b448deSdougm ret = SA_SYSTEM_ERR; 31046185db85Sdougm 31056185db85Sdougm return (ret); 31066185db85Sdougm } 31076185db85Sdougm 31086185db85Sdougm /* 31096185db85Sdougm * sa_create_property(name, value) 31106185db85Sdougm * 31116185db85Sdougm * Create a new property with the specified name and value. 31126185db85Sdougm */ 31136185db85Sdougm 31146185db85Sdougm sa_property_t 31156185db85Sdougm sa_create_property(char *name, char *value) 31166185db85Sdougm { 31176185db85Sdougm xmlNodePtr node; 31186185db85Sdougm 31196185db85Sdougm node = xmlNewNode(NULL, (xmlChar *)"option"); 31206185db85Sdougm if (node != NULL) { 31216185db85Sdougm xmlSetProp(node, (xmlChar *)"type", (xmlChar *)name); 31226185db85Sdougm xmlSetProp(node, (xmlChar *)"value", (xmlChar *)value); 31236185db85Sdougm } 31246185db85Sdougm return ((sa_property_t)node); 31256185db85Sdougm } 31266185db85Sdougm 31276185db85Sdougm /* 31286185db85Sdougm * sa_add_property(object, property) 31296185db85Sdougm * 31306185db85Sdougm * Add the specified property to the object. Issue the appropriate 31316185db85Sdougm * transaction or mark a ZFS object as needing an update. 31326185db85Sdougm */ 31336185db85Sdougm 31346185db85Sdougm int 31356185db85Sdougm sa_add_property(void *object, sa_property_t property) 31366185db85Sdougm { 31376185db85Sdougm int ret = SA_OK; 31386185db85Sdougm sa_group_t parent; 31396185db85Sdougm sa_group_t group; 31406185db85Sdougm char *proto; 31416185db85Sdougm 31426185db85Sdougm proto = sa_get_optionset_attr(object, "type"); 31436185db85Sdougm if (property != NULL) { 314457b448deSdougm if ((ret = sa_valid_property(object, proto, property)) == 314557b448deSdougm SA_OK) { 314657b448deSdougm property = (sa_property_t)xmlAddChild( 314757b448deSdougm (xmlNodePtr)object, (xmlNodePtr)property); 314857b448deSdougm } else { 314957b448deSdougm if (proto != NULL) 315057b448deSdougm sa_free_attr_string(proto); 315157b448deSdougm return (ret); 315257b448deSdougm } 31536185db85Sdougm } 31546185db85Sdougm 31556185db85Sdougm if (proto != NULL) 315657b448deSdougm sa_free_attr_string(proto); 31576185db85Sdougm 31586185db85Sdougm parent = sa_get_parent_group(object); 3159*da6c28aaSamw if (!sa_is_persistent(parent)) 316057b448deSdougm return (ret); 31616185db85Sdougm 3162*da6c28aaSamw if (sa_is_resource(parent)) { 3163*da6c28aaSamw /* 3164*da6c28aaSamw * Resources are children of share. Need to go up two 3165*da6c28aaSamw * levels to find the group but the parent needs to be 3166*da6c28aaSamw * the share at this point in order to get the "id". 3167*da6c28aaSamw */ 3168*da6c28aaSamw parent = sa_get_parent_group(parent); 316957b448deSdougm group = sa_get_parent_group(parent); 3170*da6c28aaSamw } else if (sa_is_share(parent)) { 3171*da6c28aaSamw group = sa_get_parent_group(parent); 3172*da6c28aaSamw } else { 317357b448deSdougm group = parent; 3174*da6c28aaSamw } 3175549ec3ffSdougm 317657b448deSdougm if (property == NULL) { 317757b448deSdougm ret = SA_NO_MEMORY; 317857b448deSdougm } else { 317957b448deSdougm char oname[SA_STRSIZE]; 318057b448deSdougm 318157b448deSdougm if (!is_zfs_group(group)) { 318257b448deSdougm char *id = NULL; 318357b448deSdougm sa_handle_impl_t impl_handle; 318457b448deSdougm scfutilhandle_t *scf_handle; 318557b448deSdougm 318657b448deSdougm impl_handle = (sa_handle_impl_t)sa_find_group_handle( 318757b448deSdougm group); 318857b448deSdougm if (impl_handle == NULL || 318957b448deSdougm impl_handle->scfhandle == NULL) 319057b448deSdougm ret = SA_SYSTEM_ERR; 319157b448deSdougm if (ret == SA_OK) { 319257b448deSdougm scf_handle = impl_handle->scfhandle; 319357b448deSdougm if (sa_is_share((sa_group_t)parent)) { 319457b448deSdougm id = sa_get_share_attr( 319557b448deSdougm (sa_share_t)parent, "id"); 319657b448deSdougm } 319757b448deSdougm if (scf_handle->trans == NULL) { 319857b448deSdougm if (is_nodetype(object, "optionset")) { 319957b448deSdougm (void) sa_optionset_name( 320057b448deSdougm (sa_optionset_t)object, 320157b448deSdougm oname, sizeof (oname), id); 320257b448deSdougm } else { 320357b448deSdougm (void) sa_security_name( 320457b448deSdougm (sa_optionset_t)object, 320557b448deSdougm oname, sizeof (oname), id); 320657b448deSdougm } 320757b448deSdougm ret = sa_start_transaction(scf_handle, 320857b448deSdougm oname); 320957b448deSdougm } 321057b448deSdougm if (ret == SA_OK) { 321157b448deSdougm char *name; 321257b448deSdougm char *value; 321357b448deSdougm name = sa_get_property_attr(property, 321457b448deSdougm "type"); 321557b448deSdougm value = sa_get_property_attr(property, 321657b448deSdougm "value"); 321757b448deSdougm if (name != NULL && value != NULL) { 321857b448deSdougm if (scf_handle->scf_state == 321957b448deSdougm SCH_STATE_INIT) { 322057b448deSdougm ret = sa_set_property( 322157b448deSdougm scf_handle, name, 322257b448deSdougm value); 322357b448deSdougm } 322457b448deSdougm } else { 322557b448deSdougm ret = SA_CONFIG_ERR; 322657b448deSdougm } 322757b448deSdougm if (name != NULL) 322857b448deSdougm sa_free_attr_string( 322957b448deSdougm name); 323057b448deSdougm if (value != NULL) 323157b448deSdougm sa_free_attr_string(value); 323257b448deSdougm } 323357b448deSdougm if (id != NULL) 323457b448deSdougm sa_free_attr_string(id); 323557b448deSdougm } 323657b448deSdougm } else { 323757b448deSdougm /* 323857b448deSdougm * ZFS is a special case. We do want 323957b448deSdougm * to allow editing property/security 324057b448deSdougm * lists since we can have a better 324157b448deSdougm * syntax and we also want to keep 324257b448deSdougm * things consistent when possible. 324357b448deSdougm * 324457b448deSdougm * Right now, we defer until the 324557b448deSdougm * sa_commit_properties so we can get 324657b448deSdougm * them all at once. We do need to 324757b448deSdougm * mark the share as "changed" 324857b448deSdougm */ 324957b448deSdougm zfs_set_update((sa_share_t)parent); 32506185db85Sdougm } 32516185db85Sdougm } 32526185db85Sdougm return (ret); 32536185db85Sdougm } 32546185db85Sdougm 32556185db85Sdougm /* 32566185db85Sdougm * sa_remove_property(property) 32576185db85Sdougm * 32586185db85Sdougm * Remove the specied property from its containing object. Update the 32596185db85Sdougm * repository as appropriate. 32606185db85Sdougm */ 32616185db85Sdougm 32626185db85Sdougm int 32636185db85Sdougm sa_remove_property(sa_property_t property) 32646185db85Sdougm { 32656185db85Sdougm int ret = SA_OK; 32666185db85Sdougm 32676185db85Sdougm if (property != NULL) { 32686185db85Sdougm sa_optionset_t optionset; 32696185db85Sdougm sa_group_t group; 32706185db85Sdougm optionset = sa_get_property_parent(property); 32716185db85Sdougm if (optionset != NULL) { 327257b448deSdougm group = sa_get_optionset_parent(optionset); 327357b448deSdougm if (group != NULL) { 327457b448deSdougm ret = sa_set_prop_by_prop(optionset, group, 327557b448deSdougm property, SA_PROP_OP_REMOVE); 327657b448deSdougm } 32776185db85Sdougm } 32786185db85Sdougm xmlUnlinkNode((xmlNodePtr)property); 32796185db85Sdougm xmlFreeNode((xmlNodePtr)property); 32806185db85Sdougm } else { 328157b448deSdougm ret = SA_NO_SUCH_PROP; 32826185db85Sdougm } 32836185db85Sdougm return (ret); 32846185db85Sdougm } 32856185db85Sdougm 32866185db85Sdougm /* 32876185db85Sdougm * sa_update_property(property, value) 32886185db85Sdougm * 32896185db85Sdougm * Update the specified property to the new value. If value is NULL, 32906185db85Sdougm * we currently treat this as a remove. 32916185db85Sdougm */ 32926185db85Sdougm 32936185db85Sdougm int 32946185db85Sdougm sa_update_property(sa_property_t property, char *value) 32956185db85Sdougm { 32966185db85Sdougm int ret = SA_OK; 32976185db85Sdougm if (value == NULL) { 32986185db85Sdougm return (sa_remove_property(property)); 32996185db85Sdougm } else { 33006185db85Sdougm sa_optionset_t optionset; 33016185db85Sdougm sa_group_t group; 33026185db85Sdougm set_node_attr((void *)property, "value", value); 33036185db85Sdougm optionset = sa_get_property_parent(property); 33046185db85Sdougm if (optionset != NULL) { 330557b448deSdougm group = sa_get_optionset_parent(optionset); 330657b448deSdougm if (group != NULL) { 330757b448deSdougm ret = sa_set_prop_by_prop(optionset, group, 330857b448deSdougm property, SA_PROP_OP_UPDATE); 330957b448deSdougm } 33106185db85Sdougm } else { 331157b448deSdougm ret = SA_NO_SUCH_PROP; 33126185db85Sdougm } 33136185db85Sdougm } 33146185db85Sdougm return (ret); 33156185db85Sdougm } 33166185db85Sdougm 33176185db85Sdougm /* 33186185db85Sdougm * sa_get_protocol_property(propset, prop) 33196185db85Sdougm * 33206185db85Sdougm * Get the specified protocol specific property. These are global to 33216185db85Sdougm * the protocol and not specific to a group or share. 33226185db85Sdougm */ 33236185db85Sdougm 33246185db85Sdougm sa_property_t 33256185db85Sdougm sa_get_protocol_property(sa_protocol_properties_t propset, char *prop) 33266185db85Sdougm { 33276185db85Sdougm xmlNodePtr node = (xmlNodePtr)propset; 33286185db85Sdougm xmlChar *value = NULL; 33296185db85Sdougm 33306185db85Sdougm for (node = node->children; node != NULL; 333157b448deSdougm node = node->next) { 333257b448deSdougm if (xmlStrcmp(node->name, (xmlChar *)"option") == 0) { 333357b448deSdougm if (prop == NULL) 333457b448deSdougm break; 333557b448deSdougm value = xmlGetProp(node, (xmlChar *)"type"); 333657b448deSdougm if (value != NULL && 333757b448deSdougm xmlStrcasecmp(value, (xmlChar *)prop) == 0) { 333857b448deSdougm break; 333957b448deSdougm } 334057b448deSdougm if (value != NULL) { 334157b448deSdougm xmlFree(value); 334257b448deSdougm value = NULL; 334357b448deSdougm } 33446185db85Sdougm } 33456185db85Sdougm } 33466185db85Sdougm if (value != NULL) 33476185db85Sdougm xmlFree(value); 33486185db85Sdougm if (node != NULL && xmlStrcmp(node->name, (xmlChar *)"option") != 0) { 334957b448deSdougm /* 335057b448deSdougm * avoid a non option node -- it is possible to be a 335157b448deSdougm * text node 335257b448deSdougm */ 335357b448deSdougm node = NULL; 33546185db85Sdougm } 33556185db85Sdougm return ((sa_property_t)node); 33566185db85Sdougm } 33576185db85Sdougm 33586185db85Sdougm /* 33596185db85Sdougm * sa_get_next_protocol_property(prop) 33606185db85Sdougm * 33616185db85Sdougm * Get the next protocol specific property in the list. 33626185db85Sdougm */ 33636185db85Sdougm 33646185db85Sdougm sa_property_t 33656185db85Sdougm sa_get_next_protocol_property(sa_property_t prop) 33666185db85Sdougm { 33676185db85Sdougm xmlNodePtr node; 33686185db85Sdougm 33696185db85Sdougm for (node = ((xmlNodePtr)prop)->next; node != NULL; 337057b448deSdougm node = node->next) { 33716185db85Sdougm if (xmlStrcmp(node->name, (xmlChar *)"option") == 0) { 33726185db85Sdougm break; 33736185db85Sdougm } 33746185db85Sdougm } 33756185db85Sdougm return ((sa_property_t)node); 33766185db85Sdougm } 33776185db85Sdougm 33786185db85Sdougm /* 33796185db85Sdougm * sa_set_protocol_property(prop, value) 33806185db85Sdougm * 33816185db85Sdougm * Set the specified property to have the new value. The protocol 33826185db85Sdougm * specific plugin will then be called to update the property. 33836185db85Sdougm */ 33846185db85Sdougm 33856185db85Sdougm int 33866185db85Sdougm sa_set_protocol_property(sa_property_t prop, char *value) 33876185db85Sdougm { 33886185db85Sdougm sa_protocol_properties_t propset; 33896185db85Sdougm char *proto; 33906185db85Sdougm int ret = SA_INVALID_PROTOCOL; 33916185db85Sdougm 33926185db85Sdougm propset = ((xmlNodePtr)prop)->parent; 33936185db85Sdougm if (propset != NULL) { 339457b448deSdougm proto = sa_get_optionset_attr(propset, "type"); 339557b448deSdougm if (proto != NULL) { 339657b448deSdougm set_node_attr((xmlNodePtr)prop, "value", value); 339757b448deSdougm ret = sa_proto_set_property(proto, prop); 339857b448deSdougm sa_free_attr_string(proto); 339957b448deSdougm } 34006185db85Sdougm } 34016185db85Sdougm return (ret); 34026185db85Sdougm } 34036185db85Sdougm 34046185db85Sdougm /* 34056185db85Sdougm * sa_add_protocol_property(propset, prop) 34066185db85Sdougm * 3407*da6c28aaSamw * Add a new property to the protocol specific property set. 34086185db85Sdougm */ 34096185db85Sdougm 34106185db85Sdougm int 34116185db85Sdougm sa_add_protocol_property(sa_protocol_properties_t propset, sa_property_t prop) 34126185db85Sdougm { 34136185db85Sdougm xmlNodePtr node; 34146185db85Sdougm 34156185db85Sdougm /* should check for legitimacy */ 34166185db85Sdougm node = xmlAddChild((xmlNodePtr)propset, (xmlNodePtr)prop); 34176185db85Sdougm if (node != NULL) 341857b448deSdougm return (SA_OK); 34196185db85Sdougm return (SA_NO_MEMORY); 34206185db85Sdougm } 34216185db85Sdougm 34226185db85Sdougm /* 34236185db85Sdougm * sa_create_protocol_properties(proto) 34246185db85Sdougm * 3425*da6c28aaSamw * Create a protocol specific property set. 34266185db85Sdougm */ 34276185db85Sdougm 34286185db85Sdougm sa_protocol_properties_t 34296185db85Sdougm sa_create_protocol_properties(char *proto) 34306185db85Sdougm { 34316185db85Sdougm xmlNodePtr node; 343257b448deSdougm 34336185db85Sdougm node = xmlNewNode(NULL, (xmlChar *)"propertyset"); 343457b448deSdougm if (node != NULL) 343557b448deSdougm xmlSetProp(node, (xmlChar *)"type", (xmlChar *)proto); 34366185db85Sdougm return (node); 34376185db85Sdougm } 3438*da6c28aaSamw 3439*da6c28aaSamw /* 3440*da6c28aaSamw * sa_get_share_resource(share, resource) 3441*da6c28aaSamw * 3442*da6c28aaSamw * Get the named resource from the share, if it exists. If resource is 3443*da6c28aaSamw * NULL, get the first resource. 3444*da6c28aaSamw */ 3445*da6c28aaSamw 3446*da6c28aaSamw sa_resource_t 3447*da6c28aaSamw sa_get_share_resource(sa_share_t share, char *resource) 3448*da6c28aaSamw { 3449*da6c28aaSamw xmlNodePtr node = NULL; 3450*da6c28aaSamw xmlChar *name; 3451*da6c28aaSamw 3452*da6c28aaSamw if (share != NULL) { 3453*da6c28aaSamw for (node = ((xmlNodePtr)share)->children; node != NULL; 3454*da6c28aaSamw node = node->next) { 3455*da6c28aaSamw if (xmlStrcmp(node->name, (xmlChar *)"resource") == 0) { 3456*da6c28aaSamw if (resource == NULL) { 3457*da6c28aaSamw /* 3458*da6c28aaSamw * We are looking for the first 3459*da6c28aaSamw * resource node and not a names 3460*da6c28aaSamw * resource. 3461*da6c28aaSamw */ 3462*da6c28aaSamw break; 3463*da6c28aaSamw } else { 3464*da6c28aaSamw /* is it the correct share? */ 3465*da6c28aaSamw name = xmlGetProp(node, 3466*da6c28aaSamw (xmlChar *)"name"); 3467*da6c28aaSamw if (name != NULL && 3468*da6c28aaSamw xmlStrcasecmp(name, 3469*da6c28aaSamw (xmlChar *)resource) == 0) { 3470*da6c28aaSamw xmlFree(name); 3471*da6c28aaSamw break; 3472*da6c28aaSamw } 3473*da6c28aaSamw xmlFree(name); 3474*da6c28aaSamw } 3475*da6c28aaSamw } 3476*da6c28aaSamw } 3477*da6c28aaSamw } 3478*da6c28aaSamw return ((sa_resource_t)node); 3479*da6c28aaSamw } 3480*da6c28aaSamw 3481*da6c28aaSamw /* 3482*da6c28aaSamw * sa_get_next_resource(resource) 3483*da6c28aaSamw * Return the next share following the specified share 3484*da6c28aaSamw * from the internal list of shares. Returns NULL if there 3485*da6c28aaSamw * are no more shares. The list is relative to the same 3486*da6c28aaSamw * group. 3487*da6c28aaSamw */ 3488*da6c28aaSamw sa_share_t 3489*da6c28aaSamw sa_get_next_resource(sa_resource_t resource) 3490*da6c28aaSamw { 3491*da6c28aaSamw xmlNodePtr node = NULL; 3492*da6c28aaSamw 3493*da6c28aaSamw if (resource != NULL) { 3494*da6c28aaSamw for (node = ((xmlNodePtr)resource)->next; node != NULL; 3495*da6c28aaSamw node = node->next) { 3496*da6c28aaSamw if (xmlStrcmp(node->name, (xmlChar *)"resource") == 0) 3497*da6c28aaSamw break; 3498*da6c28aaSamw } 3499*da6c28aaSamw } 3500*da6c28aaSamw return ((sa_share_t)node); 3501*da6c28aaSamw } 3502*da6c28aaSamw 3503*da6c28aaSamw /* 3504*da6c28aaSamw * _sa_get_next_resource_index(share) 3505*da6c28aaSamw * 3506*da6c28aaSamw * get the next resource index number (one greater then current largest) 3507*da6c28aaSamw */ 3508*da6c28aaSamw 3509*da6c28aaSamw static int 3510*da6c28aaSamw _sa_get_next_resource_index(sa_share_t share) 3511*da6c28aaSamw { 3512*da6c28aaSamw sa_resource_t resource; 3513*da6c28aaSamw int index = 0; 3514*da6c28aaSamw char *id; 3515*da6c28aaSamw 3516*da6c28aaSamw for (resource = sa_get_share_resource(share, NULL); 3517*da6c28aaSamw resource != NULL; 3518*da6c28aaSamw resource = sa_get_next_resource(resource)) { 3519*da6c28aaSamw id = get_node_attr((void *)resource, "id"); 3520*da6c28aaSamw if (id != NULL) { 3521*da6c28aaSamw int val; 3522*da6c28aaSamw val = atoi(id); 3523*da6c28aaSamw if (val > index) 3524*da6c28aaSamw index = val; 3525*da6c28aaSamw sa_free_attr_string(id); 3526*da6c28aaSamw } 3527*da6c28aaSamw } 3528*da6c28aaSamw return (index + 1); 3529*da6c28aaSamw } 3530*da6c28aaSamw 3531*da6c28aaSamw 3532*da6c28aaSamw /* 3533*da6c28aaSamw * sa_add_resource(share, resource, persist, &err) 3534*da6c28aaSamw * 3535*da6c28aaSamw * Adds a new resource name associated with share. The resource name 3536*da6c28aaSamw * must be unique in the system and will be case insensitive (eventually). 3537*da6c28aaSamw */ 3538*da6c28aaSamw 3539*da6c28aaSamw sa_resource_t 3540*da6c28aaSamw sa_add_resource(sa_share_t share, char *resource, int persist, int *error) 3541*da6c28aaSamw { 3542*da6c28aaSamw xmlNodePtr node; 3543*da6c28aaSamw int err = SA_OK; 3544*da6c28aaSamw sa_resource_t res; 3545*da6c28aaSamw sa_group_t group; 3546*da6c28aaSamw sa_handle_t handle; 3547*da6c28aaSamw char istring[8]; /* just big enough for an integer value */ 3548*da6c28aaSamw int index; 3549*da6c28aaSamw 3550*da6c28aaSamw group = sa_get_parent_group(share); 3551*da6c28aaSamw handle = sa_find_group_handle(group); 3552*da6c28aaSamw res = sa_find_resource(handle, resource); 3553*da6c28aaSamw if (res != NULL) { 3554*da6c28aaSamw err = SA_DUPLICATE_NAME; 3555*da6c28aaSamw res = NULL; 3556*da6c28aaSamw } else { 3557*da6c28aaSamw node = xmlNewChild((xmlNodePtr)share, NULL, 3558*da6c28aaSamw (xmlChar *)"resource", NULL); 3559*da6c28aaSamw if (node != NULL) { 3560*da6c28aaSamw xmlSetProp(node, (xmlChar *)"name", 3561*da6c28aaSamw (xmlChar *)resource); 3562*da6c28aaSamw xmlSetProp(node, (xmlChar *)"type", persist ? 3563*da6c28aaSamw (xmlChar *)"persist" : (xmlChar *)"transient"); 3564*da6c28aaSamw if (persist != SA_SHARE_TRANSIENT) { 3565*da6c28aaSamw index = _sa_get_next_resource_index(share); 3566*da6c28aaSamw (void) snprintf(istring, sizeof (istring), "%d", 3567*da6c28aaSamw index); 3568*da6c28aaSamw xmlSetProp(node, (xmlChar *)"id", 3569*da6c28aaSamw (xmlChar *)istring); 3570*da6c28aaSamw if (!sa_group_is_zfs(group) && 3571*da6c28aaSamw sa_is_persistent((sa_group_t)share)) { 3572*da6c28aaSamw /* ZFS doesn't use resource names */ 3573*da6c28aaSamw sa_handle_impl_t ihandle; 3574*da6c28aaSamw ihandle = (sa_handle_impl_t) 3575*da6c28aaSamw sa_find_group_handle( 3576*da6c28aaSamw group); 3577*da6c28aaSamw if (ihandle != NULL) 3578*da6c28aaSamw err = sa_commit_share( 3579*da6c28aaSamw ihandle->scfhandle, group, 3580*da6c28aaSamw share); 3581*da6c28aaSamw else 3582*da6c28aaSamw err = SA_SYSTEM_ERR; 3583*da6c28aaSamw } 3584*da6c28aaSamw } 3585*da6c28aaSamw } 3586*da6c28aaSamw } 3587*da6c28aaSamw if (error != NULL) 3588*da6c28aaSamw *error = err; 3589*da6c28aaSamw return ((sa_resource_t)node); 3590*da6c28aaSamw } 3591*da6c28aaSamw 3592*da6c28aaSamw /* 3593*da6c28aaSamw * sa_remove_resource(resource) 3594*da6c28aaSamw * 3595*da6c28aaSamw * Remove the resource name from the share (and the system) 3596*da6c28aaSamw */ 3597*da6c28aaSamw 3598*da6c28aaSamw int 3599*da6c28aaSamw sa_remove_resource(sa_resource_t resource) 3600*da6c28aaSamw { 3601*da6c28aaSamw sa_share_t share; 3602*da6c28aaSamw sa_group_t group; 3603*da6c28aaSamw char *type; 3604*da6c28aaSamw int ret = SA_OK; 3605*da6c28aaSamw int transient = 0; 3606*da6c28aaSamw 3607*da6c28aaSamw share = sa_get_resource_parent(resource); 3608*da6c28aaSamw type = sa_get_share_attr(share, "type"); 3609*da6c28aaSamw group = sa_get_parent_group(share); 3610*da6c28aaSamw 3611*da6c28aaSamw 3612*da6c28aaSamw if (type != NULL) { 3613*da6c28aaSamw if (strcmp(type, "persist") != 0) 3614*da6c28aaSamw transient = 1; 3615*da6c28aaSamw sa_free_attr_string(type); 3616*da6c28aaSamw } 3617*da6c28aaSamw 3618*da6c28aaSamw /* Remove from the share */ 3619*da6c28aaSamw xmlUnlinkNode((xmlNode *)resource); 3620*da6c28aaSamw xmlFreeNode((xmlNode *)resource); 3621*da6c28aaSamw 3622*da6c28aaSamw /* only do SMF action if permanent and not ZFS */ 3623*da6c28aaSamw if (!transient && !sa_group_is_zfs(group)) { 3624*da6c28aaSamw sa_handle_impl_t ihandle; 3625*da6c28aaSamw ihandle = (sa_handle_impl_t)sa_find_group_handle(group); 3626*da6c28aaSamw if (ihandle != NULL) 3627*da6c28aaSamw ret = sa_commit_share(ihandle->scfhandle, group, share); 3628*da6c28aaSamw else 3629*da6c28aaSamw ret = SA_SYSTEM_ERR; 3630*da6c28aaSamw } 3631*da6c28aaSamw return (ret); 3632*da6c28aaSamw } 3633*da6c28aaSamw 3634*da6c28aaSamw /* 3635*da6c28aaSamw * proto_resource_rename(handle, group, resource, newname) 3636*da6c28aaSamw * 3637*da6c28aaSamw * Helper function for sa_rename_resource that notifies the protocol 3638*da6c28aaSamw * of a resource name change prior to a config repository update. 3639*da6c28aaSamw */ 3640*da6c28aaSamw static int 3641*da6c28aaSamw proto_rename_resource(sa_handle_t handle, sa_group_t group, 3642*da6c28aaSamw sa_resource_t resource, char *newname) 3643*da6c28aaSamw { 3644*da6c28aaSamw sa_optionset_t optionset; 3645*da6c28aaSamw int ret = SA_OK; 3646*da6c28aaSamw int err; 3647*da6c28aaSamw 3648*da6c28aaSamw for (optionset = sa_get_optionset(group, NULL); 3649*da6c28aaSamw optionset != NULL; 3650*da6c28aaSamw optionset = sa_get_next_optionset(optionset)) { 3651*da6c28aaSamw char *type; 3652*da6c28aaSamw type = sa_get_optionset_attr(optionset, "type"); 3653*da6c28aaSamw if (type != NULL) { 3654*da6c28aaSamw err = sa_proto_rename_resource(handle, type, resource, 3655*da6c28aaSamw newname); 3656*da6c28aaSamw if (err != SA_OK) 3657*da6c28aaSamw ret = err; 3658*da6c28aaSamw sa_free_attr_string(type); 3659*da6c28aaSamw } 3660*da6c28aaSamw } 3661*da6c28aaSamw return (ret); 3662*da6c28aaSamw } 3663*da6c28aaSamw 3664*da6c28aaSamw /* 3665*da6c28aaSamw * sa_rename_resource(resource, newname) 3666*da6c28aaSamw * 3667*da6c28aaSamw * Rename the resource to the new name, if it is unique. 3668*da6c28aaSamw */ 3669*da6c28aaSamw 3670*da6c28aaSamw int 3671*da6c28aaSamw sa_rename_resource(sa_resource_t resource, char *newname) 3672*da6c28aaSamw { 3673*da6c28aaSamw sa_share_t share; 3674*da6c28aaSamw sa_group_t group = NULL; 3675*da6c28aaSamw sa_resource_t target; 3676*da6c28aaSamw int ret = SA_CONFIG_ERR; 3677*da6c28aaSamw sa_handle_t handle = NULL; 3678*da6c28aaSamw 3679*da6c28aaSamw share = sa_get_resource_parent(resource); 3680*da6c28aaSamw if (share == NULL) 3681*da6c28aaSamw return (ret); 3682*da6c28aaSamw 3683*da6c28aaSamw group = sa_get_parent_group(share); 3684*da6c28aaSamw if (group == NULL) 3685*da6c28aaSamw return (ret); 3686*da6c28aaSamw 3687*da6c28aaSamw handle = (sa_handle_impl_t)sa_find_group_handle(group); 3688*da6c28aaSamw if (handle == NULL) 3689*da6c28aaSamw return (ret); 3690*da6c28aaSamw 3691*da6c28aaSamw target = sa_find_resource(handle, newname); 3692*da6c28aaSamw if (target != NULL) { 3693*da6c28aaSamw ret = SA_DUPLICATE_NAME; 3694*da6c28aaSamw } else { 3695*da6c28aaSamw /* 3696*da6c28aaSamw * Everything appears to be valid at this 3697*da6c28aaSamw * point. Change the name of the active share and then 3698*da6c28aaSamw * update the share in the appropriate repository. 3699*da6c28aaSamw */ 3700*da6c28aaSamw ret = proto_rename_resource(handle, group, resource, newname); 3701*da6c28aaSamw set_node_attr(resource, "name", newname); 3702*da6c28aaSamw if (!sa_group_is_zfs(group) && 3703*da6c28aaSamw sa_is_persistent((sa_group_t)share)) { 3704*da6c28aaSamw sa_handle_impl_t ihandle = (sa_handle_impl_t)handle; 3705*da6c28aaSamw ret = sa_commit_share(ihandle->scfhandle, group, 3706*da6c28aaSamw share); 3707*da6c28aaSamw } 3708*da6c28aaSamw } 3709*da6c28aaSamw return (ret); 3710*da6c28aaSamw } 3711*da6c28aaSamw 3712*da6c28aaSamw /* 3713*da6c28aaSamw * sa_get_resource_attr(resource, tag) 3714*da6c28aaSamw * 3715*da6c28aaSamw * Get the named attribute of the resource. "name" and "id" are 3716*da6c28aaSamw * currently defined. NULL if tag not defined. 3717*da6c28aaSamw */ 3718*da6c28aaSamw 3719*da6c28aaSamw char * 3720*da6c28aaSamw sa_get_resource_attr(sa_resource_t resource, char *tag) 3721*da6c28aaSamw { 3722*da6c28aaSamw return (get_node_attr((void *)resource, tag)); 3723*da6c28aaSamw } 3724*da6c28aaSamw 3725*da6c28aaSamw /* 3726*da6c28aaSamw * sa_set_resource_attr(resource, tag, value) 3727*da6c28aaSamw * 3728*da6c28aaSamw * Get the named attribute of the resource. "name" and "id" are 3729*da6c28aaSamw * currently defined. NULL if tag not defined. Currently we don't do 3730*da6c28aaSamw * much, but additional checking may be needed in the future. 3731*da6c28aaSamw */ 3732*da6c28aaSamw 3733*da6c28aaSamw int 3734*da6c28aaSamw sa_set_resource_attr(sa_resource_t resource, char *tag, char *value) 3735*da6c28aaSamw { 3736*da6c28aaSamw set_node_attr((void *)resource, tag, value); 3737*da6c28aaSamw return (SA_OK); 3738*da6c28aaSamw } 3739*da6c28aaSamw 3740*da6c28aaSamw /* 3741*da6c28aaSamw * sa_get_resource_parent(resource_t) 3742*da6c28aaSamw * 3743*da6c28aaSamw * Returns the share associated with the resource. 3744*da6c28aaSamw */ 3745*da6c28aaSamw 3746*da6c28aaSamw sa_share_t 3747*da6c28aaSamw sa_get_resource_parent(sa_resource_t resource) 3748*da6c28aaSamw { 3749*da6c28aaSamw sa_share_t share = NULL; 3750*da6c28aaSamw 3751*da6c28aaSamw if (resource != NULL) 3752*da6c28aaSamw share = (sa_share_t)((xmlNodePtr)resource)->parent; 3753*da6c28aaSamw return (share); 3754*da6c28aaSamw } 3755*da6c28aaSamw 3756*da6c28aaSamw /* 3757*da6c28aaSamw * find_resource(group, name) 3758*da6c28aaSamw * 3759*da6c28aaSamw * Find the resource within the group. 3760*da6c28aaSamw */ 3761*da6c28aaSamw 3762*da6c28aaSamw static sa_resource_t 3763*da6c28aaSamw find_resource(sa_group_t group, char *resname) 3764*da6c28aaSamw { 3765*da6c28aaSamw sa_share_t share; 3766*da6c28aaSamw sa_resource_t resource = NULL; 3767*da6c28aaSamw char *name; 3768*da6c28aaSamw 3769*da6c28aaSamw /* Iterate over all the shares and resources in the group. */ 3770*da6c28aaSamw for (share = sa_get_share(group, NULL); 3771*da6c28aaSamw share != NULL && resource == NULL; 3772*da6c28aaSamw share = sa_get_next_share(share)) { 3773*da6c28aaSamw for (resource = sa_get_share_resource(share, NULL); 3774*da6c28aaSamw resource != NULL; 3775*da6c28aaSamw resource = sa_get_next_resource(resource)) { 3776*da6c28aaSamw name = sa_get_resource_attr(resource, "name"); 3777*da6c28aaSamw if (name != NULL && xmlStrcasecmp((xmlChar*)name, 3778*da6c28aaSamw (xmlChar*)resname) == 0) { 3779*da6c28aaSamw sa_free_attr_string(name); 3780*da6c28aaSamw break; 3781*da6c28aaSamw } 3782*da6c28aaSamw if (name != NULL) { 3783*da6c28aaSamw sa_free_attr_string(name); 3784*da6c28aaSamw } 3785*da6c28aaSamw } 3786*da6c28aaSamw } 3787*da6c28aaSamw return (resource); 3788*da6c28aaSamw } 3789*da6c28aaSamw 3790*da6c28aaSamw /* 3791*da6c28aaSamw * sa_find_resource(name) 3792*da6c28aaSamw * 3793*da6c28aaSamw * Find the named resource in the system. 3794*da6c28aaSamw */ 3795*da6c28aaSamw 3796*da6c28aaSamw sa_resource_t 3797*da6c28aaSamw sa_find_resource(sa_handle_t handle, char *name) 3798*da6c28aaSamw { 3799*da6c28aaSamw sa_group_t group; 3800*da6c28aaSamw sa_group_t zgroup; 3801*da6c28aaSamw sa_resource_t resource = NULL; 3802*da6c28aaSamw 3803*da6c28aaSamw /* 3804*da6c28aaSamw * Iterate over all groups and zfs subgroups and check for 3805*da6c28aaSamw * resource name in them. 3806*da6c28aaSamw */ 3807*da6c28aaSamw for (group = sa_get_group(handle, NULL); group != NULL; 3808*da6c28aaSamw group = sa_get_next_group(group)) { 3809*da6c28aaSamw 3810*da6c28aaSamw if (is_zfs_group(group)) { 3811*da6c28aaSamw for (zgroup = 3812*da6c28aaSamw (sa_group_t)_sa_get_child_node((xmlNodePtr)group, 3813*da6c28aaSamw (xmlChar *)"group"); 3814*da6c28aaSamw zgroup != NULL && resource == NULL; 3815*da6c28aaSamw zgroup = sa_get_next_group(zgroup)) { 3816*da6c28aaSamw resource = find_resource(zgroup, name); 3817*da6c28aaSamw } 3818*da6c28aaSamw } else { 3819*da6c28aaSamw resource = find_resource(group, name); 3820*da6c28aaSamw } 3821*da6c28aaSamw if (resource != NULL) 3822*da6c28aaSamw break; 3823*da6c28aaSamw } 3824*da6c28aaSamw return (resource); 3825*da6c28aaSamw } 3826*da6c28aaSamw 3827*da6c28aaSamw /* 3828*da6c28aaSamw * sa_get_resource(group, resource) 3829*da6c28aaSamw * 3830*da6c28aaSamw * Search all the shares in the specified group for a share with a 3831*da6c28aaSamw * resource name matching the one specified. 3832*da6c28aaSamw * 3833*da6c28aaSamw * In the future, it may be advantageous to allow group to be NULL and 3834*da6c28aaSamw * search all groups but that isn't needed at present. 3835*da6c28aaSamw */ 3836*da6c28aaSamw 3837*da6c28aaSamw sa_resource_t 3838*da6c28aaSamw sa_get_resource(sa_group_t group, char *resource) 3839*da6c28aaSamw { 3840*da6c28aaSamw sa_share_t share = NULL; 3841*da6c28aaSamw sa_resource_t res = NULL; 3842*da6c28aaSamw 3843*da6c28aaSamw if (resource != NULL) { 3844*da6c28aaSamw for (share = sa_get_share(group, NULL); 3845*da6c28aaSamw share != NULL && res == NULL; 3846*da6c28aaSamw share = sa_get_next_share(share)) { 3847*da6c28aaSamw res = sa_get_share_resource(share, resource); 3848*da6c28aaSamw } 3849*da6c28aaSamw } 3850*da6c28aaSamw return (res); 3851*da6c28aaSamw } 3852*da6c28aaSamw 3853*da6c28aaSamw /* 3854*da6c28aaSamw * sa_enable_resource, protocol) 3855*da6c28aaSamw * Disable the specified share to the specified protocol. 3856*da6c28aaSamw * If protocol is NULL, then all protocols. 3857*da6c28aaSamw */ 3858*da6c28aaSamw int 3859*da6c28aaSamw sa_enable_resource(sa_resource_t resource, char *protocol) 3860*da6c28aaSamw { 3861*da6c28aaSamw int ret = SA_OK; 3862*da6c28aaSamw char **protocols; 3863*da6c28aaSamw int numproto; 3864*da6c28aaSamw 3865*da6c28aaSamw if (protocol != NULL) { 3866*da6c28aaSamw ret = sa_proto_share_resource(protocol, resource); 3867*da6c28aaSamw } else { 3868*da6c28aaSamw /* need to do all protocols */ 3869*da6c28aaSamw if ((numproto = sa_get_protocols(&protocols)) >= 0) { 3870*da6c28aaSamw int i, err; 3871*da6c28aaSamw for (i = 0; i < numproto; i++) { 3872*da6c28aaSamw err = sa_proto_share_resource( 3873*da6c28aaSamw protocols[i], resource); 3874*da6c28aaSamw if (err != SA_OK) 3875*da6c28aaSamw ret = err; 3876*da6c28aaSamw } 3877*da6c28aaSamw free(protocols); 3878*da6c28aaSamw } 3879*da6c28aaSamw } 3880*da6c28aaSamw if (ret == SA_OK) 3881*da6c28aaSamw (void) sa_set_resource_attr(resource, "shared", NULL); 3882*da6c28aaSamw 3883*da6c28aaSamw return (ret); 3884*da6c28aaSamw } 3885*da6c28aaSamw 3886*da6c28aaSamw /* 3887*da6c28aaSamw * sa_disable_resource(resource, protocol) 3888*da6c28aaSamw * 3889*da6c28aaSamw * Disable the specified share for the specified protocol. If 3890*da6c28aaSamw * protocol is NULL, then all protocols. If the underlying 3891*da6c28aaSamw * protocol doesn't implement disable at the resource level, we 3892*da6c28aaSamw * disable at the share level. 3893*da6c28aaSamw */ 3894*da6c28aaSamw int 3895*da6c28aaSamw sa_disable_resource(sa_resource_t resource, char *protocol) 3896*da6c28aaSamw { 3897*da6c28aaSamw int ret = SA_OK; 3898*da6c28aaSamw char **protocols; 3899*da6c28aaSamw int numproto; 3900*da6c28aaSamw 3901*da6c28aaSamw if (protocol != NULL) { 3902*da6c28aaSamw ret = sa_proto_unshare_resource(protocol, resource); 3903*da6c28aaSamw if (ret == SA_NOT_IMPLEMENTED) { 3904*da6c28aaSamw sa_share_t parent; 3905*da6c28aaSamw /* 3906*da6c28aaSamw * The protocol doesn't implement unshare 3907*da6c28aaSamw * resource. That implies that resource names are 3908*da6c28aaSamw * simple aliases for this protocol so we need to 3909*da6c28aaSamw * unshare the share. 3910*da6c28aaSamw */ 3911*da6c28aaSamw parent = sa_get_resource_parent(resource); 3912*da6c28aaSamw if (parent != NULL) 3913*da6c28aaSamw ret = sa_disable_share(parent, protocol); 3914*da6c28aaSamw else 3915*da6c28aaSamw ret = SA_CONFIG_ERR; 3916*da6c28aaSamw } 3917*da6c28aaSamw } else { 3918*da6c28aaSamw /* need to do all protocols */ 3919*da6c28aaSamw if ((numproto = sa_get_protocols(&protocols)) >= 0) { 3920*da6c28aaSamw int i, err; 3921*da6c28aaSamw for (i = 0; i < numproto; i++) { 3922*da6c28aaSamw err = sa_proto_unshare_resource(protocols[i], 3923*da6c28aaSamw resource); 3924*da6c28aaSamw if (err == SA_NOT_SUPPORTED) { 3925*da6c28aaSamw sa_share_t parent; 3926*da6c28aaSamw parent = sa_get_resource_parent( 3927*da6c28aaSamw resource); 3928*da6c28aaSamw if (parent != NULL) 3929*da6c28aaSamw err = sa_disable_share(parent, 3930*da6c28aaSamw protocols[i]); 3931*da6c28aaSamw else 3932*da6c28aaSamw err = SA_CONFIG_ERR; 3933*da6c28aaSamw } 3934*da6c28aaSamw if (err != SA_OK) 3935*da6c28aaSamw ret = err; 3936*da6c28aaSamw } 3937*da6c28aaSamw free(protocols); 3938*da6c28aaSamw } 3939*da6c28aaSamw } 3940*da6c28aaSamw if (ret == SA_OK) 3941*da6c28aaSamw (void) sa_set_resource_attr(resource, "shared", NULL); 3942*da6c28aaSamw 3943*da6c28aaSamw return (ret); 3944*da6c28aaSamw } 3945*da6c28aaSamw 3946*da6c28aaSamw /* 3947*da6c28aaSamw * sa_set_resource_description(resource, content) 3948*da6c28aaSamw * 3949*da6c28aaSamw * Set the description of share to content. 3950*da6c28aaSamw */ 3951*da6c28aaSamw 3952*da6c28aaSamw int 3953*da6c28aaSamw sa_set_resource_description(sa_resource_t resource, char *content) 3954*da6c28aaSamw { 3955*da6c28aaSamw xmlNodePtr node; 3956*da6c28aaSamw sa_group_t group; 3957*da6c28aaSamw sa_share_t share; 3958*da6c28aaSamw int ret = SA_OK; 3959*da6c28aaSamw 3960*da6c28aaSamw for (node = ((xmlNodePtr)resource)->children; 3961*da6c28aaSamw node != NULL; 3962*da6c28aaSamw node = node->next) { 3963*da6c28aaSamw if (xmlStrcmp(node->name, (xmlChar *)"description") == 0) { 3964*da6c28aaSamw break; 3965*da6c28aaSamw } 3966*da6c28aaSamw } 3967*da6c28aaSamw 3968*da6c28aaSamw /* no existing description but want to add */ 3969*da6c28aaSamw if (node == NULL && content != NULL) { 3970*da6c28aaSamw /* add a description */ 3971*da6c28aaSamw node = _sa_set_share_description(resource, content); 3972*da6c28aaSamw } else if (node != NULL && content != NULL) { 3973*da6c28aaSamw /* update a description */ 3974*da6c28aaSamw xmlNodeSetContent(node, (xmlChar *)content); 3975*da6c28aaSamw } else if (node != NULL && content == NULL) { 3976*da6c28aaSamw /* remove an existing description */ 3977*da6c28aaSamw xmlUnlinkNode(node); 3978*da6c28aaSamw xmlFreeNode(node); 3979*da6c28aaSamw } 3980*da6c28aaSamw share = sa_get_resource_parent(resource); 3981*da6c28aaSamw group = sa_get_parent_group(share); 3982*da6c28aaSamw if (group != NULL && sa_is_persistent(share)) { 3983*da6c28aaSamw sa_handle_impl_t impl_handle; 3984*da6c28aaSamw impl_handle = (sa_handle_impl_t)sa_find_group_handle(group); 3985*da6c28aaSamw if (impl_handle != NULL) 3986*da6c28aaSamw ret = sa_commit_share(impl_handle->scfhandle, 3987*da6c28aaSamw group, share); 3988*da6c28aaSamw else 3989*da6c28aaSamw ret = SA_SYSTEM_ERR; 3990*da6c28aaSamw } 3991*da6c28aaSamw return (ret); 3992*da6c28aaSamw } 3993*da6c28aaSamw 3994*da6c28aaSamw /* 3995*da6c28aaSamw * sa_get_resource_description(share) 3996*da6c28aaSamw * 3997*da6c28aaSamw * Return the description text for the specified share if it 3998*da6c28aaSamw * exists. NULL if no description exists. 3999*da6c28aaSamw */ 4000*da6c28aaSamw 4001*da6c28aaSamw char * 4002*da6c28aaSamw sa_get_resource_description(sa_resource_t resource) 4003*da6c28aaSamw { 4004*da6c28aaSamw xmlChar *description = NULL; 4005*da6c28aaSamw xmlNodePtr node; 4006*da6c28aaSamw 4007*da6c28aaSamw for (node = ((xmlNodePtr)resource)->children; node != NULL; 4008*da6c28aaSamw node = node->next) { 4009*da6c28aaSamw if (xmlStrcmp(node->name, (xmlChar *)"description") == 0) 4010*da6c28aaSamw break; 4011*da6c28aaSamw } 4012*da6c28aaSamw if (node != NULL) { 4013*da6c28aaSamw description = xmlNodeGetContent(node); 4014*da6c28aaSamw fixproblemchars((char *)description); 4015*da6c28aaSamw } 4016*da6c28aaSamw return ((char *)description); 4017*da6c28aaSamw } 4018