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) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Copyright (c) 2011 Gunnar Beutner
25 * Copyright (c) 2012 Cyril Plisko. All rights reserved.
26 * Copyright (c) 2019, 2020 by Delphix. All rights reserved.
27 */
28
29 #include <dirent.h>
30 #include <stdio.h>
31 #include <string.h>
32 #include <strings.h>
33 #include <errno.h>
34 #include <fcntl.h>
35 #include <sys/file.h>
36 #include <sys/stat.h>
37 #include <sys/types.h>
38 #include <sys/wait.h>
39 #include <unistd.h>
40 #include <libzfs.h>
41 #include <libshare.h>
42 #include "libshare_impl.h"
43 #include "nfs.h"
44
45 #define FILE_HEADER "# !!! DO NOT EDIT THIS FILE MANUALLY !!!\n\n"
46 #define ZFS_EXPORTS_DIR "/etc/exports.d"
47 #define ZFS_EXPORTS_FILE ZFS_EXPORTS_DIR"/zfs.exports"
48 #define ZFS_EXPORTS_LOCK ZFS_EXPORTS_FILE".lock"
49
50 static sa_fstype_t *nfs_fstype;
51
52 typedef int (*nfs_shareopt_callback_t)(const char *opt, const char *value,
53 void *cookie);
54
55 typedef int (*nfs_host_callback_t)(const char *sharepath, const char *filename,
56 const char *host, const char *security, const char *access, void *cookie);
57
58 static int nfs_lock_fd = -1;
59
60 /*
61 * The nfs_exports_[lock|unlock] is used to guard against conconcurrent
62 * updates to the exports file. Each protocol is responsible for
63 * providing the necessary locking to ensure consistency.
64 */
65 static int
nfs_exports_lock(void)66 nfs_exports_lock(void)
67 {
68 nfs_lock_fd = open(ZFS_EXPORTS_LOCK,
69 O_RDWR | O_CREAT, 0600);
70 if (nfs_lock_fd == -1) {
71 fprintf(stderr, "failed to lock %s: %s\n",
72 ZFS_EXPORTS_LOCK, strerror(errno));
73 return (errno);
74 }
75 if (flock(nfs_lock_fd, LOCK_EX) != 0) {
76 fprintf(stderr, "failed to lock %s: %s\n",
77 ZFS_EXPORTS_LOCK, strerror(errno));
78 return (errno);
79 }
80 return (0);
81 }
82
83 static void
nfs_exports_unlock(void)84 nfs_exports_unlock(void)
85 {
86 verify(nfs_lock_fd > 0);
87
88 if (flock(nfs_lock_fd, LOCK_UN) != 0) {
89 fprintf(stderr, "failed to unlock %s: %s\n",
90 ZFS_EXPORTS_LOCK, strerror(errno));
91 }
92 close(nfs_lock_fd);
93 nfs_lock_fd = -1;
94 }
95
96 /*
97 * Invokes the specified callback function for each Solaris share option
98 * listed in the specified string.
99 */
100 static int
foreach_nfs_shareopt(const char * shareopts,nfs_shareopt_callback_t callback,void * cookie)101 foreach_nfs_shareopt(const char *shareopts,
102 nfs_shareopt_callback_t callback, void *cookie)
103 {
104 char *shareopts_dup, *opt, *cur, *value;
105 int was_nul, error;
106
107 if (shareopts == NULL)
108 return (SA_OK);
109
110 if (strcmp(shareopts, "on") == 0)
111 shareopts = "rw,crossmnt";
112
113 shareopts_dup = strdup(shareopts);
114
115
116 if (shareopts_dup == NULL)
117 return (SA_NO_MEMORY);
118
119 opt = shareopts_dup;
120 was_nul = 0;
121
122 while (1) {
123 cur = opt;
124
125 while (*cur != ',' && *cur != '\0')
126 cur++;
127
128 if (*cur == '\0')
129 was_nul = 1;
130
131 *cur = '\0';
132
133 if (cur > opt) {
134 value = strchr(opt, '=');
135
136 if (value != NULL) {
137 *value = '\0';
138 value++;
139 }
140
141 error = callback(opt, value, cookie);
142
143 if (error != SA_OK) {
144 free(shareopts_dup);
145 return (error);
146 }
147 }
148
149 opt = cur + 1;
150
151 if (was_nul)
152 break;
153 }
154
155 free(shareopts_dup);
156
157 return (SA_OK);
158 }
159
160 typedef struct nfs_host_cookie_s {
161 nfs_host_callback_t callback;
162 const char *sharepath;
163 void *cookie;
164 const char *filename;
165 const char *security;
166 } nfs_host_cookie_t;
167
168 /*
169 * Helper function for foreach_nfs_host. This function checks whether the
170 * current share option is a host specification and invokes a callback
171 * function with information about the host.
172 */
173 static int
foreach_nfs_host_cb(const char * opt,const char * value,void * pcookie)174 foreach_nfs_host_cb(const char *opt, const char *value, void *pcookie)
175 {
176 int error;
177 const char *access;
178 char *host_dup, *host, *next;
179 nfs_host_cookie_t *udata = (nfs_host_cookie_t *)pcookie;
180
181 #ifdef DEBUG
182 fprintf(stderr, "foreach_nfs_host_cb: key=%s, value=%s\n", opt, value);
183 #endif
184
185 if (strcmp(opt, "sec") == 0)
186 udata->security = value;
187
188 if (strcmp(opt, "rw") == 0 || strcmp(opt, "ro") == 0) {
189 if (value == NULL)
190 value = "*";
191
192 access = opt;
193
194 host_dup = strdup(value);
195
196 if (host_dup == NULL)
197 return (SA_NO_MEMORY);
198
199 host = host_dup;
200
201 do {
202 next = strchr(host, ':');
203 if (next != NULL) {
204 *next = '\0';
205 next++;
206 }
207
208 error = udata->callback(udata->filename,
209 udata->sharepath, host, udata->security,
210 access, udata->cookie);
211
212 if (error != SA_OK) {
213 free(host_dup);
214
215 return (error);
216 }
217
218 host = next;
219 } while (host != NULL);
220
221 free(host_dup);
222 }
223
224 return (SA_OK);
225 }
226
227 /*
228 * Invokes a callback function for all NFS hosts that are set for a share.
229 */
230 static int
foreach_nfs_host(sa_share_impl_t impl_share,char * filename,nfs_host_callback_t callback,void * cookie)231 foreach_nfs_host(sa_share_impl_t impl_share, char *filename,
232 nfs_host_callback_t callback, void *cookie)
233 {
234 nfs_host_cookie_t udata;
235 char *shareopts;
236
237 udata.callback = callback;
238 udata.sharepath = impl_share->sa_mountpoint;
239 udata.cookie = cookie;
240 udata.filename = filename;
241 udata.security = "sys";
242
243 shareopts = FSINFO(impl_share, nfs_fstype)->shareopts;
244
245 return (foreach_nfs_shareopt(shareopts, foreach_nfs_host_cb,
246 &udata));
247 }
248
249 /*
250 * Converts a Solaris NFS host specification to its Linux equivalent.
251 */
252 static int
get_linux_hostspec(const char * solaris_hostspec,char ** plinux_hostspec)253 get_linux_hostspec(const char *solaris_hostspec, char **plinux_hostspec)
254 {
255 /*
256 * For now we just support CIDR masks (e.g. @192.168.0.0/16) and host
257 * wildcards (e.g. *.example.org).
258 */
259 if (solaris_hostspec[0] == '@') {
260 /*
261 * Solaris host specifier, e.g. @192.168.0.0/16; we just need
262 * to skip the @ in this case
263 */
264 *plinux_hostspec = strdup(solaris_hostspec + 1);
265 } else {
266 *plinux_hostspec = strdup(solaris_hostspec);
267 }
268
269 if (*plinux_hostspec == NULL) {
270 return (SA_NO_MEMORY);
271 }
272
273 return (SA_OK);
274 }
275
276 /*
277 * Adds a Linux share option to an array of NFS options.
278 */
279 static int
add_linux_shareopt(char ** plinux_opts,const char * key,const char * value)280 add_linux_shareopt(char **plinux_opts, const char *key, const char *value)
281 {
282 size_t len = 0;
283 char *new_linux_opts;
284
285 if (*plinux_opts != NULL)
286 len = strlen(*plinux_opts);
287
288 new_linux_opts = realloc(*plinux_opts, len + 1 + strlen(key) +
289 (value ? 1 + strlen(value) : 0) + 1);
290
291 if (new_linux_opts == NULL)
292 return (SA_NO_MEMORY);
293
294 new_linux_opts[len] = '\0';
295
296 if (len > 0)
297 strcat(new_linux_opts, ",");
298
299 strcat(new_linux_opts, key);
300
301 if (value != NULL) {
302 strcat(new_linux_opts, "=");
303 strcat(new_linux_opts, value);
304 }
305
306 *plinux_opts = new_linux_opts;
307
308 return (SA_OK);
309 }
310
311 /*
312 * Validates and converts a single Solaris share option to its Linux
313 * equivalent.
314 */
315 static int
get_linux_shareopts_cb(const char * key,const char * value,void * cookie)316 get_linux_shareopts_cb(const char *key, const char *value, void *cookie)
317 {
318 char **plinux_opts = (char **)cookie;
319
320 /* host-specific options, these are taken care of elsewhere */
321 if (strcmp(key, "ro") == 0 || strcmp(key, "rw") == 0 ||
322 strcmp(key, "sec") == 0)
323 return (SA_OK);
324
325 if (strcmp(key, "anon") == 0)
326 key = "anonuid";
327
328 if (strcmp(key, "root_mapping") == 0) {
329 (void) add_linux_shareopt(plinux_opts, "root_squash", NULL);
330 key = "anonuid";
331 }
332
333 if (strcmp(key, "nosub") == 0)
334 key = "subtree_check";
335
336 if (strcmp(key, "insecure") != 0 && strcmp(key, "secure") != 0 &&
337 strcmp(key, "async") != 0 && strcmp(key, "sync") != 0 &&
338 strcmp(key, "no_wdelay") != 0 && strcmp(key, "wdelay") != 0 &&
339 strcmp(key, "nohide") != 0 && strcmp(key, "hide") != 0 &&
340 strcmp(key, "crossmnt") != 0 &&
341 strcmp(key, "no_subtree_check") != 0 &&
342 strcmp(key, "subtree_check") != 0 &&
343 strcmp(key, "insecure_locks") != 0 &&
344 strcmp(key, "secure_locks") != 0 &&
345 strcmp(key, "no_auth_nlm") != 0 && strcmp(key, "auth_nlm") != 0 &&
346 strcmp(key, "no_acl") != 0 && strcmp(key, "mountpoint") != 0 &&
347 strcmp(key, "mp") != 0 && strcmp(key, "fsuid") != 0 &&
348 strcmp(key, "refer") != 0 && strcmp(key, "replicas") != 0 &&
349 strcmp(key, "root_squash") != 0 &&
350 strcmp(key, "no_root_squash") != 0 &&
351 strcmp(key, "all_squash") != 0 &&
352 strcmp(key, "no_all_squash") != 0 && strcmp(key, "fsid") != 0 &&
353 strcmp(key, "anonuid") != 0 && strcmp(key, "anongid") != 0) {
354 return (SA_SYNTAX_ERR);
355 }
356
357 (void) add_linux_shareopt(plinux_opts, key, value);
358
359 return (SA_OK);
360 }
361
362 /*
363 * Takes a string containing Solaris share options (e.g. "sync,no_acl") and
364 * converts them to a NULL-terminated array of Linux NFS options.
365 */
366 static int
get_linux_shareopts(const char * shareopts,char ** plinux_opts)367 get_linux_shareopts(const char *shareopts, char **plinux_opts)
368 {
369 int error;
370
371 assert(plinux_opts != NULL);
372
373 *plinux_opts = NULL;
374
375 /* no_subtree_check - Default as of nfs-utils v1.1.0 */
376 (void) add_linux_shareopt(plinux_opts, "no_subtree_check", NULL);
377
378 /* mountpoint - Restrict exports to ZFS mountpoints */
379 (void) add_linux_shareopt(plinux_opts, "mountpoint", NULL);
380
381 error = foreach_nfs_shareopt(shareopts, get_linux_shareopts_cb,
382 plinux_opts);
383
384 if (error != SA_OK) {
385 free(*plinux_opts);
386 *plinux_opts = NULL;
387 }
388
389 return (error);
390 }
391
392 static char *
nfs_init_tmpfile(void)393 nfs_init_tmpfile(void)
394 {
395 char *tmpfile = NULL;
396 struct stat sb;
397
398 if (stat(ZFS_EXPORTS_DIR, &sb) < 0 &&
399 mkdir(ZFS_EXPORTS_DIR, 0755) < 0) {
400 fprintf(stderr, "failed to create %s: %s\n",
401 ZFS_EXPORTS_DIR, strerror(errno));
402 return (NULL);
403 }
404
405 if (asprintf(&tmpfile, "%s%s", ZFS_EXPORTS_FILE, ".XXXXXXXX") == -1) {
406 fprintf(stderr, "Unable to allocate temporary file\n");
407 return (NULL);
408 }
409
410 int fd = mkstemp(tmpfile);
411 if (fd == -1) {
412 fprintf(stderr, "Unable to create temporary file: %s",
413 strerror(errno));
414 free(tmpfile);
415 return (NULL);
416 }
417 close(fd);
418 return (tmpfile);
419 }
420
421 static int
nfs_fini_tmpfile(char * tmpfile)422 nfs_fini_tmpfile(char *tmpfile)
423 {
424 if (rename(tmpfile, ZFS_EXPORTS_FILE) == -1) {
425 fprintf(stderr, "Unable to rename %s: %s\n", tmpfile,
426 strerror(errno));
427 unlink(tmpfile);
428 free(tmpfile);
429 return (SA_SYSTEM_ERR);
430 }
431 free(tmpfile);
432 return (SA_OK);
433 }
434
435 /*
436 * This function populates an entry into /etc/exports.d/zfs.exports.
437 * This file is consumed by the linux nfs server so that zfs shares are
438 * automatically exported upon boot or whenever the nfs server restarts.
439 */
440 static int
nfs_add_entry(const char * filename,const char * sharepath,const char * host,const char * security,const char * access_opts,void * pcookie)441 nfs_add_entry(const char *filename, const char *sharepath,
442 const char *host, const char *security, const char *access_opts,
443 void *pcookie)
444 {
445 int error;
446 char *linuxhost;
447 const char *linux_opts = (const char *)pcookie;
448
449 error = get_linux_hostspec(host, &linuxhost);
450 if (error != SA_OK)
451 return (error);
452
453 if (linux_opts == NULL)
454 linux_opts = "";
455
456 FILE *fp = fopen(filename, "a+");
457 if (fp == NULL) {
458 fprintf(stderr, "failed to open %s file: %s", filename,
459 strerror(errno));
460 free(linuxhost);
461 return (SA_SYSTEM_ERR);
462 }
463
464 if (fprintf(fp, "%s %s(sec=%s,%s,%s)\n", sharepath, linuxhost,
465 security, access_opts, linux_opts) < 0) {
466 fprintf(stderr, "failed to write to %s\n", filename);
467 free(linuxhost);
468 fclose(fp);
469 return (SA_SYSTEM_ERR);
470 }
471
472 free(linuxhost);
473 if (fclose(fp) != 0) {
474 fprintf(stderr, "Unable to close file %s: %s\n",
475 filename, strerror(errno));
476 return (SA_SYSTEM_ERR);
477 }
478 return (SA_OK);
479 }
480
481 /*
482 * This function copies all entries from the exports file to "filename",
483 * omitting any entries for the specified mountpoint.
484 */
485 static int
nfs_copy_entries(char * filename,const char * mountpoint)486 nfs_copy_entries(char *filename, const char *mountpoint)
487 {
488 char *buf = NULL;
489 size_t buflen = 0;
490 int error = SA_OK;
491
492 FILE *oldfp = fopen(ZFS_EXPORTS_FILE, "r");
493 FILE *newfp = fopen(filename, "w+");
494 if (newfp == NULL) {
495 fprintf(stderr, "failed to open %s file: %s", filename,
496 strerror(errno));
497 fclose(oldfp);
498 return (SA_SYSTEM_ERR);
499 }
500 fputs(FILE_HEADER, newfp);
501
502 /*
503 * The ZFS_EXPORTS_FILE may not exist yet. If that's the
504 * case then just write out the new file.
505 */
506 if (oldfp != NULL) {
507 while (getline(&buf, &buflen, oldfp) != -1) {
508 char *space = NULL;
509
510 if (buf[0] == '\n' || buf[0] == '#')
511 continue;
512
513 if ((space = strchr(buf, ' ')) != NULL) {
514 int mountpoint_len = strlen(mountpoint);
515
516 if (space - buf == mountpoint_len &&
517 strncmp(mountpoint, buf,
518 mountpoint_len) == 0) {
519 continue;
520 }
521 }
522 fputs(buf, newfp);
523 }
524
525 if (ferror(oldfp) != 0) {
526 error = ferror(oldfp);
527 }
528 if (fclose(oldfp) != 0) {
529 fprintf(stderr, "Unable to close file %s: %s\n",
530 filename, strerror(errno));
531 error = error != 0 ? error : SA_SYSTEM_ERR;
532 }
533 }
534
535 if (error == 0 && ferror(newfp) != 0) {
536 error = ferror(newfp);
537 }
538
539 free(buf);
540 if (fclose(newfp) != 0) {
541 fprintf(stderr, "Unable to close file %s: %s\n",
542 filename, strerror(errno));
543 error = error != 0 ? error : SA_SYSTEM_ERR;
544 }
545 return (error);
546 }
547
548 /*
549 * Enables NFS sharing for the specified share.
550 */
551 static int
nfs_enable_share(sa_share_impl_t impl_share)552 nfs_enable_share(sa_share_impl_t impl_share)
553 {
554 char *shareopts, *linux_opts;
555 char *filename = NULL;
556 int error;
557
558 if ((filename = nfs_init_tmpfile()) == NULL)
559 return (SA_SYSTEM_ERR);
560
561 error = nfs_exports_lock();
562 if (error != 0) {
563 unlink(filename);
564 free(filename);
565 return (error);
566 }
567
568 error = nfs_copy_entries(filename, impl_share->sa_mountpoint);
569 if (error != SA_OK) {
570 unlink(filename);
571 free(filename);
572 nfs_exports_unlock();
573 return (error);
574 }
575
576 shareopts = FSINFO(impl_share, nfs_fstype)->shareopts;
577 error = get_linux_shareopts(shareopts, &linux_opts);
578 if (error != SA_OK) {
579 unlink(filename);
580 free(filename);
581 nfs_exports_unlock();
582 return (error);
583 }
584
585 error = foreach_nfs_host(impl_share, filename, nfs_add_entry,
586 linux_opts);
587 free(linux_opts);
588 if (error == 0) {
589 error = nfs_fini_tmpfile(filename);
590 } else {
591 unlink(filename);
592 free(filename);
593 }
594 nfs_exports_unlock();
595 return (error);
596 }
597
598 /*
599 * Disables NFS sharing for the specified share.
600 */
601 static int
nfs_disable_share(sa_share_impl_t impl_share)602 nfs_disable_share(sa_share_impl_t impl_share)
603 {
604 int error;
605 char *filename = NULL;
606
607 if ((filename = nfs_init_tmpfile()) == NULL)
608 return (SA_SYSTEM_ERR);
609
610 error = nfs_exports_lock();
611 if (error != 0) {
612 unlink(filename);
613 free(filename);
614 return (error);
615 }
616
617 error = nfs_copy_entries(filename, impl_share->sa_mountpoint);
618 if (error != SA_OK) {
619 unlink(filename);
620 free(filename);
621 nfs_exports_unlock();
622 return (error);
623 }
624 error = nfs_fini_tmpfile(filename);
625 nfs_exports_unlock();
626 return (error);
627 }
628
629 static boolean_t
nfs_is_shared(sa_share_impl_t impl_share)630 nfs_is_shared(sa_share_impl_t impl_share)
631 {
632 size_t buflen = 0;
633 char *buf = NULL;
634
635 FILE *fp = fopen(ZFS_EXPORTS_FILE, "r");
636 if (fp == NULL) {
637 return (B_FALSE);
638 }
639 while ((getline(&buf, &buflen, fp)) != -1) {
640 char *space = NULL;
641
642 if ((space = strchr(buf, ' ')) != NULL) {
643 int mountpoint_len = strlen(impl_share->sa_mountpoint);
644
645 if (space - buf == mountpoint_len &&
646 strncmp(impl_share->sa_mountpoint, buf,
647 mountpoint_len) == 0) {
648 fclose(fp);
649 free(buf);
650 return (B_TRUE);
651 }
652 }
653 }
654 free(buf);
655 fclose(fp);
656 return (B_FALSE);
657 }
658
659 /*
660 * Checks whether the specified NFS share options are syntactically correct.
661 */
662 static int
nfs_validate_shareopts(const char * shareopts)663 nfs_validate_shareopts(const char *shareopts)
664 {
665 char *linux_opts;
666 int error;
667
668 error = get_linux_shareopts(shareopts, &linux_opts);
669
670 if (error != SA_OK)
671 return (error);
672
673 free(linux_opts);
674 return (SA_OK);
675 }
676
677 static int
nfs_update_shareopts(sa_share_impl_t impl_share,const char * shareopts)678 nfs_update_shareopts(sa_share_impl_t impl_share, const char *shareopts)
679 {
680 FSINFO(impl_share, nfs_fstype)->shareopts = (char *)shareopts;
681 return (SA_OK);
682 }
683
684 /*
685 * Clears a share's NFS options. Used by libshare to
686 * clean up shares that are about to be free()'d.
687 */
688 static void
nfs_clear_shareopts(sa_share_impl_t impl_share)689 nfs_clear_shareopts(sa_share_impl_t impl_share)
690 {
691 FSINFO(impl_share, nfs_fstype)->shareopts = NULL;
692 }
693
694 static int
nfs_commit_shares(void)695 nfs_commit_shares(void)
696 {
697 char *argv[] = {
698 "/usr/sbin/exportfs",
699 "-ra",
700 NULL
701 };
702
703 return (libzfs_run_process(argv[0], argv, 0));
704 }
705
706 static const sa_share_ops_t nfs_shareops = {
707 .enable_share = nfs_enable_share,
708 .disable_share = nfs_disable_share,
709 .is_shared = nfs_is_shared,
710
711 .validate_shareopts = nfs_validate_shareopts,
712 .update_shareopts = nfs_update_shareopts,
713 .clear_shareopts = nfs_clear_shareopts,
714 .commit_shares = nfs_commit_shares,
715 };
716
717 /*
718 * Initializes the NFS functionality of libshare.
719 */
720 void
libshare_nfs_init(void)721 libshare_nfs_init(void)
722 {
723 nfs_fstype = register_fstype("nfs", &nfs_shareops);
724 }
725