usr.sbin/autofs/automount.c

   1 /*-
   2  * Copyright (c) 2014 The FreeBSD Foundation
   3  * All rights reserved.
   4  *
   5  * This software was developed by Edward Tomasz Napierala under sponsorship
   6  * from the FreeBSD Foundation.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  */
  30
  31 #include <sys/cdefs.h>
  32 __FBSDID("$FreeBSD$");
  33
  34 #include <sys/types.h>
  35 #include <sys/time.h>
  36 #include <sys/ioctl.h>
  37 #include <sys/param.h>
  38 #include <sys/linker.h>
  39 #include <sys/mount.h>
  40 #include <sys/socket.h>
  41 #include <sys/stat.h>
  42 #include <sys/wait.h>
  43 #include <sys/utsname.h>
  44 #include <assert.h>
  45 #include <ctype.h>
  46 #include <errno.h>
  47 #include <fcntl.h>
  48 #include <libgen.h>
  49 #include <netdb.h>
  50 #include <signal.h>
  51 #include <stdbool.h>
  52 #include <stdint.h>
  53 #include <stdio.h>
  54 #include <stdlib.h>
  55 #include <string.h>
  56 #include <unistd.h>
  57
  58 #include <libutil.h>
  59
  60 #include "common.h"
  61 #include "mntopts.h"
  62
  63 static int
  64 unmount_by_statfs(const struct statfs *sb, bool force)
  65 {
  66         char *fsid_str;
  67         int error, ret, flags;
  68
  69         ret = asprintf(&fsid_str, "FSID:%d:%d",
  70             sb->f_fsid.val[0], sb->f_fsid.val[1]);
  71         if (ret < 0)
  72                 log_err(1, "asprintf");
  73
  74         log_debugx("unmounting %s using %s", sb->f_mntonname, fsid_str);
  75
  76         flags = MNT_BYFSID;
  77         if (force)
  78                 flags |= MNT_FORCE;
  79         error = unmount(fsid_str, flags);
  80         free(fsid_str);
  81         if (error != 0)
  82                 log_warn("cannot unmount %s", sb->f_mntonname);
  83
  84         return (error);
  85 }
  86
  87 static const struct statfs *
  88 find_statfs(const struct statfs *mntbuf, int nitems, const char *mountpoint)
  89 {
  90         int i;
  91
  92         for (i = 0; i < nitems; i++) {
  93                 if (strcmp(mntbuf[i].f_mntonname, mountpoint) == 0)
  94                         return (mntbuf + i);
  95         }
  96
  97         return (NULL);
  98 }
  99
 100 static void
 101 mount_autofs(const char *from, const char *fspath, const char *options,
 102     const char *prefix)
 103 {
 104         struct iovec *iov = NULL;
 105         char errmsg[255];
 106         int error, iovlen = 0;
 107
 108         create_directory(fspath);
 109
 110         log_debugx("mounting %s on %s, prefix \"%s\", options \"%s\"",
 111             from, fspath, prefix, options);
 112         memset(errmsg, 0, sizeof(errmsg));
 113
 114         build_iovec(&iov, &iovlen, "fstype",
 115             __DECONST(void *, "autofs"), (size_t)-1);
 116         build_iovec(&iov, &iovlen, "fspath",
 117             __DECONST(void *, fspath), (size_t)-1);
 118         build_iovec(&iov, &iovlen, "from",
 119             __DECONST(void *, from), (size_t)-1);
 120         build_iovec(&iov, &iovlen, "errmsg",
 121             errmsg, sizeof(errmsg));
 122
 123         /*
 124          * Append the options and mountpoint defined in auto_master(5);
 125          * this way automountd(8) does not need to parse it.
 126          */
 127         build_iovec(&iov, &iovlen, "master_options",
 128             __DECONST(void *, options), (size_t)-1);
 129         build_iovec(&iov, &iovlen, "master_prefix",
 130             __DECONST(void *, prefix), (size_t)-1);
 131
 132         error = nmount(iov, iovlen, 0);
 133         if (error != 0) {
 134                 if (*errmsg != '\0') {
 135                         log_err(1, "cannot mount %s on %s: %s",
 136                             from, fspath, errmsg);
 137                 } else {
 138                         log_err(1, "cannot mount %s on %s", from, fspath);
 139                 }
 140         }
 141 }
 142
 143 static void
 144 mount_if_not_already(const struct node *n, const char *map,
 145     const struct statfs *mntbuf, int nitems)
 146 {
 147         const struct statfs *sb;
 148         char *mountpoint;
 149         char *from;
 150         int ret;
 151
 152         ret = asprintf(&from, "map %s", map);
 153         if (ret < 0)
 154                 log_err(1, "asprintf");
 155
 156         mountpoint = node_path(n);
 157         sb = find_statfs(mntbuf, nitems, mountpoint);
 158         if (sb != NULL) {
 159                 if (strcmp(sb->f_fstypename, "autofs") != 0) {
 160                         log_debugx("unknown filesystem mounted "
 161                             "on %s; mounting", mountpoint);
 162                         /*
 163                          * XXX: Compare options and 'from',
 164                          *      and update the mount if necessary.
 165                          */
 166                 } else {
 167                         log_debugx("autofs already mounted "
 168                             "on %s", mountpoint);
 169                         free(from);
 170                         free(mountpoint);
 171                         return;
 172                 }
 173         } else {
 174                 log_debugx("nothing mounted on %s; mounting",
 175                     mountpoint);
 176         }
 177
 178         mount_autofs(from, mountpoint, n->n_options, n->n_key);
 179         free(from);
 180         free(mountpoint);
 181 }
 182
 183 static void
 184 mount_unmount(struct node *root)
 185 {
 186         struct statfs *mntbuf;
 187         struct node *n, *n2, *n3;
 188         int i, nitems;
 189
 190         nitems = getmntinfo(&mntbuf, MNT_WAIT);
 191         if (nitems <= 0)
 192                 log_err(1, "getmntinfo");
 193
 194         log_debugx("unmounting stale autofs mounts");
 195
 196         for (i = 0; i < nitems; i++) {
 197                 if (strcmp(mntbuf[i].f_fstypename, "autofs") != 0) {
 198                         log_debugx("skipping %s, filesystem type is not autofs",
 199                             mntbuf[i].f_mntonname);
 200                         continue;
 201                 }
 202
 203                 n = node_find(root, mntbuf[i].f_mntonname);
 204                 if (n != NULL) {
 205                         log_debugx("leaving autofs mounted on %s",
 206                             mntbuf[i].f_mntonname);
 207                         continue;
 208                 }
 209
 210                 log_debugx("autofs mounted on %s not found "
 211                     "in new configuration; unmounting", mntbuf[i].f_mntonname);
 212                 unmount_by_statfs(&(mntbuf[i]), false);
 213         }
 214
 215         log_debugx("mounting new autofs mounts");
 216
 217         TAILQ_FOREACH(n, &root->n_children, n_next) {
 218                 if (!node_is_direct_map(n)) {
 219                         mount_if_not_already(n, n->n_map, mntbuf, nitems);
 220                         continue;
 221                 }
 222
 223                 TAILQ_FOREACH(n2, &n->n_children, n_next) {
 224                         TAILQ_FOREACH(n3, &n2->n_children, n_next) {
 225                                 mount_if_not_already(n3, n->n_map,
 226                                     mntbuf, nitems);
 227                         }
 228                 }
 229         }
 230 }
 231
 232 static void
 233 flush_autofs(const char *fspath)
 234 {
 235         struct iovec *iov = NULL;
 236         char errmsg[255];
 237         int error, iovlen = 0;
 238
 239         log_debugx("flushing %s", fspath);
 240         memset(errmsg, 0, sizeof(errmsg));
 241
 242         build_iovec(&iov, &iovlen, "fstype",
 243             __DECONST(void *, "autofs"), (size_t)-1);
 244         build_iovec(&iov, &iovlen, "fspath",
 245             __DECONST(void *, fspath), (size_t)-1);
 246         build_iovec(&iov, &iovlen, "errmsg",
 247             errmsg, sizeof(errmsg));
 248
 249         error = nmount(iov, iovlen, MNT_UPDATE);
 250         if (error != 0) {
 251                 if (*errmsg != '\0') {
 252                         log_err(1, "cannot flush %s: %s",
 253                             fspath, errmsg);
 254                 } else {
 255                         log_err(1, "cannot flush %s", fspath);
 256                 }
 257         }
 258 }
 259
 260 static void
 261 flush_caches(void)
 262 {
 263         struct statfs *mntbuf;
 264         int i, nitems;
 265
 266         nitems = getmntinfo(&mntbuf, MNT_WAIT);
 267         if (nitems <= 0)
 268                 log_err(1, "getmntinfo");
 269
 270         log_debugx("flushing autofs caches");
 271
 272         for (i = 0; i < nitems; i++) {
 273                 if (strcmp(mntbuf[i].f_fstypename, "autofs") != 0) {
 274                         log_debugx("skipping %s, filesystem type is not autofs",
 275                             mntbuf[i].f_mntonname);
 276                         continue;
 277                 }
 278
 279                 flush_autofs(mntbuf[i].f_mntonname);
 280         }
 281 }
 282
 283 static void
 284 unmount_automounted(bool force)
 285 {
 286         struct statfs *mntbuf;
 287         int i, nitems;
 288
 289         nitems = getmntinfo(&mntbuf, MNT_WAIT);
 290         if (nitems <= 0)
 291                 log_err(1, "getmntinfo");
 292
 293         log_debugx("unmounting automounted filesystems");
 294
 295         for (i = 0; i < nitems; i++) {
 296                 if (strcmp(mntbuf[i].f_fstypename, "autofs") == 0) {
 297                         log_debugx("skipping %s, filesystem type is autofs",
 298                             mntbuf[i].f_mntonname);
 299                         continue;
 300                 }
 301
 302                 if ((mntbuf[i].f_flags & MNT_AUTOMOUNTED) == 0) {
 303                         log_debugx("skipping %s, not automounted",
 304                             mntbuf[i].f_mntonname);
 305                         continue;
 306                 }
 307
 308                 unmount_by_statfs(&(mntbuf[i]), force);
 309         }
 310 }
 311
 312 static void
 313 usage_automount(void)
 314 {
 315
 316         fprintf(stderr, "usage: automount [-D name=value][-o opts][-Lcfuv]\n");
 317         exit(1);
 318 }
 319
 320 int
 321 main_automount(int argc, char **argv)
 322 {
 323         struct node *root;
 324         int ch, debug = 0, show_maps = 0;
 325         char *options = NULL;
 326         bool do_unmount = false, force_unmount = false, flush = false;
 327
 328         /*
 329          * Note that in automount(8), the only purpose of variable
 330          * handling is to aid in debugging maps (automount -L).
 331          */
 332         defined_init();
 333
 334         while ((ch = getopt(argc, argv, "D:Lfco:uv")) != -1) {
 335                 switch (ch) {
 336                 case 'D':
 337                         defined_parse_and_add(optarg);
 338                         break;
 339                 case 'L':
 340                         show_maps++;
 341                         break;
 342                 case 'c':
 343                         flush = true;
 344                         break;
 345                 case 'f':
 346                         force_unmount = true;
 347                         break;
 348                 case 'o':
 349                         if (options == NULL) {
 350                                 options = checked_strdup(optarg);
 351                         } else {
 352                                 options =
 353                                     separated_concat(options, optarg, ',');
 354                         }
 355                         break;
 356                 case 'u':
 357                         do_unmount = true;
 358                         break;
 359                 case 'v':
 360                         debug++;
 361                         break;
 362                 case '?':
 363                 default:
 364                         usage_automount();
 365                 }
 366         }
 367         argc -= optind;
 368         if (argc != 0)
 369                 usage_automount();
 370
 371         if (force_unmount && !do_unmount)
 372                 usage_automount();
 373
 374         log_init(debug);
 375
 376         if (flush) {
 377                 flush_caches();
 378                 return (0);
 379         }
 380
 381         if (do_unmount) {
 382                 unmount_automounted(force_unmount);
 383                 return (0);
 384         }
 385
 386         root = node_new_root();
 387         parse_master(root, AUTO_MASTER_PATH);
 388
 389         if (show_maps) {
 390                 if (options != NULL) {
 391                         root->n_options = separated_concat(options,
 392                             root->n_options, ',');
 393                 }
 394                 if (show_maps > 1) {
 395                         node_expand_indirect_maps(root);
 396                         node_expand_ampersand(root, NULL);
 397                 }
 398                 node_expand_defined(root);
 399                 node_print(root);
 400                 return (0);
 401         }
 402
 403         mount_unmount(root);
 404
 405         return (0);
 406 }