lib/mountlist.c

   1 /* mountlist.c -- return a list of mounted filesystems
   2    Copyright (C) 1991, 1992 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., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  17
  18 #include <stdio.h>
  19 #include <sys/types.h>
  20 #include "mountlist.h"
  21
  22 #ifdef STDC_HEADERS
  23 #include <stdlib.h>
  24 #else
  25 void free ();
  26 #endif
  27 #if defined(USG) || defined(STDC_HEADERS)
  28 #include <string.h>
  29 #else
  30 #include <strings.h>
  31 #endif
  32
  33 char *strstr ();
  34 char *xmalloc ();
  35 char *xrealloc ();
  36 char *xstrdup ();
  37 void error ();
  38
  39 #ifdef MOUNTED_GETMNTENT1       /* 4.3BSD, SunOS, HP-UX, Dynix, Irix.  */
  40 #include <mntent.h>
  41 #if !defined(MOUNTED)
  42 #  if defined(MNT_MNTTAB)       /* HP-UX.  */
  43 #    define MOUNTED MNT_MNTTAB
  44 #  endif
  45 #  if defined(MNTTABNAME)       /* Dynix.  */
  46 #    define MOUNTED MNTTABNAME
  47 #  endif
  48 #endif
  49 #endif
  50
  51 #ifdef MOUNTED_GETMNTINFO       /* 4.4BSD.  */
  52 #include <sys/mount.h>
  53 #endif
  54
  55 #ifdef MOUNTED_GETMNT           /* Ultrix.  */
  56 #include <sys/param.h>
  57 #include <sys/mount.h>
  58 #include <sys/fs_types.h>
  59 #endif
  60
  61 #ifdef MOUNTED_FREAD            /* SVR2.  */
  62 #include <mnttab.h>
  63 #endif
  64
  65 #ifdef MOUNTED_FREAD_FSTYP      /* SVR3.  */
  66 #include <mnttab.h>
  67 #include <sys/fstyp.h>
  68 #include <sys/statfs.h>
  69 #endif
  70
  71 #ifdef MOUNTED_GETMNTENT2       /* SVR4.  */
  72 #include <sys/mnttab.h>
  73 #endif
  74
  75 #ifdef MOUNTED_VMOUNT           /* AIX.  */
  76 #include <fshelp.h>
  77 #include <sys/vfs.h>
  78 #endif
  79
  80 #ifdef MOUNTED_GETMNTENT1       /* 4.3BSD, SunOS, HP-UX, Dynix, Irix.  */
  81 /* Return the value of the hexadecimal number represented by CP.
  82    No prefix (like '0x') or suffix (like 'h') is expected to be
  83    part of CP. */
  84
  85 static int
  86 xatoi (cp)
  87      char *cp;
  88 {
  89   int val;
  90
  91   val = 0;
  92   while (*cp)
  93     {
  94       if (*cp >= 'a' && *cp <= 'f')
  95         val = val * 16 + *cp - 'a' + 10;
  96       else if (*cp >= 'A' && *cp <= 'F')
  97         val = val * 16 + *cp - 'A' + 10;
  98       else if (*cp >= '0' && *cp <= '9')
  99         val = val * 16 + *cp - '0';
 100       else
 101         break;
 102       cp++;
 103     }
 104   return val;
 105 }
 106 #endif /* MOUNTED_GETMNTENT1.  */
 107
 108 #ifdef MOUNTED_GETMNTINFO       /* 4.4BSD.  */
 109 static char *
 110 fstype_to_string (t)
 111      short t;
 112 {
 113   switch (t)
 114     {
 115     case MOUNT_UFS:
 116       return "ufs";
 117     case MOUNT_NFS:
 118       return "nfs";
 119     case MOUNT_PC:
 120       return "pc";
 121 #ifdef MOUNT_MFS
 122     case MOUNT_MFS:
 123       return "mfs";
 124 #endif
 125 #ifdef MOUNT_LO
 126     case MOUNT_LO:
 127       return "lo";
 128 #endif
 129 #ifdef MOUNT_TFS
 130     case MOUNT_TFS:
 131       return "tfs";
 132 #endif
 133 #ifdef MOUNT_TMP
 134     case MOUNT_TMP:
 135       return "tmp";
 136 #endif
 137     default:
 138       return "?";
 139     }
 140 }
 141 #endif /* MOUNTED_GETMNTINFO */
 142
 143 #ifdef MOUNTED_VMOUNT           /* AIX.  */
 144 static char *
 145 fstype_to_string (t)
 146      int t;
 147 {
 148   struct vfs_ent *e;
 149
 150   e = getvfsbytype (t);
 151   if (!e || !e->vfsent_name)
 152     return "none";
 153   else
 154     return e->vfsent_name;
 155 }
 156 #endif /* MOUNTED_VMOUNT */
 157
 158 /* Return a list of the currently mounted filesystems, or NULL on error.
 159    Add each entry to the tail of the list so that they stay in order.
 160    If NEED_FS_TYPE is nonzero, ensure that the filesystem type fields in
 161    the returned list are valid.  Otherwise, they might not be.
 162    If ALL_FS is zero, do not return entries for filesystems that
 163    are automounter (dummy) entries.  */
 164
 165 struct mount_entry *
 166 read_filesystem_list (need_fs_type, all_fs)
 167      int need_fs_type, all_fs;
 168 {
 169   struct mount_entry *mount_list;
 170   struct mount_entry *me;
 171   struct mount_entry *mtail;
 172
 173   /* Start the list off with a dummy entry. */
 174   me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry));
 175   me->me_next = NULL;
 176   mount_list = mtail = me;
 177
 178 #ifdef MOUNTED_GETMNTENT1       /* 4.3BSD, SunOS, HP-UX, Dynix, Irix.  */
 179   {
 180     struct mntent *mnt;
 181     char *table = MOUNTED;
 182     FILE *fp;
 183     char *devopt;
 184
 185     fp = setmntent (table, "r");
 186     if (fp == NULL)
 187       return NULL;
 188
 189     while ((mnt = getmntent (fp)))
 190       {
 191         if (!all_fs && (!strcmp (mnt->mnt_type, "ignore")
 192                         || !strcmp (mnt->mnt_type, "auto")))
 193           continue;
 194
 195         me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry));
 196         me->me_devname = xstrdup (mnt->mnt_fsname);
 197         me->me_mountdir = xstrdup (mnt->mnt_dir);
 198         me->me_type = xstrdup (mnt->mnt_type);
 199         devopt = strstr (mnt->mnt_opts, "dev=");
 200         if (devopt)
 201           {
 202             if (devopt[4] == '0' && (devopt[5] == 'x' || devopt[5] == 'X'))
 203               me->me_dev = xatoi (devopt + 6);
 204             else
 205               me->me_dev = xatoi (devopt + 4);
 206           }
 207         else
 208           me->me_dev = -1;      /* Magic; means not known yet. */
 209         me->me_next = NULL;
 210
 211         /* Add to the linked list. */
 212         mtail->me_next = me;
 213         mtail = me;
 214       }
 215
 216     if (endmntent (fp) == 0)
 217       return NULL;
 218   }
 219 #endif /* MOUNTED_GETMNTENT1. */
 220
 221 #ifdef MOUNTED_GETMNTINFO       /* 4.4BSD.  */
 222   {
 223     struct statfs *fsp;
 224     int entries;
 225
 226     entries = getmntinfo (&fsp, MNT_NOWAIT);
 227     if (entries < 0)
 228       return NULL;
 229     while (entries-- > 0)
 230       {
 231         me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry));
 232         me->me_devname = xstrdup (fsp->f_mntfromname);
 233         me->me_mountdir = xstrdup (fsp->f_mntonname);
 234         me->me_type = fstype_to_string (fsp->f_type);
 235         me->me_dev = -1;        /* Magic; means not known yet. */
 236         me->me_next = NULL;
 237
 238         /* Add to the linked list. */
 239         mtail->me_next = me;
 240         mtail = me;
 241         fsp++;
 242       }
 243   }
 244 #endif /* MOUNTED_GETMNTINFO */
 245
 246 #ifdef MOUNTED_GETMNT           /* Ultrix.  */
 247   {
 248     int offset = 0;
 249     int val;
 250     struct fs_data fsd;
 251
 252     while ((val = getmnt (&offset, &fsd, sizeof (fsd), NOSTAT_MANY,
 253                           (char *) 0)) > 0)
 254       {
 255         me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry));
 256         me->me_devname = xstrdup (fsd.fd_req.devname);
 257         me->me_mountdir = xstrdup (fsd.fd_req.path);
 258         me->me_type = gt_names[fsd.fd_req.fstype];
 259         me->me_dev = fsd.fd_req.dev;
 260         me->me_next = NULL;
 261
 262         /* Add to the linked list. */
 263         mtail->me_next = me;
 264         mtail = me;
 265       }
 266     if (val < 0)
 267       return NULL;
 268   }
 269 #endif /* MOUNTED_GETMNT. */
 270
 271 #if defined (MOUNTED_FREAD) || defined (MOUNTED_FREAD_FSTYP) /* SVR[23].  */
 272   {
 273     struct mnttab mnt;
 274     char *table = "/etc/mnttab";
 275     FILE *fp;
 276
 277     fp = fopen (table, "r");
 278     if (fp == NULL)
 279       return NULL;
 280
 281     while (fread (&mnt, sizeof mnt, 1, fp) > 0)
 282       {
 283         me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry));
 284 #ifdef GETFSTYP                 /* SVR3.  */
 285         me->me_devname = xstrdup (mnt.mt_dev);
 286 #else
 287         me->me_devname = xmalloc (strlen (mnt.mt_dev) + 6);
 288         strcpy (me->me_devname, "/dev/");
 289         strcpy (me->me_devname + 5, mnt.mt_dev);
 290 #endif
 291         me->me_mountdir = xstrdup (mnt.mt_filsys);
 292         me->me_dev = -1;        /* Magic; means not known yet. */
 293         me->me_type = "";
 294 #ifdef GETFSTYP                 /* SVR3.  */
 295         if (need_fs_type)
 296           {
 297             struct statfs fsd;
 298             char typebuf[FSTYPSZ];
 299
 300             if (statfs (me->me_mountdir, &fsd, sizeof fsd, 0) != -1
 301                 && sysfs (GETFSTYP, fsd.f_fstyp, typebuf) != -1)
 302               me->me_type = xstrdup (typebuf);
 303           }
 304 #endif
 305         me->me_next = NULL;
 306
 307         /* Add to the linked list. */
 308         mtail->me_next = me;
 309         mtail = me;
 310       }
 311
 312     if (fclose (fp) == EOF)
 313       return NULL;
 314   }
 315 #endif /* MOUNTED_FREAD || MOUNTED_FREAD_FSTYP.  */
 316
 317 #ifdef MOUNTED_GETMNTENT2       /* SVR4.  */
 318   {
 319     struct mnttab mnt;
 320     char *table = MNTTAB;
 321     FILE *fp;
 322     int ret;
 323
 324     fp = fopen (table, "r");
 325     if (fp == NULL)
 326       return NULL;
 327
 328     while ((ret = getmntent (fp, &mnt)) == 0)
 329       {
 330         me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry));
 331         me->me_devname = xstrdup (mnt.mnt_special);
 332         me->me_mountdir = xstrdup (mnt.mnt_mountp);
 333         me->me_type = xstrdup (mnt.mnt_fstype);
 334         me->me_dev = -1;        /* Magic; means not known yet. */
 335         me->me_next = NULL;
 336
 337         /* Add to the linked list. */
 338         mtail->me_next = me;
 339         mtail = me;
 340       }
 341
 342     if (ret > 0)
 343       return NULL;
 344    if (fclose (fp) == EOF)
 345       return NULL;
 346   }
 347 #endif /* MOUNTED_GETMNTENT2.  */
 348
 349 #ifdef MOUNTED_VMOUNT           /* AIX.  */
 350   {
 351     int bufsize;
 352     char *entries, *thisent;
 353     struct vmount *vmp;
 354
 355     /* Ask how many bytes to allocate for the mounted filesystem info.  */
 356     mntctl (MCTL_QUERY, sizeof bufsize, (struct vmount *) &bufsize);
 357     entries = xmalloc (bufsize);
 358
 359     /* Get the list of mounted filesystems.  */
 360     mntctl (MCTL_QUERY, bufsize, (struct vmount *) entries);
 361
 362     for (thisent = entries; thisent < entries + bufsize;
 363          thisent += vmp->vmt_length)
 364       {
 365         vmp = (struct vmount *) thisent;
 366         me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry));
 367         if (vmp->vmt_flags & MNT_REMOTE)
 368           {
 369             char *host, *path;
 370
 371             /* Prepend the remote pathname.  */
 372             host = thisent + vmp->vmt_data[VMT_HOSTNAME].vmt_off;
 373             path = thisent + vmp->vmt_data[VMT_OBJECT].vmt_off;
 374             me->me_devname = xmalloc (strlen (host) + strlen (path) + 2);
 375             strcpy (me->me_devname, host);
 376             strcat (me->me_devname, ":");
 377             strcat (me->me_devname, path);
 378           }
 379         else
 380           {
 381             me->me_devname = xstrdup (thisent +
 382                                       vmp->vmt_data[VMT_OBJECT].vmt_off);
 383           }
 384         me->me_mountdir = xstrdup (thisent + vmp->vmt_data[VMT_STUB].vmt_off);
 385         me->me_type = xstrdup (fstype_to_string (vmp->vmt_gfstype));
 386         me->me_dev = -1;        /* vmt_fsid might be the info we want.  */
 387         me->me_next = NULL;
 388
 389         /* Add to the linked list. */
 390         mtail->me_next = me;
 391         mtail = me;
 392       }
 393     free (entries);
 394   }
 395 #endif /* MOUNTED_VMOUNT. */
 396
 397   /* Free the dummy head. */
 398   me = mount_list;
 399   mount_list = mount_list->me_next;
 400   free (me);
 401   return mount_list;
 402 }