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 606185db85Sdougm /* 616185db85Sdougm * internal data structures 626185db85Sdougm */ 636185db85Sdougm 646185db85Sdougm extern struct sa_proto_plugin *sap_proto_list; 656185db85Sdougm 666185db85Sdougm /* current SMF/SVC repository handle */ 67549ec3ffSdougm extern void getlegacyconfig(sa_handle_t, char *, xmlNodePtr *); 68549ec3ffSdougm extern int gettransients(sa_handle_impl_t, xmlNodePtr *); 696185db85Sdougm extern int sa_valid_property(void *, char *, sa_property_t); 706185db85Sdougm extern char *sa_fstype(char *); 716185db85Sdougm extern int sa_is_share(void *); 726185db85Sdougm extern ssize_t scf_max_name_len; /* defined in scfutil during initialization */ 736185db85Sdougm extern int sa_group_is_zfs(sa_group_t); 746185db85Sdougm extern int sa_path_is_zfs(char *); 756185db85Sdougm extern int sa_zfs_set_sharenfs(sa_group_t, char *, int); 76549ec3ffSdougm extern void update_legacy_config(sa_handle_t); 776185db85Sdougm extern int issubdir(char *, char *); 7857b448deSdougm extern int sa_zfs_init(sa_handle_impl_t); 79549ec3ffSdougm extern void sa_zfs_fini(sa_handle_impl_t); 80a99982a7Sdougm extern void sablocksigs(sigset_t *); 81a99982a7Sdougm extern void saunblocksigs(sigset_t *); 826185db85Sdougm 83549ec3ffSdougm /* 84549ec3ffSdougm * Data structures for finding/managing the document root to access 85549ec3ffSdougm * handle mapping. The list isn't expected to grow very large so a 86549ec3ffSdougm * simple list is acceptable. The purpose is to provide a way to start 87549ec3ffSdougm * with a group or share and find the library handle needed for 88549ec3ffSdougm * various operations. 89549ec3ffSdougm */ 90549ec3ffSdougm mutex_t sa_global_lock; 91549ec3ffSdougm struct doc2handle { 92549ec3ffSdougm struct doc2handle *next; 93549ec3ffSdougm xmlNodePtr root; 94549ec3ffSdougm sa_handle_impl_t handle; 95549ec3ffSdougm }; 96549ec3ffSdougm 9757b448deSdougm /* definitions used in a couple of property functions */ 9857b448deSdougm #define SA_PROP_OP_REMOVE 1 9957b448deSdougm #define SA_PROP_OP_ADD 2 10057b448deSdougm #define SA_PROP_OP_UPDATE 3 10157b448deSdougm 102549ec3ffSdougm static struct doc2handle *sa_global_handles = NULL; 1036185db85Sdougm 1046185db85Sdougm /* helper functions */ 1056185db85Sdougm 106549ec3ffSdougm /* 107549ec3ffSdougm * sa_errorstr(err) 108549ec3ffSdougm * 109549ec3ffSdougm * convert an error value to an error string 110549ec3ffSdougm */ 111549ec3ffSdougm 1126185db85Sdougm char * 1136185db85Sdougm sa_errorstr(int err) 1146185db85Sdougm { 1156185db85Sdougm static char errstr[32]; 1166185db85Sdougm char *ret = NULL; 1176185db85Sdougm 1186185db85Sdougm switch (err) { 1196185db85Sdougm case SA_OK: 12024424a35Sdougm ret = dgettext(TEXT_DOMAIN, "ok"); 1216185db85Sdougm break; 1226185db85Sdougm case SA_NO_SUCH_PATH: 12324424a35Sdougm ret = dgettext(TEXT_DOMAIN, "path doesn't exist"); 1246185db85Sdougm break; 1256185db85Sdougm case SA_NO_MEMORY: 12624424a35Sdougm ret = dgettext(TEXT_DOMAIN, "no memory"); 1276185db85Sdougm break; 1286185db85Sdougm case SA_DUPLICATE_NAME: 12924424a35Sdougm ret = dgettext(TEXT_DOMAIN, "name in use"); 1306185db85Sdougm break; 1316185db85Sdougm case SA_BAD_PATH: 13224424a35Sdougm ret = dgettext(TEXT_DOMAIN, "bad path"); 1336185db85Sdougm break; 1346185db85Sdougm case SA_NO_SUCH_GROUP: 13524424a35Sdougm ret = dgettext(TEXT_DOMAIN, "no such group"); 1366185db85Sdougm break; 1376185db85Sdougm case SA_CONFIG_ERR: 13824424a35Sdougm ret = dgettext(TEXT_DOMAIN, "configuration error"); 1396185db85Sdougm break; 1406185db85Sdougm case SA_SYSTEM_ERR: 14124424a35Sdougm ret = dgettext(TEXT_DOMAIN, "system error"); 1426185db85Sdougm break; 1436185db85Sdougm case SA_SYNTAX_ERR: 14424424a35Sdougm ret = dgettext(TEXT_DOMAIN, "syntax error"); 1456185db85Sdougm break; 1466185db85Sdougm case SA_NO_PERMISSION: 14724424a35Sdougm ret = dgettext(TEXT_DOMAIN, "no permission"); 1486185db85Sdougm break; 1496185db85Sdougm case SA_BUSY: 15024424a35Sdougm ret = dgettext(TEXT_DOMAIN, "busy"); 1516185db85Sdougm break; 1526185db85Sdougm case SA_NO_SUCH_PROP: 15324424a35Sdougm ret = dgettext(TEXT_DOMAIN, "no such property"); 1546185db85Sdougm break; 1556185db85Sdougm case SA_INVALID_NAME: 15624424a35Sdougm ret = dgettext(TEXT_DOMAIN, "invalid name"); 1576185db85Sdougm break; 1586185db85Sdougm case SA_INVALID_PROTOCOL: 15924424a35Sdougm ret = dgettext(TEXT_DOMAIN, "invalid protocol"); 1606185db85Sdougm break; 1616185db85Sdougm case SA_NOT_ALLOWED: 16224424a35Sdougm ret = dgettext(TEXT_DOMAIN, "operation not allowed"); 1636185db85Sdougm break; 1646185db85Sdougm case SA_BAD_VALUE: 16524424a35Sdougm ret = dgettext(TEXT_DOMAIN, "bad property value"); 1666185db85Sdougm break; 1676185db85Sdougm case SA_INVALID_SECURITY: 16824424a35Sdougm ret = dgettext(TEXT_DOMAIN, "invalid security type"); 1696185db85Sdougm break; 1706185db85Sdougm case SA_NO_SUCH_SECURITY: 17124424a35Sdougm ret = dgettext(TEXT_DOMAIN, "security type not found"); 1726185db85Sdougm break; 1736185db85Sdougm case SA_VALUE_CONFLICT: 17424424a35Sdougm ret = dgettext(TEXT_DOMAIN, "property value conflict"); 1756185db85Sdougm break; 1766185db85Sdougm case SA_NOT_IMPLEMENTED: 17724424a35Sdougm ret = dgettext(TEXT_DOMAIN, "not implemented"); 1786185db85Sdougm break; 1796185db85Sdougm case SA_INVALID_PATH: 18024424a35Sdougm ret = dgettext(TEXT_DOMAIN, "invalid path"); 1816185db85Sdougm break; 1826185db85Sdougm case SA_NOT_SUPPORTED: 18324424a35Sdougm ret = dgettext(TEXT_DOMAIN, "operation not supported"); 1846185db85Sdougm break; 1856185db85Sdougm case SA_PROP_SHARE_ONLY: 18624424a35Sdougm ret = dgettext(TEXT_DOMAIN, "property not valid for group"); 1876185db85Sdougm break; 1886185db85Sdougm case SA_NOT_SHARED: 18924424a35Sdougm ret = dgettext(TEXT_DOMAIN, "not shared"); 1906185db85Sdougm break; 1916185db85Sdougm default: 1926185db85Sdougm (void) snprintf(errstr, sizeof (errstr), 19324424a35Sdougm dgettext(TEXT_DOMAIN, "unknown %d"), err); 1946185db85Sdougm ret = errstr; 1956185db85Sdougm } 1966185db85Sdougm return (ret); 1976185db85Sdougm } 1986185db85Sdougm 1996185db85Sdougm /* 200549ec3ffSdougm * Document root to active handle mapping functions. These are only 201549ec3ffSdougm * used internally. A mutex is used to prevent access while the list 202549ec3ffSdougm * is changing. In general, the list will be relatively short - one 203549ec3ffSdougm * item per thread that has called sa_init(). 204549ec3ffSdougm */ 205549ec3ffSdougm 206549ec3ffSdougm sa_handle_impl_t 207549ec3ffSdougm get_handle_for_root(xmlNodePtr root) 208549ec3ffSdougm { 209549ec3ffSdougm struct doc2handle *item; 210549ec3ffSdougm 211549ec3ffSdougm (void) mutex_lock(&sa_global_lock); 212549ec3ffSdougm for (item = sa_global_handles; item != NULL; item = item->next) { 213549ec3ffSdougm if (item->root == root) 214549ec3ffSdougm break; 215549ec3ffSdougm } 216549ec3ffSdougm (void) mutex_unlock(&sa_global_lock); 217549ec3ffSdougm if (item != NULL) 218549ec3ffSdougm return (item->handle); 219549ec3ffSdougm return (NULL); 220549ec3ffSdougm } 221549ec3ffSdougm 222549ec3ffSdougm static int 223549ec3ffSdougm add_handle_for_root(xmlNodePtr root, sa_handle_impl_t handle) 224549ec3ffSdougm { 225549ec3ffSdougm struct doc2handle *item; 226549ec3ffSdougm int ret = SA_NO_MEMORY; 227549ec3ffSdougm 228549ec3ffSdougm item = (struct doc2handle *)calloc(sizeof (struct doc2handle), 1); 229549ec3ffSdougm if (item != NULL) { 230549ec3ffSdougm item->root = root; 231549ec3ffSdougm item->handle = handle; 232549ec3ffSdougm (void) mutex_lock(&sa_global_lock); 233549ec3ffSdougm item->next = sa_global_handles; 234549ec3ffSdougm sa_global_handles = item; 235549ec3ffSdougm (void) mutex_unlock(&sa_global_lock); 236549ec3ffSdougm ret = SA_OK; 237549ec3ffSdougm } 238549ec3ffSdougm return (ret); 239549ec3ffSdougm } 240549ec3ffSdougm 241549ec3ffSdougm /* 242549ec3ffSdougm * remove_handle_for_root(root) 243549ec3ffSdougm * 244549ec3ffSdougm * Walks the list of handles and removes the one for this "root" from 245549ec3ffSdougm * the list. It is up to the caller to free the data. 246549ec3ffSdougm */ 247549ec3ffSdougm 248549ec3ffSdougm static void 249549ec3ffSdougm remove_handle_for_root(xmlNodePtr root) 250549ec3ffSdougm { 251549ec3ffSdougm struct doc2handle *item, *prev; 252549ec3ffSdougm 253549ec3ffSdougm (void) mutex_lock(&sa_global_lock); 254549ec3ffSdougm for (prev = NULL, item = sa_global_handles; item != NULL; 255549ec3ffSdougm item = item->next) { 256549ec3ffSdougm if (item->root == root) { 257549ec3ffSdougm /* first in the list */ 25857b448deSdougm if (prev == NULL) 259549ec3ffSdougm sa_global_handles = sa_global_handles->next; 26057b448deSdougm else 261549ec3ffSdougm prev->next = item->next; 262549ec3ffSdougm /* Item is out of the list so free the list structure */ 263549ec3ffSdougm free(item); 264549ec3ffSdougm break; 265549ec3ffSdougm } 266549ec3ffSdougm prev = item; 267549ec3ffSdougm } 268549ec3ffSdougm (void) mutex_unlock(&sa_global_lock); 269549ec3ffSdougm } 270549ec3ffSdougm 271549ec3ffSdougm /* 272549ec3ffSdougm * sa_find_group_handle(sa_group_t group) 273549ec3ffSdougm * 274549ec3ffSdougm * Find the sa_handle_t for the configuration associated with this 275549ec3ffSdougm * group. 276549ec3ffSdougm */ 277549ec3ffSdougm sa_handle_t 278549ec3ffSdougm sa_find_group_handle(sa_group_t group) 279549ec3ffSdougm { 280549ec3ffSdougm xmlNodePtr node = (xmlNodePtr)group; 281549ec3ffSdougm sa_handle_t handle; 282549ec3ffSdougm 283549ec3ffSdougm while (node != NULL) { 284549ec3ffSdougm if (strcmp((char *)(node->name), "sharecfg") == 0) { 285549ec3ffSdougm /* have the root so get the handle */ 286549ec3ffSdougm handle = (sa_handle_t)get_handle_for_root(node); 287549ec3ffSdougm return (handle); 288549ec3ffSdougm } 289549ec3ffSdougm node = node->parent; 290549ec3ffSdougm } 291549ec3ffSdougm return (NULL); 292549ec3ffSdougm } 293549ec3ffSdougm 294549ec3ffSdougm /* 2956185db85Sdougm * set_legacy_timestamp(root, path, timevalue) 2966185db85Sdougm * 2976185db85Sdougm * add the current timestamp value to the configuration for use in 2986185db85Sdougm * determining when to update the legacy files. For SMF, this 2996185db85Sdougm * property is kept in default/operation/legacy_timestamp 3006185db85Sdougm */ 3016185db85Sdougm 3026185db85Sdougm static void 3036185db85Sdougm set_legacy_timestamp(xmlNodePtr root, char *path, uint64_t tval) 3046185db85Sdougm { 3056185db85Sdougm xmlNodePtr node; 3066185db85Sdougm xmlChar *lpath = NULL; 307549ec3ffSdougm sa_handle_impl_t handle; 308549ec3ffSdougm 309549ec3ffSdougm /* Have to have a handle or else we weren't initialized. */ 310549ec3ffSdougm handle = get_handle_for_root(root); 311549ec3ffSdougm if (handle == NULL) 312549ec3ffSdougm return; 3136185db85Sdougm 3146185db85Sdougm for (node = root->xmlChildrenNode; node != NULL; 3156185db85Sdougm node = node->next) { 3166185db85Sdougm if (xmlStrcmp(node->name, (xmlChar *)"legacy") == 0) { 3176185db85Sdougm /* a possible legacy node for this path */ 3186185db85Sdougm lpath = xmlGetProp(node, (xmlChar *)"path"); 31957b448deSdougm if (lpath != NULL && 32057b448deSdougm xmlStrcmp(lpath, (xmlChar *)path) == 0) { 3216185db85Sdougm xmlFree(lpath); 3226185db85Sdougm break; 3236185db85Sdougm } 3246185db85Sdougm if (lpath != NULL) 3256185db85Sdougm xmlFree(lpath); 3266185db85Sdougm } 3276185db85Sdougm } 3286185db85Sdougm if (node == NULL) { 3296185db85Sdougm /* need to create the first legacy timestamp node */ 3306185db85Sdougm node = xmlNewChild(root, NULL, (xmlChar *)"legacy", NULL); 3316185db85Sdougm } 3326185db85Sdougm if (node != NULL) { 3336185db85Sdougm char tstring[32]; 3346185db85Sdougm int ret; 3356185db85Sdougm 3366185db85Sdougm (void) snprintf(tstring, sizeof (tstring), "%lld", tval); 3376185db85Sdougm xmlSetProp(node, (xmlChar *)"timestamp", (xmlChar *)tstring); 3386185db85Sdougm xmlSetProp(node, (xmlChar *)"path", (xmlChar *)path); 3396185db85Sdougm /* now commit to SMF */ 340549ec3ffSdougm ret = sa_get_instance(handle->scfhandle, "default"); 3416185db85Sdougm if (ret == SA_OK) { 34257b448deSdougm ret = sa_start_transaction(handle->scfhandle, 34357b448deSdougm "operation"); 3446185db85Sdougm if (ret == SA_OK) { 34557b448deSdougm ret = sa_set_property(handle->scfhandle, 34657b448deSdougm "legacy-timestamp", tstring); 3476185db85Sdougm if (ret == SA_OK) { 34857b448deSdougm (void) sa_end_transaction( 34957b448deSdougm handle->scfhandle); 3506185db85Sdougm } else { 351549ec3ffSdougm sa_abort_transaction(handle->scfhandle); 3526185db85Sdougm } 3536185db85Sdougm } 3546185db85Sdougm } 3556185db85Sdougm } 3566185db85Sdougm } 3576185db85Sdougm 3586185db85Sdougm /* 3596185db85Sdougm * is_shared(share) 3606185db85Sdougm * 3616185db85Sdougm * determine if the specified share is currently shared or not. 3626185db85Sdougm */ 3636185db85Sdougm static int 3646185db85Sdougm is_shared(sa_share_t share) 3656185db85Sdougm { 3666185db85Sdougm char *shared; 3676185db85Sdougm int result = 0; /* assume not */ 3686185db85Sdougm 3696185db85Sdougm shared = sa_get_share_attr(share, "shared"); 3706185db85Sdougm if (shared != NULL) { 3716185db85Sdougm if (strcmp(shared, "true") == 0) 3726185db85Sdougm result = 1; 3736185db85Sdougm sa_free_attr_string(shared); 3746185db85Sdougm } 3756185db85Sdougm return (result); 3766185db85Sdougm } 3776185db85Sdougm 3786185db85Sdougm /* 379a99982a7Sdougm * checksubdirgroup(group, newpath, strictness) 380f345c0beSdougm * 381a99982a7Sdougm * check all the specified newpath against all the paths in the 382a99982a7Sdougm * group. This is a helper function for checksubdir to make it easier 383a99982a7Sdougm * to also check ZFS subgroups. 384a99982a7Sdougm * The strictness values mean: 385f345c0beSdougm * SA_CHECK_NORMAL == only check newpath against shares that are active 386f345c0beSdougm * SA_CHECK_STRICT == check newpath against both active shares and those 387f345c0beSdougm * stored in the repository 3886185db85Sdougm */ 3896185db85Sdougm static int 390a99982a7Sdougm checksubdirgroup(sa_group_t group, char *newpath, int strictness) 3916185db85Sdougm { 3926185db85Sdougm sa_share_t share; 393a99982a7Sdougm char *path; 394a99982a7Sdougm int issub = SA_OK; 3956185db85Sdougm 3966185db85Sdougm for (share = sa_get_share(group, NULL); share != NULL; 3976185db85Sdougm share = sa_get_next_share(share)) { 3986185db85Sdougm /* 3996185db85Sdougm * The original behavior of share never checked 4006185db85Sdougm * against the permanent configuration 4016185db85Sdougm * (/etc/dfs/dfstab). PIT has a number of cases where 4026185db85Sdougm * it depends on this older behavior even though it 4036185db85Sdougm * could be considered incorrect. We may tighten this 4046185db85Sdougm * up in the future. 4056185db85Sdougm */ 406f345c0beSdougm if (strictness == SA_CHECK_NORMAL && !is_shared(share)) 4076185db85Sdougm continue; 4086185db85Sdougm 4096185db85Sdougm path = sa_get_share_attr(share, "path"); 410f345c0beSdougm /* 411f345c0beSdougm * If path is NULL, then a share is in the process of 412f345c0beSdougm * construction or someone has modified the property 413a99982a7Sdougm * group inappropriately. It should be 414a99982a7Sdougm * ignored. issubdir() comes from the original share 415a99982a7Sdougm * implementation and does the difficult part of 416a99982a7Sdougm * checking subdirectories. 417f345c0beSdougm */ 418f345c0beSdougm if (path == NULL) 419f345c0beSdougm continue; 4206185db85Sdougm if (newpath != NULL && 4216185db85Sdougm (strcmp(path, newpath) == 0 || issubdir(newpath, path) || 4226185db85Sdougm issubdir(path, newpath))) { 4236185db85Sdougm sa_free_attr_string(path); 4246185db85Sdougm path = NULL; 4256185db85Sdougm issub = SA_INVALID_PATH; 4266185db85Sdougm break; 4276185db85Sdougm } 4286185db85Sdougm sa_free_attr_string(path); 4296185db85Sdougm path = NULL; 4306185db85Sdougm } 431a99982a7Sdougm return (issub); 432a99982a7Sdougm } 433a99982a7Sdougm 434a99982a7Sdougm /* 435a99982a7Sdougm * checksubdir(newpath, strictness) 436a99982a7Sdougm * 437a99982a7Sdougm * checksubdir determines if the specified path (newpath) is a 438a99982a7Sdougm * subdirectory of another share. It calls checksubdirgroup() to do 439a99982a7Sdougm * the complicated work. The strictness parameter determines how 440a99982a7Sdougm * strict a check to make against the path. The strictness values 441a99982a7Sdougm * mean: SA_CHECK_NORMAL == only check newpath against shares that are 442a99982a7Sdougm * active SA_CHECK_STRICT == check newpath against both active shares 443a99982a7Sdougm * and those * stored in the repository 444a99982a7Sdougm */ 445a99982a7Sdougm static int 446549ec3ffSdougm checksubdir(sa_handle_t handle, char *newpath, int strictness) 447a99982a7Sdougm { 448a99982a7Sdougm sa_group_t group; 449a99982a7Sdougm int issub; 450a99982a7Sdougm char *path = NULL; 451a99982a7Sdougm 452549ec3ffSdougm for (issub = 0, group = sa_get_group(handle, NULL); 45357b448deSdougm group != NULL && !issub; group = sa_get_next_group(group)) { 454a99982a7Sdougm if (sa_group_is_zfs(group)) { 455a99982a7Sdougm sa_group_t subgroup; 456a99982a7Sdougm for (subgroup = sa_get_sub_group(group); 457a99982a7Sdougm subgroup != NULL && !issub; 458a99982a7Sdougm subgroup = sa_get_next_group(subgroup)) 45957b448deSdougm issub = checksubdirgroup(subgroup, newpath, 46057b448deSdougm strictness); 461a99982a7Sdougm } else { 462a99982a7Sdougm issub = checksubdirgroup(group, newpath, strictness); 463a99982a7Sdougm } 4646185db85Sdougm } 4656185db85Sdougm if (path != NULL) 4666185db85Sdougm sa_free_attr_string(path); 4676185db85Sdougm return (issub); 4686185db85Sdougm } 4696185db85Sdougm 4706185db85Sdougm /* 471f345c0beSdougm * validpath(path, strictness) 4726185db85Sdougm * determine if the provided path is valid for a share. It shouldn't 4736185db85Sdougm * be a sub-dir of an already shared path or the parent directory of a 4746185db85Sdougm * share path. 4756185db85Sdougm */ 4766185db85Sdougm static int 477549ec3ffSdougm validpath(sa_handle_t handle, char *path, int strictness) 4786185db85Sdougm { 4796185db85Sdougm int error = SA_OK; 4806185db85Sdougm struct stat st; 4816185db85Sdougm sa_share_t share; 4826185db85Sdougm char *fstype; 4836185db85Sdougm 48457b448deSdougm if (*path != '/') 4856185db85Sdougm return (SA_BAD_PATH); 48657b448deSdougm 4876185db85Sdougm if (stat(path, &st) < 0) { 4886185db85Sdougm error = SA_NO_SUCH_PATH; 4896185db85Sdougm } else { 490549ec3ffSdougm share = sa_find_share(handle, path); 49157b448deSdougm if (share != NULL) 4926185db85Sdougm error = SA_DUPLICATE_NAME; 49357b448deSdougm 4946185db85Sdougm if (error == SA_OK) { 4956185db85Sdougm /* 49657b448deSdougm * check for special case with file system 49757b448deSdougm * that might have restrictions. For now, ZFS 49857b448deSdougm * is the only case since it has its own idea 49957b448deSdougm * of how to configure shares. We do this 50057b448deSdougm * before subdir checking since things like 50157b448deSdougm * ZFS will do that for us. This should also 50257b448deSdougm * be done via plugin interface. 5036185db85Sdougm */ 5046185db85Sdougm fstype = sa_fstype(path); 5056185db85Sdougm if (fstype != NULL && strcmp(fstype, "zfs") == 0) { 506549ec3ffSdougm if (sa_zfs_is_shared(handle, path)) 507a99982a7Sdougm error = SA_INVALID_NAME; 5086185db85Sdougm } 5096185db85Sdougm if (fstype != NULL) 5106185db85Sdougm sa_free_fstype(fstype); 5116185db85Sdougm } 51257b448deSdougm if (error == SA_OK) 513549ec3ffSdougm error = checksubdir(handle, path, strictness); 5146185db85Sdougm } 5156185db85Sdougm return (error); 5166185db85Sdougm } 5176185db85Sdougm 5186185db85Sdougm /* 5196185db85Sdougm * check to see if group/share is persistent. 5206185db85Sdougm */ 5216185db85Sdougm static int 5226185db85Sdougm is_persistent(sa_group_t group) 5236185db85Sdougm { 5246185db85Sdougm char *type; 5256185db85Sdougm int persist = 1; 5266185db85Sdougm 5276185db85Sdougm type = sa_get_group_attr(group, "type"); 5286185db85Sdougm if (type != NULL && strcmp(type, "transient") == 0) 5296185db85Sdougm persist = 0; 5306185db85Sdougm if (type != NULL) 5316185db85Sdougm sa_free_attr_string(type); 5326185db85Sdougm return (persist); 5336185db85Sdougm } 5346185db85Sdougm 5356185db85Sdougm /* 5366185db85Sdougm * sa_valid_group_name(name) 5376185db85Sdougm * 5386185db85Sdougm * check that the "name" contains only valid characters and otherwise 5396185db85Sdougm * fits the required naming conventions. Valid names must start with 5406185db85Sdougm * an alphabetic and the remainder may consist of only alphanumeric 5416185db85Sdougm * plus the '-' and '_' characters. This name limitation comes from 5426185db85Sdougm * inherent limitations in SMF. 5436185db85Sdougm */ 5446185db85Sdougm 5456185db85Sdougm int 5466185db85Sdougm sa_valid_group_name(char *name) 5476185db85Sdougm { 5486185db85Sdougm int ret = 1; 5496185db85Sdougm ssize_t len; 5506185db85Sdougm 5516185db85Sdougm if (name != NULL && isalpha(*name)) { 5526185db85Sdougm char c; 5536185db85Sdougm len = strlen(name); 5546185db85Sdougm if (len < (scf_max_name_len - sizeof ("group:"))) { 5556185db85Sdougm for (c = *name++; c != '\0' && ret != 0; c = *name++) { 5566185db85Sdougm if (!isalnum(c) && c != '-' && c != '_') 5576185db85Sdougm ret = 0; 5586185db85Sdougm } 5596185db85Sdougm } else { 5606185db85Sdougm ret = 0; 5616185db85Sdougm } 5626185db85Sdougm } else { 5636185db85Sdougm ret = 0; 5646185db85Sdougm } 5656185db85Sdougm return (ret); 5666185db85Sdougm } 5676185db85Sdougm 5686185db85Sdougm 5696185db85Sdougm /* 5706185db85Sdougm * is_zfs_group(group) 5716185db85Sdougm * Determine if the specified group is a ZFS sharenfs group 5726185db85Sdougm */ 5736185db85Sdougm static int 5746185db85Sdougm is_zfs_group(sa_group_t group) 5756185db85Sdougm { 5766185db85Sdougm int ret = 0; 5776185db85Sdougm xmlNodePtr parent; 5786185db85Sdougm xmlChar *zfs; 5796185db85Sdougm 58057b448deSdougm if (strcmp((char *)((xmlNodePtr)group)->name, "share") == 0) 5816185db85Sdougm parent = (xmlNodePtr)sa_get_parent_group(group); 58257b448deSdougm else 5836185db85Sdougm parent = (xmlNodePtr)group; 5846185db85Sdougm zfs = xmlGetProp(parent, (xmlChar *)"zfs"); 5856185db85Sdougm if (zfs != NULL) { 5866185db85Sdougm xmlFree(zfs); 5876185db85Sdougm ret = 1; 5886185db85Sdougm } 5896185db85Sdougm return (ret); 5906185db85Sdougm } 5916185db85Sdougm 5926185db85Sdougm /* 5936185db85Sdougm * sa_optionset_name(optionset, oname, len, id) 5946185db85Sdougm * return the SMF name for the optionset. If id is not NULL, it 5956185db85Sdougm * will have the GUID value for a share and should be used 5966185db85Sdougm * instead of the keyword "optionset" which is used for 5976185db85Sdougm * groups. If the optionset doesn't have a protocol type 5986185db85Sdougm * associated with it, "default" is used. This shouldn't happen 5996185db85Sdougm * at this point but may be desirable in the future if there are 6006185db85Sdougm * protocol independent properties added. The name is returned in 6016185db85Sdougm * oname. 6026185db85Sdougm */ 6036185db85Sdougm 6046185db85Sdougm static int 6056185db85Sdougm sa_optionset_name(sa_optionset_t optionset, char *oname, size_t len, char *id) 6066185db85Sdougm { 6076185db85Sdougm char *proto; 6086185db85Sdougm 6096185db85Sdougm if (id == NULL) 6106185db85Sdougm id = "optionset"; 6116185db85Sdougm 6126185db85Sdougm proto = sa_get_optionset_attr(optionset, "type"); 6136185db85Sdougm len = snprintf(oname, len, "%s_%s", id, proto ? proto : "default"); 6146185db85Sdougm 6156185db85Sdougm if (proto != NULL) 6166185db85Sdougm sa_free_attr_string(proto); 6176185db85Sdougm return (len); 6186185db85Sdougm } 6196185db85Sdougm 6206185db85Sdougm /* 6216185db85Sdougm * sa_security_name(optionset, oname, len, id) 6226185db85Sdougm * 6236185db85Sdougm * return the SMF name for the security. If id is not NULL, it will 6246185db85Sdougm * have the GUID value for a share and should be used instead of the 6256185db85Sdougm * keyword "optionset" which is used for groups. If the optionset 6266185db85Sdougm * doesn't have a protocol type associated with it, "default" is 6276185db85Sdougm * used. This shouldn't happen at this point but may be desirable in 6286185db85Sdougm * the future if there are protocol independent properties added. The 6296185db85Sdougm * name is returned in oname. The security type is also encoded into 6306185db85Sdougm * the name. In the future, this wil *be handled a bit differently. 6316185db85Sdougm */ 6326185db85Sdougm 6336185db85Sdougm static int 6346185db85Sdougm sa_security_name(sa_security_t security, char *oname, size_t len, char *id) 6356185db85Sdougm { 6366185db85Sdougm char *proto; 6376185db85Sdougm char *sectype; 6386185db85Sdougm 6396185db85Sdougm if (id == NULL) 6406185db85Sdougm id = "optionset"; 6416185db85Sdougm 6426185db85Sdougm proto = sa_get_security_attr(security, "type"); 6436185db85Sdougm sectype = sa_get_security_attr(security, "sectype"); 64457b448deSdougm len = snprintf(oname, len, "%s_%s_%s", id, proto ? proto : "default", 6456185db85Sdougm sectype ? sectype : "default"); 6466185db85Sdougm if (proto != NULL) 6476185db85Sdougm sa_free_attr_string(proto); 6486185db85Sdougm if (sectype != NULL) 6496185db85Sdougm sa_free_attr_string(sectype); 6506185db85Sdougm return (len); 6516185db85Sdougm } 6526185db85Sdougm 6536185db85Sdougm /* 65457b448deSdougm * verifydefgroupopts(handle) 65557b448deSdougm * 65657b448deSdougm * Make sure a "default" group exists and has default protocols enabled. 65757b448deSdougm */ 65857b448deSdougm static void 65957b448deSdougm verifydefgroupopts(sa_handle_t handle) 66057b448deSdougm { 66157b448deSdougm sa_group_t defgrp; 66257b448deSdougm sa_optionset_t opt; 66357b448deSdougm defgrp = sa_get_group(handle, "default"); 66457b448deSdougm if (defgrp != NULL) { 66557b448deSdougm opt = sa_get_optionset(defgrp, NULL); 66657b448deSdougm /* 66757b448deSdougm * NFS is the default for default group 66857b448deSdougm */ 66957b448deSdougm if (opt == NULL) 67057b448deSdougm opt = sa_create_optionset(defgrp, "nfs"); 67157b448deSdougm } 67257b448deSdougm } 67357b448deSdougm 67457b448deSdougm /* 675f345c0beSdougm * sa_init(init_service) 6766185db85Sdougm * Initialize the API 6776185db85Sdougm * find all the shared objects 6786185db85Sdougm * init the tables with all objects 6796185db85Sdougm * read in the current configuration 6806185db85Sdougm */ 6816185db85Sdougm 68257b448deSdougm #define GETPROP(prop) scf_simple_prop_next_astring(prop) 68357b448deSdougm #define CHECKTSTAMP(st, tval) stat(SA_LEGACY_DFSTAB, &st) >= 0 && \ 68457b448deSdougm tval != TSTAMP(st.st_ctim) 68557b448deSdougm 686549ec3ffSdougm sa_handle_t 6876185db85Sdougm sa_init(int init_service) 6886185db85Sdougm { 6896185db85Sdougm struct stat st; 6906185db85Sdougm int legacy = 0; 6916185db85Sdougm uint64_t tval = 0; 692a99982a7Sdougm int lockfd; 693a99982a7Sdougm sigset_t old; 694a99982a7Sdougm int updatelegacy = B_FALSE; 695a99982a7Sdougm scf_simple_prop_t *prop; 696549ec3ffSdougm sa_handle_impl_t handle; 697549ec3ffSdougm int err; 6986185db85Sdougm 699549ec3ffSdougm handle = calloc(sizeof (struct sa_handle_impl), 1); 700549ec3ffSdougm 701549ec3ffSdougm if (handle != NULL) { 7026185db85Sdougm /* get protocol specific structures */ 7036185db85Sdougm (void) proto_plugin_init(); 7046185db85Sdougm if (init_service & SA_INIT_SHARE_API) { 7056185db85Sdougm /* 70657b448deSdougm * initialize access into libzfs. We use this 70757b448deSdougm * when collecting info about ZFS datasets and 70857b448deSdougm * shares. 7091cea05afSdougm */ 71057b448deSdougm if (sa_zfs_init(handle) == B_FALSE) { 71157b448deSdougm free(handle); 71257b448deSdougm (void) proto_plugin_fini(); 71357b448deSdougm return (NULL); 71457b448deSdougm } 7151cea05afSdougm /* 7166185db85Sdougm * since we want to use SMF, initialize an svc handle 7176185db85Sdougm * and find out what is there. 7186185db85Sdougm */ 719549ec3ffSdougm handle->scfhandle = sa_scf_init(handle); 720549ec3ffSdougm if (handle->scfhandle != NULL) { 721a99982a7Sdougm /* 722a99982a7Sdougm * Need to lock the extraction of the 723a99982a7Sdougm * configuration if the dfstab file has 724a99982a7Sdougm * changed. Lock everything now and release if 725a99982a7Sdougm * not needed. Use a file that isn't being 726a99982a7Sdougm * manipulated by other parts of the system in 727a99982a7Sdougm * order to not interfere with locking. Using 728a99982a7Sdougm * dfstab doesn't work. 729a99982a7Sdougm */ 730a99982a7Sdougm sablocksigs(&old); 731a99982a7Sdougm lockfd = open(DFS_LOCK_FILE, O_RDWR); 732a99982a7Sdougm if (lockfd >= 0) { 733a99982a7Sdougm extern int errno; 734a99982a7Sdougm errno = 0; 735a99982a7Sdougm (void) lockf(lockfd, F_LOCK, 0); 736a99982a7Sdougm /* 73757b448deSdougm * Check whether we are going to need 73857b448deSdougm * to merge any dfstab changes. This 73957b448deSdougm * is done by comparing the value of 74057b448deSdougm * legacy-timestamp with the current 74157b448deSdougm * st_ctim of the file. If they are 74257b448deSdougm * different, an update is needed and 74357b448deSdougm * the file must remain locked until 74457b448deSdougm * the merge is done in order to 74557b448deSdougm * prevent multiple startups from 74657b448deSdougm * changing the SMF repository at the 74757b448deSdougm * same time. The first to get the 74857b448deSdougm * lock will make any changes before 74957b448deSdougm * the others can read the repository. 750a99982a7Sdougm */ 75157b448deSdougm prop = scf_simple_prop_get 75257b448deSdougm (handle->scfhandle->handle, 75357b448deSdougm (const char *)SA_SVC_FMRI_BASE 75457b448deSdougm ":default", "operation", 755a99982a7Sdougm "legacy-timestamp"); 756a99982a7Sdougm if (prop != NULL) { 757a99982a7Sdougm char *i64; 75857b448deSdougm i64 = GETPROP(prop); 75957b448deSdougm if (i64 != NULL) 76057b448deSdougm tval = strtoull(i64, 76157b448deSdougm NULL, 0); 76257b448deSdougm if (CHECKTSTAMP(st, tval)) 763a99982a7Sdougm updatelegacy = B_TRUE; 76457b448deSdougm scf_simple_prop_free(prop); 765a99982a7Sdougm } else { 76657b448deSdougm /* 76757b448deSdougm * We haven't set the 76857b448deSdougm * timestamp before so do it. 76957b448deSdougm */ 770a99982a7Sdougm updatelegacy = B_TRUE; 771a99982a7Sdougm } 772a99982a7Sdougm } 773a99982a7Sdougm if (updatelegacy == B_FALSE) { 774a99982a7Sdougm /* Don't need the lock anymore */ 775a99982a7Sdougm (void) lockf(lockfd, F_ULOCK, 0); 776a99982a7Sdougm (void) close(lockfd); 777a99982a7Sdougm } 7781d1813a7Sdougm 7791d1813a7Sdougm /* 7801d1813a7Sdougm * It is essential that the document tree and 7811d1813a7Sdougm * the internal list of roots to handles be 7821d1813a7Sdougm * setup before anything that might try to 7831d1813a7Sdougm * create a new object is called. The document 7841d1813a7Sdougm * tree is the combination of handle->doc and 7851d1813a7Sdougm * handle->tree. This allows searches, 7861d1813a7Sdougm * etc. when all you have is an object in the 7871d1813a7Sdougm * tree. 7881d1813a7Sdougm */ 7891d1813a7Sdougm handle->doc = xmlNewDoc((xmlChar *)"1.0"); 79057b448deSdougm handle->tree = xmlNewNode(NULL, 79157b448deSdougm (xmlChar *)"sharecfg"); 79257b448deSdougm if (handle->doc != NULL && 79357b448deSdougm handle->tree != NULL) { 79457b448deSdougm xmlDocSetRootElement(handle->doc, 79557b448deSdougm handle->tree); 79657b448deSdougm err = add_handle_for_root(handle->tree, 79757b448deSdougm handle); 7981d1813a7Sdougm if (err == SA_OK) 79957b448deSdougm err = sa_get_config( 80057b448deSdougm handle->scfhandle, 8011d1813a7Sdougm handle->tree, handle); 8021d1813a7Sdougm } else { 8031d1813a7Sdougm if (handle->doc != NULL) 8041d1813a7Sdougm xmlFreeDoc(handle->doc); 8051d1813a7Sdougm if (handle->tree != NULL) 8061d1813a7Sdougm xmlFreeNode(handle->tree); 8071d1813a7Sdougm err = SA_NO_MEMORY; 8081d1813a7Sdougm } 8091d1813a7Sdougm 810a99982a7Sdougm saunblocksigs(&old); 811549ec3ffSdougm 812549ec3ffSdougm if (err != SA_OK) { 813549ec3ffSdougm /* 8141d1813a7Sdougm * If we couldn't add the tree handle 8151d1813a7Sdougm * to the list, then things are going 8161d1813a7Sdougm * to fail badly. Might as well undo 8171d1813a7Sdougm * everything now and fail the 8181d1813a7Sdougm * sa_init(). 819549ec3ffSdougm */ 820549ec3ffSdougm sa_fini(handle); 821549ec3ffSdougm return (NULL); 822549ec3ffSdougm } 823549ec3ffSdougm 8246185db85Sdougm if (tval == 0) { 82557b448deSdougm /* 82657b448deSdougm * first time so make sure 82757b448deSdougm * default is setup 82857b448deSdougm */ 82957b448deSdougm verifydefgroupopts(handle); 8306185db85Sdougm } 8311d1813a7Sdougm 832a99982a7Sdougm if (updatelegacy == B_TRUE) { 833a99982a7Sdougm sablocksigs(&old); 834549ec3ffSdougm getlegacyconfig((sa_handle_t)handle, 835549ec3ffSdougm SA_LEGACY_DFSTAB, &handle->tree); 8366185db85Sdougm if (stat(SA_LEGACY_DFSTAB, &st) >= 0) 837*546405c3Sdougm set_legacy_timestamp( 838*546405c3Sdougm handle->tree, 8396185db85Sdougm SA_LEGACY_DFSTAB, 8406185db85Sdougm TSTAMP(st.st_ctim)); 841a99982a7Sdougm saunblocksigs(&old); 842*546405c3Sdougm /* 843*546405c3Sdougm * Safe to unlock now to allow 844*546405c3Sdougm * others to run 845*546405c3Sdougm */ 846a99982a7Sdougm (void) lockf(lockfd, F_ULOCK, 0); 847a99982a7Sdougm (void) close(lockfd); 8486185db85Sdougm } 849549ec3ffSdougm legacy |= sa_get_zfs_shares(handle, "zfs"); 850549ec3ffSdougm legacy |= gettransients(handle, &handle->tree); 8516185db85Sdougm } 8526185db85Sdougm } 8536185db85Sdougm } 854549ec3ffSdougm return ((sa_handle_t)handle); 8556185db85Sdougm } 8566185db85Sdougm 8576185db85Sdougm /* 858549ec3ffSdougm * sa_fini(handle) 8596185db85Sdougm * Uninitialize the API structures including the configuration 8601cea05afSdougm * data structures and ZFS related data. 8616185db85Sdougm */ 8626185db85Sdougm 8636185db85Sdougm void 864549ec3ffSdougm sa_fini(sa_handle_t handle) 8656185db85Sdougm { 866549ec3ffSdougm sa_handle_impl_t impl_handle = (sa_handle_impl_t)handle; 867549ec3ffSdougm 868549ec3ffSdougm if (impl_handle != NULL) { 869549ec3ffSdougm /* 870549ec3ffSdougm * Free the config trees and any other data structures 871549ec3ffSdougm * used in the handle. 872549ec3ffSdougm */ 873549ec3ffSdougm if (impl_handle->doc != NULL) 874549ec3ffSdougm xmlFreeDoc(impl_handle->doc); 875549ec3ffSdougm sa_scf_fini(impl_handle->scfhandle); 876549ec3ffSdougm sa_zfs_fini(impl_handle); 877549ec3ffSdougm 878549ec3ffSdougm /* Remove and free the entry in the global list. */ 879549ec3ffSdougm remove_handle_for_root(impl_handle->tree); 880549ec3ffSdougm 881549ec3ffSdougm /* Make sure we free the handle */ 882549ec3ffSdougm free(impl_handle); 883549ec3ffSdougm 884549ec3ffSdougm /* 885549ec3ffSdougm * If this was the last handle to release, unload the 886549ec3ffSdougm * plugins that were loaded. 887549ec3ffSdougm */ 888549ec3ffSdougm if (sa_global_handles == NULL) 889549ec3ffSdougm (void) proto_plugin_fini(); 890549ec3ffSdougm 8916185db85Sdougm } 8926185db85Sdougm } 8936185db85Sdougm 8946185db85Sdougm /* 8956185db85Sdougm * sa_get_protocols(char **protocol) 8966185db85Sdougm * Get array of protocols that are supported 8976185db85Sdougm * Returns pointer to an allocated and NULL terminated 8986185db85Sdougm * array of strings. Caller must free. 8996185db85Sdougm * This really should be determined dynamically. 9006185db85Sdougm * If there aren't any defined, return -1. 9016185db85Sdougm * Use free() to return memory. 9026185db85Sdougm */ 9036185db85Sdougm 9046185db85Sdougm int 9056185db85Sdougm sa_get_protocols(char ***protocols) 9066185db85Sdougm { 9076185db85Sdougm int numproto = -1; 9086185db85Sdougm 9096185db85Sdougm if (protocols != NULL) { 9106185db85Sdougm struct sa_proto_plugin *plug; 9116185db85Sdougm for (numproto = 0, plug = sap_proto_list; plug != NULL; 9126185db85Sdougm plug = plug->plugin_next) { 9136185db85Sdougm numproto++; 9146185db85Sdougm } 9156185db85Sdougm 9166185db85Sdougm *protocols = calloc(numproto + 1, sizeof (char *)); 9176185db85Sdougm if (*protocols != NULL) { 9186185db85Sdougm int ret = 0; 9196185db85Sdougm for (plug = sap_proto_list; plug != NULL; 9206185db85Sdougm plug = plug->plugin_next) { 9216185db85Sdougm /* faking for now */ 92257b448deSdougm (*protocols)[ret++] = 92357b448deSdougm plug->plugin_ops->sa_protocol; 9246185db85Sdougm } 9256185db85Sdougm } else { 9266185db85Sdougm numproto = -1; 9276185db85Sdougm } 9286185db85Sdougm } 9296185db85Sdougm return (numproto); 9306185db85Sdougm } 9316185db85Sdougm 9326185db85Sdougm /* 9336185db85Sdougm * find_group_by_name(node, group) 9346185db85Sdougm * 9356185db85Sdougm * search the XML document subtree specified by node to find the group 9366185db85Sdougm * specified by group. Searching subtree allows subgroups to be 9376185db85Sdougm * searched for. 9386185db85Sdougm */ 9396185db85Sdougm 9406185db85Sdougm static xmlNodePtr 9416185db85Sdougm find_group_by_name(xmlNodePtr node, xmlChar *group) 9426185db85Sdougm { 9436185db85Sdougm xmlChar *name = NULL; 9446185db85Sdougm 9456185db85Sdougm for (node = node->xmlChildrenNode; node != NULL; 9466185db85Sdougm node = node->next) { 9476185db85Sdougm if (xmlStrcmp(node->name, (xmlChar *)"group") == 0) { 9486185db85Sdougm /* if no groupname, return the first found */ 9496185db85Sdougm if (group == NULL) 9506185db85Sdougm break; 9516185db85Sdougm name = xmlGetProp(node, (xmlChar *)"name"); 95257b448deSdougm if (name != NULL && xmlStrcmp(name, group) == 0) 9536185db85Sdougm break; 9546185db85Sdougm if (name != NULL) { 9556185db85Sdougm xmlFree(name); 9566185db85Sdougm name = NULL; 9576185db85Sdougm } 9586185db85Sdougm } 9596185db85Sdougm } 9606185db85Sdougm if (name != NULL) 9616185db85Sdougm xmlFree(name); 9626185db85Sdougm return (node); 9636185db85Sdougm } 9646185db85Sdougm 9656185db85Sdougm /* 9666185db85Sdougm * sa_get_group(groupname) 9676185db85Sdougm * Return the "group" specified. If groupname is NULL, 9686185db85Sdougm * return the first group of the list of groups. 9696185db85Sdougm */ 9706185db85Sdougm sa_group_t 971549ec3ffSdougm sa_get_group(sa_handle_t handle, char *groupname) 9726185db85Sdougm { 9736185db85Sdougm xmlNodePtr node = NULL; 9746185db85Sdougm char *subgroup = NULL; 9756185db85Sdougm char *group = NULL; 976549ec3ffSdougm sa_handle_impl_t impl_handle = (sa_handle_impl_t)handle; 9776185db85Sdougm 978549ec3ffSdougm if (impl_handle != NULL && impl_handle->tree != NULL) { 9796185db85Sdougm if (groupname != NULL) { 9806185db85Sdougm group = strdup(groupname); 981a3351425Sdougm if (group != NULL) { 9826185db85Sdougm subgroup = strchr(group, '/'); 9836185db85Sdougm if (subgroup != NULL) 9846185db85Sdougm *subgroup++ = '\0'; 9856185db85Sdougm } 986a3351425Sdougm } 987a3351425Sdougm /* 988a3351425Sdougm * We want to find the, possibly, named group. If 989a3351425Sdougm * group is not NULL, then lookup the name. If it is 990a3351425Sdougm * NULL, we only do the find if groupname is also 991a3351425Sdougm * NULL. This allows lookup of the "first" group in 992a3351425Sdougm * the internal list. 993a3351425Sdougm */ 994a3351425Sdougm if (group != NULL || groupname == NULL) 995a3351425Sdougm node = find_group_by_name(impl_handle->tree, 996a3351425Sdougm (xmlChar *)group); 997a3351425Sdougm 9986185db85Sdougm /* if a subgroup, find it before returning */ 99957b448deSdougm if (subgroup != NULL && node != NULL) 10006185db85Sdougm node = find_group_by_name(node, (xmlChar *)subgroup); 10016185db85Sdougm } 10026185db85Sdougm if (node != NULL && (char *)group != NULL) 1003549ec3ffSdougm (void) sa_get_instance(impl_handle->scfhandle, (char *)group); 10046185db85Sdougm if (group != NULL) 10056185db85Sdougm free(group); 10066185db85Sdougm return ((sa_group_t)(node)); 10076185db85Sdougm } 10086185db85Sdougm 10096185db85Sdougm /* 10106185db85Sdougm * sa_get_next_group(group) 10116185db85Sdougm * Return the "next" group after the specified group from 10126185db85Sdougm * the internal group list. NULL if there are no more. 10136185db85Sdougm */ 10146185db85Sdougm sa_group_t 10156185db85Sdougm sa_get_next_group(sa_group_t group) 10166185db85Sdougm { 10176185db85Sdougm xmlNodePtr ngroup = NULL; 10186185db85Sdougm if (group != NULL) { 10196185db85Sdougm for (ngroup = ((xmlNodePtr)group)->next; ngroup != NULL; 10206185db85Sdougm ngroup = ngroup->next) { 10216185db85Sdougm if (xmlStrcmp(ngroup->name, (xmlChar *)"group") == 0) 10226185db85Sdougm break; 10236185db85Sdougm } 10246185db85Sdougm } 10256185db85Sdougm return ((sa_group_t)ngroup); 10266185db85Sdougm } 10276185db85Sdougm 10286185db85Sdougm /* 10296185db85Sdougm * sa_get_share(group, sharepath) 10306185db85Sdougm * Return the share object for the share specified. The share 10316185db85Sdougm * must be in the specified group. Return NULL if not found. 10326185db85Sdougm */ 10336185db85Sdougm sa_share_t 10346185db85Sdougm sa_get_share(sa_group_t group, char *sharepath) 10356185db85Sdougm { 10366185db85Sdougm xmlNodePtr node = NULL; 10376185db85Sdougm xmlChar *path; 10386185db85Sdougm 10396185db85Sdougm /* 10406185db85Sdougm * For future scalability, this should end up building a cache 10416185db85Sdougm * since it will get called regularly by the mountd and info 10426185db85Sdougm * services. 10436185db85Sdougm */ 10446185db85Sdougm if (group != NULL) { 10456185db85Sdougm for (node = ((xmlNodePtr)group)->children; node != NULL; 10466185db85Sdougm node = node->next) { 10476185db85Sdougm if (xmlStrcmp(node->name, (xmlChar *)"share") == 0) { 10486185db85Sdougm if (sharepath == NULL) { 10496185db85Sdougm break; 10506185db85Sdougm } else { 10516185db85Sdougm /* is it the correct share? */ 105257b448deSdougm path = xmlGetProp(node, 105357b448deSdougm (xmlChar *)"path"); 10546185db85Sdougm if (path != NULL && 105557b448deSdougm xmlStrcmp(path, 105657b448deSdougm (xmlChar *)sharepath) == 0) { 10576185db85Sdougm xmlFree(path); 10586185db85Sdougm break; 10596185db85Sdougm } 10606185db85Sdougm xmlFree(path); 10616185db85Sdougm } 10626185db85Sdougm } 10636185db85Sdougm } 10646185db85Sdougm } 10656185db85Sdougm return ((sa_share_t)node); 10666185db85Sdougm } 10676185db85Sdougm 10686185db85Sdougm /* 10696185db85Sdougm * sa_get_next_share(share) 10706185db85Sdougm * Return the next share following the specified share 10716185db85Sdougm * from the internal list of shares. Returns NULL if there 10726185db85Sdougm * are no more shares. The list is relative to the same 10736185db85Sdougm * group. 10746185db85Sdougm */ 10756185db85Sdougm sa_share_t 10766185db85Sdougm sa_get_next_share(sa_share_t share) 10776185db85Sdougm { 10786185db85Sdougm xmlNodePtr node = NULL; 10796185db85Sdougm 10806185db85Sdougm if (share != NULL) { 10816185db85Sdougm for (node = ((xmlNodePtr)share)->next; node != NULL; 10826185db85Sdougm node = node->next) { 10836185db85Sdougm if (xmlStrcmp(node->name, (xmlChar *)"share") == 0) { 10846185db85Sdougm break; 10856185db85Sdougm } 10866185db85Sdougm } 10876185db85Sdougm } 10886185db85Sdougm return ((sa_share_t)node); 10896185db85Sdougm } 10906185db85Sdougm 10916185db85Sdougm /* 10926185db85Sdougm * _sa_get_child_node(node, type) 10936185db85Sdougm * 10946185db85Sdougm * find the child node of the specified node that has "type". This is 10956185db85Sdougm * used to implement several internal functions. 10966185db85Sdougm */ 10976185db85Sdougm 10986185db85Sdougm static xmlNodePtr 10996185db85Sdougm _sa_get_child_node(xmlNodePtr node, xmlChar *type) 11006185db85Sdougm { 11016185db85Sdougm xmlNodePtr child; 11026185db85Sdougm for (child = node->xmlChildrenNode; child != NULL; 11036185db85Sdougm child = child->next) 11046185db85Sdougm if (xmlStrcmp(child->name, type) == 0) 11056185db85Sdougm return (child); 11066185db85Sdougm return ((xmlNodePtr)NULL); 11076185db85Sdougm } 11086185db85Sdougm 11096185db85Sdougm /* 11106185db85Sdougm * find_share(group, path) 11116185db85Sdougm * 11126185db85Sdougm * Search all the shares in the specified group for one that has the 11136185db85Sdougm * specified path. 11146185db85Sdougm */ 11156185db85Sdougm 11166185db85Sdougm static sa_share_t 11176185db85Sdougm find_share(sa_group_t group, char *sharepath) 11186185db85Sdougm { 11196185db85Sdougm sa_share_t share; 11206185db85Sdougm char *path; 11216185db85Sdougm 11226185db85Sdougm for (share = sa_get_share(group, NULL); share != NULL; 11236185db85Sdougm share = sa_get_next_share(share)) { 11246185db85Sdougm path = sa_get_share_attr(share, "path"); 11256185db85Sdougm if (path != NULL && strcmp(path, sharepath) == 0) { 11266185db85Sdougm sa_free_attr_string(path); 11276185db85Sdougm break; 11286185db85Sdougm } 11296185db85Sdougm if (path != NULL) 11306185db85Sdougm sa_free_attr_string(path); 11316185db85Sdougm } 11326185db85Sdougm return (share); 11336185db85Sdougm } 11346185db85Sdougm 11356185db85Sdougm /* 11366185db85Sdougm * sa_get_sub_group(group) 11376185db85Sdougm * 11386185db85Sdougm * Get the first sub-group of group. The sa_get_next_group() function 11396185db85Sdougm * can be used to get the rest. This is currently only used for ZFS 11406185db85Sdougm * sub-groups but could be used to implement a more general mechanism. 11416185db85Sdougm */ 11426185db85Sdougm 11436185db85Sdougm sa_group_t 11446185db85Sdougm sa_get_sub_group(sa_group_t group) 11456185db85Sdougm { 11466185db85Sdougm return ((sa_group_t)_sa_get_child_node((xmlNodePtr)group, 11476185db85Sdougm (xmlChar *)"group")); 11486185db85Sdougm } 11496185db85Sdougm 11506185db85Sdougm /* 11516185db85Sdougm * sa_find_share(sharepath) 11526185db85Sdougm * Finds a share regardless of group. In the future, this 11536185db85Sdougm * function should utilize a cache and hash table of some kind. 11546185db85Sdougm * The current assumption is that a path will only be shared 11556185db85Sdougm * once. In the future, this may change as implementation of 11566185db85Sdougm * resource names comes into being. 11576185db85Sdougm */ 11586185db85Sdougm sa_share_t 1159549ec3ffSdougm sa_find_share(sa_handle_t handle, char *sharepath) 11606185db85Sdougm { 11616185db85Sdougm sa_group_t group; 11626185db85Sdougm sa_group_t zgroup; 11636185db85Sdougm sa_share_t share = NULL; 11646185db85Sdougm int done = 0; 11656185db85Sdougm 1166549ec3ffSdougm for (group = sa_get_group(handle, NULL); group != NULL && !done; 11676185db85Sdougm group = sa_get_next_group(group)) { 11686185db85Sdougm if (is_zfs_group(group)) { 116957b448deSdougm for (zgroup = 117057b448deSdougm (sa_group_t)_sa_get_child_node((xmlNodePtr)group, 11716185db85Sdougm (xmlChar *)"group"); 117257b448deSdougm zgroup != NULL; 117357b448deSdougm zgroup = sa_get_next_group(zgroup)) { 11746185db85Sdougm share = find_share(zgroup, sharepath); 11756185db85Sdougm if (share != NULL) 11766185db85Sdougm break; 11776185db85Sdougm } 11786185db85Sdougm } else { 11796185db85Sdougm share = find_share(group, sharepath); 11806185db85Sdougm } 11816185db85Sdougm if (share != NULL) 11826185db85Sdougm break; 11836185db85Sdougm } 11846185db85Sdougm return (share); 11856185db85Sdougm } 11866185db85Sdougm 11876185db85Sdougm /* 1188f345c0beSdougm * sa_check_path(group, path, strictness) 11896185db85Sdougm * 11906185db85Sdougm * check that path is a valid path relative to the group. Currently, 11916185db85Sdougm * we are ignoring the group and checking only the NFS rules. Later, 11926185db85Sdougm * we may want to use the group to then check against the protocols 1193f345c0beSdougm * enabled on the group. The strictness values mean: 1194f345c0beSdougm * SA_CHECK_NORMAL == only check newpath against shares that are active 1195f345c0beSdougm * SA_CHECK_STRICT == check newpath against both active shares and those 1196f345c0beSdougm * stored in the repository 11976185db85Sdougm */ 11986185db85Sdougm 11996185db85Sdougm int 1200f345c0beSdougm sa_check_path(sa_group_t group, char *path, int strictness) 12016185db85Sdougm { 1202549ec3ffSdougm sa_handle_t handle; 1203549ec3ffSdougm 1204549ec3ffSdougm handle = sa_find_group_handle(group); 1205549ec3ffSdougm return (validpath(handle, path, strictness)); 12066185db85Sdougm } 12076185db85Sdougm 12086185db85Sdougm /* 12096185db85Sdougm * _sa_add_share(group, sharepath, persist, *error) 12106185db85Sdougm * 12116185db85Sdougm * common code for all types of add_share. sa_add_share() is the 12126185db85Sdougm * public API, we also need to be able to do this when parsing legacy 12136185db85Sdougm * files and construction of the internal configuration while 12146185db85Sdougm * extracting config info from SMF. 12156185db85Sdougm */ 12166185db85Sdougm 12176185db85Sdougm sa_share_t 12186185db85Sdougm _sa_add_share(sa_group_t group, char *sharepath, int persist, int *error) 12196185db85Sdougm { 12206185db85Sdougm xmlNodePtr node = NULL; 12216185db85Sdougm int err; 12226185db85Sdougm 12236185db85Sdougm err = SA_OK; /* assume success */ 12246185db85Sdougm 122557b448deSdougm node = xmlNewChild((xmlNodePtr)group, NULL, (xmlChar *)"share", NULL); 12266185db85Sdougm if (node != NULL) { 12276185db85Sdougm xmlSetProp(node, (xmlChar *)"path", (xmlChar *)sharepath); 122857b448deSdougm xmlSetProp(node, (xmlChar *)"type", 122957b448deSdougm persist ? (xmlChar *)"persist" : (xmlChar *)"transient"); 12306185db85Sdougm if (persist != SA_SHARE_TRANSIENT) { 12316185db85Sdougm /* 12326185db85Sdougm * persistent shares come in two flavors: SMF and 12336185db85Sdougm * ZFS. Sort this one out based on target group and 12346185db85Sdougm * path type. Currently, only NFS is supported in the 12356185db85Sdougm * ZFS group and it is always on. 12366185db85Sdougm */ 123757b448deSdougm if (sa_group_is_zfs(group) && 123857b448deSdougm sa_path_is_zfs(sharepath)) { 12396185db85Sdougm err = sa_zfs_set_sharenfs(group, sharepath, 1); 12406185db85Sdougm } else { 1241549ec3ffSdougm sa_handle_impl_t impl_handle; 124257b448deSdougm impl_handle = 124357b448deSdougm (sa_handle_impl_t)sa_find_group_handle( 124457b448deSdougm group); 124557b448deSdougm if (impl_handle != NULL) { 124657b448deSdougm err = sa_commit_share( 124757b448deSdougm impl_handle->scfhandle, group, 12486185db85Sdougm (sa_share_t)node); 124957b448deSdougm } else { 1250549ec3ffSdougm err = SA_SYSTEM_ERR; 12516185db85Sdougm } 12526185db85Sdougm } 125357b448deSdougm } 12546185db85Sdougm if (err == SA_NO_PERMISSION && persist & SA_SHARE_PARSER) { 12556185db85Sdougm /* called by the dfstab parser so could be a show */ 12566185db85Sdougm err = SA_OK; 12576185db85Sdougm } 12586185db85Sdougm if (err != SA_OK) { 12596185db85Sdougm /* 12606185db85Sdougm * we couldn't commit to the repository so undo 12616185db85Sdougm * our internal state to reflect reality. 12626185db85Sdougm */ 12636185db85Sdougm xmlUnlinkNode(node); 12646185db85Sdougm xmlFreeNode(node); 12656185db85Sdougm node = NULL; 12666185db85Sdougm } 12676185db85Sdougm } else { 12686185db85Sdougm err = SA_NO_MEMORY; 12696185db85Sdougm } 12706185db85Sdougm if (error != NULL) 12716185db85Sdougm *error = err; 12726185db85Sdougm return (node); 12736185db85Sdougm } 12746185db85Sdougm 12756185db85Sdougm /* 12766185db85Sdougm * sa_add_share(group, sharepath, persist, *error) 12776185db85Sdougm * 12786185db85Sdougm * Add a new share object to the specified group. The share will 12796185db85Sdougm * have the specified sharepath and will only be constructed if 12806185db85Sdougm * it is a valid path to be shared. NULL is returned on error 12816185db85Sdougm * and a detailed error value will be returned via the error 12826185db85Sdougm * pointer. 12836185db85Sdougm */ 12846185db85Sdougm sa_share_t 12856185db85Sdougm sa_add_share(sa_group_t group, char *sharepath, int persist, int *error) 12866185db85Sdougm { 12876185db85Sdougm xmlNodePtr node = NULL; 12886185db85Sdougm sa_share_t dup; 1289f345c0beSdougm int strictness = SA_CHECK_NORMAL; 1290549ec3ffSdougm sa_handle_t handle; 1291f345c0beSdougm 1292f345c0beSdougm /* 1293f345c0beSdougm * If the share is to be permanent, use strict checking so a 1294f345c0beSdougm * bad config doesn't get created. Transient shares only need 1295f345c0beSdougm * to check against the currently active 1296f345c0beSdougm * shares. SA_SHARE_PARSER is a modifier used internally to 1297f345c0beSdougm * indicate that we are being called by the dfstab parser and 1298f345c0beSdougm * that we need strict checking in all cases. Normally persist 1299f345c0beSdougm * is in integer value but SA_SHARE_PARSER may be or'd into 1300f345c0beSdougm * it as an override. 1301f345c0beSdougm */ 1302f345c0beSdougm if (persist & SA_SHARE_PARSER || persist == SA_SHARE_PERMANENT) 1303f345c0beSdougm strictness = SA_CHECK_STRICT; 13046185db85Sdougm 1305549ec3ffSdougm handle = sa_find_group_handle(group); 1306549ec3ffSdougm 1307549ec3ffSdougm if ((dup = sa_find_share(handle, sharepath)) == NULL && 130857b448deSdougm (*error = sa_check_path(group, sharepath, strictness)) == SA_OK) { 13096185db85Sdougm node = _sa_add_share(group, sharepath, persist, error); 13106185db85Sdougm } 13116185db85Sdougm if (dup != NULL) 13126185db85Sdougm *error = SA_DUPLICATE_NAME; 13136185db85Sdougm 13146185db85Sdougm return ((sa_share_t)node); 13156185db85Sdougm } 13166185db85Sdougm 13176185db85Sdougm /* 13186185db85Sdougm * sa_enable_share(share, protocol) 13196185db85Sdougm * Enable the specified share to the specified protocol. 13206185db85Sdougm * If protocol is NULL, then all protocols. 13216185db85Sdougm */ 13226185db85Sdougm int 13236185db85Sdougm sa_enable_share(sa_share_t share, char *protocol) 13246185db85Sdougm { 13256185db85Sdougm char *sharepath; 13266185db85Sdougm struct stat st; 13276185db85Sdougm int err = 0; 13286185db85Sdougm 13296185db85Sdougm sharepath = sa_get_share_attr(share, "path"); 13306185db85Sdougm if (stat(sharepath, &st) < 0) { 13316185db85Sdougm err = SA_NO_SUCH_PATH; 13326185db85Sdougm } else { 13336185db85Sdougm /* tell the server about the share */ 13346185db85Sdougm if (protocol != NULL) { 13356185db85Sdougm /* lookup protocol specific handler */ 13366185db85Sdougm err = sa_proto_share(protocol, share); 13376185db85Sdougm if (err == SA_OK) 133857b448deSdougm (void) sa_set_share_attr(share, "shared", 133957b448deSdougm "true"); 13406185db85Sdougm } else { 134157b448deSdougm /* 134257b448deSdougm * Tell all protocols. Only NFS for now but 134357b448deSdougm * SMB is coming. 134457b448deSdougm */ 134557b448deSdougm err = sa_proto_share("nfs", share); 13466185db85Sdougm (void) sa_set_share_attr(share, "shared", "true"); 13476185db85Sdougm } 13486185db85Sdougm } 13496185db85Sdougm if (sharepath != NULL) 13506185db85Sdougm sa_free_attr_string(sharepath); 13516185db85Sdougm return (err); 13526185db85Sdougm } 13536185db85Sdougm 13546185db85Sdougm /* 13556185db85Sdougm * sa_disable_share(share, protocol) 13566185db85Sdougm * Disable the specified share to the specified protocol. 13576185db85Sdougm * If protocol is NULL, then all protocols. 13586185db85Sdougm */ 13596185db85Sdougm int 13606185db85Sdougm sa_disable_share(sa_share_t share, char *protocol) 13616185db85Sdougm { 13626185db85Sdougm char *path; 13636185db85Sdougm char *shared; 13646185db85Sdougm int ret = SA_OK; 13656185db85Sdougm 13666185db85Sdougm path = sa_get_share_attr(share, "path"); 13676185db85Sdougm shared = sa_get_share_attr(share, "shared"); 13686185db85Sdougm 13696185db85Sdougm if (protocol != NULL) { 13706185db85Sdougm ret = sa_proto_unshare(protocol, path); 13716185db85Sdougm } else { 13726185db85Sdougm /* need to do all protocols */ 13736185db85Sdougm ret = sa_proto_unshare("nfs", path); 13746185db85Sdougm } 13756185db85Sdougm if (ret == SA_OK) 13766185db85Sdougm (void) sa_set_share_attr(share, "shared", NULL); 13776185db85Sdougm if (path != NULL) 13786185db85Sdougm sa_free_attr_string(path); 13796185db85Sdougm if (shared != NULL) 13806185db85Sdougm sa_free_attr_string(shared); 13816185db85Sdougm return (ret); 13826185db85Sdougm } 13836185db85Sdougm 13846185db85Sdougm /* 13856185db85Sdougm * sa_remove_share(share) 13866185db85Sdougm * 13876185db85Sdougm * remove the specified share from its containing group. 13886185db85Sdougm * Remove from the SMF or ZFS configuration space. 13896185db85Sdougm */ 13906185db85Sdougm 13916185db85Sdougm int 13926185db85Sdougm sa_remove_share(sa_share_t share) 13936185db85Sdougm { 13946185db85Sdougm sa_group_t group; 13956185db85Sdougm int ret = SA_OK; 13966185db85Sdougm char *type; 13976185db85Sdougm int transient = 0; 13986185db85Sdougm char *groupname; 13996185db85Sdougm char *zfs; 14006185db85Sdougm 14016185db85Sdougm type = sa_get_share_attr(share, "type"); 14026185db85Sdougm group = sa_get_parent_group(share); 14036185db85Sdougm zfs = sa_get_group_attr(group, "zfs"); 14046185db85Sdougm groupname = sa_get_group_attr(group, "name"); 14056185db85Sdougm if (type != NULL && strcmp(type, "persist") != 0) 14066185db85Sdougm transient = 1; 14076185db85Sdougm if (type != NULL) 14086185db85Sdougm sa_free_attr_string(type); 14096185db85Sdougm 14106185db85Sdougm /* remove the node from its group then free the memory */ 14116185db85Sdougm 14126185db85Sdougm /* 14136185db85Sdougm * need to test if "busy" 14146185db85Sdougm */ 14156185db85Sdougm /* only do SMF action if permanent */ 14166185db85Sdougm if (!transient || zfs != NULL) { 14176185db85Sdougm /* remove from legacy dfstab as well as possible SMF */ 14186185db85Sdougm ret = sa_delete_legacy(share); 14196185db85Sdougm if (ret == SA_OK) { 14206185db85Sdougm if (!sa_group_is_zfs(group)) { 1421549ec3ffSdougm sa_handle_impl_t impl_handle; 142257b448deSdougm impl_handle = (sa_handle_impl_t) 142357b448deSdougm sa_find_group_handle(group); 142457b448deSdougm if (impl_handle != NULL) { 142557b448deSdougm ret = sa_delete_share( 142657b448deSdougm impl_handle->scfhandle, group, 142757b448deSdougm share); 14286185db85Sdougm } else { 142957b448deSdougm ret = SA_SYSTEM_ERR; 143057b448deSdougm } 143157b448deSdougm } else { 143257b448deSdougm char *sharepath = sa_get_share_attr(share, 143357b448deSdougm "path"); 14346185db85Sdougm if (sharepath != NULL) { 143557b448deSdougm ret = sa_zfs_set_sharenfs(group, 143657b448deSdougm sharepath, 0); 14376185db85Sdougm sa_free_attr_string(sharepath); 14386185db85Sdougm } 14396185db85Sdougm } 14406185db85Sdougm } 14416185db85Sdougm } 14426185db85Sdougm if (groupname != NULL) 14436185db85Sdougm sa_free_attr_string(groupname); 14446185db85Sdougm if (zfs != NULL) 14456185db85Sdougm sa_free_attr_string(zfs); 14466185db85Sdougm 14476185db85Sdougm xmlUnlinkNode((xmlNodePtr)share); 14486185db85Sdougm xmlFreeNode((xmlNodePtr)share); 14496185db85Sdougm return (ret); 14506185db85Sdougm } 14516185db85Sdougm 14526185db85Sdougm /* 14536185db85Sdougm * sa_move_share(group, share) 14546185db85Sdougm * 14556185db85Sdougm * move the specified share to the specified group. Update SMF 14566185db85Sdougm * appropriately. 14576185db85Sdougm */ 14586185db85Sdougm 14596185db85Sdougm int 14606185db85Sdougm sa_move_share(sa_group_t group, sa_share_t share) 14616185db85Sdougm { 14626185db85Sdougm sa_group_t oldgroup; 14636185db85Sdougm int ret = SA_OK; 14646185db85Sdougm 14656185db85Sdougm /* remove the node from its group then free the memory */ 14666185db85Sdougm 14676185db85Sdougm oldgroup = sa_get_parent_group(share); 14686185db85Sdougm if (oldgroup != group) { 1469549ec3ffSdougm sa_handle_impl_t impl_handle; 14706185db85Sdougm xmlUnlinkNode((xmlNodePtr)share); 147157b448deSdougm /* 147257b448deSdougm * now that the share isn't in its old group, add to 147357b448deSdougm * the new one 147457b448deSdougm */ 14756185db85Sdougm xmlAddChild((xmlNodePtr)group, (xmlNodePtr)share); 14766185db85Sdougm /* need to deal with SMF */ 1477549ec3ffSdougm impl_handle = (sa_handle_impl_t)sa_find_group_handle(group); 1478549ec3ffSdougm if (impl_handle != NULL) { 14796185db85Sdougm /* 14806185db85Sdougm * need to remove from old group first and then add to 14816185db85Sdougm * new group. Ideally, we would do the other order but 14826185db85Sdougm * need to avoid having the share in two groups at the 14836185db85Sdougm * same time. 14846185db85Sdougm */ 148557b448deSdougm ret = sa_delete_share(impl_handle->scfhandle, oldgroup, 148657b448deSdougm share); 1487549ec3ffSdougm if (ret == SA_OK) 148857b448deSdougm ret = sa_commit_share(impl_handle->scfhandle, 148957b448deSdougm group, share); 1490549ec3ffSdougm } else { 1491549ec3ffSdougm ret = SA_SYSTEM_ERR; 14926185db85Sdougm } 14936185db85Sdougm } 14946185db85Sdougm return (ret); 14956185db85Sdougm } 14966185db85Sdougm 14976185db85Sdougm /* 14986185db85Sdougm * sa_get_parent_group(share) 14996185db85Sdougm * 15006185db85Sdougm * Return the containg group for the share. If a group was actually 15016185db85Sdougm * passed in, we don't want a parent so return NULL. 15026185db85Sdougm */ 15036185db85Sdougm 15046185db85Sdougm sa_group_t 15056185db85Sdougm sa_get_parent_group(sa_share_t share) 15066185db85Sdougm { 15076185db85Sdougm xmlNodePtr node = NULL; 15086185db85Sdougm if (share != NULL) { 15096185db85Sdougm node = ((xmlNodePtr)share)->parent; 15106185db85Sdougm /* 15116185db85Sdougm * make sure parent is a group and not sharecfg since 15126185db85Sdougm * we may be cheating and passing in a group. 15136185db85Sdougm * Eventually, groups of groups might come into being. 15146185db85Sdougm */ 15156185db85Sdougm if (node == NULL || 15166185db85Sdougm xmlStrcmp(node->name, (xmlChar *)"sharecfg") == 0) 15176185db85Sdougm node = NULL; 15186185db85Sdougm } 15196185db85Sdougm return ((sa_group_t)node); 15206185db85Sdougm } 15216185db85Sdougm 15226185db85Sdougm /* 1523549ec3ffSdougm * _sa_create_group(impl_handle, groupname) 15246185db85Sdougm * 15256185db85Sdougm * Create a group in the document. The caller will need to deal with 15266185db85Sdougm * configuration store and activation. 15276185db85Sdougm */ 15286185db85Sdougm 15296185db85Sdougm sa_group_t 1530549ec3ffSdougm _sa_create_group(sa_handle_impl_t impl_handle, char *groupname) 15316185db85Sdougm { 15326185db85Sdougm xmlNodePtr node = NULL; 15336185db85Sdougm 15346185db85Sdougm if (sa_valid_group_name(groupname)) { 153557b448deSdougm node = xmlNewChild(impl_handle->tree, NULL, (xmlChar *)"group", 153657b448deSdougm NULL); 15376185db85Sdougm if (node != NULL) { 153857b448deSdougm xmlSetProp(node, (xmlChar *)"name", 153957b448deSdougm (xmlChar *)groupname); 154057b448deSdougm xmlSetProp(node, (xmlChar *)"state", 154157b448deSdougm (xmlChar *)"enabled"); 15426185db85Sdougm } 15436185db85Sdougm } 15446185db85Sdougm return ((sa_group_t)node); 15456185db85Sdougm } 15466185db85Sdougm 15476185db85Sdougm /* 15486185db85Sdougm * _sa_create_zfs_group(group, groupname) 15496185db85Sdougm * 15506185db85Sdougm * Create a ZFS subgroup under the specified group. This may 15516185db85Sdougm * eventually form the basis of general sub-groups, but is currently 15526185db85Sdougm * restricted to ZFS. 15536185db85Sdougm */ 15546185db85Sdougm sa_group_t 15556185db85Sdougm _sa_create_zfs_group(sa_group_t group, char *groupname) 15566185db85Sdougm { 15576185db85Sdougm xmlNodePtr node = NULL; 15586185db85Sdougm 155957b448deSdougm node = xmlNewChild((xmlNodePtr)group, NULL, (xmlChar *)"group", NULL); 15606185db85Sdougm if (node != NULL) { 15616185db85Sdougm xmlSetProp(node, (xmlChar *)"name", (xmlChar *)groupname); 15626185db85Sdougm xmlSetProp(node, (xmlChar *)"state", (xmlChar *)"enabled"); 15636185db85Sdougm } 15646185db85Sdougm 15656185db85Sdougm return ((sa_group_t)node); 15666185db85Sdougm } 15676185db85Sdougm 15686185db85Sdougm /* 15696185db85Sdougm * sa_create_group(groupname, *error) 15706185db85Sdougm * 15716185db85Sdougm * Create a new group with groupname. Need to validate that it is a 15726185db85Sdougm * legal name for SMF and the construct the SMF service instance of 15736185db85Sdougm * svc:/network/shares/group to implement the group. All necessary 15746185db85Sdougm * operational properties must be added to the group at this point 15756185db85Sdougm * (via the SMF transaction model). 15766185db85Sdougm */ 15776185db85Sdougm sa_group_t 1578549ec3ffSdougm sa_create_group(sa_handle_t handle, char *groupname, int *error) 15796185db85Sdougm { 15806185db85Sdougm xmlNodePtr node = NULL; 15816185db85Sdougm sa_group_t group; 15826185db85Sdougm int ret; 158357b448deSdougm char rbacstr[SA_STRSIZE]; 1584549ec3ffSdougm sa_handle_impl_t impl_handle = (sa_handle_impl_t)handle; 15856185db85Sdougm 15866185db85Sdougm ret = SA_OK; 15876185db85Sdougm 1588549ec3ffSdougm if (impl_handle == NULL || impl_handle->scfhandle == NULL) { 15896185db85Sdougm ret = SA_SYSTEM_ERR; 15906185db85Sdougm goto err; 15916185db85Sdougm } 15926185db85Sdougm 1593549ec3ffSdougm group = sa_get_group(handle, groupname); 15946185db85Sdougm if (group != NULL) { 15956185db85Sdougm ret = SA_DUPLICATE_NAME; 15966185db85Sdougm } else { 15976185db85Sdougm if (sa_valid_group_name(groupname)) { 1598549ec3ffSdougm node = xmlNewChild(impl_handle->tree, NULL, 15996185db85Sdougm (xmlChar *)"group", NULL); 16006185db85Sdougm if (node != NULL) { 160157b448deSdougm xmlSetProp(node, (xmlChar *)"name", 160257b448deSdougm (xmlChar *)groupname); 16036185db85Sdougm /* default to the group being enabled */ 160457b448deSdougm xmlSetProp(node, (xmlChar *)"state", 160557b448deSdougm (xmlChar *)"enabled"); 160657b448deSdougm ret = sa_create_instance(impl_handle->scfhandle, 160757b448deSdougm groupname); 16086185db85Sdougm if (ret == SA_OK) { 160957b448deSdougm ret = sa_start_transaction( 161057b448deSdougm impl_handle->scfhandle, 1611549ec3ffSdougm "operation"); 16126185db85Sdougm } 16136185db85Sdougm if (ret == SA_OK) { 161457b448deSdougm ret = sa_set_property( 161557b448deSdougm impl_handle->scfhandle, 1616549ec3ffSdougm "state", "enabled"); 16176185db85Sdougm if (ret == SA_OK) { 161857b448deSdougm ret = sa_end_transaction( 161957b448deSdougm impl_handle->scfhandle); 16206185db85Sdougm } else { 162157b448deSdougm sa_abort_transaction( 162257b448deSdougm impl_handle->scfhandle); 16236185db85Sdougm } 16246185db85Sdougm } 16256185db85Sdougm if (ret == SA_OK) { 16266185db85Sdougm /* initialize the RBAC strings */ 162757b448deSdougm ret = sa_start_transaction( 162857b448deSdougm impl_handle->scfhandle, 1629549ec3ffSdougm "general"); 16306185db85Sdougm if (ret == SA_OK) { 163157b448deSdougm (void) snprintf(rbacstr, 163257b448deSdougm sizeof (rbacstr), "%s.%s", 16336185db85Sdougm SA_RBAC_MANAGE, groupname); 163457b448deSdougm ret = sa_set_property( 163557b448deSdougm impl_handle->scfhandle, 16366185db85Sdougm "action_authorization", 16376185db85Sdougm rbacstr); 16386185db85Sdougm } 16396185db85Sdougm if (ret == SA_OK) { 164057b448deSdougm (void) snprintf(rbacstr, 164157b448deSdougm sizeof (rbacstr), "%s.%s", 16426185db85Sdougm SA_RBAC_VALUE, groupname); 164357b448deSdougm ret = sa_set_property( 164457b448deSdougm impl_handle->scfhandle, 16456185db85Sdougm "value_authorization", 16466185db85Sdougm rbacstr); 16476185db85Sdougm } 16486185db85Sdougm if (ret == SA_OK) { 164957b448deSdougm ret = sa_end_transaction( 165057b448deSdougm impl_handle->scfhandle); 16516185db85Sdougm } else { 165257b448deSdougm sa_abort_transaction( 165357b448deSdougm impl_handle->scfhandle); 16546185db85Sdougm } 16556185db85Sdougm } 16566185db85Sdougm if (ret != SA_OK) { 16576185db85Sdougm /* 165857b448deSdougm * Couldn't commit the group 165957b448deSdougm * so we need to undo 166057b448deSdougm * internally. 16616185db85Sdougm */ 16626185db85Sdougm xmlUnlinkNode(node); 16636185db85Sdougm xmlFreeNode(node); 16646185db85Sdougm node = NULL; 16656185db85Sdougm } 16666185db85Sdougm } else { 16676185db85Sdougm ret = SA_NO_MEMORY; 16686185db85Sdougm } 16696185db85Sdougm } else { 16706185db85Sdougm ret = SA_INVALID_NAME; 16716185db85Sdougm } 16726185db85Sdougm } 16736185db85Sdougm err: 16746185db85Sdougm if (error != NULL) 16756185db85Sdougm *error = ret; 16766185db85Sdougm return ((sa_group_t)node); 16776185db85Sdougm } 16786185db85Sdougm 16796185db85Sdougm /* 16806185db85Sdougm * sa_remove_group(group) 16816185db85Sdougm * 16826185db85Sdougm * Remove the specified group. This deletes from the SMF repository. 16836185db85Sdougm * All property groups and properties are removed. 16846185db85Sdougm */ 16856185db85Sdougm 16866185db85Sdougm int 16876185db85Sdougm sa_remove_group(sa_group_t group) 16886185db85Sdougm { 16896185db85Sdougm char *name; 16906185db85Sdougm int ret = SA_OK; 1691549ec3ffSdougm sa_handle_impl_t impl_handle; 16926185db85Sdougm 1693549ec3ffSdougm impl_handle = (sa_handle_impl_t)sa_find_group_handle(group); 1694549ec3ffSdougm if (impl_handle != NULL) { 16956185db85Sdougm name = sa_get_group_attr(group, "name"); 16966185db85Sdougm if (name != NULL) { 1697549ec3ffSdougm ret = sa_delete_instance(impl_handle->scfhandle, name); 16986185db85Sdougm sa_free_attr_string(name); 16996185db85Sdougm } 17006185db85Sdougm xmlUnlinkNode((xmlNodePtr)group); /* make sure unlinked */ 17016185db85Sdougm xmlFreeNode((xmlNodePtr)group); /* now it is gone */ 1702549ec3ffSdougm } else { 1703549ec3ffSdougm ret = SA_SYSTEM_ERR; 1704549ec3ffSdougm } 17056185db85Sdougm return (ret); 17066185db85Sdougm } 17076185db85Sdougm 17086185db85Sdougm /* 17096185db85Sdougm * sa_update_config() 17106185db85Sdougm * 17116185db85Sdougm * Used to update legacy files that need to be updated in bulk 17126185db85Sdougm * Currently, this is a placeholder and will go away in a future 17136185db85Sdougm * release. 17146185db85Sdougm */ 17156185db85Sdougm 17166185db85Sdougm int 1717549ec3ffSdougm sa_update_config(sa_handle_t handle) 17186185db85Sdougm { 17196185db85Sdougm /* 17206185db85Sdougm * do legacy files first so we can tell when they change. 17216185db85Sdougm * This will go away when we start updating individual records 17226185db85Sdougm * rather than the whole file. 17236185db85Sdougm */ 1724549ec3ffSdougm update_legacy_config(handle); 17256185db85Sdougm return (SA_OK); 17266185db85Sdougm } 17276185db85Sdougm 17286185db85Sdougm /* 17296185db85Sdougm * get_node_attr(node, tag) 17306185db85Sdougm * 17316185db85Sdougm * Get the speficied tag(attribute) if it exists on the node. This is 17326185db85Sdougm * used internally by a number of attribute oriented functions. 17336185db85Sdougm */ 17346185db85Sdougm 17356185db85Sdougm static char * 17366185db85Sdougm get_node_attr(void *nodehdl, char *tag) 17376185db85Sdougm { 17386185db85Sdougm xmlNodePtr node = (xmlNodePtr)nodehdl; 17396185db85Sdougm xmlChar *name = NULL; 17406185db85Sdougm 174157b448deSdougm if (node != NULL) 17426185db85Sdougm name = xmlGetProp(node, (xmlChar *)tag); 17436185db85Sdougm return ((char *)name); 17446185db85Sdougm } 17456185db85Sdougm 17466185db85Sdougm /* 17476185db85Sdougm * get_node_attr(node, tag) 17486185db85Sdougm * 17496185db85Sdougm * Set the speficied tag(attribute) to the specified value This is 17506185db85Sdougm * used internally by a number of attribute oriented functions. It 17516185db85Sdougm * doesn't update the repository, only the internal document state. 17526185db85Sdougm */ 17536185db85Sdougm 17546185db85Sdougm void 17556185db85Sdougm set_node_attr(void *nodehdl, char *tag, char *value) 17566185db85Sdougm { 17576185db85Sdougm xmlNodePtr node = (xmlNodePtr)nodehdl; 17586185db85Sdougm if (node != NULL && tag != NULL) { 175957b448deSdougm if (value != NULL) 17606185db85Sdougm xmlSetProp(node, (xmlChar *)tag, (xmlChar *)value); 176157b448deSdougm else 17626185db85Sdougm xmlUnsetProp(node, (xmlChar *)tag); 17636185db85Sdougm } 17646185db85Sdougm } 17656185db85Sdougm 17666185db85Sdougm /* 17676185db85Sdougm * sa_get_group_attr(group, tag) 17686185db85Sdougm * 17696185db85Sdougm * Get the specied attribute, if defined, for the group. 17706185db85Sdougm */ 17716185db85Sdougm 17726185db85Sdougm char * 17736185db85Sdougm sa_get_group_attr(sa_group_t group, char *tag) 17746185db85Sdougm { 17756185db85Sdougm return (get_node_attr((void *)group, tag)); 17766185db85Sdougm } 17776185db85Sdougm 17786185db85Sdougm /* 17796185db85Sdougm * sa_set_group_attr(group, tag, value) 17806185db85Sdougm * 17816185db85Sdougm * set the specified tag/attribute on the group using value as its 17826185db85Sdougm * value. 17836185db85Sdougm * 17846185db85Sdougm * This will result in setting the property in the SMF repository as 17856185db85Sdougm * well as in the internal document. 17866185db85Sdougm */ 17876185db85Sdougm 17886185db85Sdougm int 17896185db85Sdougm sa_set_group_attr(sa_group_t group, char *tag, char *value) 17906185db85Sdougm { 17916185db85Sdougm int ret; 17926185db85Sdougm char *groupname; 1793549ec3ffSdougm sa_handle_impl_t impl_handle; 17946185db85Sdougm 1795549ec3ffSdougm impl_handle = (sa_handle_impl_t)sa_find_group_handle(group); 1796549ec3ffSdougm if (impl_handle != NULL) { 17976185db85Sdougm groupname = sa_get_group_attr(group, "name"); 1798549ec3ffSdougm ret = sa_get_instance(impl_handle->scfhandle, groupname); 17996185db85Sdougm if (ret == SA_OK) { 18006185db85Sdougm set_node_attr((void *)group, tag, value); 180157b448deSdougm ret = sa_start_transaction(impl_handle->scfhandle, 180257b448deSdougm "operation"); 18036185db85Sdougm if (ret == SA_OK) { 180457b448deSdougm ret = sa_set_property(impl_handle->scfhandle, 180557b448deSdougm tag, value); 18066185db85Sdougm if (ret == SA_OK) 180757b448deSdougm (void) sa_end_transaction( 180857b448deSdougm impl_handle->scfhandle); 180957b448deSdougm else 181057b448deSdougm sa_abort_transaction( 181157b448deSdougm impl_handle->scfhandle); 18126185db85Sdougm } 18136185db85Sdougm } 18146185db85Sdougm if (groupname != NULL) 18156185db85Sdougm sa_free_attr_string(groupname); 1816549ec3ffSdougm } else { 1817549ec3ffSdougm ret = SA_SYSTEM_ERR; 1818549ec3ffSdougm } 18196185db85Sdougm return (ret); 18206185db85Sdougm } 18216185db85Sdougm 18226185db85Sdougm /* 18236185db85Sdougm * sa_get_share_attr(share, tag) 18246185db85Sdougm * 18256185db85Sdougm * Return the value of the tag/attribute set on the specified 18266185db85Sdougm * share. Returns NULL if the tag doesn't exist. 18276185db85Sdougm */ 18286185db85Sdougm 18296185db85Sdougm char * 18306185db85Sdougm sa_get_share_attr(sa_share_t share, char *tag) 18316185db85Sdougm { 18326185db85Sdougm return (get_node_attr((void *)share, tag)); 18336185db85Sdougm } 18346185db85Sdougm 18356185db85Sdougm /* 18366185db85Sdougm * sa_get_resource(group, resource) 18376185db85Sdougm * 18386185db85Sdougm * Search all the shares in the speified group for a share with a 18396185db85Sdougm * resource name matching the one specified. 18406185db85Sdougm * 18416185db85Sdougm * In the future, it may be advantageous to allow group to be NULL and 18426185db85Sdougm * search all groups but that isn't needed at present. 18436185db85Sdougm */ 18446185db85Sdougm 18456185db85Sdougm sa_share_t 18466185db85Sdougm sa_get_resource(sa_group_t group, char *resource) 18476185db85Sdougm { 18486185db85Sdougm sa_share_t share = NULL; 18496185db85Sdougm char *name = NULL; 18506185db85Sdougm 18516185db85Sdougm if (resource != NULL) { 18526185db85Sdougm for (share = sa_get_share(group, NULL); share != NULL; 18536185db85Sdougm share = sa_get_next_share(share)) { 18546185db85Sdougm name = sa_get_share_attr(share, "resource"); 18556185db85Sdougm if (name != NULL) { 18566185db85Sdougm if (strcmp(name, resource) == 0) 18576185db85Sdougm break; 18586185db85Sdougm sa_free_attr_string(name); 18596185db85Sdougm name = NULL; 18606185db85Sdougm } 18616185db85Sdougm } 18626185db85Sdougm if (name != NULL) 18636185db85Sdougm sa_free_attr_string(name); 18646185db85Sdougm } 18656185db85Sdougm return ((sa_share_t)share); 18666185db85Sdougm } 18676185db85Sdougm 18686185db85Sdougm /* 18696185db85Sdougm * _sa_set_share_description(share, description) 18706185db85Sdougm * 18716185db85Sdougm * Add a description tag with text contents to the specified share. 18726185db85Sdougm * A separate XML tag is used rather than a property. 18736185db85Sdougm */ 18746185db85Sdougm 18756185db85Sdougm xmlNodePtr 18766185db85Sdougm _sa_set_share_description(sa_share_t share, char *content) 18776185db85Sdougm { 18786185db85Sdougm xmlNodePtr node; 187957b448deSdougm node = xmlNewChild((xmlNodePtr)share, NULL, (xmlChar *)"description", 188057b448deSdougm NULL); 18816185db85Sdougm xmlNodeSetContent(node, (xmlChar *)content); 18826185db85Sdougm return (node); 18836185db85Sdougm } 18846185db85Sdougm 18856185db85Sdougm /* 18866185db85Sdougm * sa_set_share_attr(share, tag, value) 18876185db85Sdougm * 18886185db85Sdougm * Set the share attribute specified by tag to the specified value. In 18896185db85Sdougm * the case of "resource", enforce a no duplicates in a group rule. If 18906185db85Sdougm * the share is not transient, commit the changes to the repository 18916185db85Sdougm * else just update the share internally. 18926185db85Sdougm */ 18936185db85Sdougm 18946185db85Sdougm int 18956185db85Sdougm sa_set_share_attr(sa_share_t share, char *tag, char *value) 18966185db85Sdougm { 18976185db85Sdougm sa_group_t group; 18986185db85Sdougm sa_share_t resource; 18996185db85Sdougm int ret = SA_OK; 19006185db85Sdougm 19016185db85Sdougm group = sa_get_parent_group(share); 19026185db85Sdougm 19036185db85Sdougm /* 19046185db85Sdougm * There are some attributes that may have specific 19056185db85Sdougm * restrictions on them. Initially, only "resource" has 19066185db85Sdougm * special meaning that needs to be checked. Only one instance 19076185db85Sdougm * of a resource name may exist within a group. 19086185db85Sdougm */ 19096185db85Sdougm 19106185db85Sdougm if (strcmp(tag, "resource") == 0) { 19116185db85Sdougm resource = sa_get_resource(group, value); 19126185db85Sdougm if (resource != share && resource != NULL) 19136185db85Sdougm ret = SA_DUPLICATE_NAME; 19146185db85Sdougm } 19156185db85Sdougm if (ret == SA_OK) { 19166185db85Sdougm set_node_attr((void *)share, tag, value); 19176185db85Sdougm if (group != NULL) { 19186185db85Sdougm char *type; 19196185db85Sdougm /* we can probably optimize this some */ 19206185db85Sdougm type = sa_get_share_attr(share, "type"); 1921549ec3ffSdougm if (type == NULL || strcmp(type, "transient") != 0) { 1922549ec3ffSdougm sa_handle_impl_t impl_handle; 192357b448deSdougm impl_handle = 192457b448deSdougm (sa_handle_impl_t)sa_find_group_handle( 192557b448deSdougm group); 192657b448deSdougm if (impl_handle != NULL) { 192757b448deSdougm ret = sa_commit_share( 192857b448deSdougm impl_handle->scfhandle, group, 192957b448deSdougm share); 193057b448deSdougm } else { 1931549ec3ffSdougm ret = SA_SYSTEM_ERR; 1932549ec3ffSdougm } 193357b448deSdougm } 19346185db85Sdougm if (type != NULL) 19356185db85Sdougm sa_free_attr_string(type); 19366185db85Sdougm } 19376185db85Sdougm } 19386185db85Sdougm return (ret); 19396185db85Sdougm } 19406185db85Sdougm 19416185db85Sdougm /* 19426185db85Sdougm * sa_get_property_attr(prop, tag) 19436185db85Sdougm * 19446185db85Sdougm * Get the value of the specified property attribute. Standard 19456185db85Sdougm * attributes are "type" and "value". 19466185db85Sdougm */ 19476185db85Sdougm 19486185db85Sdougm char * 19496185db85Sdougm sa_get_property_attr(sa_property_t prop, char *tag) 19506185db85Sdougm { 19516185db85Sdougm return (get_node_attr((void *)prop, tag)); 19526185db85Sdougm } 19536185db85Sdougm 19546185db85Sdougm /* 19556185db85Sdougm * sa_get_optionset_attr(prop, tag) 19566185db85Sdougm * 19576185db85Sdougm * Get the value of the specified property attribute. Standard 19586185db85Sdougm * attribute is "type". 19596185db85Sdougm */ 19606185db85Sdougm 19616185db85Sdougm char * 19626185db85Sdougm sa_get_optionset_attr(sa_property_t optionset, char *tag) 19636185db85Sdougm { 19646185db85Sdougm return (get_node_attr((void *)optionset, tag)); 19656185db85Sdougm 19666185db85Sdougm } 19676185db85Sdougm 19686185db85Sdougm /* 19696185db85Sdougm * sa_set_optionset_attr(optionset, tag, value) 19706185db85Sdougm * 19716185db85Sdougm * Set the specified attribute(tag) to the specified value on the 19726185db85Sdougm * optionset. 19736185db85Sdougm */ 19746185db85Sdougm 19756185db85Sdougm void 19766185db85Sdougm sa_set_optionset_attr(sa_group_t optionset, char *tag, char *value) 19776185db85Sdougm { 19786185db85Sdougm set_node_attr((void *)optionset, tag, value); 19796185db85Sdougm } 19806185db85Sdougm 19816185db85Sdougm /* 19826185db85Sdougm * sa_free_attr_string(string) 19836185db85Sdougm * 19846185db85Sdougm * Free the string that was returned in one of the sa_get_*_attr() 19856185db85Sdougm * functions. 19866185db85Sdougm */ 19876185db85Sdougm 19886185db85Sdougm void 19896185db85Sdougm sa_free_attr_string(char *string) 19906185db85Sdougm { 19916185db85Sdougm xmlFree((xmlChar *)string); 19926185db85Sdougm } 19936185db85Sdougm 19946185db85Sdougm /* 19956185db85Sdougm * sa_get_optionset(group, proto) 19966185db85Sdougm * 19976185db85Sdougm * Return the optionset, if it exists, that is associated with the 19986185db85Sdougm * specified protocol. 19996185db85Sdougm */ 20006185db85Sdougm 20016185db85Sdougm sa_optionset_t 20026185db85Sdougm sa_get_optionset(void *group, char *proto) 20036185db85Sdougm { 20046185db85Sdougm xmlNodePtr node; 20056185db85Sdougm xmlChar *value = NULL; 20066185db85Sdougm 20076185db85Sdougm for (node = ((xmlNodePtr)group)->children; node != NULL; 20086185db85Sdougm node = node->next) { 20096185db85Sdougm if (xmlStrcmp(node->name, (xmlChar *)"optionset") == 0) { 20106185db85Sdougm value = xmlGetProp(node, (xmlChar *)"type"); 20116185db85Sdougm if (proto != NULL) { 20126185db85Sdougm if (value != NULL && 20136185db85Sdougm xmlStrcmp(value, (xmlChar *)proto) == 0) { 20146185db85Sdougm break; 20156185db85Sdougm } 20166185db85Sdougm if (value != NULL) { 20176185db85Sdougm xmlFree(value); 20186185db85Sdougm value = NULL; 20196185db85Sdougm } 20206185db85Sdougm } else { 20216185db85Sdougm break; 20226185db85Sdougm } 20236185db85Sdougm } 20246185db85Sdougm } 20256185db85Sdougm if (value != NULL) 20266185db85Sdougm xmlFree(value); 20276185db85Sdougm return ((sa_optionset_t)node); 20286185db85Sdougm } 20296185db85Sdougm 20306185db85Sdougm /* 20316185db85Sdougm * sa_get_next_optionset(optionset) 20326185db85Sdougm * 20336185db85Sdougm * Return the next optionset in the group. NULL if this was the last. 20346185db85Sdougm */ 20356185db85Sdougm 20366185db85Sdougm sa_optionset_t 20376185db85Sdougm sa_get_next_optionset(sa_optionset_t optionset) 20386185db85Sdougm { 20396185db85Sdougm xmlNodePtr node; 20406185db85Sdougm 20416185db85Sdougm for (node = ((xmlNodePtr)optionset)->next; node != NULL; 20426185db85Sdougm node = node->next) { 20436185db85Sdougm if (xmlStrcmp(node->name, (xmlChar *)"optionset") == 0) { 20446185db85Sdougm break; 20456185db85Sdougm } 20466185db85Sdougm } 20476185db85Sdougm return ((sa_optionset_t)node); 20486185db85Sdougm } 20496185db85Sdougm 20506185db85Sdougm /* 20516185db85Sdougm * sa_get_security(group, sectype, proto) 20526185db85Sdougm * 20536185db85Sdougm * Return the security optionset. The internal name is a hold over 20546185db85Sdougm * from the implementation and will be changed before the API is 20556185db85Sdougm * finalized. This is really a named optionset that can be negotiated 20566185db85Sdougm * as a group of properties (like NFS security options). 20576185db85Sdougm */ 20586185db85Sdougm 20596185db85Sdougm sa_security_t 20606185db85Sdougm sa_get_security(sa_group_t group, char *sectype, char *proto) 20616185db85Sdougm { 20626185db85Sdougm xmlNodePtr node; 20636185db85Sdougm xmlChar *value = NULL; 20646185db85Sdougm 20656185db85Sdougm for (node = ((xmlNodePtr)group)->children; node != NULL; 20666185db85Sdougm node = node->next) { 20676185db85Sdougm if (xmlStrcmp(node->name, (xmlChar *)"security") == 0) { 20686185db85Sdougm if (proto != NULL) { 20696185db85Sdougm value = xmlGetProp(node, (xmlChar *)"type"); 20706185db85Sdougm if (value == NULL || 20716185db85Sdougm (value != NULL && 20726185db85Sdougm xmlStrcmp(value, (xmlChar *)proto) != 0)) { 20736185db85Sdougm /* it doesn't match so continue */ 20746185db85Sdougm xmlFree(value); 20756185db85Sdougm value = NULL; 20766185db85Sdougm continue; 20776185db85Sdougm } 20786185db85Sdougm } 20796185db85Sdougm if (value != NULL) { 20806185db85Sdougm xmlFree(value); 20816185db85Sdougm value = NULL; 20826185db85Sdougm } 20836185db85Sdougm /* potential match */ 20846185db85Sdougm if (sectype != NULL) { 20856185db85Sdougm value = xmlGetProp(node, (xmlChar *)"sectype"); 20866185db85Sdougm if (value != NULL && 20876185db85Sdougm xmlStrcmp(value, (xmlChar *)sectype) == 0) { 20886185db85Sdougm break; 20896185db85Sdougm } 20906185db85Sdougm } else { 20916185db85Sdougm break; 20926185db85Sdougm } 20936185db85Sdougm } 20946185db85Sdougm if (value != NULL) { 20956185db85Sdougm xmlFree(value); 20966185db85Sdougm value = NULL; 20976185db85Sdougm } 20986185db85Sdougm } 20996185db85Sdougm if (value != NULL) 21006185db85Sdougm xmlFree(value); 21016185db85Sdougm return ((sa_security_t)node); 21026185db85Sdougm } 21036185db85Sdougm 21046185db85Sdougm /* 21056185db85Sdougm * sa_get_next_security(security) 21066185db85Sdougm * 21076185db85Sdougm * Get the next security optionset if one exists. 21086185db85Sdougm */ 21096185db85Sdougm 21106185db85Sdougm sa_security_t 21116185db85Sdougm sa_get_next_security(sa_security_t security) 21126185db85Sdougm { 21136185db85Sdougm xmlNodePtr node; 21146185db85Sdougm 21156185db85Sdougm for (node = ((xmlNodePtr)security)->next; node != NULL; 21166185db85Sdougm node = node->next) { 21176185db85Sdougm if (xmlStrcmp(node->name, (xmlChar *)"security") == 0) { 21186185db85Sdougm break; 21196185db85Sdougm } 21206185db85Sdougm } 21216185db85Sdougm return ((sa_security_t)node); 21226185db85Sdougm } 21236185db85Sdougm 21246185db85Sdougm /* 21256185db85Sdougm * sa_get_property(optionset, prop) 21266185db85Sdougm * 21276185db85Sdougm * Get the property object with the name specified in prop from the 21286185db85Sdougm * optionset. 21296185db85Sdougm */ 21306185db85Sdougm 21316185db85Sdougm sa_property_t 21326185db85Sdougm sa_get_property(sa_optionset_t optionset, char *prop) 21336185db85Sdougm { 21346185db85Sdougm xmlNodePtr node = (xmlNodePtr)optionset; 21356185db85Sdougm xmlChar *value = NULL; 21366185db85Sdougm 21376185db85Sdougm if (optionset == NULL) 21386185db85Sdougm return (NULL); 21396185db85Sdougm 21406185db85Sdougm for (node = node->children; node != NULL; 21416185db85Sdougm node = node->next) { 21426185db85Sdougm if (xmlStrcmp(node->name, (xmlChar *)"option") == 0) { 21436185db85Sdougm if (prop == NULL) 21446185db85Sdougm break; 21456185db85Sdougm value = xmlGetProp(node, (xmlChar *)"type"); 214657b448deSdougm if (value != NULL && 214757b448deSdougm xmlStrcmp(value, (xmlChar *)prop) == 0) { 21486185db85Sdougm break; 21496185db85Sdougm } 21506185db85Sdougm if (value != NULL) { 21516185db85Sdougm xmlFree(value); 21526185db85Sdougm value = NULL; 21536185db85Sdougm } 21546185db85Sdougm } 21556185db85Sdougm } 21566185db85Sdougm if (value != NULL) 21576185db85Sdougm xmlFree(value); 21586185db85Sdougm if (node != NULL && xmlStrcmp(node->name, (xmlChar *)"option") != 0) { 215957b448deSdougm /* 216057b448deSdougm * avoid a non option node -- it is possible to be a 216157b448deSdougm * text node 216257b448deSdougm */ 21636185db85Sdougm node = NULL; 21646185db85Sdougm } 21656185db85Sdougm return ((sa_property_t)node); 21666185db85Sdougm } 21676185db85Sdougm 21686185db85Sdougm /* 21696185db85Sdougm * sa_get_next_property(property) 21706185db85Sdougm * 21716185db85Sdougm * Get the next property following the specified property. NULL if 21726185db85Sdougm * this was the last. 21736185db85Sdougm */ 21746185db85Sdougm 21756185db85Sdougm sa_property_t 21766185db85Sdougm sa_get_next_property(sa_property_t property) 21776185db85Sdougm { 21786185db85Sdougm xmlNodePtr node; 21796185db85Sdougm 21806185db85Sdougm for (node = ((xmlNodePtr)property)->next; node != NULL; 21816185db85Sdougm node = node->next) { 21826185db85Sdougm if (xmlStrcmp(node->name, (xmlChar *)"option") == 0) { 21836185db85Sdougm break; 21846185db85Sdougm } 21856185db85Sdougm } 21866185db85Sdougm return ((sa_property_t)node); 21876185db85Sdougm } 21886185db85Sdougm 21896185db85Sdougm /* 21906185db85Sdougm * sa_set_share_description(share, content) 21916185db85Sdougm * 21926185db85Sdougm * Set the description of share to content. 21936185db85Sdougm */ 21946185db85Sdougm 21956185db85Sdougm int 21966185db85Sdougm sa_set_share_description(sa_share_t share, char *content) 21976185db85Sdougm { 21986185db85Sdougm xmlNodePtr node; 21996185db85Sdougm sa_group_t group; 22006185db85Sdougm int ret = SA_OK; 22016185db85Sdougm 22026185db85Sdougm for (node = ((xmlNodePtr)share)->children; node != NULL; 22036185db85Sdougm node = node->next) { 22046185db85Sdougm if (xmlStrcmp(node->name, (xmlChar *)"description") == 0) { 22056185db85Sdougm break; 22066185db85Sdougm } 22076185db85Sdougm } 22086185db85Sdougm group = sa_get_parent_group(share); 22096185db85Sdougm /* no existing description but want to add */ 22106185db85Sdougm if (node == NULL && content != NULL) { 22116185db85Sdougm /* add a description */ 22126185db85Sdougm node = _sa_set_share_description(share, content); 22136185db85Sdougm } else if (node != NULL && content != NULL) { 22146185db85Sdougm /* update a description */ 22156185db85Sdougm xmlNodeSetContent(node, (xmlChar *)content); 22166185db85Sdougm } else if (node != NULL && content == NULL) { 22176185db85Sdougm /* remove an existing description */ 22186185db85Sdougm xmlUnlinkNode(node); 22196185db85Sdougm xmlFreeNode(node); 22206185db85Sdougm } 2221549ec3ffSdougm if (group != NULL && is_persistent((sa_group_t)share)) { 2222549ec3ffSdougm sa_handle_impl_t impl_handle; 2223549ec3ffSdougm impl_handle = (sa_handle_impl_t)sa_find_group_handle(group); 222457b448deSdougm if (impl_handle != NULL) { 222557b448deSdougm ret = sa_commit_share(impl_handle->scfhandle, group, 222657b448deSdougm share); 222757b448deSdougm } else { 2228549ec3ffSdougm ret = SA_SYSTEM_ERR; 2229549ec3ffSdougm } 223057b448deSdougm } 22316185db85Sdougm return (ret); 22326185db85Sdougm } 22336185db85Sdougm 22346185db85Sdougm /* 22356185db85Sdougm * fixproblemchars(string) 22366185db85Sdougm * 22376185db85Sdougm * don't want any newline or tab characters in the text since these 22386185db85Sdougm * could break display of data and legacy file formats. 22396185db85Sdougm */ 22406185db85Sdougm static void 22416185db85Sdougm fixproblemchars(char *str) 22426185db85Sdougm { 22436185db85Sdougm int c; 22446185db85Sdougm for (c = *str; c != '\0'; c = *++str) { 22456185db85Sdougm if (c == '\t' || c == '\n') 22466185db85Sdougm *str = ' '; 22476185db85Sdougm else if (c == '"') 22486185db85Sdougm *str = '\''; 22496185db85Sdougm } 22506185db85Sdougm } 22516185db85Sdougm 22526185db85Sdougm /* 22536185db85Sdougm * sa_get_share_description(share) 22546185db85Sdougm * 22556185db85Sdougm * Return the description text for the specified share if it 22566185db85Sdougm * exists. NULL if no description exists. 22576185db85Sdougm */ 22586185db85Sdougm 22596185db85Sdougm char * 22606185db85Sdougm sa_get_share_description(sa_share_t share) 22616185db85Sdougm { 22626185db85Sdougm xmlChar *description = NULL; 22636185db85Sdougm xmlNodePtr node; 22646185db85Sdougm 22656185db85Sdougm for (node = ((xmlNodePtr)share)->children; node != NULL; 22666185db85Sdougm node = node->next) { 22676185db85Sdougm if (xmlStrcmp(node->name, (xmlChar *)"description") == 0) { 22686185db85Sdougm break; 22696185db85Sdougm } 22706185db85Sdougm } 22716185db85Sdougm if (node != NULL) { 22726185db85Sdougm description = xmlNodeGetContent((xmlNodePtr)share); 22736185db85Sdougm fixproblemchars((char *)description); 22746185db85Sdougm } 22756185db85Sdougm return ((char *)description); 22766185db85Sdougm } 22776185db85Sdougm 22786185db85Sdougm /* 22796185db85Sdougm * sa_free(share_description(description) 22806185db85Sdougm * 22816185db85Sdougm * Free the description string. 22826185db85Sdougm */ 22836185db85Sdougm 22846185db85Sdougm void 22856185db85Sdougm sa_free_share_description(char *description) 22866185db85Sdougm { 22876185db85Sdougm xmlFree((xmlChar *)description); 22886185db85Sdougm } 22896185db85Sdougm 22906185db85Sdougm /* 22916185db85Sdougm * sa_create_optionset(group, proto) 22926185db85Sdougm * 22936185db85Sdougm * Create an optionset for the specified protocol in the specied 22946185db85Sdougm * group. This is manifested as a property group within SMF. 22956185db85Sdougm */ 22966185db85Sdougm 22976185db85Sdougm sa_optionset_t 22986185db85Sdougm sa_create_optionset(sa_group_t group, char *proto) 22996185db85Sdougm { 23006185db85Sdougm sa_optionset_t optionset; 23016185db85Sdougm sa_group_t parent = group; 23026185db85Sdougm 23036185db85Sdougm optionset = sa_get_optionset(group, proto); 23046185db85Sdougm if (optionset != NULL) { 23056185db85Sdougm /* can't have a duplicate protocol */ 23066185db85Sdougm optionset = NULL; 23076185db85Sdougm } else { 23086185db85Sdougm optionset = (sa_optionset_t)xmlNewChild((xmlNodePtr)group, 230957b448deSdougm NULL, (xmlChar *)"optionset", NULL); 23106185db85Sdougm /* 23116185db85Sdougm * only put to repository if on a group and we were 23126185db85Sdougm * able to create an optionset. 23136185db85Sdougm */ 23146185db85Sdougm if (optionset != NULL) { 231557b448deSdougm char oname[SA_STRSIZE]; 23166185db85Sdougm char *groupname; 23176185db85Sdougm char *id = NULL; 23186185db85Sdougm 23196185db85Sdougm if (sa_is_share(group)) 23206185db85Sdougm parent = sa_get_parent_group((sa_share_t)group); 23216185db85Sdougm 23226185db85Sdougm sa_set_optionset_attr(optionset, "type", proto); 23236185db85Sdougm 23246185db85Sdougm if (sa_is_share(group)) { 23256185db85Sdougm id = sa_get_share_attr((sa_share_t)group, "id"); 23266185db85Sdougm } 23276185db85Sdougm (void) sa_optionset_name(optionset, oname, 23286185db85Sdougm sizeof (oname), id); 23296185db85Sdougm groupname = sa_get_group_attr(parent, "name"); 23306185db85Sdougm if (groupname != NULL && is_persistent(group)) { 2331549ec3ffSdougm sa_handle_impl_t impl_handle; 233257b448deSdougm impl_handle = (sa_handle_impl_t) 233357b448deSdougm sa_find_group_handle(group); 2334549ec3ffSdougm assert(impl_handle != NULL); 2335549ec3ffSdougm if (impl_handle != NULL) { 233657b448deSdougm (void) sa_get_instance( 233757b448deSdougm impl_handle->scfhandle, 2338549ec3ffSdougm groupname); 233957b448deSdougm (void) sa_create_pgroup( 234057b448deSdougm impl_handle->scfhandle, oname); 23416185db85Sdougm } 2342549ec3ffSdougm } 2343549ec3ffSdougm if (groupname != NULL) 2344549ec3ffSdougm sa_free_attr_string(groupname); 23456185db85Sdougm if (id != NULL) 23466185db85Sdougm sa_free_attr_string(id); 23476185db85Sdougm } 23486185db85Sdougm } 23496185db85Sdougm return (optionset); 23506185db85Sdougm } 23516185db85Sdougm 23526185db85Sdougm /* 23536185db85Sdougm * sa_get_property_parent(property) 23546185db85Sdougm * 23556185db85Sdougm * Given a property, return the object it is a property of. This will 23566185db85Sdougm * be an optionset of some type. 23576185db85Sdougm */ 23586185db85Sdougm 23596185db85Sdougm static sa_optionset_t 23606185db85Sdougm sa_get_property_parent(sa_property_t property) 23616185db85Sdougm { 23626185db85Sdougm xmlNodePtr node = NULL; 23636185db85Sdougm 236457b448deSdougm if (property != NULL) 23656185db85Sdougm node = ((xmlNodePtr)property)->parent; 23666185db85Sdougm return ((sa_optionset_t)node); 23676185db85Sdougm } 23686185db85Sdougm 23696185db85Sdougm /* 23706185db85Sdougm * sa_get_optionset_parent(optionset) 23716185db85Sdougm * 23726185db85Sdougm * Return the parent of the specified optionset. This could be a group 23736185db85Sdougm * or a share. 23746185db85Sdougm */ 23756185db85Sdougm 23766185db85Sdougm static sa_group_t 23776185db85Sdougm sa_get_optionset_parent(sa_optionset_t optionset) 23786185db85Sdougm { 23796185db85Sdougm xmlNodePtr node = NULL; 23806185db85Sdougm 238157b448deSdougm if (optionset != NULL) 23826185db85Sdougm node = ((xmlNodePtr)optionset)->parent; 23836185db85Sdougm return ((sa_group_t)node); 23846185db85Sdougm } 23856185db85Sdougm 23866185db85Sdougm /* 23876185db85Sdougm * zfs_needs_update(share) 23886185db85Sdougm * 23896185db85Sdougm * In order to avoid making multiple updates to a ZFS share when 23906185db85Sdougm * setting properties, the share attribute "changed" will be set to 23916185db85Sdougm * true when a property is added or modifed. When done adding 23926185db85Sdougm * properties, we can then detect that an update is needed. We then 23936185db85Sdougm * clear the state here to detect additional changes. 23946185db85Sdougm */ 23956185db85Sdougm 23966185db85Sdougm static int 23976185db85Sdougm zfs_needs_update(sa_share_t share) 23986185db85Sdougm { 23996185db85Sdougm char *attr; 24006185db85Sdougm int result = 0; 24016185db85Sdougm 24026185db85Sdougm attr = sa_get_share_attr(share, "changed"); 24036185db85Sdougm if (attr != NULL) { 24046185db85Sdougm sa_free_attr_string(attr); 24056185db85Sdougm result = 1; 24066185db85Sdougm } 24076185db85Sdougm set_node_attr((void *)share, "changed", NULL); 24086185db85Sdougm return (result); 24096185db85Sdougm } 24106185db85Sdougm 24116185db85Sdougm /* 24126185db85Sdougm * zfs_set_update(share) 24136185db85Sdougm * 24146185db85Sdougm * Set the changed attribute of the share to true. 24156185db85Sdougm */ 24166185db85Sdougm 24176185db85Sdougm static void 24186185db85Sdougm zfs_set_update(sa_share_t share) 24196185db85Sdougm { 24206185db85Sdougm set_node_attr((void *)share, "changed", "true"); 24216185db85Sdougm } 24226185db85Sdougm 24236185db85Sdougm /* 24246185db85Sdougm * sa_commit_properties(optionset, clear) 24256185db85Sdougm * 24266185db85Sdougm * Check if SMF or ZFS config and either update or abort the pending 24276185db85Sdougm * changes. 24286185db85Sdougm */ 24296185db85Sdougm 24306185db85Sdougm int 24316185db85Sdougm sa_commit_properties(sa_optionset_t optionset, int clear) 24326185db85Sdougm { 24336185db85Sdougm sa_group_t group; 24346185db85Sdougm sa_group_t parent; 24356185db85Sdougm int zfs = 0; 24366185db85Sdougm int needsupdate = 0; 24376185db85Sdougm int ret = SA_OK; 2438549ec3ffSdougm sa_handle_impl_t impl_handle; 24396185db85Sdougm 24406185db85Sdougm group = sa_get_optionset_parent(optionset); 24416185db85Sdougm if (group != NULL && (sa_is_share(group) || is_zfs_group(group))) { 24426185db85Sdougm /* only update ZFS if on a share */ 24436185db85Sdougm parent = sa_get_parent_group(group); 24446185db85Sdougm zfs++; 244557b448deSdougm if (parent != NULL && is_zfs_group(parent)) 24466185db85Sdougm needsupdate = zfs_needs_update(group); 244757b448deSdougm else 24486185db85Sdougm zfs = 0; 24496185db85Sdougm } 24506185db85Sdougm if (zfs) { 24516185db85Sdougm if (!clear && needsupdate) 24526185db85Sdougm ret = sa_zfs_update((sa_share_t)group); 24536185db85Sdougm } else { 2454549ec3ffSdougm impl_handle = (sa_handle_impl_t)sa_find_group_handle(group); 2455549ec3ffSdougm if (impl_handle != NULL) { 245657b448deSdougm if (clear) { 245757b448deSdougm (void) sa_abort_transaction( 245857b448deSdougm impl_handle->scfhandle); 245957b448deSdougm } else { 246057b448deSdougm ret = sa_end_transaction( 246157b448deSdougm impl_handle->scfhandle); 246257b448deSdougm } 2463549ec3ffSdougm } else { 2464549ec3ffSdougm ret = SA_SYSTEM_ERR; 2465549ec3ffSdougm } 24666185db85Sdougm } 24676185db85Sdougm return (ret); 24686185db85Sdougm } 24696185db85Sdougm 24706185db85Sdougm /* 24716185db85Sdougm * sa_destroy_optionset(optionset) 24726185db85Sdougm * 24736185db85Sdougm * Remove the optionset from its group. Update the repostory to 24746185db85Sdougm * reflect this change. 24756185db85Sdougm */ 24766185db85Sdougm 24776185db85Sdougm int 24786185db85Sdougm sa_destroy_optionset(sa_optionset_t optionset) 24796185db85Sdougm { 248057b448deSdougm char name[SA_STRSIZE]; 24816185db85Sdougm int len; 24826185db85Sdougm int ret; 24836185db85Sdougm char *id = NULL; 24846185db85Sdougm sa_group_t group; 24856185db85Sdougm int ispersist = 1; 24866185db85Sdougm 24876185db85Sdougm /* now delete the prop group */ 24886185db85Sdougm group = sa_get_optionset_parent(optionset); 24896185db85Sdougm if (group != NULL && sa_is_share(group)) { 24906185db85Sdougm ispersist = is_persistent(group); 24916185db85Sdougm id = sa_get_share_attr((sa_share_t)group, "id"); 24926185db85Sdougm } 24936185db85Sdougm if (ispersist) { 2494549ec3ffSdougm sa_handle_impl_t impl_handle; 24956185db85Sdougm len = sa_optionset_name(optionset, name, sizeof (name), id); 2496549ec3ffSdougm impl_handle = (sa_handle_impl_t)sa_find_group_handle(group); 2497549ec3ffSdougm if (impl_handle != NULL) { 24986185db85Sdougm if (len > 0) { 249957b448deSdougm ret = sa_delete_pgroup(impl_handle->scfhandle, 250057b448deSdougm name); 2501549ec3ffSdougm } 2502549ec3ffSdougm } else { 2503549ec3ffSdougm ret = SA_SYSTEM_ERR; 25046185db85Sdougm } 25056185db85Sdougm } 25066185db85Sdougm xmlUnlinkNode((xmlNodePtr)optionset); 25076185db85Sdougm xmlFreeNode((xmlNodePtr)optionset); 25086185db85Sdougm if (id != NULL) 25096185db85Sdougm sa_free_attr_string(id); 25106185db85Sdougm return (ret); 25116185db85Sdougm } 25126185db85Sdougm 25136185db85Sdougm /* private to the implementation */ 25146185db85Sdougm int 25156185db85Sdougm _sa_remove_optionset(sa_optionset_t optionset) 25166185db85Sdougm { 25176185db85Sdougm int ret = SA_OK; 25186185db85Sdougm 25196185db85Sdougm xmlUnlinkNode((xmlNodePtr)optionset); 25206185db85Sdougm xmlFreeNode((xmlNodePtr)optionset); 25216185db85Sdougm return (ret); 25226185db85Sdougm } 25236185db85Sdougm 25246185db85Sdougm /* 25256185db85Sdougm * sa_create_security(group, sectype, proto) 25266185db85Sdougm * 25276185db85Sdougm * Create a security optionset (one that has a type name and a 25286185db85Sdougm * proto). Security is left over from a pure NFS implementation. The 25296185db85Sdougm * naming will change in the future when the API is released. 25306185db85Sdougm */ 25316185db85Sdougm sa_security_t 25326185db85Sdougm sa_create_security(sa_group_t group, char *sectype, char *proto) 25336185db85Sdougm { 25346185db85Sdougm sa_security_t security; 25356185db85Sdougm char *id = NULL; 25366185db85Sdougm sa_group_t parent; 25376185db85Sdougm char *groupname = NULL; 25386185db85Sdougm 25396185db85Sdougm if (group != NULL && sa_is_share(group)) { 25406185db85Sdougm id = sa_get_share_attr((sa_share_t)group, "id"); 25416185db85Sdougm parent = sa_get_parent_group(group); 25426185db85Sdougm if (parent != NULL) 25436185db85Sdougm groupname = sa_get_group_attr(parent, "name"); 25446185db85Sdougm } else if (group != NULL) { 25456185db85Sdougm groupname = sa_get_group_attr(group, "name"); 25466185db85Sdougm } 25476185db85Sdougm 25486185db85Sdougm security = sa_get_security(group, sectype, proto); 25496185db85Sdougm if (security != NULL) { 25506185db85Sdougm /* can't have a duplicate security option */ 25516185db85Sdougm security = NULL; 25526185db85Sdougm } else { 25536185db85Sdougm security = (sa_security_t)xmlNewChild((xmlNodePtr)group, 255457b448deSdougm NULL, (xmlChar *)"security", NULL); 25556185db85Sdougm if (security != NULL) { 255657b448deSdougm char oname[SA_STRSIZE]; 25576185db85Sdougm sa_set_security_attr(security, "type", proto); 25586185db85Sdougm 25596185db85Sdougm sa_set_security_attr(security, "sectype", sectype); 25606185db85Sdougm (void) sa_security_name(security, oname, 25616185db85Sdougm sizeof (oname), id); 25626185db85Sdougm if (groupname != NULL && is_persistent(group)) { 2563549ec3ffSdougm sa_handle_impl_t impl_handle; 2564549ec3ffSdougm impl_handle = 256557b448deSdougm (sa_handle_impl_t)sa_find_group_handle( 256657b448deSdougm group); 2567549ec3ffSdougm if (impl_handle != NULL) { 256857b448deSdougm (void) sa_get_instance( 256957b448deSdougm impl_handle->scfhandle, groupname); 257057b448deSdougm (void) sa_create_pgroup( 257157b448deSdougm impl_handle->scfhandle, oname); 2572549ec3ffSdougm } 25736185db85Sdougm } 25746185db85Sdougm } 25756185db85Sdougm } 25766185db85Sdougm if (groupname != NULL) 25776185db85Sdougm sa_free_attr_string(groupname); 25786185db85Sdougm return (security); 25796185db85Sdougm } 25806185db85Sdougm 25816185db85Sdougm /* 25826185db85Sdougm * sa_destroy_security(security) 25836185db85Sdougm * 25846185db85Sdougm * Remove the specified optionset from the document and the 25856185db85Sdougm * configuration. 25866185db85Sdougm */ 25876185db85Sdougm 25886185db85Sdougm int 25896185db85Sdougm sa_destroy_security(sa_security_t security) 25906185db85Sdougm { 259157b448deSdougm char name[SA_STRSIZE]; 25926185db85Sdougm int len; 25936185db85Sdougm int ret = SA_OK; 25946185db85Sdougm char *id = NULL; 25956185db85Sdougm sa_group_t group; 25966185db85Sdougm int iszfs = 0; 25976185db85Sdougm int ispersist = 1; 25986185db85Sdougm 25996185db85Sdougm group = sa_get_optionset_parent(security); 26006185db85Sdougm 26016185db85Sdougm if (group != NULL) 26026185db85Sdougm iszfs = sa_group_is_zfs(group); 26036185db85Sdougm 26046185db85Sdougm if (group != NULL && !iszfs) { 26056185db85Sdougm if (sa_is_share(group)) 26066185db85Sdougm ispersist = is_persistent(group); 26076185db85Sdougm id = sa_get_share_attr((sa_share_t)group, "id"); 26086185db85Sdougm } 26096185db85Sdougm if (ispersist) { 26106185db85Sdougm len = sa_security_name(security, name, sizeof (name), id); 26116185db85Sdougm if (!iszfs && len > 0) { 2612549ec3ffSdougm sa_handle_impl_t impl_handle; 261357b448deSdougm impl_handle = 261457b448deSdougm (sa_handle_impl_t)sa_find_group_handle(group); 2615549ec3ffSdougm if (impl_handle != NULL) { 261657b448deSdougm ret = sa_delete_pgroup(impl_handle->scfhandle, 261757b448deSdougm name); 2618549ec3ffSdougm } else { 2619549ec3ffSdougm ret = SA_SYSTEM_ERR; 2620549ec3ffSdougm } 26216185db85Sdougm } 26226185db85Sdougm } 26236185db85Sdougm xmlUnlinkNode((xmlNodePtr)security); 26246185db85Sdougm xmlFreeNode((xmlNodePtr)security); 262557b448deSdougm if (iszfs) 26266185db85Sdougm ret = sa_zfs_update(group); 26276185db85Sdougm if (id != NULL) 26286185db85Sdougm sa_free_attr_string(id); 26296185db85Sdougm return (ret); 26306185db85Sdougm } 26316185db85Sdougm 26326185db85Sdougm /* 26336185db85Sdougm * sa_get_security_attr(optionset, tag) 26346185db85Sdougm * 26356185db85Sdougm * Return the specified attribute value from the optionset. 26366185db85Sdougm */ 26376185db85Sdougm 26386185db85Sdougm char * 26396185db85Sdougm sa_get_security_attr(sa_property_t optionset, char *tag) 26406185db85Sdougm { 26416185db85Sdougm return (get_node_attr((void *)optionset, tag)); 26426185db85Sdougm 26436185db85Sdougm } 26446185db85Sdougm 26456185db85Sdougm /* 26466185db85Sdougm * sa_set_security_attr(optionset, tag, value) 26476185db85Sdougm * 26486185db85Sdougm * Set the optioset attribute specied by tag to the specified value. 26496185db85Sdougm */ 26506185db85Sdougm 26516185db85Sdougm void 26526185db85Sdougm sa_set_security_attr(sa_group_t optionset, char *tag, char *value) 26536185db85Sdougm { 26546185db85Sdougm set_node_attr((void *)optionset, tag, value); 26556185db85Sdougm } 26566185db85Sdougm 26576185db85Sdougm /* 26586185db85Sdougm * is_nodetype(node, type) 26596185db85Sdougm * 26606185db85Sdougm * Check to see if node is of the type specified. 26616185db85Sdougm */ 26626185db85Sdougm 26636185db85Sdougm static int 26646185db85Sdougm is_nodetype(void *node, char *type) 26656185db85Sdougm { 26666185db85Sdougm return (strcmp((char *)((xmlNodePtr)node)->name, type) == 0); 26676185db85Sdougm } 26686185db85Sdougm 266957b448deSdougm 267057b448deSdougm /* 267157b448deSdougm * add_or_update() 267257b448deSdougm * 267357b448deSdougm * Add or update a property. Pulled out of sa_set_prop_by_prop for 267457b448deSdougm * readability. 267557b448deSdougm */ 267657b448deSdougm static int 267757b448deSdougm add_or_update(scfutilhandle_t *scf_handle, int type, scf_value_t *value, 267857b448deSdougm scf_transaction_entry_t *entry, char *name, char *valstr) 267957b448deSdougm { 268057b448deSdougm int ret = SA_SYSTEM_ERR; 268157b448deSdougm 268257b448deSdougm if (value != NULL) { 268357b448deSdougm if (type == SA_PROP_OP_ADD) 268457b448deSdougm ret = scf_transaction_property_new(scf_handle->trans, 268557b448deSdougm entry, name, SCF_TYPE_ASTRING); 268657b448deSdougm else 268757b448deSdougm ret = scf_transaction_property_change(scf_handle->trans, 268857b448deSdougm entry, name, SCF_TYPE_ASTRING); 268957b448deSdougm if (ret == 0) { 269057b448deSdougm ret = scf_value_set_astring(value, valstr); 269157b448deSdougm if (ret == 0) 269257b448deSdougm ret = scf_entry_add_value(entry, value); 269357b448deSdougm if (ret == 0) 269457b448deSdougm return (ret); 269557b448deSdougm scf_value_destroy(value); 269657b448deSdougm } else { 269757b448deSdougm scf_entry_destroy(entry); 269857b448deSdougm } 269957b448deSdougm } 270057b448deSdougm return (SA_SYSTEM_ERR); 270157b448deSdougm } 270257b448deSdougm 27036185db85Sdougm /* 27046185db85Sdougm * sa_set_prop_by_prop(optionset, group, prop, type) 27056185db85Sdougm * 27066185db85Sdougm * Add/remove/update the specified property prop into the optionset or 27076185db85Sdougm * share. If a share, sort out which property group based on GUID. In 27086185db85Sdougm * all cases, the appropriate transaction is set (or ZFS share is 27096185db85Sdougm * marked as needing an update) 27106185db85Sdougm */ 27116185db85Sdougm 27126185db85Sdougm static int 27136185db85Sdougm sa_set_prop_by_prop(sa_optionset_t optionset, sa_group_t group, 27146185db85Sdougm sa_property_t prop, int type) 27156185db85Sdougm { 27166185db85Sdougm char *name; 27176185db85Sdougm char *valstr; 27186185db85Sdougm int ret = SA_OK; 27196185db85Sdougm scf_transaction_entry_t *entry; 27206185db85Sdougm scf_value_t *value; 27216185db85Sdougm int opttype; /* 1 == optionset, 0 == security */ 27226185db85Sdougm char *id = NULL; 27236185db85Sdougm int iszfs = 0; 27246185db85Sdougm int isshare = 0; 27256185db85Sdougm sa_group_t parent = NULL; 2726549ec3ffSdougm sa_handle_impl_t impl_handle; 2727549ec3ffSdougm scfutilhandle_t *scf_handle; 27286185db85Sdougm 27296185db85Sdougm if (!is_persistent(group)) { 27306185db85Sdougm /* 27316185db85Sdougm * if the group/share is not persistent we don't need 27326185db85Sdougm * to do anything here 27336185db85Sdougm */ 27346185db85Sdougm return (SA_OK); 27356185db85Sdougm } 2736549ec3ffSdougm impl_handle = (sa_handle_impl_t)sa_find_group_handle(group); 273757b448deSdougm if (impl_handle == NULL || impl_handle->scfhandle == NULL) 2738549ec3ffSdougm return (SA_SYSTEM_ERR); 2739549ec3ffSdougm scf_handle = impl_handle->scfhandle; 27406185db85Sdougm name = sa_get_property_attr(prop, "type"); 27416185db85Sdougm valstr = sa_get_property_attr(prop, "value"); 27426185db85Sdougm entry = scf_entry_create(scf_handle->handle); 27436185db85Sdougm opttype = is_nodetype((void *)optionset, "optionset"); 27446185db85Sdougm 27456185db85Sdougm if (valstr != NULL && entry != NULL) { 27466185db85Sdougm if (sa_is_share(group)) { 27476185db85Sdougm isshare = 1; 27486185db85Sdougm parent = sa_get_parent_group(group); 274957b448deSdougm if (parent != NULL) 27506185db85Sdougm iszfs = is_zfs_group(parent); 27516185db85Sdougm } else { 27526185db85Sdougm iszfs = is_zfs_group(group); 27536185db85Sdougm } 27546185db85Sdougm if (!iszfs) { 27556185db85Sdougm if (scf_handle->trans == NULL) { 275657b448deSdougm char oname[SA_STRSIZE]; 27576185db85Sdougm char *groupname = NULL; 27586185db85Sdougm if (isshare) { 27596185db85Sdougm if (parent != NULL) { 276057b448deSdougm groupname = 276157b448deSdougm sa_get_group_attr(parent, 276257b448deSdougm "name"); 27636185db85Sdougm } 276457b448deSdougm id = 276557b448deSdougm sa_get_share_attr((sa_share_t)group, 276657b448deSdougm "id"); 27676185db85Sdougm } else { 276857b448deSdougm groupname = sa_get_group_attr(group, 276957b448deSdougm "name"); 27706185db85Sdougm } 27716185db85Sdougm if (groupname != NULL) { 277257b448deSdougm ret = sa_get_instance(scf_handle, 277357b448deSdougm groupname); 27746185db85Sdougm sa_free_attr_string(groupname); 27756185db85Sdougm } 27766185db85Sdougm if (opttype) 277757b448deSdougm (void) sa_optionset_name(optionset, 277857b448deSdougm oname, sizeof (oname), id); 27796185db85Sdougm else 278057b448deSdougm (void) sa_security_name(optionset, 278157b448deSdougm oname, sizeof (oname), id); 27826185db85Sdougm ret = sa_start_transaction(scf_handle, oname); 27836185db85Sdougm } 27846185db85Sdougm if (ret == SA_OK) { 27856185db85Sdougm switch (type) { 27866185db85Sdougm case SA_PROP_OP_REMOVE: 2787549ec3ffSdougm ret = scf_transaction_property_delete( 278857b448deSdougm scf_handle->trans, entry, name); 27896185db85Sdougm break; 27906185db85Sdougm case SA_PROP_OP_ADD: 27916185db85Sdougm case SA_PROP_OP_UPDATE: 279257b448deSdougm value = scf_value_create( 279357b448deSdougm scf_handle->handle); 279457b448deSdougm ret = add_or_update(scf_handle, type, 279557b448deSdougm value, entry, name, valstr); 27966185db85Sdougm break; 27976185db85Sdougm } 27986185db85Sdougm } 27996185db85Sdougm } else { 28006185db85Sdougm /* 28016185db85Sdougm * ZFS update. The calling function would have updated 28026185db85Sdougm * the internal XML structure. Just need to flag it as 28036185db85Sdougm * changed for ZFS. 28046185db85Sdougm */ 28056185db85Sdougm zfs_set_update((sa_share_t)group); 28066185db85Sdougm } 28076185db85Sdougm } 28086185db85Sdougm 28096185db85Sdougm if (name != NULL) 28106185db85Sdougm sa_free_attr_string(name); 28116185db85Sdougm if (valstr != NULL) 28126185db85Sdougm sa_free_attr_string(valstr); 28136185db85Sdougm else if (entry != NULL) 28146185db85Sdougm scf_entry_destroy(entry); 28156185db85Sdougm 28166185db85Sdougm if (ret == -1) 28176185db85Sdougm ret = SA_SYSTEM_ERR; 28186185db85Sdougm 28196185db85Sdougm return (ret); 28206185db85Sdougm } 28216185db85Sdougm 28226185db85Sdougm /* 28236185db85Sdougm * sa_create_property(name, value) 28246185db85Sdougm * 28256185db85Sdougm * Create a new property with the specified name and value. 28266185db85Sdougm */ 28276185db85Sdougm 28286185db85Sdougm sa_property_t 28296185db85Sdougm sa_create_property(char *name, char *value) 28306185db85Sdougm { 28316185db85Sdougm xmlNodePtr node; 28326185db85Sdougm 28336185db85Sdougm node = xmlNewNode(NULL, (xmlChar *)"option"); 28346185db85Sdougm if (node != NULL) { 28356185db85Sdougm xmlSetProp(node, (xmlChar *)"type", (xmlChar *)name); 28366185db85Sdougm xmlSetProp(node, (xmlChar *)"value", (xmlChar *)value); 28376185db85Sdougm } 28386185db85Sdougm return ((sa_property_t)node); 28396185db85Sdougm } 28406185db85Sdougm 28416185db85Sdougm /* 28426185db85Sdougm * sa_add_property(object, property) 28436185db85Sdougm * 28446185db85Sdougm * Add the specified property to the object. Issue the appropriate 28456185db85Sdougm * transaction or mark a ZFS object as needing an update. 28466185db85Sdougm */ 28476185db85Sdougm 28486185db85Sdougm int 28496185db85Sdougm sa_add_property(void *object, sa_property_t property) 28506185db85Sdougm { 28516185db85Sdougm int ret = SA_OK; 28526185db85Sdougm sa_group_t parent; 28536185db85Sdougm sa_group_t group; 28546185db85Sdougm char *proto; 28556185db85Sdougm 28566185db85Sdougm proto = sa_get_optionset_attr(object, "type"); 28576185db85Sdougm if (property != NULL) { 285857b448deSdougm if ((ret = sa_valid_property(object, proto, property)) == 285957b448deSdougm SA_OK) { 286057b448deSdougm property = (sa_property_t)xmlAddChild( 286157b448deSdougm (xmlNodePtr)object, (xmlNodePtr)property); 28626185db85Sdougm } else { 28636185db85Sdougm if (proto != NULL) 28646185db85Sdougm sa_free_attr_string(proto); 28656185db85Sdougm return (ret); 28666185db85Sdougm } 28676185db85Sdougm } 28686185db85Sdougm 28696185db85Sdougm if (proto != NULL) 28706185db85Sdougm sa_free_attr_string(proto); 28716185db85Sdougm 28726185db85Sdougm parent = sa_get_parent_group(object); 28736185db85Sdougm if (!is_persistent(parent)) { 28746185db85Sdougm return (ret); 28756185db85Sdougm } 28766185db85Sdougm 28776185db85Sdougm if (sa_is_share(parent)) 28786185db85Sdougm group = sa_get_parent_group(parent); 28796185db85Sdougm else 28806185db85Sdougm group = parent; 28816185db85Sdougm 288257b448deSdougm if (property == NULL) { 28836185db85Sdougm ret = SA_NO_MEMORY; 288457b448deSdougm } else { 288557b448deSdougm char oname[SA_STRSIZE]; 28866185db85Sdougm 28876185db85Sdougm if (!is_zfs_group(group)) { 28886185db85Sdougm char *id = NULL; 2889549ec3ffSdougm sa_handle_impl_t impl_handle; 2890549ec3ffSdougm scfutilhandle_t *scf_handle; 2891549ec3ffSdougm 289257b448deSdougm impl_handle = (sa_handle_impl_t)sa_find_group_handle( 289357b448deSdougm group); 289457b448deSdougm if (impl_handle == NULL || 289557b448deSdougm impl_handle->scfhandle == NULL) 2896549ec3ffSdougm ret = SA_SYSTEM_ERR; 2897549ec3ffSdougm if (ret == SA_OK) { 2898549ec3ffSdougm scf_handle = impl_handle->scfhandle; 28996185db85Sdougm if (sa_is_share((sa_group_t)parent)) { 290057b448deSdougm id = sa_get_share_attr( 290157b448deSdougm (sa_share_t)parent, "id"); 29026185db85Sdougm } 29036185db85Sdougm if (scf_handle->trans == NULL) { 290457b448deSdougm if (is_nodetype(object, "optionset")) { 290557b448deSdougm (void) sa_optionset_name( 290657b448deSdougm (sa_optionset_t)object, 29076185db85Sdougm oname, sizeof (oname), id); 290857b448deSdougm } else { 290957b448deSdougm (void) sa_security_name( 291057b448deSdougm (sa_optionset_t)object, 29116185db85Sdougm oname, sizeof (oname), id); 291257b448deSdougm } 291357b448deSdougm ret = sa_start_transaction(scf_handle, 291457b448deSdougm oname); 29156185db85Sdougm } 29166185db85Sdougm if (ret == SA_OK) { 29176185db85Sdougm char *name; 29186185db85Sdougm char *value; 291957b448deSdougm name = sa_get_property_attr(property, 292057b448deSdougm "type"); 292157b448deSdougm value = sa_get_property_attr(property, 292257b448deSdougm "value"); 29236185db85Sdougm if (name != NULL && value != NULL) { 292457b448deSdougm if (scf_handle->scf_state == 292557b448deSdougm SCH_STATE_INIT) { 292657b448deSdougm ret = sa_set_property( 292757b448deSdougm scf_handle, name, 292857b448deSdougm value); 292957b448deSdougm } 293057b448deSdougm } else { 29316185db85Sdougm ret = SA_CONFIG_ERR; 293257b448deSdougm } 29336185db85Sdougm if (name != NULL) 293457b448deSdougm sa_free_attr_string( 293557b448deSdougm name); 29366185db85Sdougm if (value != NULL) 29376185db85Sdougm sa_free_attr_string(value); 29386185db85Sdougm } 29396185db85Sdougm if (id != NULL) 29406185db85Sdougm sa_free_attr_string(id); 2941549ec3ffSdougm } 29426185db85Sdougm } else { 29436185db85Sdougm /* 294457b448deSdougm * ZFS is a special case. We do want 294557b448deSdougm * to allow editing property/security 294657b448deSdougm * lists since we can have a better 294757b448deSdougm * syntax and we also want to keep 294857b448deSdougm * things consistent when possible. 29496185db85Sdougm * 295057b448deSdougm * Right now, we defer until the 295157b448deSdougm * sa_commit_properties so we can get 295257b448deSdougm * them all at once. We do need to 295357b448deSdougm * mark the share as "changed" 29546185db85Sdougm */ 29556185db85Sdougm zfs_set_update((sa_share_t)parent); 29566185db85Sdougm } 29576185db85Sdougm } 29586185db85Sdougm return (ret); 29596185db85Sdougm } 29606185db85Sdougm 29616185db85Sdougm /* 29626185db85Sdougm * sa_remove_property(property) 29636185db85Sdougm * 29646185db85Sdougm * Remove the specied property from its containing object. Update the 29656185db85Sdougm * repository as appropriate. 29666185db85Sdougm */ 29676185db85Sdougm 29686185db85Sdougm int 29696185db85Sdougm sa_remove_property(sa_property_t property) 29706185db85Sdougm { 29716185db85Sdougm int ret = SA_OK; 29726185db85Sdougm 29736185db85Sdougm if (property != NULL) { 29746185db85Sdougm sa_optionset_t optionset; 29756185db85Sdougm sa_group_t group; 29766185db85Sdougm optionset = sa_get_property_parent(property); 29776185db85Sdougm if (optionset != NULL) { 29786185db85Sdougm group = sa_get_optionset_parent(optionset); 29796185db85Sdougm if (group != NULL) { 298057b448deSdougm ret = sa_set_prop_by_prop(optionset, group, 298157b448deSdougm property, SA_PROP_OP_REMOVE); 29826185db85Sdougm } 29836185db85Sdougm } 29846185db85Sdougm xmlUnlinkNode((xmlNodePtr)property); 29856185db85Sdougm xmlFreeNode((xmlNodePtr)property); 29866185db85Sdougm } else { 29876185db85Sdougm ret = SA_NO_SUCH_PROP; 29886185db85Sdougm } 29896185db85Sdougm return (ret); 29906185db85Sdougm } 29916185db85Sdougm 29926185db85Sdougm /* 29936185db85Sdougm * sa_update_property(property, value) 29946185db85Sdougm * 29956185db85Sdougm * Update the specified property to the new value. If value is NULL, 29966185db85Sdougm * we currently treat this as a remove. 29976185db85Sdougm */ 29986185db85Sdougm 29996185db85Sdougm int 30006185db85Sdougm sa_update_property(sa_property_t property, char *value) 30016185db85Sdougm { 30026185db85Sdougm int ret = SA_OK; 30036185db85Sdougm if (value == NULL) { 30046185db85Sdougm return (sa_remove_property(property)); 30056185db85Sdougm } else { 30066185db85Sdougm sa_optionset_t optionset; 30076185db85Sdougm sa_group_t group; 30086185db85Sdougm set_node_attr((void *)property, "value", value); 30096185db85Sdougm optionset = sa_get_property_parent(property); 30106185db85Sdougm if (optionset != NULL) { 30116185db85Sdougm group = sa_get_optionset_parent(optionset); 30126185db85Sdougm if (group != NULL) { 301357b448deSdougm ret = sa_set_prop_by_prop(optionset, group, 301457b448deSdougm property, SA_PROP_OP_UPDATE); 30156185db85Sdougm } 30166185db85Sdougm } else { 30176185db85Sdougm ret = SA_NO_SUCH_PROP; 30186185db85Sdougm } 30196185db85Sdougm } 30206185db85Sdougm return (ret); 30216185db85Sdougm } 30226185db85Sdougm 30236185db85Sdougm /* 30246185db85Sdougm * sa_get_protocol_property(propset, prop) 30256185db85Sdougm * 30266185db85Sdougm * Get the specified protocol specific property. These are global to 30276185db85Sdougm * the protocol and not specific to a group or share. 30286185db85Sdougm */ 30296185db85Sdougm 30306185db85Sdougm sa_property_t 30316185db85Sdougm sa_get_protocol_property(sa_protocol_properties_t propset, char *prop) 30326185db85Sdougm { 30336185db85Sdougm xmlNodePtr node = (xmlNodePtr)propset; 30346185db85Sdougm xmlChar *value = NULL; 30356185db85Sdougm 30366185db85Sdougm for (node = node->children; node != NULL; 30376185db85Sdougm node = node->next) { 30386185db85Sdougm if (xmlStrcmp(node->name, (xmlChar *)"option") == 0) { 30396185db85Sdougm if (prop == NULL) 30406185db85Sdougm break; 30416185db85Sdougm value = xmlGetProp(node, (xmlChar *)"type"); 30426185db85Sdougm if (value != NULL && 30436185db85Sdougm xmlStrcasecmp(value, (xmlChar *)prop) == 0) { 30446185db85Sdougm break; 30456185db85Sdougm } 30466185db85Sdougm if (value != NULL) { 30476185db85Sdougm xmlFree(value); 30486185db85Sdougm value = NULL; 30496185db85Sdougm } 30506185db85Sdougm } 30516185db85Sdougm } 30526185db85Sdougm if (value != NULL) 30536185db85Sdougm xmlFree(value); 30546185db85Sdougm if (node != NULL && xmlStrcmp(node->name, (xmlChar *)"option") != 0) { 305557b448deSdougm /* 305657b448deSdougm * avoid a non option node -- it is possible to be a 305757b448deSdougm * text node 305857b448deSdougm */ 30596185db85Sdougm node = NULL; 30606185db85Sdougm } 30616185db85Sdougm return ((sa_property_t)node); 30626185db85Sdougm } 30636185db85Sdougm 30646185db85Sdougm /* 30656185db85Sdougm * sa_get_next_protocol_property(prop) 30666185db85Sdougm * 30676185db85Sdougm * Get the next protocol specific property in the list. 30686185db85Sdougm */ 30696185db85Sdougm 30706185db85Sdougm sa_property_t 30716185db85Sdougm sa_get_next_protocol_property(sa_property_t prop) 30726185db85Sdougm { 30736185db85Sdougm xmlNodePtr node; 30746185db85Sdougm 30756185db85Sdougm for (node = ((xmlNodePtr)prop)->next; node != NULL; 30766185db85Sdougm node = node->next) { 30776185db85Sdougm if (xmlStrcmp(node->name, (xmlChar *)"option") == 0) { 30786185db85Sdougm break; 30796185db85Sdougm } 30806185db85Sdougm } 30816185db85Sdougm return ((sa_property_t)node); 30826185db85Sdougm } 30836185db85Sdougm 30846185db85Sdougm /* 30856185db85Sdougm * sa_set_protocol_property(prop, value) 30866185db85Sdougm * 30876185db85Sdougm * Set the specified property to have the new value. The protocol 30886185db85Sdougm * specific plugin will then be called to update the property. 30896185db85Sdougm */ 30906185db85Sdougm 30916185db85Sdougm int 30926185db85Sdougm sa_set_protocol_property(sa_property_t prop, char *value) 30936185db85Sdougm { 30946185db85Sdougm sa_protocol_properties_t propset; 30956185db85Sdougm char *proto; 30966185db85Sdougm int ret = SA_INVALID_PROTOCOL; 30976185db85Sdougm 30986185db85Sdougm propset = ((xmlNodePtr)prop)->parent; 30996185db85Sdougm if (propset != NULL) { 31006185db85Sdougm proto = sa_get_optionset_attr(propset, "type"); 31016185db85Sdougm if (proto != NULL) { 31026185db85Sdougm set_node_attr((xmlNodePtr)prop, "value", value); 31036185db85Sdougm ret = sa_proto_set_property(proto, prop); 31043472f5dcSdougm sa_free_attr_string(proto); 31056185db85Sdougm } 31066185db85Sdougm } 31076185db85Sdougm return (ret); 31086185db85Sdougm } 31096185db85Sdougm 31106185db85Sdougm /* 31116185db85Sdougm * sa_add_protocol_property(propset, prop) 31126185db85Sdougm * 31136185db85Sdougm * Add a new property to the protocol sepcific property set. 31146185db85Sdougm */ 31156185db85Sdougm 31166185db85Sdougm int 31176185db85Sdougm sa_add_protocol_property(sa_protocol_properties_t propset, sa_property_t prop) 31186185db85Sdougm { 31196185db85Sdougm xmlNodePtr node; 31206185db85Sdougm 31216185db85Sdougm /* should check for legitimacy */ 31226185db85Sdougm node = xmlAddChild((xmlNodePtr)propset, (xmlNodePtr)prop); 31236185db85Sdougm if (node != NULL) 31246185db85Sdougm return (SA_OK); 31256185db85Sdougm return (SA_NO_MEMORY); 31266185db85Sdougm } 31276185db85Sdougm 31286185db85Sdougm /* 31296185db85Sdougm * sa_create_protocol_properties(proto) 31306185db85Sdougm * 31316185db85Sdougm * Create a protocol specifity property set. 31326185db85Sdougm */ 31336185db85Sdougm 31346185db85Sdougm sa_protocol_properties_t 31356185db85Sdougm sa_create_protocol_properties(char *proto) 31366185db85Sdougm { 31376185db85Sdougm xmlNodePtr node; 313857b448deSdougm 31396185db85Sdougm node = xmlNewNode(NULL, (xmlChar *)"propertyset"); 314057b448deSdougm if (node != NULL) 31416185db85Sdougm xmlSetProp(node, (xmlChar *)"type", (xmlChar *)proto); 31426185db85Sdougm return (node); 31436185db85Sdougm } 3144