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   (void) path;
 225
 226 #ifdef AFS
 227   if (in_afs(path))
 228     {
 229       fstype_known = 1;
 230       return xstrdup("afs");
 231     }
 232 #endif
 233
 234   entries = must_read_fs_list(true);
 235   for (type=NULL, entry=entries; entry; entry=entry->me_next)
 236     {
 237 #ifdef MNTTYPE_IGNORE
 238       if (!strcmp (entry->me_type, MNTTYPE_IGNORE))
 239         continue;
 240 #endif
 241       set_fstype_devno(entry);
 242       if (entry->me_dev == statp->st_dev)
 243         {
 244           type = xstrdup(entry->me_type);
 245           break;
 246         }
 247     }
 248   free_file_system_list(entries);
 249
 250   /* Don't cache unknown values. */
 251   fstype_known = (type != NULL);
 252
 253   return type ? type : xstrdup(_("unknown"));
 254 }
 255
 256
 257 char *
 258 get_mounted_filesystems (void)
 259 {
 260   char *result = NULL;
 261   size_t alloc_size = 0u;
 262   size_t used = 0u;
 263   struct mount_entry *entries, *entry;
 264
 265   entries = must_read_fs_list(false);
 266   for (entry=entries; entry; entry=entry->me_next)
 267     {
 268       size_t len;
 269
 270 #ifdef MNTTYPE_IGNORE
 271       if (!strcmp (entry->me_type, MNTTYPE_IGNORE))
 272         continue;
 273 #endif
 274       set_fstype_devno(entry);
 275
 276       len = strlen(entry->me_mountdir) + 1;
 277       result = extendbuf(result, used+len, &alloc_size);
 278       strcpy(&result[used], entry->me_mountdir);
 279       used += len;              /* len already includes one for the \0 */
 280     }
 281
 282   free_file_system_list(entries);
 283   return result;
 284 }
 285
 286
 287 dev_t *
 288 get_mounted_devices (size_t *n)
 289 {
 290   size_t alloc_size = 0u;
 291   size_t used = 0u;
 292   struct mount_entry *entries, *entry;
 293   dev_t *result = NULL;
 294
 295   /* Use read_file_system_list() rather than must_read_fs_list()
 296    * because on some system this is always called at startup,
 297    * and find should only exit fatally if it needs to use the
 298    * result of this operation.   If we can't get the fs list
 299    * but we never need the information, there is no need to fail.
 300    */
 301   for (entry = entries = read_file_system_list(false);
 302        entry;
 303        entry = entry->me_next)
 304     {
 305       result = extendbuf(result, sizeof(dev_t)*(used+1), &alloc_size);
 306       set_fstype_devno(entry);
 307       result[used] = entry->me_dev;
 308       ++used;
 309     }
 310   free_file_system_list(entries);
 311   *n = used;
 312   return result;
 313 }
 314
 315
 316