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