git.sur5r.net Git - bacula/bacula/blob - bacula/src/findlib/fstype.c

   1 /*
   2  *  Implement routines to determine file system types.
   3  *
   4  *   Written by Preben 'Peppe' Guldberg, December MMIV
   5  *
   6  *   Version $Id$
   7  */
   8
   9 /*
  10    Copyright (C) 2005 Kern Sibbald
  11
  12    This program is free software; you can redistribute it and/or
  13    modify it under the terms of the GNU General Public License as
  14    published by the Free Software Foundation; either version 2 of
  15    the License, or (at your option) any later version.
  16
  17    This program is distributed in the hope that it will be useful,
  18    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  20    General Public License for more details.
  21
  22    You should have received a copy of the GNU General Public
  23    License along with this program; if not, write to the Free
  24    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  25    MA 02111-1307, USA.
  26
  27  */
  28
  29 #ifndef TEST_PROGRAM
  30
  31 #include "bacula.h"
  32 #include "find.h"
  33
  34 #else /* Set up for testing a stand alone program */
  35
  36 #include <stdio.h>
  37 #include <stdlib.h>
  38 #include <string.h>
  39 #define SUPPORTEDOSES \
  40    "HAVE_DARWIN_OS\n" \
  41    "HAVE_FREEBSD_OS\n" \
  42    "HAVE_HPUX_OS\n" \
  43    "HAVE_IRIX_OS\n" \
  44    "HAVE_LINUX_OS\n" \
  45    "HAVE_NETBSD_OS\n" \
  46    "HAVE_OPENBSD_OS\n" \
  47    "HAVE_SUN_OS\n" \
  48    "HAVE_WIN32\n"
  49 #define false              0
  50 #define true               1
  51 #define bstrncpy           strncpy
  52 #define Dmsg0(n,s)         fprintf(stderr, s)
  53 #define Dmsg1(n,s,a1)      fprintf(stderr, s, a1)
  54 #define Dmsg2(n,s,a1,a2)   fprintf(stderr, s, a1, a2)
  55 #endif
  56
  57 /*
  58  * These functions should be implemented for each OS
  59  *
  60  *       bool fstype(const char *fname, char *fs, int fslen);
  61  */
  62 #if defined(HAVE_DARWIN_OS) \
  63    || defined(HAVE_FREEBSD_OS ) \
  64    || defined(HAVE_OPENBSD_OS)
  65
  66 #include <sys/param.h>
  67 #include <sys/mount.h>
  68
  69 bool fstype(const char *fname, char *fs, int fslen)
  70 {
  71    struct statfs st;
  72    if (statfs(fname, &st) == 0) {
  73       bstrncpy(fs, st.f_fstypename, fslen);
  74       return true;
  75    }
  76    Dmsg1(50, "statfs() failed for \"%s\"\n", fname);
  77    return false;
  78 }
  79 #elif defined(HAVE_NETBSD_OS)
  80 #include <sys/param.h>
  81 #include <sys/mount.h>
  82 #ifdef HAVE_SYS_STATVFS_H
  83 #include <sys/statvfs.h>
  84 #else
  85 #define statvfs statfs
  86 #endif
  87
  88 bool fstype(const char *fname, char *fs, int fslen)
  89 {
  90    struct statvfs st;
  91    if (statvfs(fname, &st) == 0) {
  92       bstrncpy(fs, st.f_fstypename, fslen);
  93       return true;
  94    }
  95    Dmsg1(50, "statfs() failed for \"%s\"\n", fname);
  96    return false;
  97 }
  98 #elif defined(HAVE_HPUX_OS) \
  99    || defined(HAVE_IRIX_OS)
 100
 101 #include <sys/types.h>
 102 #include <sys/statvfs.h>
 103
 104 bool fstype(const char *fname, char *fs, int fslen)
 105 {
 106    struct statvfs st;
 107    if (statvfs(fname, &st) == 0) {
 108       bstrncpy(fs, st.f_basetype, fslen);
 109       return true;
 110    }
 111    Dmsg1(50, "statfs() failed for \"%s\"\n", fname);
 112    return false;
 113 }
 114
 115 #elif defined(HAVE_LINUX_OS)
 116
 117 #include <sys/vfs.h>
 118
 119 bool fstype(const char *fname, char *fs, int fslen)
 120 {
 121    struct statfs st;
 122    if (statfs(fname, &st) == 0) {
 123       /*
 124        * Values nicked from statfs(2), testing and
 125        *
 126        *    $ grep -r SUPER_MAGIC /usr/include/linux
 127        *
 128        * Entries are sorted on ("fsname")
 129        */
 130       switch (st.f_type) {
 131
 132       /* Known good values */
 133       case 0xef53:         bstrncpy(fs, "ext2", fslen); return true;          /* EXT2_SUPER_MAGIC */
 134    /* case 0xef53:         ext2 and ext3 are the same */                      /* EXT3_SUPER_MAGIC */
 135       case 0x3153464a:     bstrncpy(fs, "jfs", fslen); return true;           /* JFS_SUPER_MAGIC */
 136       case 0x5346544e:     bstrncpy(fs, "ntfs", fslen); return true;          /* NTFS_SB_MAGIC */
 137       case 0x9fa0:         bstrncpy(fs, "proc", fslen); return true;          /* PROC_SUPER_MAGIC */
 138       case 0x52654973:     bstrncpy(fs, "reiserfs", fslen); return true;      /* REISERFS_SUPER_MAGIC */
 139       case 0x58465342:     bstrncpy(fs, "xfs", fslen); return true;           /* XFS_SB_MAGIC */
 140       case 0x9fa2:         bstrncpy(fs, "usbdevfs", fslen); return true;      /* USBDEVICE_SUPER_MAGIC */
 141       case 0x62656572:     bstrncpy(fs, "sysfs", fslen); return true;         /* SYSFS_MAGIC */
 142       case 0x517B:         bstrncpy(fs, "smbfs", fslen); return true;         /* SMB_SUPER_MAGIC */
 143       case 0x9660:         bstrncpy(fs, "iso9660", fslen); return true;       /* ISOFS_SUPER_MAGIC */
 144
 145 #if 0       /* These need confirmation */
 146       case 0xadf5:         bstrncpy(fs, "adfs", fslen); return true;          /* ADFS_SUPER_MAGIC */
 147       case 0xadff:         bstrncpy(fs, "affs", fslen); return true;          /* AFFS_SUPER_MAGIC */
 148       case 0x6B414653:     bstrncpy(fs, "afs", fslen); return true;           /* AFS_FS_MAGIC */
 149       case 0x0187:         bstrncpy(fs, "autofs", fslen); return true;        /* AUTOFS_SUPER_MAGIC */
 150       case 0x62646576:     bstrncpy(fs, "bdev", fslen); return true;          /* ??? */
 151       case 0x42465331:     bstrncpy(fs, "befs", fslen); return true;          /* BEFS_SUPER_MAGIC */
 152       case 0x1BADFACE:     bstrncpy(fs, "bfs", fslen); return true;           /* BFS_MAGIC */
 153       case 0x42494e4d:     bstrncpy(fs, "binfmt_misc", fslen); return true;   /* ??? */
 154       case (('C'<<8)|'N'): bstrncpy(fs, "capifs", fslen); return true;        /* CAPIFS_SUPER_MAGIC */
 155       case 0xFF534D42:     bstrncpy(fs, "cifs", fslen); return true;          /* CIFS_MAGIC_NUMBER */
 156       case 0x73757245:     bstrncpy(fs, "coda", fslen); return true;          /* CODA_SUPER_MAGIC */
 157       case 0x012ff7b7:     bstrncpy(fs, "coherent", fslen); return true;      /* COH_SUPER_MAGIC */
 158       case 0x28cd3d45:     bstrncpy(fs, "cramfs", fslen); return true;        /* CRAMFS_MAGIC */
 159       case 0x1373:         bstrncpy(fs, "devfs", fslen); return true;         /* DEVFS_SUPER_MAGIC */
 160       case 0x1cd1:         bstrncpy(fs, "devpts", fslen); return true;        /* ??? */
 161       case 0x414A53:       bstrncpy(fs, "efs", fslen); return true;           /* EFS_SUPER_MAGIC */
 162       case 0x03111965:     bstrncpy(fs, "eventpollfs", fslen); return true;   /* EVENTPOLLFS_MAGIC */
 163       case 0x137d:         bstrncpy(fs, "ext", fslen); return true;           /* EXT_SUPER_MAGIC */
 164       case 0xef51:         bstrncpy(fs, "ext2", fslen); return true;          /* EXT2_OLD_SUPER_MAGIC */
 165       case 0xBAD1DEA:      bstrncpy(fs, "futexfs", fslen); return true;       /* ??? */
 166       case 0xaee71ee7:     bstrncpy(fs, "gadgetfs", fslen); return true;      /* GADGETFS_MAGIC */
 167       case 0x00c0ffee:     bstrncpy(fs, "hostfs", fslen); return true;        /* HOSTFS_SUPER_MAGIC */
 168       case 0xf995e849:     bstrncpy(fs, "hpfs", fslen); return true;          /* HPFS_SUPER_MAGIC */
 169       case 0xb00000ee:     bstrncpy(fs, "hppfs", fslen); return true;         /* HPPFS_SUPER_MAGIC */
 170       case 0x958458f6:     bstrncpy(fs, "hugetlbfs", fslen); return true;     /* HUGETLBFS_MAGIC */
 171       case 0x12061983:     bstrncpy(fs, "hwgfs", fslen); return true;         /* HWGFS_MAGIC */
 172       case 0x66726f67:     bstrncpy(fs, "ibmasmfs", fslen); return true;      /* IBMASMFS_MAGIC */
 173       case 0x9660:         bstrncpy(fs, "isofs", fslen); return true;         /* ISOFS_SUPER_MAGIC */
 174       case 0x07c0:         bstrncpy(fs, "jffs", fslen); return true;          /* JFFS_MAGIC_SB_BITMASK */
 175       case 0x72b6:         bstrncpy(fs, "jffs2", fslen); return true;         /* JFFS2_SUPER_MAGIC */
 176       case 0x2468:         bstrncpy(fs, "minix", fslen); return true;         /* MINIX2_SUPER_MAGIC */
 177       case 0x2478:         bstrncpy(fs, "minix", fslen); return true;         /* MINIX2_SUPER_MAGIC2 */
 178       case 0x137f:         bstrncpy(fs, "minix", fslen); return true;         /* MINIX_SUPER_MAGIC */
 179       case 0x138f:         bstrncpy(fs, "minix", fslen); return true;         /* MINIX_SUPER_MAGIC2 */
 180       case 0x19800202:     bstrncpy(fs, "mqueue", fslen); return true;        /* MQUEUE_MAGIC */
 181       case 0x4d44:         bstrncpy(fs, "msdos", fslen); return true;         /* MSDOS_SUPER_MAGIC */
 182       case 0x564c:         bstrncpy(fs, "ncpfs", fslen); return true;         /* NCP_SUPER_MAGIC */
 183       case 0x6969:         bstrncpy(fs, "nfs", fslen); return true;           /* NFS_SUPER_MAGIC */
 184       case 0x9fa1:         bstrncpy(fs, "openpromfs", fslen); return true;    /* OPENPROM_SUPER_MAGIC */
 185       case 0x6f70726f:     bstrncpy(fs, "oprofilefs", fslen); return true;    /* OPROFILEFS_MAGIC */
 186       case 0xa0b4d889:     bstrncpy(fs, "pfmfs", fslen); return true;         /* PFMFS_MAGIC */
 187       case 0x50495045:     bstrncpy(fs, "pipfs", fslen); return true;         /* PIPEFS_MAGIC */
 188       case 0x002f:         bstrncpy(fs, "qnx4", fslen); return true;          /* QNX4_SUPER_MAGIC */
 189       case 0x858458f6:     bstrncpy(fs, "ramfs", fslen); return true;         /* RAMFS_MAGIC */
 190       case 0x7275:         bstrncpy(fs, "romfs", fslen); return true;         /* ROMFS_MAGIC */
 191       case 0x858458f6:     bstrncpy(fs, "rootfs", fslen); return true;        /* RAMFS_MAGIC */
 192       case 0x67596969:     bstrncpy(fs, "rpc_pipefs", fslen); return true;    /* RPCAUTH_GSSMAGIC */
 193       case 0x534F434B:     bstrncpy(fs, "sockfs", fslen); return true;        /* SOCKFS_MAGIC */
 194       case 0x012ff7b6:     bstrncpy(fs, "sysv2", fslen); return true;         /* SYSV2_SUPER_MAGIC */
 195       case 0x012ff7b5:     bstrncpy(fs, "sysv4", fslen); return true;         /* SYSV4_SUPER_MAGIC */
 196       case 0x858458f6:     bstrncpy(fs, "tmpfs", fslen); return true;         /* RAMFS_MAGIC */
 197       case 0x01021994:     bstrncpy(fs, "tmpfs", fslen); return true;         /* TMPFS_MAGIC */
 198       case 0x15013346:     bstrncpy(fs, "udf", fslen); return true;           /* UDF_SUPER_MAGIC */
 199       case 0x00011954:     bstrncpy(fs, "ufs", fslen); return true;           /* UFS_MAGIC */
 200       case 0xa501FCF5:     bstrncpy(fs, "vxfs", fslen); return true;          /* VXFS_SUPER_MAGIC */
 201       case 0x012ff7b4:     bstrncpy(fs, "xenix", fslen); return true;         /* XENIX_SUPER_MAGIC */
 202       case 0x012fd16d:     bstrncpy(fs, "xiafs", fslen); return true;         /* _XIAFS_SUPER_MAGIC */
 203 #endif
 204
 205       default:
 206          Dmsg2(10, "Unknown file system type \"0x%x\" for \"%s\".\n", st.f_type,
 207                fname);
 208          return false;
 209       }
 210    }
 211    Dmsg1(50, "statfs() failed for \"%s\"\n", fname);
 212    return false;
 213 }
 214
 215 #elif defined(HAVE_SUN_OS)
 216
 217 #include <sys/types.h>
 218 #include <sys/stat.h>
 219
 220 bool fstype(const char *fname, char *fs, int fslen)
 221 {
 222    struct stat st;
 223    if (lstat(fname, &st) == 0) {
 224       bstrncpy(fs, st.st_fstype, fslen);
 225       return true;
 226    }
 227    Dmsg1(50, "lstat() failed for \"%s\"\n", fname);
 228    return false;
 229 }
 230
 231 #elif defined (__digital__) && defined (__unix__)  /* Tru64 */
 232 /* Tru64 */
 233 #include <sys/stat.h>
 234 #include <sys/mount.h>
 235
 236 bool fstype(const char *fname, char *fs, int fslen)
 237 {
 238    struct statfs st;
 239    if (statfs((char *)fname, &st) == 0) {
 240       switch (st.f_type) {
 241       /* Known good values */
 242       case 0xa:         bstrncpy(fs, "advfs", fslen); return true;        /* Tru64 AdvFS */
 243       case 0xe:         bstrncpy(fs, "nfs", fslen); return true;          /* Tru64 NFS   */
 244       default:
 245          Dmsg2(10, "Unknown file system type \"0x%x\" for \"%s\".\n", st.f_type,
 246                fname);
 247          return false;
 248       }
 249    }
 250    Dmsg1(50, "statfs() failed for \"%s\"\n", fname);
 251    return false;
 252 }
 253 /* Tru64 */
 254
 255 #elif defined (HAVE_WIN32)
 256 /* Windows */
 257
 258 bool fstype(const char *fname, char *fs, int fslen)
 259 {
 260    DWORD componentlength;
 261    DWORD fsflags;
 262    CHAR rootpath[4];
 263    UINT oldmode;
 264    BOOL result;
 265
 266    /* Copy Drive Letter, colon, and backslash to rootpath */
 267    bstrncpy(rootpath, fname, sizeof(rootpath));
 268
 269    /* We don't want any popups if there isn't any media in the drive */
 270    oldmode = SetErrorMode(SEM_FAILCRITICALERRORS);
 271
 272    result = GetVolumeInformation(rootpath, NULL, 0, NULL, &componentlength, &fsflags, fs, fslen);
 273
 274    SetErrorMode(oldmode);
 275
 276    if (result) {
 277       /* Windows returns NTFS, FAT, etc.  Make it lowercase to be consistent with other OSes */
 278       lcase(fs);
 279    } else {
 280       Dmsg2(10, "GetVolumeInformation() failed for \"%s\", Error = %d.\n", rootpath, GetLastError());
 281    }
 282
 283    return result != 0;
 284 }
 285 /* Windows */
 286
 287 #else    /* No recognised OS */
 288
 289 bool fstype(const char *fname, char *fs, int fslen)
 290 {
 291    Dmsg0(10, "!!! fstype() not implemented for this OS. !!!\n");
 292 #ifdef TEST_PROGRAM
 293    Dmsg1(10, "Please define one of the following when compiling:\n\n%s\n",
 294          SUPPORTEDOSES);
 295    exit(EXIT_FAILURE);
 296 #endif
 297
 298    return false;
 299 }
 300 #endif
 301
 302 #ifdef TEST_PROGRAM
 303 int main(int argc, char **argv)
 304 {
 305    char *p;
 306    char fs[1000];
 307    int status = 0;
 308
 309    if (argc < 2) {
 310       p = (argc < 1) ? "fstype" : argv[0];
 311       printf("usage:\t%s path ...\n"
 312             "\t%s prints the file system type and pathname of the paths.\n",
 313             p, p);
 314       return EXIT_FAILURE;
 315    }
 316    while (*++argv) {
 317       if (!fstype(*argv, fs, sizeof(fs))) {
 318          status = EXIT_FAILURE;
 319       } else {
 320          printf("%s\t%s\n", fs, *argv);
 321       }
 322    }
 323    return status;
 324 }
 325 #endif