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