usr.sbin/autofs/automount.c

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