1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved. 24 * Copyright 2014 Nexenta Systems, Inc. All rights reserved. 25 */ 26 27 /* 28 * NFS specific functions 29 */ 30 #include <stdio.h> 31 #include <string.h> 32 #include <ctype.h> 33 #include <stdlib.h> 34 #include <unistd.h> 35 #include <zone.h> 36 #include <errno.h> 37 #include <locale.h> 38 #include <signal.h> 39 #include <strings.h> 40 #include "libshare.h" 41 #include "libshare_impl.h" 42 #include <nfs/export.h> 43 #include <pwd.h> 44 #include <limits.h> 45 #include <libscf.h> 46 #include <syslog.h> 47 #include <rpcsvc/daemon_utils.h> 48 #include "nfslog_config.h" 49 #include "nfslogtab.h" 50 #include "libshare_nfs.h" 51 #include <nfs/nfs.h> 52 #include <nfs/nfssys.h> 53 #include "smfcfg.h" 54 55 /* should really be in some global place */ 56 #define DEF_WIN 30000 57 #define OPT_CHUNK 1024 58 59 int debug = 0; 60 61 #define NFS_SERVER_SVC "svc:/network/nfs/server:default" 62 #define NFS_CLIENT_SVC (char *)"svc:/network/nfs/client:default" 63 64 /* internal functions */ 65 static int nfs_init(); 66 static void nfs_fini(); 67 static int nfs_enable_share(sa_share_t); 68 static int nfs_disable_share(sa_share_t, char *); 69 static int nfs_validate_property(sa_handle_t, sa_property_t, sa_optionset_t); 70 static int nfs_validate_security_mode(char *); 71 static int nfs_is_security_opt(char *); 72 static int nfs_parse_legacy_options(sa_group_t, char *); 73 static char *nfs_format_options(sa_group_t, int); 74 static int nfs_set_proto_prop(sa_property_t); 75 static sa_protocol_properties_t nfs_get_proto_set(); 76 static char *nfs_get_status(); 77 static char *nfs_space_alias(char *); 78 static uint64_t nfs_features(); 79 80 /* 81 * ops vector that provides the protocol specific info and operations 82 * for share management. 83 */ 84 85 struct sa_plugin_ops sa_plugin_ops = { 86 SA_PLUGIN_VERSION, 87 "nfs", 88 nfs_init, 89 nfs_fini, 90 nfs_enable_share, 91 nfs_disable_share, 92 nfs_validate_property, 93 nfs_validate_security_mode, 94 nfs_is_security_opt, 95 nfs_parse_legacy_options, 96 nfs_format_options, 97 nfs_set_proto_prop, 98 nfs_get_proto_set, 99 nfs_get_status, 100 nfs_space_alias, 101 NULL, /* update_legacy */ 102 NULL, /* delete_legacy */ 103 NULL, /* change_notify */ 104 NULL, /* enable_resource */ 105 NULL, /* disable_resource */ 106 nfs_features, 107 NULL, /* transient shares */ 108 NULL, /* notify resource */ 109 NULL, /* rename_resource */ 110 NULL, /* run_command */ 111 NULL, /* command_help */ 112 NULL /* delete_proto_section */ 113 }; 114 115 /* 116 * list of support services needed 117 * defines should come from head/rpcsvc/daemon_utils.h 118 */ 119 120 static char *service_list_default[] = 121 { STATD, LOCKD, MOUNTD, NFSD, NFSMAPID, RQUOTAD, REPARSED, NULL }; 122 static char *service_list_logging[] = 123 { STATD, LOCKD, MOUNTD, NFSD, NFSMAPID, RQUOTAD, NFSLOGD, REPARSED, 124 NULL }; 125 126 /* 127 * option definitions. Make sure to keep the #define for the option 128 * index just before the entry it is the index for. Changing the order 129 * can cause breakage. E.g OPT_RW is index 1 and must precede the 130 * line that includes the SHOPT_RW and OPT_RW entries. 131 */ 132 133 struct option_defs optdefs[] = { 134 #define OPT_RO 0 135 {SHOPT_RO, OPT_RO, OPT_TYPE_ACCLIST}, 136 #define OPT_RW 1 137 {SHOPT_RW, OPT_RW, OPT_TYPE_ACCLIST}, 138 #define OPT_ROOT 2 139 {SHOPT_ROOT, OPT_ROOT, OPT_TYPE_ACCLIST}, 140 #define OPT_SECURE 3 141 {SHOPT_SECURE, OPT_SECURE, OPT_TYPE_DEPRECATED}, 142 #define OPT_ANON 4 143 {SHOPT_ANON, OPT_ANON, OPT_TYPE_USER}, 144 #define OPT_WINDOW 5 145 {SHOPT_WINDOW, OPT_WINDOW, OPT_TYPE_NUMBER}, 146 #define OPT_NOSUID 6 147 {SHOPT_NOSUID, OPT_NOSUID, OPT_TYPE_BOOLEAN}, 148 #define OPT_ACLOK 7 149 {SHOPT_ACLOK, OPT_ACLOK, OPT_TYPE_BOOLEAN}, 150 #define OPT_NOSUB 8 151 {SHOPT_NOSUB, OPT_NOSUB, OPT_TYPE_BOOLEAN}, 152 #define OPT_SEC 9 153 {SHOPT_SEC, OPT_SEC, OPT_TYPE_SECURITY}, 154 #define OPT_PUBLIC 10 155 {SHOPT_PUBLIC, OPT_PUBLIC, OPT_TYPE_BOOLEAN, OPT_SHARE_ONLY}, 156 #define OPT_INDEX 11 157 {SHOPT_INDEX, OPT_INDEX, OPT_TYPE_FILE}, 158 #define OPT_LOG 12 159 {SHOPT_LOG, OPT_LOG, OPT_TYPE_LOGTAG}, 160 #define OPT_CKSUM 13 161 {SHOPT_CKSUM, OPT_CKSUM, OPT_TYPE_STRINGSET}, 162 #define OPT_NONE 14 163 {SHOPT_NONE, OPT_NONE, OPT_TYPE_ACCLIST}, 164 #define OPT_ROOT_MAPPING 15 165 {SHOPT_ROOT_MAPPING, OPT_ROOT_MAPPING, OPT_TYPE_USER}, 166 #define OPT_CHARSET_MAP 16 167 {"", OPT_CHARSET_MAP, OPT_TYPE_ACCLIST}, 168 #define OPT_NOACLFAB 17 169 {SHOPT_NOACLFAB, OPT_NOACLFAB, OPT_TYPE_BOOLEAN}, 170 #ifdef VOLATILE_FH_TEST /* XXX added for testing volatile fh's only */ 171 #define OPT_VOLFH 18 172 {SHOPT_VOLFH, OPT_VOLFH}, 173 #endif /* VOLATILE_FH_TEST */ 174 NULL 175 }; 176 177 /* 178 * Codesets that may need to be converted to UTF-8 for file paths. 179 * Add new names here to add new property support. If we ever get a 180 * way to query the kernel for character sets, this should become 181 * dynamically loaded. Make sure changes here are reflected in 182 * cmd/fs.d/nfs/mountd/nfscmd.c 183 */ 184 185 static char *legal_conv[] = { 186 "euc-cn", 187 "euc-jp", 188 "euc-jpms", 189 "euc-kr", 190 "euc-tw", 191 "iso8859-1", 192 "iso8859-2", 193 "iso8859-5", 194 "iso8859-6", 195 "iso8859-7", 196 "iso8859-8", 197 "iso8859-9", 198 "iso8859-13", 199 "iso8859-15", 200 "koi8-r", 201 NULL 202 }; 203 204 /* 205 * list of properties that are related to security flavors. 206 */ 207 static char *seclist[] = { 208 SHOPT_RO, 209 SHOPT_RW, 210 SHOPT_ROOT, 211 SHOPT_WINDOW, 212 SHOPT_NONE, 213 SHOPT_ROOT_MAPPING, 214 NULL 215 }; 216 217 /* structure for list of securities */ 218 struct securities { 219 sa_security_t security; 220 struct securities *next; 221 }; 222 223 /* 224 * findcharset(charset) 225 * 226 * Returns B_TRUE if the charset is a legal conversion otherwise 227 * B_FALSE. This will need to be rewritten to be more efficient when 228 * we have a dynamic list of legal conversions. 229 */ 230 231 static boolean_t 232 findcharset(char *charset) 233 { 234 int i; 235 236 for (i = 0; legal_conv[i] != NULL; i++) 237 if (strcmp(charset, legal_conv[i]) == 0) 238 return (B_TRUE); 239 return (B_FALSE); 240 } 241 242 /* 243 * findopt(name) 244 * 245 * Lookup option "name" in the option table and return the table 246 * index. 247 */ 248 249 static int 250 findopt(char *name) 251 { 252 int i; 253 if (name != NULL) { 254 for (i = 0; optdefs[i].tag != NULL; i++) { 255 if (strcmp(optdefs[i].tag, name) == 0) 256 return (optdefs[i].index); 257 } 258 if (findcharset(name)) 259 return (OPT_CHARSET_MAP); 260 } 261 return (-1); 262 } 263 264 /* 265 * gettype(name) 266 * 267 * Return the type of option "name". 268 */ 269 270 static int 271 gettype(char *name) 272 { 273 int optdef; 274 275 optdef = findopt(name); 276 if (optdef != -1) 277 return (optdefs[optdef].type); 278 return (OPT_TYPE_ANY); 279 } 280 281 /* 282 * nfs_validate_security_mode(mode) 283 * 284 * is the specified mode string a valid one for use with NFS? 285 */ 286 287 static int 288 nfs_validate_security_mode(char *mode) 289 { 290 seconfig_t secinfo; 291 int err; 292 293 (void) memset(&secinfo, '\0', sizeof (secinfo)); 294 err = nfs_getseconfig_byname(mode, &secinfo); 295 if (err == SC_NOERROR) 296 return (1); 297 return (0); 298 } 299 300 /* 301 * nfs_is_security_opt(tok) 302 * 303 * check to see if tok represents an option that is only valid in some 304 * security flavor. 305 */ 306 307 static int 308 nfs_is_security_opt(char *tok) 309 { 310 int i; 311 312 for (i = 0; seclist[i] != NULL; i++) { 313 if (strcmp(tok, seclist[i]) == 0) 314 return (1); 315 } 316 return (0); 317 } 318 319 /* 320 * find_security(seclist, sec) 321 * 322 * Walk the current list of security flavors and return true if it is 323 * present, else return false. 324 */ 325 326 static int 327 find_security(struct securities *seclist, sa_security_t sec) 328 { 329 while (seclist != NULL) { 330 if (seclist->security == sec) 331 return (1); 332 seclist = seclist->next; 333 } 334 return (0); 335 } 336 337 /* 338 * make_security_list(group, securitymodes, proto) 339 * go through the list of securitymodes and add them to the 340 * group's list of security optionsets. We also keep a list of 341 * those optionsets so we don't have to find them later. All of 342 * these will get copies of the same properties. 343 */ 344 345 static struct securities * 346 make_security_list(sa_group_t group, char *securitymodes, char *proto) 347 { 348 char *tok, *next = NULL; 349 struct securities *curp, *headp = NULL, *prev; 350 sa_security_t check; 351 int freetok = 0; 352 353 for (tok = securitymodes; tok != NULL; tok = next) { 354 next = strchr(tok, ':'); 355 if (next != NULL) 356 *next++ = '\0'; 357 if (strcmp(tok, "default") == 0) { 358 /* resolve default into the real type */ 359 tok = nfs_space_alias(tok); 360 freetok = 1; 361 } 362 check = sa_get_security(group, tok, proto); 363 364 /* add to the security list if it isn't there already */ 365 if (check == NULL || !find_security(headp, check)) { 366 curp = (struct securities *)calloc(1, 367 sizeof (struct securities)); 368 if (curp != NULL) { 369 if (check == NULL) { 370 curp->security = sa_create_security( 371 group, tok, proto); 372 } else { 373 curp->security = check; 374 } 375 /* 376 * note that the first time through the loop, 377 * headp will be NULL and prev will be 378 * undefined. Since headp is NULL, we set 379 * both it and prev to the curp (first 380 * structure to be allocated). 381 * 382 * later passes through the loop will have 383 * headp not being NULL and prev will be used 384 * to allocate at the end of the list. 385 */ 386 if (headp == NULL) { 387 headp = curp; 388 prev = curp; 389 } else { 390 prev->next = curp; 391 prev = curp; 392 } 393 } 394 } 395 396 if (freetok) { 397 freetok = 0; 398 sa_free_attr_string(tok); 399 } 400 } 401 return (headp); 402 } 403 404 static void 405 free_security_list(struct securities *sec) 406 { 407 struct securities *next; 408 if (sec != NULL) { 409 for (next = sec->next; sec != NULL; sec = next) { 410 next = sec->next; 411 free(sec); 412 } 413 } 414 } 415 416 /* 417 * nfs_alistcat(str1, str2, sep) 418 * 419 * concatenate str1 and str2 into a new string using sep as a separate 420 * character. If memory allocation fails, return NULL; 421 */ 422 423 static char * 424 nfs_alistcat(char *str1, char *str2, char sep) 425 { 426 char *newstr; 427 size_t len; 428 429 len = strlen(str1) + strlen(str2) + 2; 430 newstr = (char *)malloc(len); 431 if (newstr != NULL) 432 (void) snprintf(newstr, len, "%s%c%s", str1, sep, str2); 433 return (newstr); 434 } 435 436 /* 437 * add_security_prop(sec, name, value, persist) 438 * 439 * Add the property to the securities structure. This accumulates 440 * properties for as part of parsing legacy options. 441 */ 442 443 static int 444 add_security_prop(struct securities *sec, char *name, char *value, 445 int persist, int iszfs) 446 { 447 sa_property_t prop; 448 int ret = SA_OK; 449 450 for (; sec != NULL; sec = sec->next) { 451 if (value == NULL) { 452 if (strcmp(name, SHOPT_RW) == 0 || 453 strcmp(name, SHOPT_RO) == 0) 454 value = "*"; 455 else 456 value = "true"; 457 } 458 459 /* 460 * Get the existing property, if it exists, so we can 461 * determine what to do with it. The ro/rw/root 462 * properties can be merged if multiple instances of 463 * these properies are given. For example, if "rw" 464 * exists with a value "host1" and a later token of 465 * rw="host2" is seen, the values are merged into a 466 * single rw="host1:host2". 467 */ 468 prop = sa_get_property(sec->security, name); 469 470 if (prop != NULL) { 471 char *oldvalue; 472 char *newvalue; 473 474 /* 475 * The security options of ro/rw/root might appear 476 * multiple times. If they do, the values need to be 477 * merged into an access list. If it was previously 478 * empty, the new value alone is added. 479 */ 480 oldvalue = sa_get_property_attr(prop, "value"); 481 if (oldvalue != NULL) { 482 /* 483 * The general case is to concatenate the new 484 * value onto the old value for multiple 485 * rw(ro/root) properties. A special case 486 * exists when either the old or new is the 487 * "all" case. In the special case, if both 488 * are "all", then it is "all", else if one is 489 * an access-list, that replaces the "all". 490 */ 491 if (strcmp(oldvalue, "*") == 0) { 492 /* Replace old value with new value. */ 493 newvalue = strdup(value); 494 } else if (strcmp(value, "*") == 0 || 495 strcmp(oldvalue, value) == 0) { 496 /* 497 * Keep old value and ignore 498 * the new value. 499 */ 500 newvalue = NULL; 501 } else { 502 /* 503 * Make a new list of old plus new 504 * access-list. 505 */ 506 newvalue = nfs_alistcat(oldvalue, 507 value, ':'); 508 } 509 510 if (newvalue != NULL) { 511 (void) sa_remove_property(prop); 512 prop = sa_create_property(name, 513 newvalue); 514 ret = sa_add_property(sec->security, 515 prop); 516 free(newvalue); 517 } 518 if (oldvalue != NULL) 519 sa_free_attr_string(oldvalue); 520 } 521 } else { 522 prop = sa_create_property(name, value); 523 ret = sa_add_property(sec->security, prop); 524 } 525 if (ret == SA_OK && !iszfs) { 526 ret = sa_commit_properties(sec->security, !persist); 527 } 528 } 529 return (ret); 530 } 531 532 /* 533 * check to see if group/share is persistent. 534 */ 535 static int 536 is_persistent(sa_group_t group) 537 { 538 char *type; 539 int persist = 1; 540 541 type = sa_get_group_attr(group, "type"); 542 if (type != NULL && strcmp(type, "persist") != 0) 543 persist = 0; 544 if (type != NULL) 545 sa_free_attr_string(type); 546 return (persist); 547 } 548 549 /* 550 * invalid_security(options) 551 * 552 * search option string for any invalid sec= type. 553 * return true (1) if any are not valid else false (0) 554 */ 555 static int 556 invalid_security(char *options) 557 { 558 char *copy, *base, *token, *value; 559 int ret = 0; 560 561 copy = strdup(options); 562 token = base = copy; 563 while (token != NULL && ret == 0) { 564 token = strtok(base, ","); 565 base = NULL; 566 if (token != NULL) { 567 value = strchr(token, '='); 568 if (value != NULL) 569 *value++ = '\0'; 570 if (strcmp(token, "sec") == 0) { 571 /* HAVE security flavors so check them */ 572 char *tok, *next; 573 for (next = NULL, tok = value; tok != NULL; 574 tok = next) { 575 next = strchr(tok, ':'); 576 if (next != NULL) 577 *next++ = '\0'; 578 ret = !nfs_validate_security_mode(tok); 579 if (ret) 580 break; 581 } 582 } 583 } 584 } 585 if (copy != NULL) 586 free(copy); 587 return (ret); 588 } 589 590 /* 591 * nfs_parse_legacy_options(group, options) 592 * 593 * Parse the old style options into internal format and store on the 594 * specified group. Group could be a share for full legacy support. 595 */ 596 597 static int 598 nfs_parse_legacy_options(sa_group_t group, char *options) 599 { 600 char *dup; 601 char *base; 602 char *token; 603 sa_optionset_t optionset; 604 struct securities *security_list = NULL; 605 sa_property_t prop; 606 int ret = SA_OK; 607 int iszfs = 0; 608 sa_group_t parent; 609 int persist = 0; 610 char *lasts; 611 612 /* do we have an existing optionset? */ 613 optionset = sa_get_optionset(group, "nfs"); 614 if (optionset == NULL) { 615 /* didn't find existing optionset so create one */ 616 optionset = sa_create_optionset(group, "nfs"); 617 } else { 618 /* 619 * Have an existing optionset . Ideally, we would need 620 * to compare options in order to detect errors. For 621 * now, we assume that the first optionset is the 622 * correct one and the others will be the same. An 623 * empty optionset is the same as no optionset so we 624 * don't want to exit in that case. Getting an empty 625 * optionset can occur with ZFS property checking. 626 */ 627 if (sa_get_property(optionset, NULL) != NULL) 628 return (ret); 629 } 630 631 if (strcmp(options, SHOPT_RW) == 0) { 632 /* 633 * there is a special case of only the option "rw" 634 * being the default option. We don't have to do 635 * anything. 636 */ 637 return (ret); 638 } 639 640 /* 641 * check if security types are present and validate them. If 642 * any are not legal, fail. 643 */ 644 645 if (invalid_security(options)) { 646 return (SA_INVALID_SECURITY); 647 } 648 649 /* 650 * in order to not attempt to change ZFS properties unless 651 * absolutely necessary, we never do it in the legacy parsing. 652 */ 653 if (sa_is_share(group)) { 654 char *zfs; 655 parent = sa_get_parent_group(group); 656 if (parent != NULL) { 657 zfs = sa_get_group_attr(parent, "zfs"); 658 if (zfs != NULL) { 659 sa_free_attr_string(zfs); 660 iszfs++; 661 } 662 } 663 } else { 664 iszfs = sa_group_is_zfs(group); 665 } 666 667 /* We need a copy of options for the next part. */ 668 dup = strdup(options); 669 if (dup == NULL) 670 return (SA_NO_MEMORY); 671 672 /* 673 * we need to step through each option in the string and then 674 * add either the option or the security option as needed. If 675 * this is not a persistent share, don't commit to the 676 * repository. If there is an error, we also want to abort the 677 * processing and report it. 678 */ 679 persist = is_persistent(group); 680 base = dup; 681 token = dup; 682 lasts = NULL; 683 while (token != NULL && ret == SA_OK) { 684 ret = SA_OK; 685 token = strtok_r(base, ",", &lasts); 686 base = NULL; 687 if (token != NULL) { 688 char *value; 689 /* 690 * if the option has a value, it will have an '=' to 691 * separate the name from the value. The following 692 * code will result in value != NULL and token 693 * pointing to just the name if there is a value. 694 */ 695 value = strchr(token, '='); 696 if (value != NULL) { 697 *value++ = '\0'; 698 } 699 if (strcmp(token, "sec") == 0 || 700 strcmp(token, "secure") == 0) { 701 /* 702 * Once in security parsing, we only 703 * do security. We do need to move 704 * between the security node and the 705 * toplevel. The security tag goes on 706 * the root while the following ones 707 * go on the security. 708 */ 709 if (security_list != NULL) { 710 /* 711 * have an old list so close it and 712 * start the new 713 */ 714 free_security_list(security_list); 715 } 716 if (strcmp(token, "secure") == 0) { 717 value = "dh"; 718 } else { 719 if (value == NULL) { 720 ret = SA_SYNTAX_ERR; 721 break; 722 } 723 } 724 security_list = make_security_list(group, 725 value, "nfs"); 726 } else { 727 /* 728 * Note that the "old" syntax allowed a 729 * default security model This must be 730 * accounted for and internally converted to 731 * "standard" security structure. 732 */ 733 if (nfs_is_security_opt(token)) { 734 if (security_list == NULL) { 735 /* 736 * need to have a 737 * security 738 * option. This will 739 * be "closed" when a 740 * defined "sec=" 741 * option is 742 * seen. This is 743 * technically an 744 * error but will be 745 * allowed with 746 * warning. 747 */ 748 security_list = 749 make_security_list(group, 750 "default", 751 "nfs"); 752 } 753 if (security_list != NULL) { 754 ret = add_security_prop( 755 security_list, token, 756 value, persist, iszfs); 757 } else { 758 ret = SA_NO_MEMORY; 759 } 760 } else { 761 /* regular options */ 762 if (value == NULL) { 763 if (strcmp(token, SHOPT_RW) == 764 0 || strcmp(token, 765 SHOPT_RO) == 0) { 766 value = "*"; 767 } else { 768 value = "global"; 769 if (strcmp(token, 770 SHOPT_LOG) != 0) { 771 value = "true"; 772 } 773 } 774 } 775 /* 776 * In all cases, create the 777 * property specified. If the 778 * value was NULL, the default 779 * value will have been 780 * substituted. 781 */ 782 prop = sa_create_property(token, value); 783 ret = sa_add_property(optionset, prop); 784 if (ret != SA_OK) 785 break; 786 787 if (!iszfs) { 788 ret = sa_commit_properties( 789 optionset, !persist); 790 } 791 } 792 } 793 } 794 } 795 if (security_list != NULL) 796 free_security_list(security_list); 797 798 free(dup); 799 return (ret); 800 } 801 802 /* 803 * is_a_number(number) 804 * 805 * is the string a number in one of the forms we want to use? 806 */ 807 808 static int 809 is_a_number(char *number) 810 { 811 int ret = 1; 812 int hex = 0; 813 814 if (strncmp(number, "0x", 2) == 0) { 815 number += 2; 816 hex = 1; 817 } else if (*number == '-') { 818 number++; /* skip the minus */ 819 } 820 while (ret == 1 && *number != '\0') { 821 if (hex) { 822 ret = isxdigit(*number++); 823 } else { 824 ret = isdigit(*number++); 825 } 826 } 827 return (ret); 828 } 829 830 /* 831 * Look for the specified tag in the configuration file. If it is found, 832 * enable logging and set the logging configuration information for exp. 833 */ 834 static void 835 configlog(struct exportdata *exp, char *tag) 836 { 837 nfsl_config_t *configlist = NULL, *configp; 838 int error = 0; 839 char globaltag[] = DEFAULTTAG; 840 841 /* 842 * Sends config errors to stderr 843 */ 844 nfsl_errs_to_syslog = B_FALSE; 845 846 /* 847 * get the list of configuration settings 848 */ 849 error = nfsl_getconfig_list(&configlist); 850 if (error) { 851 (void) fprintf(stderr, 852 dgettext(TEXT_DOMAIN, "Cannot get log configuration: %s\n"), 853 strerror(error)); 854 } 855 856 if (tag == NULL) 857 tag = globaltag; 858 if ((configp = nfsl_findconfig(configlist, tag, &error)) == NULL) { 859 nfsl_freeconfig_list(&configlist); 860 (void) fprintf(stderr, 861 dgettext(TEXT_DOMAIN, "No tags matching \"%s\"\n"), tag); 862 /* bad configuration */ 863 error = ENOENT; 864 goto err; 865 } 866 867 if ((exp->ex_tag = strdup(tag)) == NULL) { 868 error = ENOMEM; 869 goto out; 870 } 871 if ((exp->ex_log_buffer = strdup(configp->nc_bufferpath)) == NULL) { 872 error = ENOMEM; 873 goto out; 874 } 875 exp->ex_flags |= EX_LOG; 876 if (configp->nc_rpclogpath != NULL) 877 exp->ex_flags |= EX_LOG_ALLOPS; 878 out: 879 if (configlist != NULL) 880 nfsl_freeconfig_list(&configlist); 881 882 err: 883 if (error != 0) { 884 if (exp->ex_flags != NULL) 885 free(exp->ex_tag); 886 if (exp->ex_log_buffer != NULL) 887 free(exp->ex_log_buffer); 888 (void) fprintf(stderr, 889 dgettext(TEXT_DOMAIN, "Cannot set log configuration: %s\n"), 890 strerror(error)); 891 } 892 } 893 894 /* 895 * fill_export_from_optionset(export, optionset) 896 * 897 * In order to share, we need to set all the possible general options 898 * into the export structure. Share info will be filled in by the 899 * caller. Various property values get turned into structure specific 900 * values. 901 */ 902 903 static int 904 fill_export_from_optionset(struct exportdata *export, sa_optionset_t optionset) 905 { 906 sa_property_t option; 907 int ret = SA_OK; 908 909 for (option = sa_get_property(optionset, NULL); 910 option != NULL; option = sa_get_next_property(option)) { 911 char *name; 912 char *value; 913 uint32_t val; 914 915 /* 916 * since options may be set/reset multiple times, always do an 917 * explicit set or clear of the option. This allows defaults 918 * to be set and then the protocol specific to override. 919 */ 920 921 name = sa_get_property_attr(option, "type"); 922 value = sa_get_property_attr(option, "value"); 923 switch (findopt(name)) { 924 case OPT_ANON: 925 if (value != NULL && is_a_number(value)) { 926 val = strtoul(value, NULL, 0); 927 } else { 928 struct passwd *pw; 929 pw = getpwnam(value != NULL ? value : "nobody"); 930 if (pw != NULL) { 931 val = pw->pw_uid; 932 } else { 933 val = UID_NOBODY; 934 } 935 endpwent(); 936 } 937 export->ex_anon = val; 938 break; 939 case OPT_NOSUID: 940 if (value != NULL && (strcasecmp(value, "true") == 0 || 941 strcmp(value, "1") == 0)) 942 export->ex_flags |= EX_NOSUID; 943 else 944 export->ex_flags &= ~EX_NOSUID; 945 break; 946 case OPT_ACLOK: 947 if (value != NULL && (strcasecmp(value, "true") == 0 || 948 strcmp(value, "1") == 0)) 949 export->ex_flags |= EX_ACLOK; 950 else 951 export->ex_flags &= ~EX_ACLOK; 952 break; 953 case OPT_NOSUB: 954 if (value != NULL && (strcasecmp(value, "true") == 0 || 955 strcmp(value, "1") == 0)) 956 export->ex_flags |= EX_NOSUB; 957 else 958 export->ex_flags &= ~EX_NOSUB; 959 break; 960 case OPT_PUBLIC: 961 if (value != NULL && (strcasecmp(value, "true") == 0 || 962 strcmp(value, "1") == 0)) 963 export->ex_flags |= EX_PUBLIC; 964 else 965 export->ex_flags &= ~EX_PUBLIC; 966 break; 967 case OPT_INDEX: 968 if (value != NULL && (strcmp(value, "..") == 0 || 969 strchr(value, '/') != NULL)) { 970 /* this is an error */ 971 (void) printf(dgettext(TEXT_DOMAIN, 972 "NFS: index=\"%s\" not valid;" 973 "must be a filename.\n"), 974 value); 975 break; 976 } 977 if (value != NULL && *value != '\0' && 978 strcmp(value, ".") != 0) { 979 /* valid index file string */ 980 if (export->ex_index != NULL) { 981 /* left over from "default" */ 982 free(export->ex_index); 983 } 984 /* remember to free */ 985 export->ex_index = strdup(value); 986 if (export->ex_index == NULL) { 987 (void) printf(dgettext(TEXT_DOMAIN, 988 "NFS: out of memory setting " 989 "index property\n")); 990 break; 991 } 992 export->ex_flags |= EX_INDEX; 993 } 994 break; 995 case OPT_LOG: 996 if (value == NULL) 997 value = strdup("global"); 998 if (value != NULL) 999 configlog(export, 1000 strlen(value) ? value : "global"); 1001 break; 1002 case OPT_CHARSET_MAP: 1003 /* 1004 * Set EX_CHARMAP when there is at least one 1005 * charmap conversion property. This will get 1006 * checked by the nfs server when it needs to. 1007 */ 1008 export->ex_flags |= EX_CHARMAP; 1009 break; 1010 case OPT_NOACLFAB: 1011 if (value != NULL && (strcasecmp(value, "true") == 0 || 1012 strcmp(value, "1") == 0)) 1013 export->ex_flags |= EX_NOACLFAB; 1014 else 1015 export->ex_flags &= ~EX_NOACLFAB; 1016 break; 1017 default: 1018 /* have a syntactic error */ 1019 (void) printf(dgettext(TEXT_DOMAIN, 1020 "NFS: unrecognized option %s=%s\n"), 1021 name != NULL ? name : "", 1022 value != NULL ? value : ""); 1023 break; 1024 } 1025 if (name != NULL) 1026 sa_free_attr_string(name); 1027 if (value != NULL) 1028 sa_free_attr_string(value); 1029 } 1030 return (ret); 1031 } 1032 1033 /* 1034 * cleanup_export(export) 1035 * 1036 * Cleanup the allocated areas so we don't leak memory 1037 */ 1038 1039 static void 1040 cleanup_export(struct exportdata *export) 1041 { 1042 int i; 1043 1044 if (export->ex_index != NULL) 1045 free(export->ex_index); 1046 if (export->ex_secinfo != NULL) { 1047 for (i = 0; i < export->ex_seccnt; i++) 1048 if (export->ex_secinfo[i].s_rootnames != NULL) 1049 free(export->ex_secinfo[i].s_rootnames); 1050 free(export->ex_secinfo); 1051 } 1052 } 1053 1054 /* 1055 * Given a seconfig entry and a colon-separated 1056 * list of names, allocate an array big enough 1057 * to hold the root list, then convert each name to 1058 * a principal name according to the security 1059 * info and assign it to an array element. 1060 * Return the array and its size. 1061 */ 1062 static caddr_t * 1063 get_rootnames(seconfig_t *sec, char *list, int *count) 1064 { 1065 caddr_t *a; 1066 int c, i; 1067 char *host, *p; 1068 1069 /* 1070 * Count the number of strings in the list. 1071 * This is the number of colon separators + 1. 1072 */ 1073 c = 1; 1074 for (p = list; *p; p++) 1075 if (*p == ':') 1076 c++; 1077 *count = c; 1078 1079 a = (caddr_t *)malloc(c * sizeof (char *)); 1080 if (a == NULL) { 1081 (void) printf(dgettext(TEXT_DOMAIN, 1082 "get_rootnames: no memory\n")); 1083 } else { 1084 for (i = 0; i < c; i++) { 1085 host = strtok(list, ":"); 1086 if (!nfs_get_root_principal(sec, host, &a[i])) { 1087 free(a); 1088 a = NULL; 1089 break; 1090 } 1091 list = NULL; 1092 } 1093 } 1094 1095 return (a); 1096 } 1097 1098 /* 1099 * fill_security_from_secopts(sp, secopts) 1100 * 1101 * Fill the secinfo structure from the secopts optionset. 1102 */ 1103 1104 static int 1105 fill_security_from_secopts(struct secinfo *sp, sa_security_t secopts) 1106 { 1107 sa_property_t prop; 1108 char *type; 1109 int longform; 1110 int err = SC_NOERROR; 1111 uint32_t val; 1112 1113 type = sa_get_security_attr(secopts, "sectype"); 1114 if (type != NULL) { 1115 /* named security type needs secinfo to be filled in */ 1116 err = nfs_getseconfig_byname(type, &sp->s_secinfo); 1117 sa_free_attr_string(type); 1118 if (err != SC_NOERROR) 1119 return (err); 1120 } else { 1121 /* default case */ 1122 err = nfs_getseconfig_default(&sp->s_secinfo); 1123 if (err != SC_NOERROR) 1124 return (err); 1125 } 1126 1127 err = SA_OK; 1128 for (prop = sa_get_property(secopts, NULL); 1129 prop != NULL && err == SA_OK; 1130 prop = sa_get_next_property(prop)) { 1131 char *name; 1132 char *value; 1133 1134 name = sa_get_property_attr(prop, "type"); 1135 value = sa_get_property_attr(prop, "value"); 1136 1137 longform = value != NULL && strcmp(value, "*") != 0; 1138 1139 switch (findopt(name)) { 1140 case OPT_RO: 1141 sp->s_flags |= longform ? M_ROL : M_RO; 1142 break; 1143 case OPT_RW: 1144 sp->s_flags |= longform ? M_RWL : M_RW; 1145 break; 1146 case OPT_ROOT: 1147 sp->s_flags |= M_ROOT; 1148 /* 1149 * if we are using AUTH_UNIX, handle like other things 1150 * such as RO/RW 1151 */ 1152 if (sp->s_secinfo.sc_rpcnum == AUTH_UNIX) 1153 continue; 1154 /* not AUTH_UNIX */ 1155 if (value != NULL) { 1156 sp->s_rootnames = get_rootnames(&sp->s_secinfo, 1157 value, &sp->s_rootcnt); 1158 if (sp->s_rootnames == NULL) { 1159 err = SA_BAD_VALUE; 1160 (void) fprintf(stderr, 1161 dgettext(TEXT_DOMAIN, 1162 "Bad root list\n")); 1163 } 1164 } 1165 break; 1166 case OPT_NONE: 1167 sp->s_flags |= M_NONE; 1168 break; 1169 case OPT_WINDOW: 1170 if (value != NULL) { 1171 sp->s_window = atoi(value); 1172 /* just in case */ 1173 if (sp->s_window < 0) 1174 sp->s_window = DEF_WIN; 1175 } 1176 break; 1177 case OPT_ROOT_MAPPING: 1178 if (value != NULL && is_a_number(value)) { 1179 val = strtoul(value, NULL, 0); 1180 } else { 1181 struct passwd *pw; 1182 pw = getpwnam(value != NULL ? value : "nobody"); 1183 if (pw != NULL) { 1184 val = pw->pw_uid; 1185 } else { 1186 val = UID_NOBODY; 1187 } 1188 endpwent(); 1189 } 1190 sp->s_rootid = val; 1191 break; 1192 default: 1193 break; 1194 } 1195 if (name != NULL) 1196 sa_free_attr_string(name); 1197 if (value != NULL) 1198 sa_free_attr_string(value); 1199 } 1200 /* if rw/ro options not set, use default of RW */ 1201 if ((sp->s_flags & NFS_RWMODES) == 0) 1202 sp->s_flags |= M_RW; 1203 return (err); 1204 } 1205 1206 /* 1207 * This is for testing only 1208 * It displays the export structure that 1209 * goes into the kernel. 1210 */ 1211 static void 1212 printarg(char *path, struct exportdata *ep) 1213 { 1214 int i, j; 1215 struct secinfo *sp; 1216 1217 if (debug == 0) 1218 return; 1219 1220 (void) printf("%s:\n", path); 1221 (void) printf("\tex_version = %d\n", ep->ex_version); 1222 (void) printf("\tex_path = %s\n", ep->ex_path); 1223 (void) printf("\tex_pathlen = %ld\n", (ulong_t)ep->ex_pathlen); 1224 (void) printf("\tex_flags: (0x%02x) ", ep->ex_flags); 1225 if (ep->ex_flags & EX_NOSUID) 1226 (void) printf("NOSUID "); 1227 if (ep->ex_flags & EX_ACLOK) 1228 (void) printf("ACLOK "); 1229 if (ep->ex_flags & EX_PUBLIC) 1230 (void) printf("PUBLIC "); 1231 if (ep->ex_flags & EX_NOSUB) 1232 (void) printf("NOSUB "); 1233 if (ep->ex_flags & EX_LOG) 1234 (void) printf("LOG "); 1235 if (ep->ex_flags & EX_CHARMAP) 1236 (void) printf("CHARMAP "); 1237 if (ep->ex_flags & EX_LOG_ALLOPS) 1238 (void) printf("LOG_ALLOPS "); 1239 if (ep->ex_flags == 0) 1240 (void) printf("(none)"); 1241 (void) printf("\n"); 1242 if (ep->ex_flags & EX_LOG) { 1243 (void) printf("\tex_log_buffer = %s\n", 1244 (ep->ex_log_buffer ? ep->ex_log_buffer : "(NULL)")); 1245 (void) printf("\tex_tag = %s\n", 1246 (ep->ex_tag ? ep->ex_tag : "(NULL)")); 1247 } 1248 (void) printf("\tex_anon = %d\n", ep->ex_anon); 1249 (void) printf("\tex_seccnt = %d\n", ep->ex_seccnt); 1250 (void) printf("\n"); 1251 for (i = 0; i < ep->ex_seccnt; i++) { 1252 sp = &ep->ex_secinfo[i]; 1253 (void) printf("\t\ts_secinfo = %s\n", sp->s_secinfo.sc_name); 1254 (void) printf("\t\ts_flags: (0x%02x) ", sp->s_flags); 1255 if (sp->s_flags & M_ROOT) (void) printf("M_ROOT "); 1256 if (sp->s_flags & M_RO) (void) printf("M_RO "); 1257 if (sp->s_flags & M_ROL) (void) printf("M_ROL "); 1258 if (sp->s_flags & M_RW) (void) printf("M_RW "); 1259 if (sp->s_flags & M_RWL) (void) printf("M_RWL "); 1260 if (sp->s_flags & M_NONE) (void) printf("M_NONE "); 1261 if (sp->s_flags == 0) (void) printf("(none)"); 1262 (void) printf("\n"); 1263 (void) printf("\t\ts_window = %d\n", sp->s_window); 1264 (void) printf("\t\ts_rootid = %d\n", sp->s_rootid); 1265 (void) printf("\t\ts_rootcnt = %d ", sp->s_rootcnt); 1266 (void) fflush(stdout); 1267 for (j = 0; j < sp->s_rootcnt; j++) 1268 (void) printf("%s ", sp->s_rootnames[j] ? 1269 sp->s_rootnames[j] : "<null>"); 1270 (void) printf("\n\n"); 1271 } 1272 } 1273 1274 /* 1275 * count_security(opts) 1276 * 1277 * Count the number of security types (flavors). The optionset has 1278 * been populated with the security flavors as a holding mechanism. 1279 * We later use this number to allocate data structures. 1280 */ 1281 1282 static int 1283 count_security(sa_optionset_t opts) 1284 { 1285 int count = 0; 1286 sa_property_t prop; 1287 if (opts != NULL) { 1288 for (prop = sa_get_property(opts, NULL); prop != NULL; 1289 prop = sa_get_next_property(prop)) { 1290 count++; 1291 } 1292 } 1293 return (count); 1294 } 1295 1296 /* 1297 * nfs_sprint_option(rbuff, rbuffsize, incr, prop, sep) 1298 * 1299 * provides a mechanism to format NFS properties into legacy output 1300 * format. If the buffer would overflow, it is reallocated and grown 1301 * as appropriate. Special cases of converting internal form of values 1302 * to those used by "share" are done. this function does one property 1303 * at a time. 1304 */ 1305 1306 static int 1307 nfs_sprint_option(char **rbuff, size_t *rbuffsize, size_t incr, 1308 sa_property_t prop, int sep) 1309 { 1310 char *name; 1311 char *value; 1312 int curlen; 1313 char *buff = *rbuff; 1314 size_t buffsize = *rbuffsize; 1315 int printed = B_FALSE; 1316 1317 name = sa_get_property_attr(prop, "type"); 1318 value = sa_get_property_attr(prop, "value"); 1319 if (buff != NULL) 1320 curlen = strlen(buff); 1321 else 1322 curlen = 0; 1323 if (name != NULL) { 1324 int len; 1325 len = strlen(name) + sep; 1326 1327 /* 1328 * A future RFE would be to replace this with more 1329 * generic code and to possibly handle more types. 1330 */ 1331 switch (gettype(name)) { 1332 case OPT_TYPE_BOOLEAN: 1333 /* 1334 * For NFS, boolean value of FALSE means it 1335 * doesn't show up in the option list at all. 1336 */ 1337 if (value != NULL && strcasecmp(value, "false") == 0) 1338 goto skip; 1339 if (value != NULL) { 1340 sa_free_attr_string(value); 1341 value = NULL; 1342 } 1343 break; 1344 case OPT_TYPE_ACCLIST: 1345 if (value != NULL && strcmp(value, "*") == 0) { 1346 sa_free_attr_string(value); 1347 value = NULL; 1348 } else { 1349 if (value != NULL) 1350 len += 1 + strlen(value); 1351 } 1352 break; 1353 case OPT_TYPE_LOGTAG: 1354 if (value != NULL && strlen(value) == 0) { 1355 sa_free_attr_string(value); 1356 value = NULL; 1357 } else { 1358 if (value != NULL) 1359 len += 1 + strlen(value); 1360 } 1361 break; 1362 default: 1363 if (value != NULL) 1364 len += 1 + strlen(value); 1365 break; 1366 } 1367 while (buffsize <= (curlen + len)) { 1368 /* need more room */ 1369 buffsize += incr; 1370 buff = realloc(buff, buffsize); 1371 if (buff == NULL) { 1372 /* realloc failed so free everything */ 1373 if (*rbuff != NULL) 1374 free(*rbuff); 1375 } 1376 *rbuff = buff; 1377 *rbuffsize = buffsize; 1378 if (buff == NULL) 1379 goto skip; 1380 1381 } 1382 1383 if (buff == NULL) 1384 goto skip; 1385 1386 if (value == NULL) { 1387 (void) snprintf(buff + curlen, buffsize - curlen, 1388 "%s%s", sep ? "," : "", 1389 name, value != NULL ? value : ""); 1390 } else { 1391 (void) snprintf(buff + curlen, buffsize - curlen, 1392 "%s%s=%s", sep ? "," : "", 1393 name, value != NULL ? value : ""); 1394 } 1395 printed = B_TRUE; 1396 } 1397 skip: 1398 if (name != NULL) 1399 sa_free_attr_string(name); 1400 if (value != NULL) 1401 sa_free_attr_string(value); 1402 return (printed); 1403 } 1404 1405 /* 1406 * nfs_format_options(group, hier) 1407 * 1408 * format all the options on the group into an old-style option 1409 * string. If hier is non-zero, walk up the tree to get inherited 1410 * options. 1411 */ 1412 1413 static char * 1414 nfs_format_options(sa_group_t group, int hier) 1415 { 1416 sa_optionset_t options = NULL; 1417 sa_optionset_t secoptions = NULL; 1418 sa_property_t prop, secprop; 1419 sa_security_t security = NULL; 1420 char *buff; 1421 size_t buffsize; 1422 char *sectype = NULL; 1423 int sep = 0; 1424 1425 1426 buff = malloc(OPT_CHUNK); 1427 if (buff == NULL) { 1428 return (NULL); 1429 } 1430 1431 buff[0] = '\0'; 1432 buffsize = OPT_CHUNK; 1433 1434 /* 1435 * We may have a an optionset relative to this item. format 1436 * these if we find them and then add any security definitions. 1437 */ 1438 1439 options = sa_get_derived_optionset(group, "nfs", hier); 1440 1441 /* 1442 * do the default set first but skip any option that is also 1443 * in the protocol specific optionset. 1444 */ 1445 if (options != NULL) { 1446 for (prop = sa_get_property(options, NULL); 1447 prop != NULL; prop = sa_get_next_property(prop)) { 1448 /* 1449 * use this one since we skipped any 1450 * of these that were also in 1451 * optdefault 1452 */ 1453 if (nfs_sprint_option(&buff, &buffsize, OPT_CHUNK, 1454 prop, sep)) 1455 sep = 1; 1456 if (buff == NULL) { 1457 /* 1458 * buff could become NULL if there 1459 * isn't enough memory for 1460 * nfs_sprint_option to realloc() 1461 * as necessary. We can't really 1462 * do anything about it at this 1463 * point so we return NULL. The 1464 * caller should handle the 1465 * failure. 1466 */ 1467 if (options != NULL) 1468 sa_free_derived_optionset( 1469 options); 1470 return (buff); 1471 } 1472 } 1473 } 1474 secoptions = (sa_optionset_t)sa_get_all_security_types(group, 1475 "nfs", hier); 1476 if (secoptions != NULL) { 1477 for (secprop = sa_get_property(secoptions, NULL); 1478 secprop != NULL; 1479 secprop = sa_get_next_property(secprop)) { 1480 sectype = sa_get_property_attr(secprop, "type"); 1481 security = 1482 (sa_security_t)sa_get_derived_security( 1483 group, sectype, "nfs", hier); 1484 if (security != NULL) { 1485 if (sectype != NULL) { 1486 prop = sa_create_property( 1487 "sec", sectype); 1488 if (prop == NULL) 1489 goto err; 1490 if (nfs_sprint_option(&buff, 1491 &buffsize, OPT_CHUNK, prop, sep)) 1492 sep = 1; 1493 (void) sa_remove_property(prop); 1494 if (buff == NULL) 1495 goto err; 1496 } 1497 for (prop = sa_get_property(security, 1498 NULL); prop != NULL; 1499 prop = sa_get_next_property(prop)) { 1500 if (nfs_sprint_option(&buff, 1501 &buffsize, OPT_CHUNK, prop, sep)) 1502 sep = 1; 1503 if (buff == NULL) 1504 goto err; 1505 } 1506 sa_free_derived_optionset(security); 1507 } 1508 if (sectype != NULL) 1509 sa_free_attr_string(sectype); 1510 } 1511 sa_free_derived_optionset(secoptions); 1512 } 1513 1514 if (options != NULL) 1515 sa_free_derived_optionset(options); 1516 return (buff); 1517 1518 err: 1519 /* 1520 * If we couldn't allocate memory for option printing, we need 1521 * to break out of the nested loops, cleanup and return NULL. 1522 */ 1523 if (secoptions != NULL) 1524 sa_free_derived_optionset(secoptions); 1525 if (security != NULL) 1526 sa_free_derived_optionset(security); 1527 if (sectype != NULL) 1528 sa_free_attr_string(sectype); 1529 if (options != NULL) 1530 sa_free_derived_optionset(options); 1531 return (buff); 1532 } 1533 1534 /* 1535 * Append an entry to the nfslogtab file 1536 */ 1537 static int 1538 nfslogtab_add(dir, buffer, tag) 1539 char *dir, *buffer, *tag; 1540 { 1541 FILE *f; 1542 struct logtab_ent lep; 1543 int error = 0; 1544 1545 /* 1546 * Open the file for update and create it if necessary. 1547 * This may leave the I/O offset at the end of the file, 1548 * so rewind back to the beginning of the file. 1549 */ 1550 f = fopen(NFSLOGTAB, "a+"); 1551 if (f == NULL) { 1552 error = errno; 1553 goto out; 1554 } 1555 rewind(f); 1556 1557 if (lockf(fileno(f), F_LOCK, 0L) < 0) { 1558 (void) fprintf(stderr, dgettext(TEXT_DOMAIN, 1559 "share complete, however failed to lock %s " 1560 "for update: %s\n"), NFSLOGTAB, strerror(errno)); 1561 error = -1; 1562 goto out; 1563 } 1564 1565 if (logtab_deactivate_after_boot(f) == -1) { 1566 (void) fprintf(stderr, dgettext(TEXT_DOMAIN, 1567 "share complete, however could not deactivate " 1568 "entries in %s\n"), NFSLOGTAB); 1569 error = -1; 1570 goto out; 1571 } 1572 1573 /* 1574 * Remove entries matching buffer and sharepoint since we're 1575 * going to replace it with perhaps an entry with a new tag. 1576 */ 1577 if (logtab_rement(f, buffer, dir, NULL, -1)) { 1578 (void) fprintf(stderr, dgettext(TEXT_DOMAIN, 1579 "share complete, however could not remove matching " 1580 "entries in %s\n"), NFSLOGTAB); 1581 error = -1; 1582 goto out; 1583 } 1584 1585 /* 1586 * Deactivate all active entries matching this sharepoint 1587 */ 1588 if (logtab_deactivate(f, NULL, dir, NULL)) { 1589 (void) fprintf(stderr, dgettext(TEXT_DOMAIN, 1590 "share complete, however could not deactivate matching " 1591 "entries in %s\n"), NFSLOGTAB); 1592 error = -1; 1593 goto out; 1594 } 1595 1596 lep.le_buffer = buffer; 1597 lep.le_path = dir; 1598 lep.le_tag = tag; 1599 lep.le_state = LES_ACTIVE; 1600 1601 /* 1602 * Add new sharepoint / buffer location to nfslogtab 1603 */ 1604 if (logtab_putent(f, &lep) < 0) { 1605 (void) fprintf(stderr, dgettext(TEXT_DOMAIN, 1606 "share complete, however could not add %s to %s\n"), 1607 dir, NFSLOGTAB); 1608 error = -1; 1609 } 1610 1611 out: 1612 if (f != NULL) 1613 (void) fclose(f); 1614 return (error); 1615 } 1616 1617 /* 1618 * Deactivate an entry from the nfslogtab file 1619 */ 1620 static int 1621 nfslogtab_deactivate(path) 1622 char *path; 1623 { 1624 FILE *f; 1625 int error = 0; 1626 1627 f = fopen(NFSLOGTAB, "r+"); 1628 if (f == NULL) { 1629 error = errno; 1630 goto out; 1631 } 1632 if (lockf(fileno(f), F_LOCK, 0L) < 0) { 1633 error = errno; 1634 (void) fprintf(stderr, dgettext(TEXT_DOMAIN, 1635 "share complete, however could not lock %s for " 1636 "update: %s\n"), NFSLOGTAB, strerror(error)); 1637 goto out; 1638 } 1639 if (logtab_deactivate(f, NULL, path, NULL) == -1) { 1640 error = -1; 1641 (void) fprintf(stderr, 1642 dgettext(TEXT_DOMAIN, 1643 "share complete, however could not " 1644 "deactivate %s in %s\n"), path, NFSLOGTAB); 1645 goto out; 1646 } 1647 1648 out: if (f != NULL) 1649 (void) fclose(f); 1650 1651 return (error); 1652 } 1653 1654 /* 1655 * check_public(group, skipshare) 1656 * 1657 * Check the group for any shares that have the public property 1658 * enabled. We skip "skipshare" since that is the one we are 1659 * working with. This is a separate function to make handling 1660 * subgroups simpler. Returns true if there is a share with public. 1661 */ 1662 static int 1663 check_public(sa_group_t group, sa_share_t skipshare) 1664 { 1665 int exists = B_FALSE; 1666 sa_share_t share; 1667 sa_optionset_t opt; 1668 sa_property_t prop; 1669 char *shared; 1670 1671 for (share = sa_get_share(group, NULL); share != NULL; 1672 share = sa_get_next_share(share)) { 1673 if (share == skipshare) 1674 continue; 1675 1676 opt = sa_get_optionset(share, "nfs"); 1677 if (opt == NULL) 1678 continue; 1679 prop = sa_get_property(opt, "public"); 1680 if (prop == NULL) 1681 continue; 1682 shared = sa_get_share_attr(share, "shared"); 1683 if (shared != NULL) { 1684 exists = strcmp(shared, "true") == 0; 1685 sa_free_attr_string(shared); 1686 if (exists == B_TRUE) 1687 break; 1688 } 1689 } 1690 1691 return (exists); 1692 } 1693 1694 /* 1695 * public_exists(handle, share) 1696 * 1697 * check to see if public option is set on any other share than the 1698 * one specified. Need to check zfs sub-groups as well as the top 1699 * level groups. 1700 */ 1701 static int 1702 public_exists(sa_handle_t handle, sa_share_t skipshare) 1703 { 1704 sa_group_t group = NULL; 1705 1706 /* 1707 * If we don't have a handle, we can only do syntax check. We 1708 * can't check against other shares so we assume OK and will 1709 * catch the problem only when we actually try to apply it. 1710 */ 1711 if (handle == NULL) 1712 return (SA_OK); 1713 1714 if (skipshare != NULL) { 1715 group = sa_get_parent_group(skipshare); 1716 if (group == NULL) 1717 return (SA_NO_SUCH_GROUP); 1718 } 1719 1720 for (group = sa_get_group(handle, NULL); group != NULL; 1721 group = sa_get_next_group(group)) { 1722 /* Walk any ZFS subgroups as well as all standard groups */ 1723 if (sa_group_is_zfs(group)) { 1724 sa_group_t subgroup; 1725 for (subgroup = sa_get_sub_group(group); 1726 subgroup != NULL; 1727 subgroup = sa_get_next_group(subgroup)) { 1728 if (check_public(subgroup, skipshare)) 1729 return (B_TRUE); 1730 } 1731 } else { 1732 if (check_public(group, skipshare)) 1733 return (B_TRUE); 1734 } 1735 } 1736 return (B_FALSE); 1737 } 1738 1739 /* 1740 * sa_enable_share at the protocol level, enable_share must tell the 1741 * implementation that it is to enable the share. This entails 1742 * converting the path and options into the appropriate ioctl 1743 * calls. It is assumed that all error checking of paths, etc. were 1744 * done earlier. 1745 */ 1746 static int 1747 nfs_enable_share(sa_share_t share) 1748 { 1749 struct exportdata export; 1750 sa_optionset_t secoptlist; 1751 struct secinfo *sp; 1752 int num_secinfo; 1753 sa_optionset_t opt; 1754 sa_security_t sec; 1755 sa_property_t prop; 1756 char *path; 1757 int err = SA_OK; 1758 int i; 1759 int iszfs; 1760 sa_handle_t handle; 1761 1762 /* Don't drop core if the NFS module isn't loaded. */ 1763 (void) signal(SIGSYS, SIG_IGN); 1764 1765 /* get the path since it is important in several places */ 1766 path = sa_get_share_attr(share, "path"); 1767 if (path == NULL) 1768 return (SA_NO_SUCH_PATH); 1769 1770 iszfs = sa_path_is_zfs(path); 1771 /* 1772 * find the optionsets and security sets. There may not be 1773 * any or there could be one or two for each of optionset and 1774 * security may have multiple, one per security type per 1775 * protocol type. 1776 */ 1777 opt = sa_get_derived_optionset(share, "nfs", 1); 1778 secoptlist = (sa_optionset_t)sa_get_all_security_types(share, "nfs", 1); 1779 if (secoptlist != NULL) 1780 num_secinfo = MAX(1, count_security(secoptlist)); 1781 else 1782 num_secinfo = 1; 1783 1784 /* 1785 * walk through the options and fill in the structure 1786 * appropriately. 1787 */ 1788 1789 (void) memset(&export, '\0', sizeof (export)); 1790 1791 /* 1792 * do non-security options first since there is only one after 1793 * the derived group is constructed. 1794 */ 1795 export.ex_version = EX_CURRENT_VERSION; 1796 export.ex_anon = UID_NOBODY; /* this is our default value */ 1797 export.ex_index = NULL; 1798 export.ex_path = path; 1799 export.ex_pathlen = strlen(path) + 1; 1800 1801 if (opt != NULL) 1802 err = fill_export_from_optionset(&export, opt); 1803 1804 /* 1805 * check to see if "public" is set. If it is, then make sure 1806 * no other share has it set. If it is already used, fail. 1807 */ 1808 1809 handle = sa_find_group_handle((sa_group_t)share); 1810 if (export.ex_flags & EX_PUBLIC && public_exists(handle, share)) { 1811 (void) printf(dgettext(TEXT_DOMAIN, 1812 "NFS: Cannot share more than one file " 1813 "system with 'public' property\n")); 1814 err = SA_NOT_ALLOWED; 1815 goto out; 1816 } 1817 1818 sp = calloc(num_secinfo, sizeof (struct secinfo)); 1819 if (sp == NULL) { 1820 err = SA_NO_MEMORY; 1821 (void) printf(dgettext(TEXT_DOMAIN, 1822 "NFS: NFS: no memory for security\n")); 1823 goto out; 1824 } 1825 export.ex_secinfo = sp; 1826 /* get default secinfo */ 1827 export.ex_seccnt = num_secinfo; 1828 /* 1829 * since we must have one security option defined, we 1830 * init to the default and then override as we find 1831 * defined security options. This handles the case 1832 * where we have no defined options but we need to set 1833 * up one. 1834 */ 1835 sp[0].s_window = DEF_WIN; 1836 sp[0].s_rootnames = NULL; 1837 /* setup a default in case no properties defined */ 1838 if (nfs_getseconfig_default(&sp[0].s_secinfo)) { 1839 (void) printf(dgettext(TEXT_DOMAIN, 1840 "NFS: nfs_getseconfig_default: failed to " 1841 "get default security mode\n")); 1842 err = SA_CONFIG_ERR; 1843 } 1844 if (secoptlist != NULL) { 1845 for (i = 0, prop = sa_get_property(secoptlist, NULL); 1846 prop != NULL && i < num_secinfo; 1847 prop = sa_get_next_property(prop), i++) { 1848 char *sectype; 1849 sectype = sa_get_property_attr(prop, "type"); 1850 /* 1851 * if sectype is NULL, we probably 1852 * have a memory problem and can't get 1853 * the correct values. Rather than 1854 * exporting with incorrect security, 1855 * don't share it. 1856 */ 1857 if (sectype == NULL) { 1858 err = SA_NO_MEMORY; 1859 (void) printf(dgettext(TEXT_DOMAIN, 1860 "NFS: Cannot share %s: " 1861 "no memory\n"), path); 1862 goto out; 1863 } 1864 sec = (sa_security_t)sa_get_derived_security( 1865 share, sectype, "nfs", 1); 1866 sp[i].s_window = DEF_WIN; 1867 sp[i].s_rootcnt = 0; 1868 sp[i].s_rootnames = NULL; 1869 (void) fill_security_from_secopts(&sp[i], sec); 1870 if (sec != NULL) 1871 sa_free_derived_security(sec); 1872 if (sectype != NULL) 1873 sa_free_attr_string(sectype); 1874 } 1875 } 1876 /* 1877 * when we get here, we can do the exportfs system call and 1878 * initiate thinsg. We probably want to enable the nfs.server 1879 * service first if it isn't running within SMF. 1880 */ 1881 /* check nfs.server status and start if needed */ 1882 /* now add the share to the internal tables */ 1883 printarg(path, &export); 1884 /* 1885 * call the exportfs system call which is implemented 1886 * via the nfssys() call as the EXPORTFS subfunction. 1887 */ 1888 if (iszfs) { 1889 struct exportfs_args ea; 1890 share_t sh; 1891 char *str; 1892 priv_set_t *priv_effective; 1893 int privileged; 1894 1895 /* 1896 * If we aren't a privileged user 1897 * and NFS server service isn't running 1898 * then print out an error message 1899 * and return EPERM 1900 */ 1901 1902 priv_effective = priv_allocset(); 1903 (void) getppriv(PRIV_EFFECTIVE, priv_effective); 1904 1905 privileged = (priv_isfullset(priv_effective) == B_TRUE); 1906 priv_freeset(priv_effective); 1907 1908 if (!privileged && 1909 (str = smf_get_state(NFS_SERVER_SVC)) != NULL) { 1910 err = 0; 1911 if (strcmp(str, SCF_STATE_STRING_ONLINE) != 0) { 1912 (void) printf(dgettext(TEXT_DOMAIN, 1913 "NFS: Cannot share remote " 1914 "filesystem: %s\n"), path); 1915 (void) printf(dgettext(TEXT_DOMAIN, 1916 "NFS: Service needs to be enabled " 1917 "by a privileged user\n")); 1918 err = SA_SYSTEM_ERR; 1919 errno = EPERM; 1920 } 1921 free(str); 1922 } 1923 1924 if (err == 0) { 1925 ea.dname = path; 1926 ea.uex = &export; 1927 1928 (void) sa_sharetab_fill_zfs(share, &sh, "nfs"); 1929 err = sa_share_zfs(share, NULL, path, &sh, 1930 &ea, ZFS_SHARE_NFS); 1931 if (err != SA_OK) { 1932 errno = err; 1933 err = -1; 1934 } 1935 sa_emptyshare(&sh); 1936 } 1937 } else { 1938 err = exportfs(path, &export); 1939 } 1940 1941 if (err < 0) { 1942 err = SA_SYSTEM_ERR; 1943 switch (errno) { 1944 case EREMOTE: 1945 (void) printf(dgettext(TEXT_DOMAIN, 1946 "NFS: Cannot share filesystems " 1947 "in non-global zones: %s\n"), path); 1948 err = SA_NOT_SUPPORTED; 1949 break; 1950 case EPERM: 1951 if (getzoneid() != GLOBAL_ZONEID) { 1952 (void) printf(dgettext(TEXT_DOMAIN, 1953 "NFS: Cannot share file systems " 1954 "in non-global zones: %s\n"), path); 1955 err = SA_NOT_SUPPORTED; 1956 break; 1957 } 1958 err = SA_NO_PERMISSION; 1959 break; 1960 case EEXIST: 1961 err = SA_SHARE_EXISTS; 1962 break; 1963 default: 1964 break; 1965 } 1966 } else { 1967 /* update sharetab with an add/modify */ 1968 if (!iszfs) { 1969 (void) sa_update_sharetab(share, "nfs"); 1970 } 1971 } 1972 1973 if (err == SA_OK) { 1974 /* 1975 * enable services as needed. This should probably be 1976 * done elsewhere in order to minimize the calls to 1977 * check services. 1978 */ 1979 /* 1980 * check to see if logging and other services need to 1981 * be triggered, but only if there wasn't an 1982 * error. This is probably where sharetab should be 1983 * updated with the NFS specific entry. 1984 */ 1985 if (export.ex_flags & EX_LOG) { 1986 /* enable logging */ 1987 if (nfslogtab_add(path, export.ex_log_buffer, 1988 export.ex_tag) != 0) { 1989 (void) fprintf(stderr, dgettext(TEXT_DOMAIN, 1990 "Could not enable logging for %s\n"), 1991 path); 1992 } 1993 _check_services(service_list_logging); 1994 } else { 1995 /* 1996 * don't have logging so remove it from file. It might 1997 * not be thre, but that doesn't matter. 1998 */ 1999 (void) nfslogtab_deactivate(path); 2000 _check_services(service_list_default); 2001 } 2002 } 2003 2004 out: 2005 if (path != NULL) 2006 free(path); 2007 2008 cleanup_export(&export); 2009 if (opt != NULL) 2010 sa_free_derived_optionset(opt); 2011 if (secoptlist != NULL) 2012 (void) sa_destroy_optionset(secoptlist); 2013 return (err); 2014 } 2015 2016 /* 2017 * nfs_disable_share(share, path) 2018 * 2019 * Unshare the specified share. Note that "path" is the same path as 2020 * what is in the "share" object. It is passed in to avoid an 2021 * additional lookup. A missing "path" value makes this a no-op 2022 * function. 2023 */ 2024 static int 2025 nfs_disable_share(sa_share_t share, char *path) 2026 { 2027 int err; 2028 int ret = SA_OK; 2029 int iszfs; 2030 sa_group_t parent; 2031 sa_handle_t handle; 2032 2033 if (path == NULL) 2034 return (ret); 2035 2036 /* 2037 * If the share is in a ZFS group we need to handle it 2038 * differently. Just being on a ZFS file system isn't 2039 * enough since we may be in a legacy share case. 2040 */ 2041 parent = sa_get_parent_group(share); 2042 iszfs = sa_group_is_zfs(parent); 2043 if (iszfs) { 2044 struct exportfs_args ea; 2045 share_t sh = { 0 }; 2046 ea.dname = path; 2047 ea.uex = NULL; 2048 sh.sh_path = path; 2049 sh.sh_fstype = "nfs"; 2050 2051 err = sa_share_zfs(share, NULL, path, &sh, 2052 &ea, ZFS_UNSHARE_NFS); 2053 if (err != SA_OK) { 2054 errno = err; 2055 err = -1; 2056 } 2057 } else { 2058 err = exportfs(path, NULL); 2059 } 2060 if (err < 0) { 2061 /* 2062 * TBD: only an error in some 2063 * cases - need better analysis 2064 */ 2065 switch (errno) { 2066 case EPERM: 2067 case EACCES: 2068 ret = SA_NO_PERMISSION; 2069 if (getzoneid() != GLOBAL_ZONEID) { 2070 ret = SA_NOT_SUPPORTED; 2071 } 2072 break; 2073 case EINVAL: 2074 case ENOENT: 2075 ret = SA_NO_SUCH_PATH; 2076 break; 2077 default: 2078 ret = SA_SYSTEM_ERR; 2079 break; 2080 } 2081 } 2082 if (ret == SA_OK || ret == SA_NO_SUCH_PATH) { 2083 handle = sa_find_group_handle((sa_group_t)share); 2084 if (!iszfs) 2085 (void) sa_delete_sharetab(handle, path, "nfs"); 2086 /* just in case it was logged */ 2087 (void) nfslogtab_deactivate(path); 2088 } 2089 return (ret); 2090 } 2091 2092 /* 2093 * check_rorwnone(v1, v2, v3) 2094 * 2095 * check ro vs rw vs none values. Over time this may get beefed up. 2096 * for now it just does simple checks. v1 is never NULL but v2 or v3 2097 * could be. 2098 */ 2099 2100 static int 2101 check_rorwnone(char *v1, char *v2, char *v3) 2102 { 2103 int ret = SA_OK; 2104 if (v2 != NULL && strcmp(v1, v2) == 0) 2105 ret = SA_VALUE_CONFLICT; 2106 else if (v3 != NULL && strcmp(v1, v3) == 0) 2107 ret = SA_VALUE_CONFLICT; 2108 2109 return (ret); 2110 } 2111 2112 /* 2113 * nfs_validate_property(handle, property, parent) 2114 * 2115 * Check that the property has a legitimate value for its type. 2116 */ 2117 2118 static int 2119 nfs_validate_property(sa_handle_t handle, sa_property_t property, 2120 sa_optionset_t parent) 2121 { 2122 int ret = SA_OK; 2123 char *propname; 2124 char *other1; 2125 char *other2; 2126 int optindex; 2127 nfsl_config_t *configlist; 2128 sa_group_t parent_group; 2129 char *value; 2130 2131 propname = sa_get_property_attr(property, "type"); 2132 2133 if ((optindex = findopt(propname)) < 0) 2134 ret = SA_NO_SUCH_PROP; 2135 2136 /* need to validate value range here as well */ 2137 2138 if (ret == SA_OK) { 2139 parent_group = sa_get_parent_group((sa_share_t)parent); 2140 if (optdefs[optindex].share && parent_group != NULL && 2141 !sa_is_share(parent_group)) 2142 ret = SA_PROP_SHARE_ONLY; 2143 } 2144 if (ret == SA_OK) { 2145 if (optdefs[optindex].index == OPT_PUBLIC) { 2146 /* 2147 * Public is special in that only one instance can 2148 * be in the repository at the same time. 2149 */ 2150 if (public_exists(handle, parent_group)) { 2151 sa_free_attr_string(propname); 2152 return (SA_VALUE_CONFLICT); 2153 } 2154 } 2155 value = sa_get_property_attr(property, "value"); 2156 if (value != NULL) { 2157 /* first basic type checking */ 2158 switch (optdefs[optindex].type) { 2159 case OPT_TYPE_NUMBER: 2160 /* check that the value is all digits */ 2161 if (!is_a_number(value)) 2162 ret = SA_BAD_VALUE; 2163 break; 2164 case OPT_TYPE_BOOLEAN: 2165 if (strlen(value) == 0 || 2166 strcasecmp(value, "true") == 0 || 2167 strcmp(value, "1") == 0 || 2168 strcasecmp(value, "false") == 0 || 2169 strcmp(value, "0") == 0) { 2170 ret = SA_OK; 2171 } else { 2172 ret = SA_BAD_VALUE; 2173 } 2174 break; 2175 case OPT_TYPE_USER: 2176 if (!is_a_number(value)) { 2177 struct passwd *pw; 2178 /* 2179 * in this case it would have to be a 2180 * user name 2181 */ 2182 pw = getpwnam(value); 2183 if (pw == NULL) 2184 ret = SA_BAD_VALUE; 2185 endpwent(); 2186 } else { 2187 uint64_t intval; 2188 intval = strtoull(value, NULL, 0); 2189 if (intval > UID_MAX && intval != ~0) 2190 ret = SA_BAD_VALUE; 2191 } 2192 break; 2193 case OPT_TYPE_FILE: 2194 if (strcmp(value, "..") == 0 || 2195 strchr(value, '/') != NULL) { 2196 ret = SA_BAD_VALUE; 2197 } 2198 break; 2199 case OPT_TYPE_ACCLIST: { 2200 sa_property_t oprop1; 2201 sa_property_t oprop2; 2202 char *ovalue1 = NULL; 2203 char *ovalue2 = NULL; 2204 2205 if (parent == NULL) 2206 break; 2207 /* 2208 * access list handling. Should eventually 2209 * validate that all the values make sense. 2210 * Also, ro and rw may have cross value 2211 * conflicts. 2212 */ 2213 if (strcmp(propname, SHOPT_RO) == 0) { 2214 other1 = SHOPT_RW; 2215 other2 = SHOPT_NONE; 2216 } else if (strcmp(propname, SHOPT_RW) == 0) { 2217 other1 = SHOPT_RO; 2218 other2 = SHOPT_NONE; 2219 } else if (strcmp(propname, SHOPT_NONE) == 0) { 2220 other1 = SHOPT_RO; 2221 other2 = SHOPT_RW; 2222 } else { 2223 other1 = NULL; 2224 other2 = NULL; 2225 } 2226 if (other1 == NULL && other2 == NULL) 2227 break; 2228 2229 /* compare rw(ro) with ro(rw) */ 2230 2231 oprop1 = sa_get_property(parent, other1); 2232 oprop2 = sa_get_property(parent, other2); 2233 if (oprop1 == NULL && oprop2 == NULL) 2234 break; 2235 /* 2236 * Only potential confusion if other1 2237 * or other2 exists. Check the values 2238 * and run the check if there is a 2239 * value other than the one we are 2240 * explicitly looking at. 2241 */ 2242 ovalue1 = sa_get_property_attr(oprop1, "value"); 2243 ovalue2 = sa_get_property_attr(oprop2, "value"); 2244 if (ovalue1 != NULL || ovalue2 != NULL) 2245 ret = check_rorwnone(value, ovalue1, 2246 ovalue2); 2247 2248 if (ovalue1 != NULL) 2249 sa_free_attr_string(ovalue1); 2250 if (ovalue2 != NULL) 2251 sa_free_attr_string(ovalue2); 2252 break; 2253 } 2254 case OPT_TYPE_LOGTAG: 2255 if (nfsl_getconfig_list(&configlist) == 0) { 2256 int error; 2257 if (value == NULL || 2258 strlen(value) == 0) { 2259 if (value != NULL) 2260 sa_free_attr_string( 2261 value); 2262 value = strdup("global"); 2263 } 2264 if (value != NULL && 2265 nfsl_findconfig(configlist, value, 2266 &error) == NULL) { 2267 ret = SA_BAD_VALUE; 2268 } 2269 /* Must always free when done */ 2270 nfsl_freeconfig_list(&configlist); 2271 } else { 2272 ret = SA_CONFIG_ERR; 2273 } 2274 break; 2275 case OPT_TYPE_STRING: 2276 /* whatever is here should be ok */ 2277 break; 2278 case OPT_TYPE_SECURITY: 2279 /* 2280 * The "sec" property isn't used in the 2281 * non-legacy parts of sharemgr. We need to 2282 * reject it here. For legacy, it is pulled 2283 * out well before we get here. 2284 */ 2285 ret = SA_NO_SUCH_PROP; 2286 break; 2287 default: 2288 break; 2289 } 2290 2291 if (value != NULL) 2292 sa_free_attr_string(value); 2293 2294 if (ret == SA_OK && optdefs[optindex].check != NULL) { 2295 /* do the property specific check */ 2296 ret = optdefs[optindex].check(handle, property); 2297 } 2298 } 2299 } 2300 2301 if (propname != NULL) 2302 sa_free_attr_string(propname); 2303 return (ret); 2304 } 2305 2306 /* 2307 * Protocol management functions 2308 * 2309 * Properties defined in the default files are defined in 2310 * proto_option_defs for parsing and validation. If "other" and 2311 * "compare" are set, then the value for this property should be 2312 * compared against the property specified in "other" using the 2313 * "compare" check (either <= or >=) in order to ensure that the 2314 * values are in the correct range. E.g. setting server_versmin 2315 * higher than server_versmax should not be allowed. 2316 */ 2317 2318 struct proto_option_defs { 2319 char *tag; 2320 char *name; /* display name -- remove protocol identifier */ 2321 int index; 2322 int type; 2323 union { 2324 int intval; 2325 char *string; 2326 } defvalue; 2327 uint32_t svcs; 2328 int32_t minval; 2329 int32_t maxval; 2330 char *other; 2331 int compare; 2332 #define OPT_CMP_GE 0 2333 #define OPT_CMP_LE 1 2334 int (*check)(char *); 2335 } proto_options[] = { 2336 #define PROTO_OPT_NFSD_SERVERS 0 2337 {"nfsd_servers", 2338 "servers", PROTO_OPT_NFSD_SERVERS, OPT_TYPE_NUMBER, 16, SVC_NFSD, 2339 1, INT32_MAX}, 2340 #define PROTO_OPT_LOCKD_LISTEN_BACKLOG 1 2341 {"lockd_listen_backlog", 2342 "lockd_listen_backlog", PROTO_OPT_LOCKD_LISTEN_BACKLOG, 2343 OPT_TYPE_NUMBER, 32, SVC_LOCKD, 32, INT32_MAX}, 2344 #define PROTO_OPT_LOCKD_SERVERS 2 2345 {"lockd_servers", 2346 "lockd_servers", PROTO_OPT_LOCKD_SERVERS, OPT_TYPE_NUMBER, 20, 2347 SVC_LOCKD, 1, INT32_MAX}, 2348 #define PROTO_OPT_LOCKD_RETRANSMIT_TIMEOUT 3 2349 {"lockd_retransmit_timeout", 2350 "lockd_retransmit_timeout", PROTO_OPT_LOCKD_RETRANSMIT_TIMEOUT, 2351 OPT_TYPE_NUMBER, 5, SVC_LOCKD, 0, INT32_MAX}, 2352 #define PROTO_OPT_GRACE_PERIOD 4 2353 {"grace_period", 2354 "grace_period", PROTO_OPT_GRACE_PERIOD, OPT_TYPE_NUMBER, 90, 2355 SVC_LOCKD, 0, INT32_MAX}, 2356 #define PROTO_OPT_NFS_SERVER_VERSMIN 5 2357 {"nfs_server_versmin", 2358 "server_versmin", PROTO_OPT_NFS_SERVER_VERSMIN, OPT_TYPE_NUMBER, 2359 (int)NFS_VERSMIN_DEFAULT, SVC_NFSD|SVC_MOUNTD, NFS_VERSMIN, 2360 NFS_VERSMAX, "server_versmax", OPT_CMP_LE}, 2361 #define PROTO_OPT_NFS_SERVER_VERSMAX 6 2362 {"nfs_server_versmax", 2363 "server_versmax", PROTO_OPT_NFS_SERVER_VERSMAX, OPT_TYPE_NUMBER, 2364 (int)NFS_VERSMAX_DEFAULT, SVC_NFSD|SVC_MOUNTD, NFS_VERSMIN, 2365 NFS_VERSMAX, "server_versmin", OPT_CMP_GE}, 2366 #define PROTO_OPT_NFS_CLIENT_VERSMIN 7 2367 {"nfs_client_versmin", 2368 "client_versmin", PROTO_OPT_NFS_CLIENT_VERSMIN, OPT_TYPE_NUMBER, 2369 (int)NFS_VERSMIN_DEFAULT, SVC_CLIENT, NFS_VERSMIN, NFS_VERSMAX, 2370 "client_versmax", OPT_CMP_LE}, 2371 #define PROTO_OPT_NFS_CLIENT_VERSMAX 8 2372 {"nfs_client_versmax", 2373 "client_versmax", PROTO_OPT_NFS_CLIENT_VERSMAX, OPT_TYPE_NUMBER, 2374 (int)NFS_VERSMAX_DEFAULT, SVC_CLIENT, NFS_VERSMIN, NFS_VERSMAX, 2375 "client_versmin", OPT_CMP_GE}, 2376 #define PROTO_OPT_NFS_SERVER_DELEGATION 9 2377 {"nfs_server_delegation", 2378 "server_delegation", PROTO_OPT_NFS_SERVER_DELEGATION, 2379 OPT_TYPE_ONOFF, NFS_SERVER_DELEGATION_DEFAULT, SVC_NFSD, 0, 0}, 2380 #define PROTO_OPT_NFSMAPID_DOMAIN 10 2381 {"nfsmapid_domain", 2382 "nfsmapid_domain", PROTO_OPT_NFSMAPID_DOMAIN, OPT_TYPE_DOMAIN, 2383 NULL, SVC_NFSMAPID, 0, 0}, 2384 #define PROTO_OPT_NFSD_MAX_CONNECTIONS 11 2385 {"nfsd_max_connections", 2386 "max_connections", PROTO_OPT_NFSD_MAX_CONNECTIONS, 2387 OPT_TYPE_NUMBER, -1, SVC_NFSD, -1, INT32_MAX}, 2388 #define PROTO_OPT_NFSD_PROTOCOL 12 2389 {"nfsd_protocol", 2390 "protocol", PROTO_OPT_NFSD_PROTOCOL, OPT_TYPE_PROTOCOL, 0, 2391 SVC_NFSD, 0, 0}, 2392 #define PROTO_OPT_NFSD_LISTEN_BACKLOG 13 2393 {"nfsd_listen_backlog", 2394 "listen_backlog", PROTO_OPT_NFSD_LISTEN_BACKLOG, 2395 OPT_TYPE_NUMBER, 0, SVC_NFSD, 0, INT32_MAX}, 2396 #define PROTO_OPT_NFSD_DEVICE 14 2397 {"nfsd_device", 2398 "device", PROTO_OPT_NFSD_DEVICE, 2399 OPT_TYPE_STRING, NULL, SVC_NFSD, 0, 0}, 2400 #define PROTO_OPT_MOUNTD_LISTEN_BACKLOG 15 2401 {"mountd_listen_backlog", 2402 "mountd_listen_backlog", PROTO_OPT_MOUNTD_LISTEN_BACKLOG, 2403 OPT_TYPE_NUMBER, 64, SVC_NFSD|SVC_MOUNTD, 1, INT32_MAX}, 2404 #define PROTO_OPT_MOUNTD_MAX_THREADS 16 2405 {"mountd_max_threads", 2406 "mountd_max_threads", PROTO_OPT_MOUNTD_MAX_THREADS, 2407 OPT_TYPE_NUMBER, 16, SVC_NFSD|SVC_MOUNTD, 1, INT32_MAX}, 2408 {NULL} 2409 }; 2410 2411 /* 2412 * the protoset holds the defined options so we don't have to read 2413 * them multiple times 2414 */ 2415 static sa_protocol_properties_t protoset; 2416 2417 static int 2418 findprotoopt(char *name, int whichname) 2419 { 2420 int i; 2421 for (i = 0; proto_options[i].tag != NULL; i++) { 2422 if (whichname == 1) { 2423 if (strcasecmp(proto_options[i].name, name) == 0) 2424 return (i); 2425 } else { 2426 if (strcasecmp(proto_options[i].tag, name) == 0) 2427 return (i); 2428 } 2429 } 2430 return (-1); 2431 } 2432 2433 /* 2434 * fixcaselower(str) 2435 * 2436 * convert a string to lower case (inplace). 2437 */ 2438 2439 static void 2440 fixcaselower(char *str) 2441 { 2442 while (*str) { 2443 *str = tolower(*str); 2444 str++; 2445 } 2446 } 2447 2448 /* 2449 * skipwhitespace(str) 2450 * 2451 * Skip leading white space. It is assumed that it is called with a 2452 * valid pointer. 2453 */ 2454 2455 static char * 2456 skipwhitespace(char *str) 2457 { 2458 while (*str && isspace(*str)) 2459 str++; 2460 2461 return (str); 2462 } 2463 2464 /* 2465 * extractprop() 2466 * 2467 * Extract the property and value out of the line and create the 2468 * property in the optionset. 2469 */ 2470 static int 2471 extractprop(char *name, char *value) 2472 { 2473 sa_property_t prop; 2474 int index; 2475 int ret = SA_OK; 2476 /* 2477 * Remove any leading 2478 * white space. 2479 */ 2480 name = skipwhitespace(name); 2481 2482 index = findprotoopt(name, 1); 2483 if (index >= 0) { 2484 fixcaselower(name); 2485 prop = sa_create_property(proto_options[index].name, value); 2486 if (prop != NULL) 2487 ret = sa_add_protocol_property(protoset, prop); 2488 else 2489 ret = SA_NO_MEMORY; 2490 } 2491 return (ret); 2492 } 2493 2494 scf_type_t 2495 getscftype(int type) 2496 { 2497 scf_type_t ret; 2498 2499 switch (type) { 2500 case OPT_TYPE_NUMBER: 2501 ret = SCF_TYPE_INTEGER; 2502 break; 2503 case OPT_TYPE_BOOLEAN: 2504 ret = SCF_TYPE_BOOLEAN; 2505 break; 2506 default: 2507 ret = SCF_TYPE_ASTRING; 2508 } 2509 return (ret); 2510 } 2511 2512 char * 2513 getsvcname(uint32_t svcs) 2514 { 2515 char *service; 2516 switch (svcs) { 2517 case SVC_LOCKD: 2518 service = LOCKD; 2519 break; 2520 case SVC_STATD: 2521 service = STATD; 2522 break; 2523 case SVC_NFSD: 2524 service = NFSD; 2525 break; 2526 case SVC_CLIENT: 2527 service = NFS_CLIENT_SVC; 2528 break; 2529 case SVC_NFS4CBD: 2530 service = NFS4CBD; 2531 break; 2532 case SVC_NFSMAPID: 2533 service = NFSMAPID; 2534 break; 2535 case SVC_RQUOTAD: 2536 service = RQUOTAD; 2537 break; 2538 case SVC_NFSLOGD: 2539 service = NFSLOGD; 2540 break; 2541 case SVC_REPARSED: 2542 service = REPARSED; 2543 break; 2544 default: 2545 service = NFSD; 2546 } 2547 return (service); 2548 } 2549 2550 /* 2551 * initprotofromsmf() 2552 * 2553 * Read NFS SMF properties and add the defined values to the 2554 * protoset. Note that default values are known from the built in 2555 * table in case SMF doesn't have a definition. Not having 2556 * SMF properties is OK since we have builtin default 2557 * values. 2558 */ 2559 static int 2560 initprotofromsmf() 2561 { 2562 char name[PATH_MAX]; 2563 char value[PATH_MAX]; 2564 int ret = SA_OK, bufsz = 0, i; 2565 2566 protoset = sa_create_protocol_properties("nfs"); 2567 if (protoset != NULL) { 2568 for (i = 0; proto_options[i].tag != NULL; i++) { 2569 scf_type_t ptype; 2570 char *svc_name; 2571 2572 bzero(value, PATH_MAX); 2573 (void) strncpy(name, proto_options[i].name, PATH_MAX); 2574 /* Replace NULL with the correct instance */ 2575 ptype = getscftype(proto_options[i].type); 2576 svc_name = getsvcname(proto_options[i].svcs); 2577 bufsz = PATH_MAX; 2578 ret = nfs_smf_get_prop(name, value, 2579 (char *)DEFAULT_INSTANCE, ptype, 2580 svc_name, &bufsz); 2581 if (ret == SA_OK) { 2582 ret = extractprop(name, value); 2583 } 2584 } 2585 } else { 2586 ret = SA_NO_MEMORY; 2587 } 2588 2589 return (ret); 2590 } 2591 2592 /* 2593 * add_defaults() 2594 * 2595 * Add the default values for any property not defined 2596 * in NFS SMF repository. 2597 * Values are set according to their defined types. 2598 */ 2599 2600 static void 2601 add_defaults() 2602 { 2603 int i; 2604 char number[MAXDIGITS]; 2605 2606 for (i = 0; proto_options[i].tag != NULL; i++) { 2607 sa_property_t prop; 2608 prop = sa_get_protocol_property(protoset, 2609 proto_options[i].name); 2610 if (prop == NULL) { 2611 /* add the default value */ 2612 switch (proto_options[i].type) { 2613 case OPT_TYPE_NUMBER: 2614 (void) snprintf(number, sizeof (number), "%d", 2615 proto_options[i].defvalue.intval); 2616 prop = sa_create_property(proto_options[i].name, 2617 number); 2618 break; 2619 2620 case OPT_TYPE_BOOLEAN: 2621 prop = sa_create_property(proto_options[i].name, 2622 proto_options[i].defvalue.intval ? 2623 "true" : "false"); 2624 break; 2625 2626 case OPT_TYPE_ONOFF: 2627 prop = sa_create_property(proto_options[i].name, 2628 proto_options[i].defvalue.intval ? 2629 "on" : "off"); 2630 break; 2631 2632 default: 2633 /* treat as strings of zero length */ 2634 prop = sa_create_property(proto_options[i].name, 2635 ""); 2636 break; 2637 } 2638 if (prop != NULL) 2639 (void) sa_add_protocol_property(protoset, prop); 2640 } 2641 } 2642 } 2643 2644 static void 2645 free_protoprops() 2646 { 2647 if (protoset != NULL) { 2648 xmlFreeNode(protoset); 2649 protoset = NULL; 2650 } 2651 } 2652 2653 /* 2654 * nfs_init() 2655 * 2656 * Initialize the NFS plugin. 2657 */ 2658 2659 static int 2660 nfs_init() 2661 { 2662 int ret = SA_OK; 2663 2664 if (sa_plugin_ops.sa_init != nfs_init) { 2665 (void) printf(dgettext(TEXT_DOMAIN, 2666 "NFS plugin not properly initialized\n")); 2667 return (SA_CONFIG_ERR); 2668 } 2669 2670 ret = initprotofromsmf(); 2671 if (ret != SA_OK) { 2672 (void) printf(dgettext(TEXT_DOMAIN, 2673 "NFS plugin problem with SMF repository: %s\n"), 2674 sa_errorstr(ret)); 2675 ret = SA_OK; 2676 } 2677 add_defaults(); 2678 2679 return (ret); 2680 } 2681 2682 /* 2683 * nfs_fini() 2684 * 2685 * uninitialize the NFS plugin. Want to avoid memory leaks. 2686 */ 2687 2688 static void 2689 nfs_fini() 2690 { 2691 free_protoprops(); 2692 } 2693 2694 /* 2695 * nfs_get_proto_set() 2696 * 2697 * Return an optionset with all the protocol specific properties in 2698 * it. 2699 */ 2700 2701 static sa_protocol_properties_t 2702 nfs_get_proto_set() 2703 { 2704 return (protoset); 2705 } 2706 2707 /* 2708 * service_in_state(service, chkstate) 2709 * 2710 * Want to know if the specified service is in the desired state 2711 * (chkstate) or not. Return true (1) if it is and false (0) if it 2712 * isn't. 2713 */ 2714 static int 2715 service_in_state(char *service, const char *chkstate) 2716 { 2717 char *state; 2718 int ret = B_FALSE; 2719 2720 state = smf_get_state(service); 2721 if (state != NULL) { 2722 /* got the state so get the equality for the return value */ 2723 ret = strcmp(state, chkstate) == 0 ? B_TRUE : B_FALSE; 2724 free(state); 2725 } 2726 return (ret); 2727 } 2728 2729 /* 2730 * restart_service(svcs) 2731 * 2732 * Walk through the bit mask of services that need to be restarted in 2733 * order to use the new property values. Some properties affect 2734 * multiple daemons. Should only restart a service if it is currently 2735 * enabled (online). 2736 */ 2737 2738 static void 2739 restart_service(uint32_t svcs) 2740 { 2741 uint32_t mask; 2742 int ret; 2743 char *service; 2744 2745 for (mask = 1; svcs != 0; mask <<= 1) { 2746 switch (svcs & mask) { 2747 case SVC_LOCKD: 2748 service = LOCKD; 2749 break; 2750 case SVC_STATD: 2751 service = STATD; 2752 break; 2753 case SVC_NFSD: 2754 service = NFSD; 2755 break; 2756 case SVC_MOUNTD: 2757 service = MOUNTD; 2758 break; 2759 case SVC_NFS4CBD: 2760 service = NFS4CBD; 2761 break; 2762 case SVC_NFSMAPID: 2763 service = NFSMAPID; 2764 break; 2765 case SVC_RQUOTAD: 2766 service = RQUOTAD; 2767 break; 2768 case SVC_NFSLOGD: 2769 service = NFSLOGD; 2770 break; 2771 case SVC_REPARSED: 2772 service = REPARSED; 2773 break; 2774 case SVC_CLIENT: 2775 service = NFS_CLIENT_SVC; 2776 break; 2777 default: 2778 continue; 2779 } 2780 2781 /* 2782 * Only attempt to restart the service if it is 2783 * currently running. In the future, it may be 2784 * desirable to use smf_refresh_instance if the NFS 2785 * services ever implement the refresh method. 2786 */ 2787 if (service_in_state(service, SCF_STATE_STRING_ONLINE)) { 2788 ret = smf_restart_instance(service); 2789 /* 2790 * There are only a few SMF errors at this point, but 2791 * it is also possible that a bad value may have put 2792 * the service into maintenance if there wasn't an 2793 * SMF level error. 2794 */ 2795 if (ret != 0) { 2796 (void) fprintf(stderr, 2797 dgettext(TEXT_DOMAIN, 2798 "%s failed to restart: %s\n"), 2799 service, scf_strerror(scf_error())); 2800 } else { 2801 /* 2802 * Check whether it has gone to "maintenance" 2803 * mode or not. Maintenance implies something 2804 * went wrong. 2805 */ 2806 if (service_in_state(service, 2807 SCF_STATE_STRING_MAINT)) { 2808 (void) fprintf(stderr, 2809 dgettext(TEXT_DOMAIN, 2810 "%s failed to restart\n"), 2811 service); 2812 } 2813 } 2814 } 2815 svcs &= ~mask; 2816 } 2817 } 2818 2819 /* 2820 * nfs_minmax_check(name, value) 2821 * 2822 * Verify that the value for the property specified by index is valid 2823 * relative to the opposite value in the case of a min/max variable. 2824 * Currently, server_minvers/server_maxvers and 2825 * client_minvers/client_maxvers are the only ones to check. 2826 */ 2827 2828 static int 2829 nfs_minmax_check(int index, int value) 2830 { 2831 int val; 2832 char *pval; 2833 sa_property_t prop; 2834 sa_optionset_t opts; 2835 int ret = B_TRUE; 2836 2837 if (proto_options[index].other != NULL) { 2838 /* have a property to compare against */ 2839 opts = nfs_get_proto_set(); 2840 prop = sa_get_property(opts, proto_options[index].other); 2841 /* 2842 * If we don't find the property, assume default 2843 * values which will work since the max will be at the 2844 * max and the min at the min. 2845 */ 2846 if (prop != NULL) { 2847 pval = sa_get_property_attr(prop, "value"); 2848 if (pval != NULL) { 2849 val = strtoul(pval, NULL, 0); 2850 if (proto_options[index].compare == 2851 OPT_CMP_LE) { 2852 ret = value <= val ? B_TRUE : B_FALSE; 2853 } else if (proto_options[index].compare == 2854 OPT_CMP_GE) { 2855 ret = value >= val ? B_TRUE : B_FALSE; 2856 } 2857 sa_free_attr_string(pval); 2858 } 2859 } 2860 } 2861 return (ret); 2862 } 2863 2864 /* 2865 * nfs_validate_proto_prop(index, name, value) 2866 * 2867 * Verify that the property specified by name can take the new 2868 * value. This is a sanity check to prevent bad values getting into 2869 * the default files. All values need to be checked against what is 2870 * allowed by their defined type. If a type isn't explicitly defined 2871 * here, it is treated as a string. 2872 * 2873 * Note that OPT_TYPE_NUMBER will additionally check that the value is 2874 * within the range specified and potentially against another property 2875 * value as well as specified in the proto_options members other and 2876 * compare. 2877 */ 2878 2879 static int 2880 nfs_validate_proto_prop(int index, char *name, char *value) 2881 { 2882 int ret = SA_OK; 2883 char *cp; 2884 #ifdef lint 2885 name = name; 2886 #endif 2887 switch (proto_options[index].type) { 2888 case OPT_TYPE_NUMBER: 2889 if (!is_a_number(value)) 2890 ret = SA_BAD_VALUE; 2891 else { 2892 int val; 2893 val = strtoul(value, NULL, 0); 2894 if (val < proto_options[index].minval || 2895 val > proto_options[index].maxval) 2896 ret = SA_BAD_VALUE; 2897 /* 2898 * For server_versmin/server_versmax and 2899 * client_versmin/client_versmax, the value of the 2900 * min(max) should be checked to be correct relative 2901 * to the current max(min). 2902 */ 2903 if (!nfs_minmax_check(index, val)) { 2904 ret = SA_BAD_VALUE; 2905 } 2906 } 2907 break; 2908 2909 case OPT_TYPE_DOMAIN: 2910 /* 2911 * needs to be a qualified domain so will have at 2912 * least one period and other characters on either 2913 * side of it. A zero length string is also allowed 2914 * and is the way to turn off the override. 2915 */ 2916 if (strlen(value) == 0) 2917 break; 2918 cp = strchr(value, '.'); 2919 if (cp == NULL || cp == value || strchr(value, '@') != NULL) 2920 ret = SA_BAD_VALUE; 2921 break; 2922 2923 case OPT_TYPE_BOOLEAN: 2924 if (strlen(value) == 0 || 2925 strcasecmp(value, "true") == 0 || 2926 strcmp(value, "1") == 0 || 2927 strcasecmp(value, "false") == 0 || 2928 strcmp(value, "0") == 0) { 2929 ret = SA_OK; 2930 } else { 2931 ret = SA_BAD_VALUE; 2932 } 2933 break; 2934 2935 case OPT_TYPE_ONOFF: 2936 if (strcasecmp(value, "on") != 0 && 2937 strcasecmp(value, "off") != 0) { 2938 ret = SA_BAD_VALUE; 2939 } 2940 break; 2941 2942 case OPT_TYPE_PROTOCOL: 2943 if (strlen(value) != 0 && 2944 strcasecmp(value, "all") != 0 && 2945 strcasecmp(value, "tcp") != 0 && 2946 strcasecmp(value, "udp") != 0) 2947 ret = SA_BAD_VALUE; 2948 break; 2949 2950 default: 2951 /* treat as a string */ 2952 break; 2953 } 2954 return (ret); 2955 } 2956 2957 /* 2958 * nfs_set_proto_prop(prop) 2959 * 2960 * check that prop is valid. 2961 */ 2962 2963 static int 2964 nfs_set_proto_prop(sa_property_t prop) 2965 { 2966 int ret = SA_OK; 2967 char *name; 2968 char *value; 2969 2970 name = sa_get_property_attr(prop, "type"); 2971 value = sa_get_property_attr(prop, "value"); 2972 if (name != NULL && value != NULL) { 2973 scf_type_t sctype; 2974 char *svc_name; 2975 char *instance = NULL; 2976 int index = findprotoopt(name, 1); 2977 2978 ret = nfs_validate_proto_prop(index, name, value); 2979 if (ret == SA_OK) { 2980 sctype = getscftype(proto_options[index].type); 2981 svc_name = getsvcname(proto_options[index].svcs); 2982 if (sctype == SCF_TYPE_BOOLEAN) { 2983 if (value != NULL) 2984 sa_free_attr_string(value); 2985 if (string_to_boolean(value) == 0) 2986 value = strdup("0"); 2987 else 2988 value = strdup("1"); 2989 } 2990 ret = nfs_smf_set_prop(name, value, instance, sctype, 2991 svc_name); 2992 if (ret == SA_OK) { 2993 restart_service(proto_options[index].svcs); 2994 } else { 2995 (void) printf(dgettext(TEXT_DOMAIN, 2996 "Cannot restart NFS services : %s\n"), 2997 sa_errorstr(ret)); 2998 } 2999 } 3000 } 3001 if (name != NULL) 3002 sa_free_attr_string(name); 3003 if (value != NULL) 3004 sa_free_attr_string(value); 3005 return (ret); 3006 } 3007 3008 /* 3009 * nfs_get_status() 3010 * 3011 * What is the current status of the nfsd? We use the SMF state here. 3012 * Caller must free the returned value. 3013 */ 3014 3015 static char * 3016 nfs_get_status() 3017 { 3018 return (smf_get_state(NFSD)); 3019 } 3020 3021 /* 3022 * nfs_space_alias(alias) 3023 * 3024 * Lookup the space (security) name. If it is default, convert to the 3025 * real name. 3026 */ 3027 3028 static char * 3029 nfs_space_alias(char *space) 3030 { 3031 char *name = space; 3032 seconfig_t secconf; 3033 3034 /* 3035 * Only the space named "default" is special. If it is used, 3036 * the default needs to be looked up and the real name used. 3037 * This is normally "sys" but could be changed. We always 3038 * change defautl to the real name. 3039 */ 3040 if (strcmp(space, "default") == 0 && 3041 nfs_getseconfig_default(&secconf) == 0) { 3042 if (nfs_getseconfig_bynumber(secconf.sc_nfsnum, &secconf) == 0) 3043 name = secconf.sc_name; 3044 } 3045 return (strdup(name)); 3046 } 3047 3048 /* 3049 * nfs_features() 3050 * 3051 * Return a mask of the features required. 3052 */ 3053 3054 static uint64_t 3055 nfs_features() 3056 { 3057 return ((uint64_t)SA_FEATURE_DFSTAB | SA_FEATURE_SERVER); 3058 } 3059