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 <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 }