lib/libshare/nfs.c

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