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 https://opensource.org/licenses/CDDL-1.0.
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#include <sys/types.h>
24#include <sys/stat.h>
25#include <sys/file.h>
26#include <fcntl.h>
27#include <ctype.h>
28#include <stdio.h>
29#include <errno.h>
30#include <libshare.h>
31#include <unistd.h>
32#include <libzutil.h>
33#include "nfs.h"
34
35
36/*
37 * nfs_exports_[lock|unlock] are used to guard against conconcurrent
38 * updates to the exports file. Each protocol is responsible for
39 * providing the necessary locking to ensure consistency.
40 */
41static int
42nfs_exports_lock(const char *name, int *nfs_lock_fd)
43{
44	int err;
45
46	*nfs_lock_fd = open(name, O_RDWR | O_CREAT | O_CLOEXEC, 0600);
47	if (*nfs_lock_fd == -1) {
48		err = errno;
49		fprintf(stderr, "failed to lock %s: %s\n", name,
50		    zfs_strerror(err));
51		return (err);
52	}
53
54	while ((err = flock(*nfs_lock_fd, LOCK_EX)) != 0 && errno == EINTR)
55		;
56	if (err != 0) {
57		err = errno;
58		fprintf(stderr, "failed to lock %s: %s\n", name,
59		    zfs_strerror(err));
60		(void) close(*nfs_lock_fd);
61		*nfs_lock_fd = -1;
62		return (err);
63	}
64
65	return (0);
66}
67
68static void
69nfs_exports_unlock(const char *name, int *nfs_lock_fd)
70{
71	verify(*nfs_lock_fd > 0);
72
73	if (flock(*nfs_lock_fd, LOCK_UN) != 0)
74		fprintf(stderr, "failed to unlock %s: %s\n",
75		    name, zfs_strerror(errno));
76
77	(void) close(*nfs_lock_fd);
78	*nfs_lock_fd = -1;
79}
80
81struct tmpfile {
82	/*
83	 * This only needs to be as wide as ZFS_EXPORTS_FILE and mktemp suffix,
84	 * 64 is more than enough.
85	 */
86	char name[64];
87	FILE *fp;
88};
89
90static boolean_t
91nfs_init_tmpfile(const char *prefix, const char *mdir, struct tmpfile *tmpf)
92{
93	if (mdir != NULL &&
94	    mkdir(mdir, 0755) < 0 &&
95	    errno != EEXIST) {
96		fprintf(stderr, "failed to create %s: %s\n",
97		// cppcheck-suppress uninitvar
98		    mdir, zfs_strerror(errno));
99		return (B_FALSE);
100	}
101
102	strlcpy(tmpf->name, prefix, sizeof (tmpf->name));
103	strlcat(tmpf->name, ".XXXXXXXX", sizeof (tmpf->name));
104
105	int fd = mkostemp(tmpf->name, O_CLOEXEC);
106	if (fd == -1) {
107		fprintf(stderr, "Unable to create temporary file: %s",
108		    zfs_strerror(errno));
109		return (B_FALSE);
110	}
111
112	tmpf->fp = fdopen(fd, "w+");
113	if (tmpf->fp == NULL) {
114		fprintf(stderr, "Unable to reopen temporary file: %s",
115		    zfs_strerror(errno));
116		close(fd);
117		return (B_FALSE);
118	}
119
120	return (B_TRUE);
121}
122
123static void
124nfs_abort_tmpfile(struct tmpfile *tmpf)
125{
126	unlink(tmpf->name);
127	fclose(tmpf->fp);
128}
129
130static int
131nfs_fini_tmpfile(const char *exports, struct tmpfile *tmpf)
132{
133	if (fflush(tmpf->fp) != 0) {
134		fprintf(stderr, "Failed to write to temporary file: %s\n",
135		    zfs_strerror(errno));
136		nfs_abort_tmpfile(tmpf);
137		return (SA_SYSTEM_ERR);
138	}
139
140	if (rename(tmpf->name, exports) == -1) {
141		fprintf(stderr, "Unable to rename %s -> %s: %s\n",
142		    tmpf->name, exports, zfs_strerror(errno));
143		nfs_abort_tmpfile(tmpf);
144		return (SA_SYSTEM_ERR);
145	}
146
147	(void) fchmod(fileno(tmpf->fp), 0644);
148	fclose(tmpf->fp);
149	return (SA_OK);
150}
151
152int
153nfs_escape_mountpoint(const char *mp, char **out, boolean_t *need_free)
154{
155	if (strpbrk(mp, "\t\n\v\f\r \\") == NULL) {
156		*out = (char *)mp;
157		*need_free = B_FALSE;
158		return (SA_OK);
159	} else {
160		size_t len = strlen(mp);
161		*out = malloc(len * 4 + 1);
162		if (!*out)
163			return (SA_NO_MEMORY);
164		*need_free = B_TRUE;
165
166		char *oc = *out;
167		for (const char *c = mp; c < mp + len; ++c)
168			if (memchr("\t\n\v\f\r \\", *c,
169			    strlen("\t\n\v\f\r \\"))) {
170				sprintf(oc, "\\%03hho", *c);
171				oc += 4;
172			} else
173				*oc++ = *c;
174		*oc = '\0';
175	}
176
177	return (SA_OK);
178}
179
180static int
181nfs_process_exports(const char *exports, const char *mountpoint,
182    boolean_t (*cbk)(void *userdata, char *line, boolean_t found_mountpoint),
183    void *userdata)
184{
185	int error = SA_OK;
186	boolean_t cont = B_TRUE;
187
188	FILE *oldfp = fopen(exports, "re");
189	if (oldfp != NULL) {
190		boolean_t need_mp_free;
191		char *mp;
192		if ((error = nfs_escape_mountpoint(mountpoint,
193		    &mp, &need_mp_free)) != SA_OK) {
194			(void) fclose(oldfp);
195			return (error);
196		}
197
198		char *buf = NULL, *sep;
199		size_t buflen = 0, mplen = strlen(mp);
200
201		while (cont && getline(&buf, &buflen, oldfp) != -1) {
202			if (buf[0] == '\n' || buf[0] == '#')
203				continue;
204
205			cont = cbk(userdata, buf,
206			    (sep = strpbrk(buf, "\t \n")) != NULL &&
207			    sep - buf == mplen &&
208			    strncmp(buf, mp, mplen) == 0);
209		}
210		free(buf);
211		if (need_mp_free)
212			free(mp);
213
214		if (ferror(oldfp) != 0)
215			error = ferror(oldfp);
216
217		if (fclose(oldfp) != 0) {
218			fprintf(stderr, "Unable to close file %s: %s\n",
219			    exports, zfs_strerror(errno));
220			error = error != SA_OK ? error : SA_SYSTEM_ERR;
221		}
222	}
223
224	return (error);
225}
226
227static boolean_t
228nfs_copy_entries_cb(void *userdata, char *line, boolean_t found_mountpoint)
229{
230	FILE *newfp = userdata;
231	if (!found_mountpoint)
232		fputs(line, newfp);
233	return (B_TRUE);
234}
235
236/*
237 * Copy all entries from the exports file (if it exists) to newfp,
238 * omitting any entries for the specified mountpoint.
239 */
240static int
241nfs_copy_entries(FILE *newfp, const char *exports, const char *mountpoint)
242{
243	fputs(FILE_HEADER, newfp);
244
245	int error = nfs_process_exports(
246	    exports, mountpoint, nfs_copy_entries_cb, newfp);
247
248	if (error == SA_OK && ferror(newfp) != 0)
249		error = ferror(newfp);
250
251	return (error);
252}
253
254int
255nfs_toggle_share(const char *lockfile, const char *exports,
256    const char *expdir, sa_share_impl_t impl_share,
257    int(*cbk)(sa_share_impl_t impl_share, FILE *tmpfile))
258{
259	int error, nfs_lock_fd = -1;
260	struct tmpfile tmpf;
261
262	if (!nfs_init_tmpfile(exports, expdir, &tmpf))
263		return (SA_SYSTEM_ERR);
264
265	error = nfs_exports_lock(lockfile, &nfs_lock_fd);
266	if (error != 0) {
267		nfs_abort_tmpfile(&tmpf);
268		return (error);
269	}
270
271	error = nfs_copy_entries(tmpf.fp, exports, impl_share->sa_mountpoint);
272	if (error != SA_OK)
273		goto fullerr;
274
275	error = cbk(impl_share, tmpf.fp);
276	if (error != SA_OK)
277		goto fullerr;
278
279	error = nfs_fini_tmpfile(exports, &tmpf);
280	nfs_exports_unlock(lockfile, &nfs_lock_fd);
281	return (error);
282
283fullerr:
284	nfs_abort_tmpfile(&tmpf);
285	nfs_exports_unlock(lockfile, &nfs_lock_fd);
286	return (error);
287}
288
289void
290nfs_reset_shares(const char *lockfile, const char *exports)
291{
292	int nfs_lock_fd = -1;
293
294	if (nfs_exports_lock(lockfile, &nfs_lock_fd) == 0) {
295		(void) ! truncate(exports, 0);
296		nfs_exports_unlock(lockfile, &nfs_lock_fd);
297	}
298}
299
300static boolean_t
301nfs_is_shared_cb(void *userdata, char *line, boolean_t found_mountpoint)
302{
303	(void) line;
304
305	boolean_t *found = userdata;
306	*found = found_mountpoint;
307	return (!found_mountpoint);
308}
309
310boolean_t
311nfs_is_shared_impl(const char *exports, sa_share_impl_t impl_share)
312{
313	boolean_t found = B_FALSE;
314	nfs_process_exports(exports, impl_share->sa_mountpoint,
315	    nfs_is_shared_cb, &found);
316	return (found);
317}
318