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 http://www.opensolaris.org/os/licensing.
  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 <stdio.h>
  28 #include <errno.h>
  29 #include <libshare.h>
  30 #include "nfs.h"
  31
  32
  33 static int nfs_lock_fd = -1;
  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)
  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, strerror(err));
  50                 return (err);
  51         }
  52
  53         while ((err = flock(nfs_lock_fd, LOCK_EX)) != 0 && errno == EINTR)
  54                 ;
  55         if (err != 0) {
  56                 err = errno;
  57                 fprintf(stderr, "failed to lock %s: %s\n", name, strerror(err));
  58                 (void) close(nfs_lock_fd);
  59                 nfs_lock_fd = -1;
  60                 return (err);
  61         }
  62
  63         return (0);
  64 }
  65
  66 static void
  67 nfs_exports_unlock(const char *name)
  68 {
  69         verify(nfs_lock_fd > 0);
  70
  71         if (flock(nfs_lock_fd, LOCK_UN) != 0) {
  72                 fprintf(stderr, "failed to unlock %s: %s\n",
  73                     name, strerror(errno));
  74         }
  75
  76         (void) close(nfs_lock_fd);
  77         nfs_lock_fd = -1;
  78 }
  79
  80 struct tmpfile {
  81         /*
  82          * This only needs to be as wide as ZFS_EXPORTS_FILE and mktemp suffix,
  83          * 64 is more than enough.
  84          */
  85         char name[64];
  86         FILE *fp;
  87 };
  88
  89 static boolean_t
  90 nfs_init_tmpfile(const char *prefix, const char *mdir, struct tmpfile *tmpf)
  91 {
  92         struct stat sb;
  93
  94         if (mdir != NULL &&
  95             stat(mdir, &sb) < 0 &&
  96             mkdir(mdir, 0755) < 0) {
  97                 fprintf(stderr, "failed to create %s: %s\n",
  98                     mdir, strerror(errno));
  99                 return (B_FALSE);
 100         }
 101
 102         strcpy(tmpf->name, prefix);
 103         strcat(tmpf->name, ".XXXXXXXX");
 104
 105         int fd = mkostemp(tmpf->name, O_CLOEXEC);
 106         if (fd == -1) {
 107                 fprintf(stderr, "Unable to create temporary file: %s",
 108                     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                     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                     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, 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 static int
 153 nfs_process_exports(const char *exports, const char *mountpoint,
 154     boolean_t (*cbk)(void *userdata, char *line, boolean_t found_mountpoint),
 155     void *userdata)
 156 {
 157         int error = SA_OK;
 158         boolean_t cont = B_TRUE;
 159
 160         FILE *oldfp = fopen(exports, "re");
 161         if (oldfp != NULL) {
 162                 char *buf = NULL, *sep;
 163                 size_t buflen = 0, mplen = strlen(mountpoint);
 164
 165                 while (cont && getline(&buf, &buflen, oldfp) != -1) {
 166                         if (buf[0] == '\n' || buf[0] == '#')
 167                                 continue;
 168
 169                         cont = cbk(userdata, buf,
 170                             (sep = strpbrk(buf, "\t \n")) != NULL &&
 171                             sep - buf == mplen &&
 172                             strncmp(buf, mountpoint, mplen) == 0);
 173                 }
 174                 free(buf);
 175
 176                 if (ferror(oldfp) != 0)
 177                         error = ferror(oldfp);
 178
 179                 if (fclose(oldfp) != 0) {
 180                         fprintf(stderr, "Unable to close file %s: %s\n",
 181                             exports, strerror(errno));
 182                         error = error != SA_OK ? error : SA_SYSTEM_ERR;
 183                 }
 184         }
 185
 186         return (error);
 187 }
 188
 189 static boolean_t
 190 nfs_copy_entries_cb(void *userdata, char *line, boolean_t found_mountpoint)
 191 {
 192         FILE *newfp = userdata;
 193         if (!found_mountpoint)
 194                 fputs(line, newfp);
 195         return (B_TRUE);
 196 }
 197
 198 /*
 199  * Copy all entries from the exports file (if it exists) to newfp,
 200  * omitting any entries for the specified mountpoint.
 201  */
 202 static int
 203 nfs_copy_entries(FILE *newfp, const char *exports, const char *mountpoint)
 204 {
 205         fputs(FILE_HEADER, newfp);
 206
 207         int error = nfs_process_exports(
 208             exports, mountpoint, nfs_copy_entries_cb, newfp);
 209
 210         if (error == SA_OK && ferror(newfp) != 0)
 211                 error = ferror(newfp);
 212
 213         return (error);
 214 }
 215
 216 int
 217 nfs_toggle_share(const char *lockfile, const char *exports,
 218     const char *expdir, sa_share_impl_t impl_share,
 219     int(*cbk)(sa_share_impl_t impl_share, FILE *tmpfile))
 220 {
 221         int error;
 222         struct tmpfile tmpf;
 223
 224         if (!nfs_init_tmpfile(exports, expdir, &tmpf))
 225                 return (SA_SYSTEM_ERR);
 226
 227         error = nfs_exports_lock(lockfile);
 228         if (error != 0) {
 229                 nfs_abort_tmpfile(&tmpf);
 230                 return (error);
 231         }
 232
 233         error = nfs_copy_entries(tmpf.fp, exports, impl_share->sa_mountpoint);
 234         if (error != SA_OK)
 235                 goto fullerr;
 236
 237         error = cbk(impl_share, tmpf.fp);
 238         if (error != SA_OK)
 239                 goto fullerr;
 240
 241         error = nfs_fini_tmpfile(exports, &tmpf);
 242         nfs_exports_unlock(lockfile);
 243         return (error);
 244
 245 fullerr:
 246         nfs_abort_tmpfile(&tmpf);
 247         nfs_exports_unlock(lockfile);
 248         return (error);
 249 }
 250
 251 static boolean_t
 252 nfs_is_shared_cb(void *userdata, char *line, boolean_t found_mountpoint)
 253 {
 254         boolean_t *found = userdata;
 255         *found = found_mountpoint;
 256         return (!found_mountpoint);
 257 }
 258
 259 boolean_t
 260 nfs_is_shared_impl(const char *exports, sa_share_impl_t impl_share)
 261 {
 262         boolean_t found = B_FALSE;
 263         nfs_process_exports(exports, impl_share->sa_mountpoint,
 264             nfs_is_shared_cb, &found);
 265         return (found);
 266 }