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 */ 41 static int 42 nfs_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 68 static void 69 nfs_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 81 struct 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 90 static boolean_t 91 nfs_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 123 static void 124 nfs_abort_tmpfile(struct tmpfile *tmpf) 125 { 126 unlink(tmpf->name); 127 fclose(tmpf->fp); 128 } 129 130 static int 131 nfs_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 152 int 153 nfs_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 180 static int 181 nfs_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 227 static boolean_t 228 nfs_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 */ 240 static int 241 nfs_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 254 int 255 nfs_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 283 fullerr: 284 nfs_abort_tmpfile(&tmpf); 285 nfs_exports_unlock(lockfile, &nfs_lock_fd); 286 return (error); 287 } 288 289 void 290 nfs_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 300 static boolean_t 301 nfs_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 310 boolean_t 311 nfs_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