find/fstype.c

   1 /* fstype.c -- determine type of filesystems that files are on
   2    Copyright (C) 1990, 91, 92, 93, 94, 2000, 2004 Free Software Foundation, Inc.
   3
   4    This program is free software; you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 2, or (at your option)
   7    any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program; if not, write to the Free Software
  16    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
  17    USA.
  18 */
  19
  20 /* Written by David MacKenzie <djm@gnu.org>.
  21  *
  22  * Converted to use gnulib's read_file_system_list()
  23  * by James Youngman <jay@gnu.org> (which saves a lot
  24  * of manual hacking of configure.in).
  25  */
  26
  27
  28 #include <config.h>
  29 #include <errno.h>
  30 #include <assert.h>
  31 #include <stdbool.h>
  32
  33 #ifdef HAVE_SYS_TYPES_H
  34 #include <sys/types.h>
  35 #endif
  36
  37 /* The presence of unistd.h is assumed by gnulib these days, so we
  38  * might as well assume it too.
  39  */
  40 #include <unistd.h>
  41
  42 #ifdef HAVE_SYS_MNTIO_H
  43 #ifdef HAVE_FCNTL_H
  44 #include <fcntl.h>
  45 #endif
  46 #include <sys/mntio.h>
  47 #endif
  48 #ifdef HAVE_SYS_MKDEV_H
  49 #include <sys/mkdev.h>
  50 #endif
  51
  52 #ifdef STDC_HEADERS
  53 #include <stdlib.h>
  54 #else
  55 extern int errno;
  56 #endif
  57
  58 #include "defs.h"
  59 #include "../gnulib/lib/dirname.h"
  60 #include "xalloc.h"
  61 #include "modetype.h"
  62
  63 /* Need declaration of function `xstrtoumax' */
  64 #include "../gnulib/lib/xstrtol.h"
  65
  66 #include "extendbuf.h"
  67 #include "mountlist.h"
  68
  69
  70
  71 #if ENABLE_NLS
  72 # include <libintl.h>
  73 # define _(Text) gettext (Text)
  74 #else
  75 # define _(Text) Text
  76 #endif
  77 #ifdef gettext_noop
  78 # define N_(String) gettext_noop (String)
  79 #else
  80 /* See locate.c for explanation as to why not use (String) */
  81 # define N_(String) String
  82 #endif
  83
  84 static char *filesystem_type_uncached PARAMS((const struct stat *statp, const char *path));
  85
  86
  87 /* Get MNTTYPE_IGNORE if it is available. */
  88 #if HAVE_MNTENT_H
  89 # include <mntent.h>
  90 #endif
  91 #if HAVE_SYS_MNTTAB_H
  92 # include <stdio.h>
  93 # include <sys/mnttab.h>
  94 #endif
  95
  96
  97
  98
  99
 100 static void
 101 free_file_system_list(struct mount_entry *p)
 102 {
 103   while (p)
 104     {
 105       struct mount_entry *pnext = p->me_next;
 106
 107       free(p->me_devname);
 108       free(p->me_mountdir);
 109
 110       if(p->me_type_malloced)
 111         free(p->me_type);
 112       p->me_next = NULL;
 113       free(p);
 114       p = pnext;
 115     }
 116 }
 117
 118
 119
 120
 121 #ifdef AFS
 122 #include <netinet/in.h>
 123 #include <afs/venus.h>
 124 #if __STDC__
 125 /* On SunOS 4, afs/vice.h defines this to rely on a pre-ANSI cpp.  */
 126 #undef _VICEIOCTL
 127 #define _VICEIOCTL(id)  ((unsigned int ) _IOW('V', id, struct ViceIoctl))
 128 #endif
 129 #ifndef _IOW
 130 /* AFS on Solaris 2.3 doesn't get this definition.  */
 131 #include <sys/ioccom.h>
 132 #endif
 133
 134 static int
 135 in_afs (char *path)
 136 {
 137   static char space[2048];
 138   struct ViceIoctl vi;
 139
 140   vi.in_size = 0;
 141   vi.out_size = sizeof (space);
 142   vi.out = space;
 143
 144   if (pioctl (path, VIOC_FILE_CELL_NAME, &vi, 1)
 145       && (errno == EINVAL || errno == ENOENT))
 146         return 0;
 147   return 1;
 148 }
 149 #endif /* AFS */
 150
 151 /* Nonzero if the current filesystem's type is known.  */
 152 static int fstype_known = 0;
 153
 154 /* Return a static string naming the type of filesystem that the file PATH,
 155    described by STATP, is on.
 156    RELPATH is the file name relative to the current directory.
 157    Return "unknown" if its filesystem type is unknown.  */
 158
 159 char *
 160 filesystem_type (const struct stat *statp, const char *path)
 161 {
 162   static char *current_fstype = NULL;
 163   static dev_t current_dev;
 164
 165   if (current_fstype != NULL)
 166     {
 167       if (fstype_known && statp->st_dev == current_dev)
 168         return current_fstype;  /* Cached value.  */
 169       free (current_fstype);
 170     }
 171   current_dev = statp->st_dev;
 172   current_fstype = filesystem_type_uncached (statp, path);
 173   return current_fstype;
 174 }
 175
 176 static int
 177 set_fstype_devno(struct mount_entry *p)
 178 {
 179   struct stat stbuf;
 180
 181   if (p->me_dev == (dev_t)-1)
 182     {
 183       if (0 == (options.xstat)(p->me_mountdir, &stbuf))
 184         {
 185           p->me_dev = stbuf.st_dev;
 186           return 0;
 187         }
 188       else
 189         {
 190           return -1;
 191         }
 192     }
 193   return 0;                     /* not needed */
 194 }
 195
 196 static struct mount_entry *
 197 must_read_fs_list(bool need_fs_type)
 198 {
 199   struct mount_entry *entries = read_file_system_list(need_fs_type);
 200   if (NULL == entries)
 201     {
 202       /* We cannot determine for sure which file we were trying to
 203        * use because gnulib has extracted all that stuff away.
 204        * Hence we cannot issue a specific error message here.
 205        */
 206       error(1, 0, "Cannot read mounted filesystem list");
 207     }
 208   return entries;
 209 }
 210
 211
 212
 213 /* Return a newly allocated string naming the type of filesystem that the
 214    file PATH, described by STATP, is on.
 215    RELPATH is the file name relative to the current directory.
 216    Return "unknown" if its filesystem type is unknown.  */
 217
 218 static char *
 219 filesystem_type_uncached (const struct stat *statp, const char *path)
 220 {
 221   struct mount_entry *entries, *entry;
 222   char *type;
 223
 224 #ifdef AFS
 225   if (in_afs(path))
 226     {
 227       fstype_known = 1;
 228       return xstrdup("afs");
 229     }
 230 #endif
 231
 232   entries = must_read_fs_list(true);
 233   for (type=NULL, entry=entries; entry; entry=entry->me_next)
 234     {
 235 #ifdef MNTTYPE_IGNORE
 236       if (!strcmp (entry->me_type, MNTTYPE_IGNORE))
 237         continue;
 238 #endif
 239       set_fstype_devno(entry);
 240       if (entry->me_dev == statp->st_dev)
 241         {
 242           type = xstrdup(entry->me_type);
 243           break;
 244         }
 245     }
 246   free_file_system_list(entries);
 247
 248   /* Don't cache unknown values. */
 249   fstype_known = (type != NULL);
 250
 251   return type ? type : xstrdup(_("unknown"));
 252 }
 253
 254
 255 char *
 256 get_mounted_filesystems (void)
 257 {
 258   char *result = NULL;
 259   size_t alloc_size = 0u;
 260   size_t used = 0u;
 261   struct mount_entry *entries, *entry;
 262
 263   entries = must_read_fs_list(false);
 264   for (entry=entries; entry; entry=entry->me_next)
 265     {
 266       size_t len;
 267
 268 #ifdef MNTTYPE_IGNORE
 269       if (!strcmp (entry->me_type, MNTTYPE_IGNORE))
 270         continue;
 271 #endif
 272       set_fstype_devno(entry);
 273
 274       len = strlen(entry->me_mountdir) + 1;
 275       result = extendbuf(result, used+len, &alloc_size);
 276       strcpy(&result[used], entry->me_mountdir);
 277       used += len;              /* len already includes one for the \0 */
 278     }
 279
 280   free_file_system_list(entries);
 281   return result;
 282 }
 283
 284
 285 dev_t *
 286 get_mounted_devices (size_t *n)
 287 {
 288   size_t alloc_size = 0u;
 289   size_t used = 0u;
 290   struct mount_entry *entries, *entry;
 291   dev_t *result = NULL;
 292
 293   /* Use read_file_system_list() rather than must_read_fs_list()
 294    * because on some system this is always called at startup,
 295    * and find should only exit fatally if it needs to use the
 296    * result of this operation.   If we can't get the fs list
 297    * but we never need the information, there is no need to fail.
 298    */
 299   for (entry = entries = read_file_system_list(false);
 300        entry;
 301        entry = entry->me_next)
 302     {
 303       result = extendbuf(result, sizeof(dev_t)*(used+1), &alloc_size);
 304       set_fstype_devno(entry);
 305       result[used] = entry->me_dev;
 306       ++used;
 307     }
 308   free_file_system_list(entries);
 309   *n = used;
 310   return result;
 311 }
 312
 313
 314