sys-utils/mountpoint.c

   1 /*
   2  * mountpoint(1) - see if a directory is a mountpoint
   3  *
   4  * This is libmount based reimplementation of the mountpoint(1)
   5  * from sysvinit project.
   6  *
   7  *
   8  * Copyright (C) 2011 Red Hat, Inc. All rights reserved.
   9  * Written by Karel Zak <kzak@redhat.com>
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it would be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License along
  22  * with this program; if not, write to the Free Software Foundation, Inc.,
  23  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  24  */
  25
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <errno.h>
  29 #include <string.h>
  30 #include <getopt.h>
  31 #include <unistd.h>
  32 #include <sys/types.h>
  33 #include <sys/stat.h>
  34
  35 #include <libmount.h>
  36
  37 #include "nls.h"
  38 #include "xalloc.h"
  39 #include "c.h"
  40 #include "closestream.h"
  41 #include "pathnames.h"
  42
  43 #define MOUNTPOINT_EXIT_NOMNT   32
  44
  45 struct mountpoint_control {
  46         char *path;
  47         dev_t dev;
  48         struct stat st;
  49         unsigned int
  50                 dev_devno:1,
  51                 fs_devno:1,
  52                 nofollow:1,
  53                 quiet:1;
  54 };
  55
  56 static int dir_to_device(struct mountpoint_control *ctl)
  57 {
  58         struct libmnt_table *tb = mnt_new_table_from_file(_PATH_PROC_MOUNTINFO);
  59         struct libmnt_fs *fs;
  60         struct libmnt_cache *cache;
  61         int rc = -1;
  62
  63         if (!tb) {
  64                 /*
  65                  * Fallback. Traditional way to detect mountpoints. This way
  66                  * is independent on /proc, but not able to detect bind mounts.
  67                  */
  68                 struct stat pst;
  69                 char buf[PATH_MAX], *cn;
  70                 int len;
  71
  72                 cn = mnt_resolve_path(ctl->path, NULL); /* canonicalize */
  73
  74                 len = snprintf(buf, sizeof(buf), "%s/..", cn ? cn : ctl->path);
  75                 free(cn);
  76
  77                 if (len < 0 || (size_t) len >= sizeof(buf))
  78                         return -1;
  79                 if (stat(buf, &pst) !=0)
  80                         return -1;
  81
  82                 if (ctl->st.st_dev != pst.st_dev || ctl->st.st_ino == pst.st_ino) {
  83                         ctl->dev = ctl->st.st_dev;
  84                         return 0;
  85                 }
  86
  87                 return -1;
  88         }
  89
  90         /* to canonicalize all necessary paths */
  91         cache = mnt_new_cache();
  92         mnt_table_set_cache(tb, cache);
  93         mnt_unref_cache(cache);
  94
  95         fs = mnt_table_find_target(tb, ctl->path, MNT_ITER_BACKWARD);
  96         if (fs && mnt_fs_get_target(fs)) {
  97                 ctl->dev = mnt_fs_get_devno(fs);
  98                 rc = 0;
  99         }
 100
 101         mnt_unref_table(tb);
 102         return rc;
 103 }
 104
 105 static int print_devno(const struct mountpoint_control *ctl)
 106 {
 107         if (!S_ISBLK(ctl->st.st_mode)) {
 108                 if (!ctl->quiet)
 109                         warnx(_("%s: not a block device"), ctl->path);
 110                 return -1;
 111         }
 112         printf("%u:%u\n", major(ctl->st.st_rdev), minor(ctl->st.st_rdev));
 113         return 0;
 114 }
 115
 116 static void __attribute__((__noreturn__)) usage(void)
 117 {
 118         FILE *out = stdout;
 119         fputs(USAGE_HEADER, out);
 120         fprintf(out,
 121               _(" %1$s [-qd] /path/to/directory\n"
 122                 " %1$s -x /dev/device\n"), program_invocation_short_name);
 123
 124         fputs(USAGE_SEPARATOR, out);
 125         fputs(_("Check whether a directory or file is a mountpoint.\n"), out);
 126
 127         fputs(USAGE_OPTIONS, out);
 128         fputs(_(" -q, --quiet        quiet mode - don't print anything\n"
 129                 "     --nofollow     do not follow symlink\n"
 130                 " -d, --fs-devno     print maj:min device number of the filesystem\n"
 131                 " -x, --devno        print maj:min device number of the block device\n"), out);
 132         fputs(USAGE_SEPARATOR, out);
 133         fprintf(out, USAGE_HELP_OPTIONS(20));
 134         fprintf(out, USAGE_MAN_TAIL("mountpoint(1)"));
 135
 136         exit(EXIT_SUCCESS);
 137 }
 138
 139 int main(int argc, char **argv)
 140 {
 141         int c;
 142         struct mountpoint_control ctl = { NULL };
 143
 144         enum {
 145                 OPT_NOFOLLOW = CHAR_MAX + 1
 146         };
 147
 148         static const struct option longopts[] = {
 149                 { "quiet",    no_argument, NULL, 'q' },
 150                 { "nofollow", no_argument, NULL, OPT_NOFOLLOW },
 151                 { "fs-devno", no_argument, NULL, 'd' },
 152                 { "devno",    no_argument, NULL, 'x' },
 153                 { "help",     no_argument, NULL, 'h' },
 154                 { "version",  no_argument, NULL, 'V' },
 155                 { NULL, 0, NULL, 0 }
 156         };
 157
 158         setlocale(LC_ALL, "");
 159         bindtextdomain(PACKAGE, LOCALEDIR);
 160         textdomain(PACKAGE);
 161         close_stdout_atexit();
 162
 163         mnt_init_debug(0);
 164
 165         while ((c = getopt_long(argc, argv, "qdxhV", longopts, NULL)) != -1) {
 166
 167                 switch(c) {
 168                 case 'q':
 169                         ctl.quiet = 1;
 170                         break;
 171                 case OPT_NOFOLLOW:
 172                         ctl.nofollow = 1;
 173                         break;
 174                 case 'd':
 175                         ctl.fs_devno = 1;
 176                         break;
 177                 case 'x':
 178                         ctl.dev_devno = 1;
 179                         break;
 180
 181                 case 'h':
 182                         usage();
 183                 case 'V':
 184                         print_version(EXIT_SUCCESS);
 185                 default:
 186                         errtryhelp(EXIT_FAILURE);
 187                 }
 188         }
 189
 190         if (optind + 1 != argc) {
 191                 warnx(_("bad usage"));
 192                 errtryhelp(EXIT_FAILURE);
 193         }
 194         if (ctl.nofollow && ctl.dev_devno)
 195                 errx(EXIT_FAILURE, _("%s and %s are mutually exclusive"),
 196                      "--devno", "--nofollow");
 197
 198         ctl.path = argv[optind];
 199         c = ctl.nofollow ? lstat(ctl.path, &ctl.st) : stat(ctl.path, &ctl.st);
 200         if (c) {
 201                 if (!ctl.quiet)
 202                         err(EXIT_FAILURE, "%s", ctl.path);
 203                 return EXIT_FAILURE;
 204         }
 205         if (ctl.dev_devno)
 206                 return print_devno(&ctl) ? MOUNTPOINT_EXIT_NOMNT : EXIT_SUCCESS;
 207
 208         if ((ctl.nofollow && S_ISLNK(ctl.st.st_mode)) || dir_to_device(&ctl)) {
 209                 if (!ctl.quiet)
 210                         printf(_("%s is not a mountpoint\n"), ctl.path);
 211                 return MOUNTPOINT_EXIT_NOMNT;
 212         }
 213         if (ctl.fs_devno)
 214                 printf("%u:%u\n", major(ctl.dev), minor(ctl.dev));
 215         else if (!ctl.quiet)
 216                 printf(_("%s is a mountpoint\n"), ctl.path);
 217
 218         return EXIT_SUCCESS;
 219 }