#! /bin/sh
# This is a shell archive.  Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file".  To overwrite existing
# files, type "sh file -c".  You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g..  If this archive is complete, you
# will see the following message at the end:
#		"End of archive 2 (of 3)."
# Contents:  di.c
# Wrapped by root@seer on Thu Feb 24 10:15:51 2000
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'di.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'di.c'\"
else
echo shar: Extracting \"'di.c'\" \(97566 characters\)
sed "s/^X//" >'di.c' <<'END_OF_FILE'
X#ifndef lint
Xstatic char    di_c_sccsid [] =
X"@(#)di.c	1.21";
Xstatic char    di_c_rcsid [] =
X"$Id$";
Xstatic char    di_c_source [] =
X"$Source$";
Xstatic char    copyright [] =
X"Copyright 1994-1999 Brad Lanam, Walnut Creek, CA";
X#endif
X
X/*
X * di.c
X *
X *   Copyright 1994-1999 Brad Lanam,  Walnut Creek, CA
X *
X *  Warning: Do not replace your systems 'df' command with this program.
X *           You will in all likelihood break your installation procedures.
X *
X *  Usage: di -AafntwWx [file [...]]
X *            -A   : print all fields (used for debugging)
X *            -a   : print all mounted devices; normally, those
X *                   with 0 total blocks are not printed.  e.g.
X *                   /dev/proc, /dev/fd.
X *            -d x : size to print blocks in (p, k, m, g, <n>)
X *            -f x : use format string <x>
X *            -i x : ignore filesystem type(s) x, where x is a comma
X *                   separated list.
X *            -I x : include only filesystem type(s) x, where x is a
X *                   separated list.
X *            -l   : local filesystems only
X *            -n   : don't print header
X *            -s t : sort type
X *            -t   : print totals
X *            -w n : use <n> for the block print width (default 8).
X *            -W n : use <n> for the inode print width (default 7).
X *            -x n : debug level <n>
X *
X *  All values are reported in K (1024 bytes).
X *
X *  Sort types (by name is default):
X *      n - none (mount order)
X *      s - special
X *      r - reverse sort
X *
X *  Format string values:
X *      m - mount point
X *      M - mount point, full length
X *      b - total kbytes
X *      B - total kbytes available for use by the user.
X *             [ (tot - (free - avail) ]
X *      u - kbytes used (actual number of kbytes used) [ (tot - free) ]
X *      c - calculated number of kbytes used [ (tot - avail) ]
X *      f - kbytes free
X *      v - kbytes available
X *      p - percentage not available for use.
X *          (number of blocks not available for use / total disk space)
X *             [ (tot - avail) / tot ]
X *      1 - percentage used.
X *          (actual number of blocks used / total disk space)
X *             [ (tot - free) / tot ]
X *      2 - percentage of user-available space in use (bsd style).
X *          Note that values over 100% are possible.
X *          (actual number of blocks used / disk space available to user)
X *             [ (tot - free) / (tot - (free - avail)) ]
X *      i - total i-nodes (files)
X *      U - used i-nodes
X *      F - free i-nodes
X *      P - percent i-nodes used     [ (tot - avail) / tot ]
X *      s - filesystem name (special)
X *      S - filesystem name (special), full length
X *      t - disk partition type
X *      T - disk partition type (full length)
X *      I - mount time
X *      O - mount options.
X *
X *  System V.4 `/usr/bin/df -v` Has format: msbuf1 (w/-d512 option: 512 byte blocks)
X *  System V.4 `/usr/bin/df -k` Has format: sbcvpm
X *  System V.4 `/usr/ucb/df`    Has format: sbuv2m
X *
X *  The default format string for this program is: smbuvpT
X *
X *  The environment variable "DIFMT" may be set to the desired format
X *  string.
X *
X *  Note that for filesystems that do not have (S512K fs) or systems (SysV.3)
X *  that do not report available blocks, the number of available blocks is
X *  equal to the number of free blocks.
X *
X *  HISTORY:
X *     24 feb 2000 bll
X *          Updated for BeOS.  This required changes to support c++
X *          compilation (ansi style functions).  Fixes for linux.
X *     17 dec 99 bll
X *          Added sys/fs_types.h (Digital Unix (tru64)).
X *     3 jan 99 bll
X *          Finalize changes for metaconfig.
X *          Always get stat() for disk device.
X *          Remove duplicate disks from display.
X *          Add NetBSD, Unicos, IRIX changes
X *     8 sep 97 bll
X *          Solaris large file version; AIX typo fix
X *     15 aug 95 bll
X *          Ignore will check the file system type beforehand if possible.
X *          Fixed local mount stuff for osf1.
X *     9 aug 95 bll
X *          Changed totals to use double; the totals can now be displayed with
X *          any wanted block size; sizes > one k have a single decimal point.
X *          -d option specifies block size.
X *          -l option for local file systems only.
X *     7 aug 95 bll
X *          convex fix.
X *     29 jul 95 bll
X *          Fixed bsdi variants.  The fragment size wasn't being supported.
X *     22 jul 95 bll
X *          fix problem with display widths in conjunction with ignore/include
X *     20 feb 95 bll
X *          added ignore/include file system type lists.
X *     8 jan 95 bll
X *          Added FreeBsd 2.x
X *     6 dec 94 bll
X *          sco nfs 'nothing' fix.
X *     28 nov 94 bll
X *          bsdi [bag@clipper.cs.kiev.ua (Andrey Blochintsev)]
X *     24 nov 94 bll
X *          Added FreeBsd - like OSF/1, but w/o nice mount name table.
X *     1 may 94 bll
X *          removed ill conceived mount options stuff.  Added AIX
X *          (Erik O'Shaughnessy eriko@risc.austin.ibm.com).
X *          Added coherent.
X *     9 apr 94 bll
X *          T format from Bill Davidsen. SunOS file system type.
X *          mount options.
X *     7 apr 94 bll
X *          cdrom under solaris returning -1 in addition to -2.
X *          Changed the test to test for any negative value.
X *    5 apr 94 pm
X *         Filesystem type info, and whether its read-write, readonly
X *         etc is in the mntent structure.  Added code to support it.
X *                  [Pat Myrto <pat@rwing.uucp>]
X *    25 mar 94 bll
X *          sun had f_bfree instead of f_bavail!
X *          Xenix, linux.
X *          -w, -W options, -B option, fixed width for -f M, -f S.
X *          Usage.  Allow other characters in format string.
X *     4 mar 94 bll
X *          -f B, bug fixes. bcopy.
X *          Solaris cdrom reports total, not free or avail.
X *          Allow command line specification of file names.
X *     3 mar 94 bll
X *          support for OSF/1 and ULTRIX, -F, -f M, -f S
X *                  [mogul@wrl.dec.com (Jeffrey Mogul)]
X *     3 mar 94   bll
X *          Allow command line specification of filename (s).
X *          Sort output.  Test of nonexistent return code removed.
X *     1 mar 94   bll
X *          # of inodes can be -1L if unreportable.
X *                  [jjb@jagware.bcc.com (J.J.Bailey)]
X *                  [Mark Neale <mark@edscom.demon.co.uk>]
X *          getDiskInfo () returning garbage
X *                  [costales@ICSI.Berkeley.EDU (Bryan Costales)]
X *                  [Mark Neale <mark@edscom.demon.co.uk>]
X *          pyramid #ifdefs
X *                  [vogelke@c-17igp.wpafb.af.mil (Contr Karl Vogel)]
X *          name must be maxpathlen
X *                  [Mark Neale <mark@edscom.demon.co.uk>]
X *          error prints/compile warnings.
X *                  [Mark Neale <mark@edscom.demon.co.uk>]
X *
X */
X
X#include "config.h"
X
X#include <stdio.h>
X#include <ctype.h>
X#include <errno.h>
X#if defined (I_STDLIB)
X# include <stdlib.h>
X#endif
X#if defined (I_SYS_TYPES)
X# include <sys/types.h>
X#endif
X#if defined (I_LIMITS)
X# include <limits.h>
X#endif
X#if defined (I_STRING)
X# include <string.h>
X#else
X# include <strings.h>
X#endif
X#if defined (I_MEMORY)
X# include <memory.h>
X#endif
X#if defined (I_MALLOC)
X# include <malloc.h>
X#endif
X#if defined (I_UNISTD)
X# include <unistd.h>
X#endif
X#if defined (I_TIME)
X# include <time.h>
X#endif
X#if defined (I_SYS_TIME)
X# include <sys/time.h>
X#endif
X#if defined (I_SYS_STAT)
X# include <sys/stat.h>
X#endif
X#if defined (I_SYS_PARAM)
X# include <sys/param.h>
X#endif
X
X#if defined (I_SYS_MNTTAB)
X# include <sys/mnttab.h>
X#endif
X#if defined (I_MNTTAB)
X# include <mnttab.h>
X#endif
X#if defined (I_MNTENT)
X# include <mntent.h>
X#endif
X#if defined (I_SYS_MNTENT)
X# include <sys/mntent.h>
X#endif
X#if defined (I_SYS_MOUNT)
X# include <sys/mount.h>
X#endif
X#if defined (I_SYS_FSTYPES)
X# include <sys/fstypes.h>
X#endif
X#if defined (I_SYS_FS_TYPES)
X# include <sys/fs_types.h>
X#endif
X#if defined (I_SYS_MNTCTL)
X# include <sys/mntctl.h>
X#endif
X#if defined (I_SYS_VMOUNT)
X# include <sys/vmount.h>
X#endif
X#if defined (I_SYS_STATFS) && ! defined (I_SYS_STATVFS)
X# include <sys/statfs.h>
X#endif
X#if defined (I_FSHELP)
X# include <fshelp.h>
X#endif
X#if defined (I_SYS_STATVFS)
X# include <sys/statvfs.h>
X#endif
X#if defined (I_SYS_FSTYP)
X# include <sys/fstyp.h>
X# define DI_TYPE_LEN          FSTYPSZ
X#endif
X#if defined (I_SYS_VFS)
X# include <sys/vfs.h>
X#endif
X#if defined (I_SYS_VFSTAB)
X# include <sys/vfstab.h>
X# if ! defined (DI_TYPE_LEN)
X#  define DI_TYPE_LEN         FSTYPSZ
X# endif
X#endif
X#if defined (I_FSHELP)
X# include <fshelp.h>
X#endif
X
X#if defined (I_WINDOWS)
X# include <windows.h>            /* windows */
X#endif
X#if defined (I_KERNFSINFO)
X# include <kernel/fs_info.h>
X#endif
X#if defined (I_STOR_DIRECTORY)
X# include <storage/Directory.h>
X#endif
X#if defined (I_STOR_ENTRY)
X# include <storage/Entry.h>
X#endif
X/*#if defined (I_STOR_NODE)
X# include <storage/Node.h>
X#endif  */
X#if defined (I_STOR_PATH)
X# include <storage/Path.h>
X#endif
X
X#if ! defined (HAS_MEMCPY) && ! defined (memcpy)
X# if ! defined (HAS_BCOPY)
X   error No memcpy/bcopy available.
X# else
X#  define memcpy(dst, src, cnt)     (bcopy((src), (dst), (cnt)), dst)
X# endif
X#endif
X
X#if ! defined (MAXPATHLEN)
X# if defined (_POSIX_PATH_MAX)
X#  define MAXPATHLEN        _POSIX_PATH_MAX
X# else
X#  if defined (PATH_MAX)
X#   define MAXPATHLEN        PATH_MAX
X#  endif
X#  if defined (LPNMAX)
X#   define MAXPATHLEN         LPNMAX
X#  endif
X# endif
X#endif
X
X#if ! defined (DI_TYPE_LEN)
X# define DI_TYPE_LEN          16
X#endif
X
X#define DI_FSMAGIC 5   /* base AIX configuration has 5 file systems */
X
X#if defined (HAS_STATFS_SYSV3) && ! defined (HAS_STATVFS) && \
X    ! defined (HAS_GETMNTINFO) && ! defined (HAS_GETMNT) /* SYSV.3 */
X# if defined (Ubsize) && Ubsize != ""
X#  define UBSIZE            Ubsize
X# endif
X# if ! defined (UBSIZE)
X#  define UBSIZE            512
X# endif
X#endif
X
X#if (defined (HAS_GETMNTENT) || defined (HAS_STATFS_BSD) || \
X        defined (HAS_STATFS_SYSV3)) && ! defined (HAS_GETMNTINFO) && \
X        ! defined (HAS_GETMNT)
X# if defined (MOUNTED)
X#  define DI_MOUNT_FILE        MOUNTED
X# else
X#  if defined (MNTTAB)
X#   define DI_MOUNT_FILE       MNTTAB
X#  else
X#   define DI_MOUNT_FILE       "/etc/mnttab"
X#  endif
X# endif
X#endif
X
X#if ! defined (HAS_MEMSET) && ! defined (memset)
X# if ! defined (HAS_BZERO)
X   error No memset/bzero available.
X# else
X#  define memset(s,c,n)    (bzero ((s), (n)), s)
X# endif
X#endif
X
X#if defined (NEED_GETENV_DEF)
X  extern char *getenv _((char *));
X#endif
X
X#if defined (NEED_STATFS_DEFS)
X  extern int statfs _((char *, struct statfs *));
X#endif
X
X#if defined (NEED_ERRNO_DEFS)
Xextern int     errno;
X#endif
X
X#if (defined (_LARGEFILE_SOURCE) || defined (_LARGEFILE64_SOURCE)) && \
X        _FILE_OFFSET_BITS == 64
X# define HAS_64BIT_STATFS_FLDS 1
X#endif
X
X#if defined (HAS_64BIT_STATFS_FLDS)
Xtypedef unsigned long long _fs_size_t;
Xtypedef long long _s_fs_size_t;
X#else
Xtypedef unsigned long _fs_size_t;
Xtypedef long _s_fs_size_t;
X#endif
X
X#if ! defined (HAS_OPTIND)
X  extern int optind;
X  extern char *optarg;
X#endif
X
X/* end of system specific includes/configurations */
X
X#if ! defined (TRUE)
X# define TRUE             1
X#endif
X#if ! defined (FALSE)
X# define FALSE            0
X#endif
X
X#define DI_F_ALL               0x00000001
X#define DI_F_LOCAL_ONLY        0x00000002
X#define DI_F_TOTAL             0x00000010
X#define DI_F_NO_HEADER         0x00000020
X#define DI_F_DEBUG_HDR         0x00000040
X
X    /* mount information */
X#define DI_FMT_MOUNT           'm'
X#define DI_FMT_MOUNT_FULL      'M'
X#define DI_FMT_SPECIAL         's'
X#define DI_FMT_SPECIAL_FULL    'S'
X#define DI_FMT_TYPE            't'
X#define DI_FMT_TYPE_FULL       'T'
X
X    /* disk information */
X#define DI_FMT_BTOT            'b'
X#define DI_FMT_BTOT_AVAIL      'B'
X#define DI_FMT_BUSED           'u'
X#define DI_FMT_BCUSED          'c'
X#define DI_FMT_BFREE           'f'
X#define DI_FMT_BAVAIL          'v'
X#define DI_FMT_BPERC_AVAIL     'p'
X#define DI_FMT_BPERC_FREE      '1'
X#define DI_FMT_BPERC_BSD       '2'
X#define DI_FMT_ITOT            'i'
X#define DI_FMT_IUSED           'U'
X#define DI_FMT_IFREE           'F'
X#define DI_FMT_IPERC           'P'
X#define DI_FMT_MOUNT_TIME      'I'
X#define DI_FMT_MOUNT_OPTIONS   'O'
X
X#define DI_IGNORE           0
X#define DI_OK               1
X#define DI_BAD              2
X
X#define DI_SORT_NONE        0
X#define DI_SORT_NAME        1
X#define DI_SORT_SPECIAL     2
X
X#define DI_SORT_ASCENDING   1
X#define DI_SORT_DESCENDING  -1
X
X#define DI_UNKNOWN_DEV      -1L
X#define DI_LIST_SEP         ","
X
X#define DI_ALL_FORMAT          "MTS\n\tIO\n\tbuf1\n\tbcvp\n\tBuv2\n\tiUFP"
X
X#define DI_HALF_K              512.0
X#define DI_ONE_K               1024.0
X#define DI_ONE_MEG             1048576.0
X#define DI_ONE_GIG             1073241824.0
X
X#if ! defined (MAXPATHLEN)
X# define MAXPATHLEN         255
X#endif
X#define DI_SPEC_NAME_LEN       MAXPATHLEN
X#define DI_OPT_LEN             MAXPATHLEN
X#define DI_MNT_TIME_LEN        24
X
X#define DI_RETRY_COUNT         5
X#define DI_MAX_REMOTE_TYPES    20
X
X   /* you may want to change some of these values.  Be sure to change all */
X   /* related entries.                                                    */
X/* #define DI_DEFAULT_FORMAT      "mbuvpiUFP" */
X#if ! defined (DI_DEFAULT_FORMAT)
X# define DI_DEFAULT_FORMAT      "smbuvpT"
X#endif
X#if defined (HAS_MNT_TIME)
X# define DI_DEF_MOUNT_FORMAT    "MSTIO"
X#else
X# define DI_DEF_MOUNT_FORMAT    "MSTO"
X#endif
X#define DI_PERC_FMT            "%3.0f%% "
X#define DI_PERC_LBL_FMT        "%5s"
X#define DI_NAME_LEN            MAXPATHLEN
X#define DI_FSTYPE_FMT          "%-7.7s"
X#define DI_MOUNT_FMT           "%-15.15s"
X#define DI_SPEC_FMT            "%-18.18s"
X
X#define DI_UNKNOWN_FSTYPE      "Unknown fstyp %.2d"
X
Xtypedef unsigned long _ulong;
Xtypedef int (*DI_SORT_FUNC) _((char *, char *));
X
Xtypedef struct
X{
X    double          totalBlocks;
X    double          freeBlocks;
X    double          availBlocks;
X    _fs_size_t      totalInodes;
X    _fs_size_t      freeInodes;
X    _fs_size_t      availInodes;
X    _ulong          st_dev;                      /* disk device number   */
X    _ulong          sp_dev;                      /* special device number*/
X    _ulong          sp_rdev;                     /* special rdev #       */
X    char            printFlag;                   /* do we want to print  */
X                                                 /* this entry?          */
X    char            isLocal;                     /* is this mount point  */
X                                                 /* local?               */
X    char            name [DI_NAME_LEN + 1];         /* mount point          */
X    char            special [DI_SPEC_NAME_LEN + 1]; /* special device name  */
X    char            fsType [DI_TYPE_LEN + 1];       /* type of file system  */
X    char            options [DI_OPT_LEN + 1];
X    char            mountTime [DI_MNT_TIME_LEN + 1];
X} DiskInfo;
X
Xstatic DiskInfo     *diskInfo = { (DiskInfo *) NULL };
Xstatic int          diCount = { 0 };
Xstatic int          debug = { 0 };
Xstatic _ulong       flags = { 0 };
Xstatic int          sortType = { DI_SORT_NAME };
Xstatic int          sortOrder = { DI_SORT_ASCENDING };
Xstatic char         *formatString = { DI_DEFAULT_FORMAT };
Xstatic char         mountFormat [20];
X static char         specialFormat [20];
Xstatic char         typeFormat [20];
Xstatic char         optFormat [20];
Xstatic char         mTimeFormat [20];
Xstatic int          width = { 8 };
Xstatic int          inodeWidth = { 7 };
Xstatic char         blockFormat [20];
Xstatic char         blockLabelFormat [20];
Xstatic char         inodeFormat [20];
Xstatic char         inodeLabelFormat [20];
Xstatic char         **ignoreList = { (char **) NULL };
Xstatic char         **includeList = { (char **) NULL };
Xstatic double       dispBlockSize = { DI_ONE_MEG };
Xstatic int          remoteFileSystemCount = { 0 };
Xstatic char         remoteFileSystemTypes [DI_MAX_REMOTE_TYPES][DI_TYPE_LEN];
X
X
Xstatic void cleanup             _((void));
Xstatic void printDiskInfo       _((void));
Xstatic void printInfo           _((DiskInfo *));
Xstatic void addTotals           _((DiskInfo *, DiskInfo *));
Xstatic void printTitle          _((void));
Xstatic void printPerc           _((double, double, char *));
Xstatic char *Realloc            _((char *, long));
Xstatic void sortArray           _((char *, int, int, DI_SORT_FUNC));
Xstatic int  diCompare           _((char *, char *));
Xstatic void getDiskStatInfo     _((void));
Xstatic void getDiskSpecialInfo  _((void));
Xstatic void printFileInfo       _((int, int, char *[]));
Xstatic void checkDiskInfo       _((void));
Xstatic void usage               _((void));
Xstatic void processArgs         _((int, char *[]));
Xstatic void parseList           _((char ***, char *));
Xstatic void checkIgnoreList     _((DiskInfo *));
Xstatic void checkIncludeList    _((DiskInfo *));
X
Xstatic int  getDiskEntries      _((void));
Xstatic void getDiskInfo         _((void));
X
Xint
X#if defined (CAN_PROTOTYPE)
Xmain (int argc, char *argv [])
X#else
Xmain (argc, argv)
X    int                 argc;
X    char                *argv [];
X#endif
X{
X    char                *ptr;
X
X
X    ptr = argv [0] + strlen (argv [0]) - 2;
X    if (memcmp (ptr, MPROG, 2) == 0)
X    {
X        formatString = DI_DEF_MOUNT_FORMAT;
X    }
X    else    /* don't use DIFMT env var if running mi. */
X    {
X        if ((ptr = getenv ("DIFMT")) != (char *) NULL)
X        {
X            formatString = ptr;
X        }
X    }
X
X    processArgs (argc, argv);
X    if (debug > 0)
X    {
X        printf ("di ver $Revision$\n");
X    }
X
X    if (getDiskEntries () < 0)
X    {
X        cleanup ();
X        exit (1);
X    }
X
X    getDiskInfo ();
X    getDiskSpecialInfo ();
X    checkDiskInfo ();
X    if (optind < argc)
X    {
X        getDiskStatInfo ();
X        printFileInfo (optind, argc, argv);
X    }
X    else
X    {
X        printDiskInfo ();
X    }
X
X    cleanup ();
X    exit (0);
X}
X
X/*
X * cleanup
X *
X * free up allocated memory
X *
X */
X
Xstatic void
X#if defined (CAN_PROTOTYPE)
Xcleanup (void)
X#else
Xcleanup ()
X#endif
X{
X    char        **lptr;
X
X
X    if (diskInfo != (DiskInfo *) NULL)
X    {
X        free ((char *) diskInfo);
X    }
X
X    if (ignoreList != (char **) NULL)
X    {
X        lptr = ignoreList;
X        while (*lptr != (char *) NULL)
X        {
X            free ((char *) *lptr);
X            ++lptr;
X        }
X        free ((char *) ignoreList);
X    }
X
X    if (includeList != (char **) NULL)
X    {
X        lptr = includeList;
X        while (*lptr != (char *) NULL)
X        {
X            free ((char *) *lptr);
X            ++lptr;
X        }
X        free ((char *) includeList);
X    }
X}
X
X/*
X * printDiskInfo
X *
X * Print out the disk information table.
X * Loops through all mounted disks, prints and calculates totals.
X *
X */
X
Xstatic void
X#if defined (CAN_PROTOTYPE)
XprintDiskInfo (void)
X#else
XprintDiskInfo ()
X#endif
X{
X    int                 i;
X    DiskInfo            totals;
X
X
X    memset ((char *) &totals, '\0', sizeof (DiskInfo));
X    strcpy (totals.name, "Total");
X    totals.printFlag = DI_OK;
X
X    if ((flags & DI_F_NO_HEADER) != DI_F_NO_HEADER)
X    {
X        printTitle ();
X    }
X
X    if (sortType != DI_SORT_NONE)
X    {
X        sortArray ((char *) diskInfo, sizeof (DiskInfo), diCount, diCompare);
X    }
X
X    for (i = 0; i < diCount; ++i)
X    {
X        if (( (flags & DI_F_ALL) == DI_F_ALL &&
X                diskInfo [i].printFlag != DI_BAD) ||
X                diskInfo [i].printFlag == DI_OK)
X        {
X            printInfo (&diskInfo [i]);
X            addTotals (&diskInfo [i], &totals);
X        }
X    }
X
X    if ((flags & DI_F_TOTAL) == DI_F_TOTAL &&
X            (flags & DI_F_NO_HEADER) != DI_F_NO_HEADER)
X    {
X        printInfo (&totals);
X    }
X}
X
X/*
X * printInfo
X *
X * Print the information for a single partition.  Loop through the
X * format string and print the particular items wanted.
X *
X */
X
Xstatic void
X#if defined (CAN_PROTOTYPE)
XprintInfo (DiskInfo *diskInfo)
X#else
XprintInfo (diskInfo)
X    DiskInfo            *diskInfo;
X#endif
X{
X    double              used;
X    double              totAvail;
X    char                *ptr;
X    int                 valid;
X
X
X    ptr = formatString;
X    while (*ptr)
X    {
X        valid = TRUE;
X
X        switch (*ptr)
X        {
X            case DI_FMT_MOUNT:
X            {
X                printf (DI_MOUNT_FMT, diskInfo->name);
X                break;
X            }
X
X            case DI_FMT_MOUNT_FULL:
X            {
X                printf (mountFormat, diskInfo->name);
X                break;
X            }
X
X            case DI_FMT_BTOT:
X            {
X                printf (blockFormat, diskInfo->totalBlocks);
X                break;
X            }
X
X            case DI_FMT_BTOT_AVAIL:
X            {
X                printf (blockFormat, diskInfo->totalBlocks -
X                        (diskInfo->freeBlocks - diskInfo->availBlocks));
X                break;
X            }
X
X            case DI_FMT_BUSED:
X            {
X                printf (blockFormat, diskInfo->totalBlocks -
X                        diskInfo->freeBlocks);
X                break;
X            }
X
X            case DI_FMT_BCUSED:
X            {
X                printf (blockFormat, diskInfo->totalBlocks - diskInfo->availBlocks);
X                break;
X            }
X
X            case DI_FMT_BFREE:
X            {
X                printf (blockFormat, diskInfo->freeBlocks);
X                break;
X            }
X
X            case DI_FMT_BAVAIL:
X            {
X                printf (blockFormat, diskInfo->availBlocks);
X                break;
X            }
X
X            case DI_FMT_BPERC_AVAIL:
X            {
X                used = diskInfo->totalBlocks - diskInfo->availBlocks;
X                totAvail = diskInfo->totalBlocks;
X                printPerc (used, totAvail, DI_PERC_FMT);
X                break;
X            }
X
X            case DI_FMT_BPERC_FREE:
X            {
X                used = diskInfo->totalBlocks - diskInfo->freeBlocks;
X                totAvail = diskInfo->totalBlocks;
X                printPerc (used, totAvail, DI_PERC_FMT);
X                break;
X            }
X
X            case DI_FMT_BPERC_BSD:
X            {
X                used = diskInfo->totalBlocks - diskInfo->freeBlocks;
X                totAvail = diskInfo->totalBlocks -
X                        (diskInfo->freeBlocks - diskInfo->availBlocks);
X                printPerc (used, totAvail, DI_PERC_FMT);
X                break;
X            }
X
X            case DI_FMT_ITOT:
X            {
X                printf (inodeFormat, diskInfo->totalInodes);
X                break;
X            }
X
X            case DI_FMT_IUSED:
X            {
X                printf (inodeFormat, diskInfo->totalInodes - diskInfo->freeInodes);
X                break;
X            }
X
X            case DI_FMT_IFREE:
X            {
X                printf (inodeFormat, diskInfo->freeInodes);
X                break;
X            }
X
X            case DI_FMT_IPERC:
X            {
X                used = diskInfo->totalInodes - diskInfo->availInodes;
X                totAvail = diskInfo->totalInodes;
X                printPerc (used, totAvail, DI_PERC_FMT);
X                break;
X            }
X
X            case DI_FMT_SPECIAL:
X            {
X                printf (DI_SPEC_FMT, diskInfo->special);
X                break;
X            }
X
X            case DI_FMT_SPECIAL_FULL:
X            {
X                printf (specialFormat, diskInfo->special);
X                break;
X            }
X
X            case DI_FMT_TYPE:
X            {
X                printf (DI_FSTYPE_FMT, diskInfo->fsType);
X                break;
X            }
X
X            case DI_FMT_TYPE_FULL:
X            {
X                printf (typeFormat, diskInfo->fsType);
X                break;
X            }
X
X            case DI_FMT_MOUNT_OPTIONS:
X            {
X                printf (optFormat, diskInfo->options);
X                break;
X            }
X
X            case DI_FMT_MOUNT_TIME:
X            {
X#if defined (HAS_MNT_TIME)
X                printf (mTimeFormat, diskInfo->mountTime);
X#endif
X                break;
X            }
X
X            default:
X            {
X                printf ("%c", *ptr);
X                valid = FALSE;
X                break;
X            }
X        }
X
X        ++ptr;
X        if (*ptr && valid)
X        {
X            printf (" ");
X        }
X    }
X
X    printf ("\n");
X}
X
X/*
X * addTotals
X *
X * Add up the totals for the blocks/inodes
X *
X */
X
Xstatic void
X#if defined (CAN_PROTOTYPE)
XaddTotals (DiskInfo *diskInfo, DiskInfo *totals)
X#else
XaddTotals (diskInfo, totals)
X    DiskInfo      *diskInfo;
X    DiskInfo      *totals;
X#endif
X{
X    totals->totalBlocks += diskInfo->totalBlocks;
X    totals->freeBlocks += diskInfo->freeBlocks;
X    totals->availBlocks += diskInfo->availBlocks;
X    totals->totalInodes += diskInfo->totalInodes;
X    totals->freeInodes += diskInfo->freeInodes;
X    totals->availInodes += diskInfo->availInodes;
X}
X
X/*
X * printTitle
X *
X * Loop through the format string and print the appropriate headings.
X *
X */
X
Xstatic void
X#if defined (CAN_PROTOTYPE)
XprintTitle (void)
X#else
XprintTitle ()
X#endif
X{
X    char                *ptr;
X    int                 valid;
X    char                tbuff [20];
X
X    if ((flags & DI_F_DEBUG_HDR) == DI_F_DEBUG_HDR)
X    {
X        printf ("di ver $Revision$ Default Format: %s\n",
X                DI_DEFAULT_FORMAT);
X    }
X
X    ptr = formatString;
X
X    while (*ptr)
X    {
X        valid = TRUE;
X
X        switch (*ptr)
X        {
X            case DI_FMT_MOUNT:
X            {
X                printf (DI_MOUNT_FMT, "Mount");
X                break;
X            }
X
X            case DI_FMT_MOUNT_FULL:
X            {
X                printf (mountFormat, "Mount");
X                break;
X            }
X
X            case DI_FMT_BTOT:
X            case DI_FMT_BTOT_AVAIL:
X            {
X                if (dispBlockSize == DI_ONE_K)
X                {
X                    printf (blockLabelFormat, "Kbytes");
X                }
X                else if (dispBlockSize == DI_ONE_MEG)
X                {
X                    printf (blockLabelFormat, "  Megs");
X                }
X                else if (dispBlockSize == DI_ONE_GIG)
X                {
X                    printf (blockLabelFormat, "  Gigs");
X                }
X                else if (dispBlockSize == DI_HALF_K)
X                {
X                    printf (blockLabelFormat, "  512b");
X                }
X                else
X                {
X                    sprintf (tbuff, "%6.0f", dispBlockSize);
X                    printf (blockLabelFormat, tbuff);
X                }
X                break;
X            }
X
X            case DI_FMT_BUSED:
X            case DI_FMT_BCUSED:
X            {
X                printf (blockLabelFormat, "Used");
X                break;
X            }
X
X            case DI_FMT_BFREE:
X            {
X                printf (blockLabelFormat, "Free");
X                break;
X            }
X
X            case DI_FMT_BAVAIL:
X            {
X                printf (blockLabelFormat, "Avail");
X                break;
X            }
X
X            case DI_FMT_BPERC_AVAIL:
X            case DI_FMT_BPERC_FREE:
X            case DI_FMT_BPERC_BSD:
X            {
X                printf (DI_PERC_LBL_FMT, "%used");
X                break;
X            }
X
X            case DI_FMT_ITOT:
X            {
X                printf (inodeLabelFormat, "Inodes");
X                break;
X            }
X
X            case DI_FMT_IUSED:
X            {
X                printf (inodeLabelFormat, "Used");
X                break;
X            }
X
X            case DI_FMT_IFREE:
X            {
X                printf (inodeLabelFormat, "Free");
X                break;
X            }
X
X            case DI_FMT_IPERC:
X            {
X                printf (DI_PERC_LBL_FMT, "%used");
X                break;
X            }
X
X            case DI_FMT_SPECIAL:
X            {
X                printf (DI_SPEC_FMT, "Filesystem");
X                break;
X            }
X
X            case DI_FMT_SPECIAL_FULL:
X            {
X                printf (specialFormat, "Filesystem");
X                break;
X            }
X
X            case DI_FMT_TYPE:
X            {
X                printf (DI_FSTYPE_FMT, "fsType");
X                break;
X            }
X
X            case DI_FMT_TYPE_FULL:
X            {
X                printf (typeFormat, "fs Type");
X                break;
X            }
X
X            case DI_FMT_MOUNT_OPTIONS:
X            {
X                printf (optFormat, "Options");
X                break;
X            }
X
X            case DI_FMT_MOUNT_TIME:
X            {
X#if defined (HAS_MNT_TIME)
X                printf (mTimeFormat, "Mount Time");
X#endif
X                break;
X            }
X
X            default:
X            {
X                printf ("%c", *ptr);
X                valid = FALSE;
X                break;
X            }
X        }
X
X        ++ptr;
X        if (*ptr && valid)
X        {
X            printf (" ");
X        }
X    }
X
X    printf ("\n");
X}
X
X/*
X * printPerc
X *
X * Calculate and print a percentage using the values and format passed.
X *
X */
X
Xstatic void
X#if defined (CAN_PROTOTYPE)
XprintPerc (double used, double totAvail, char *format)
X#else
XprintPerc (used, totAvail, format)
X    double      used;
X    double      totAvail;
X    char        *format;
X#endif
X{
X    double      perc;
X
X
X    if (totAvail > 0.0)
X    {
X        perc = used / totAvail;
X        perc *= 100.0;
X    }
X    else
X    {
X        perc = 0.0;
X    }
X    printf (format, perc);
X}
X
X
X/*
X * Realloc
X *
X * portable realloc
X *
X */
X
Xstatic char *
X#if defined (CAN_PROTOTYPE)
XRealloc (char *ptr, long size)
X#else
XRealloc (ptr, size)
X    char      *ptr;
X    long      size;
X#endif
X{
X    if (ptr == (char *) NULL)
X    {
X        ptr = (char *) malloc (size);
X    }
X    else
X    {
X        ptr = (char *) realloc (ptr, size);
X    }
X
X    return ptr;
X}
X
X
Xstatic void
X#if defined (CAN_PROTOTYPE)
XprintFileInfo (int optind, int argc, char *argv [])
X#else
XprintFileInfo (optind, argc, argv)
X    int                 optind;
X    int                 argc;
X    char                *argv [];
X#endif
X{
X    int                 i;
X    int                 j;
X    struct stat         statBuf;
X    DiskInfo            totals;
X
X
X    memset ((char *) &totals, '\0', sizeof (DiskInfo));
X    strcpy (totals.name, "Total");
X    totals.printFlag = DI_OK;
X
X    if ((flags & DI_F_NO_HEADER) != DI_F_NO_HEADER)
X    {
X        printTitle ();
X    }
X
X    for (i = optind; i < argc; ++i)
X    {
X        if (stat (argv [i], &statBuf) == 0)
X        {
X            for (j = 0; j < diCount; ++j)
X            {
X                if (diskInfo [j].printFlag != DI_BAD &&
X                        diskInfo [j].st_dev != DI_UNKNOWN_DEV &&
X                        (_ulong) statBuf.st_dev == diskInfo [j].st_dev)
X                {
X                    printInfo (&diskInfo [j]);
X                    addTotals (&diskInfo [j], &totals);
X                    break; /* out of inner for */
X                }
X            }
X        } /* if stat ok */
X        else
X        {
X            fprintf (stderr, "stat: %s ", argv[i]);
X            perror ("");
X        }
X    } /* for each file specified on command line */
X
X    if ((flags & DI_F_TOTAL) == DI_F_TOTAL && (flags & DI_F_NO_HEADER) != DI_F_NO_HEADER)
X    {
X        printInfo (&totals);
X    }
X}
X
X/*
X *  sortArray ()
X *
X *      shellsort!
X *
X */
X
Xstatic void
X#if defined (CAN_PROTOTYPE)
XsortArray (char *data, int dataSize, int count, DI_SORT_FUNC compareFunc)
X#else
XsortArray (data, dataSize, count, compareFunc)
X    char            *data;
X    int             dataSize;
X    int             count;
X    DI_SORT_FUNC    compareFunc;
X#endif
X{
X    register int    j;
X    char            *tempData;
X    int             i;
X    int             gap;
X
X
X    if (count <= 1)
X    {
X        return;
X    }
X
X    tempData = (char *) malloc ((unsigned) dataSize);
X    if (tempData == (char *) NULL)
X    {
X        fprintf (stderr, "malloc failed in sortArray().  errno %d\n", errno);
X        cleanup ();
X        exit (1);
X    }
X
X    gap = 1;
X    while (gap < count)
X    {
X        gap = 3 * gap + 1;
X    }
X
X    for (gap /= 3; gap > 0; gap /= 3)
X    {
X        for (i = gap; i < count; ++i)
X        {
X            memcpy ((char *) tempData, (char *) &(data [i * dataSize]),
X                    dataSize);
X            j = i - gap;
X
X            while (j >= 0 &&
X                compareFunc (&(data [j * dataSize]), tempData) > 0)
X            {
X                memcpy ((char *) &(data [(j + gap) * dataSize]),
X                        (char *) &(data [j * dataSize]), dataSize);
X                j -= gap;
X            }
X
X            j += gap;
X            if (j != i)
X            {
X                memcpy ((char *) &(data [j * dataSize]),
X                        (char *) tempData, dataSize);
X            }
X        }
X    }
X
X    free ((char *) tempData);
X}
X
X
Xstatic int
X#if defined (CAN_PROTOTYPE)
XdiCompare (char *a, char *b)
X#else
XdiCompare (a, b)
X    char        *a;
X    char        *b;
X#endif
X{
X    DiskInfo    *di1;
X    DiskInfo    *di2;
X
X
X    di1 = (DiskInfo *) a;
X    di2 = (DiskInfo *) b;
X
X
X    switch (sortType)
X    {
X        case DI_SORT_NONE:
X        {
X            break;
X        }
X
X        case DI_SORT_NAME:
X        {
X            return (strcmp (di1->name, di2->name) * sortOrder);
X        }
X
X        case DI_SORT_SPECIAL:
X        {
X            return (strcmp (di1->special, di2->special) * sortOrder);
X        }
X    } /* switch on sort type */
X
X    return 0;
X}
X
X
X/*
X * getDiskStatInfo
X *
X * gets the disk device number for each entry.
X *
X */
X
Xstatic void
X#if defined (CAN_PROTOTYPE)
XgetDiskStatInfo (void)
X#else
XgetDiskStatInfo ()
X#endif
X{
X    int         i;
X    struct stat statBuf;
X
X    for (i = 0; i < diCount; ++i)
X    {
X        diskInfo [i].st_dev = (_ulong) DI_UNKNOWN_DEV;
X
X        if (stat (diskInfo [i].name, &statBuf) == 0)
X        {
X            diskInfo [i].st_dev = (_ulong) statBuf.st_dev;
X            if (debug > 2)
X            {
X                printf ("dev: %s: %ld\n", diskInfo [i].name,
X                    diskInfo [i].st_dev);
X            }
X        }
X        else
X        {
X            fprintf (stderr, "stat: %s ", diskInfo [i].name);
X            perror ("");
X        }
X    }
X}
X
X/*
X * getDiskSpecialInfo
X *
X * gets the disk device number for each entry.
X *
X */
X
Xstatic void
X#if defined (CAN_PROTOTYPE)
XgetDiskSpecialInfo (void)
X#else
XgetDiskSpecialInfo ()
X#endif
X{
X    int         i;
X    struct stat statBuf;
X
X    for (i = 0; i < diCount; ++i)
X    {
X        if (stat (diskInfo [i].special, &statBuf) == 0)
X        {
X            diskInfo [i].sp_dev = (_ulong) statBuf.st_dev;
X            diskInfo [i].sp_rdev = (_ulong) statBuf.st_rdev;
X            if (debug > 2)
X            {
X                printf ("special dev: %s: %ld rdev: %ld\n", diskInfo [i].special,
X                        diskInfo [i].sp_dev, diskInfo [i].sp_rdev);
X            }
X        }
X        else
X        {
X            diskInfo [i].sp_dev = 0;
X            diskInfo [i].sp_rdev = 0;
X        }
X    }
X}
X
X/*
X * checkDiskInfo
X *
X * checks the disk information returned for various return values.
X *
X */
X
Xstatic void
X#if defined (CAN_PROTOTYPE)
XcheckDiskInfo (void)
X#else
XcheckDiskInfo ()
X#endif
X{
X    int           i;
X    int           j;
X    int           dupCount;
X    int           len;
X    int           maxMountString;
X    int           maxSpecialString;
X    int           maxTypeString;
X    int           maxOptString;
X    int           maxMntTimeString;
X    _fs_size_t    temp;
X    _ulong        sp_dev;
X    _ulong        sp_rdev;
X
X
X    maxMountString = (flags & DI_F_NO_HEADER) == DI_F_NO_HEADER ? 0 : 5;
X    maxSpecialString = (flags & DI_F_NO_HEADER) == DI_F_NO_HEADER ? 0 : 10;
X    maxTypeString = (flags & DI_F_NO_HEADER) == DI_F_NO_HEADER ? 0 : 7;
X    maxOptString = (flags & DI_F_NO_HEADER) == DI_F_NO_HEADER ? 0 : 7;
X    maxMntTimeString = (flags & DI_F_NO_HEADER) == DI_F_NO_HEADER ? 0 : 26;
X
X    for (i = 0; i < diCount; ++i)
X    {
X            /* Solaris reports a cdrom as having no free blocks,   */
X            /* no available.  Their df doesn't always work right!  */
X            /* -1 is returned.                                     */
X        if (debug > 2)
X        {
X            printf ("chk: %s free: %f\n", diskInfo [i].name,
X                diskInfo [i].freeBlocks);
X        }
X        if (diskInfo [i].freeBlocks < 0.0)
X        {
X            diskInfo [i].freeBlocks = 0.0;
X        }
X        if (diskInfo [i].availBlocks < 0.0)
X        {
X            diskInfo [i].availBlocks = 0.0;
X        }
X
X        temp = ~ 0;
X        if (diskInfo [i].totalInodes == temp)
X        {
X            diskInfo [i].totalInodes = 0;
X            diskInfo [i].freeInodes = 0;
X            diskInfo [i].availInodes = 0;
X        }
X
X        if (debug > 2)
X        {
X            printf ("chk: %s total: %f\n", diskInfo [i].name,
X                    diskInfo [i].totalBlocks);
X        }
X        if (diskInfo [i].totalBlocks <= 0.0 &&
X            diskInfo [i].printFlag != DI_BAD)
X        {
X            diskInfo [i].printFlag = DI_IGNORE;
X            if (debug > 2)
X            {
X                printf ("chk: ignore: totalBlocks <= 0: %s\n",
X                        diskInfo [i].name);
X            }
X        }
X
X        checkIgnoreList (&diskInfo [i]);
X        checkIncludeList (&diskInfo [i]);
X    } /* for all disks */
X
X        /* this loop sets duplicate entries to be ignored. */
X    for (i = 0; i < diCount; ++i)
X    {
X            /* don't need to bother checking real partitions */
X            /* don't bother if already ignored               */
X        if (diskInfo [i].sp_rdev != 0 &&
X            (diskInfo [i].printFlag == DI_OK ||
X            ((flags & DI_F_ALL) == DI_F_ALL &&
X            diskInfo [i].printFlag != DI_BAD)))
X        {
X            sp_dev = diskInfo [i].sp_dev;
X            sp_rdev = diskInfo [i].sp_rdev;
X            dupCount = 0;
X
X            for (j = 0; j < diCount; ++j)
X            {
X                if (diskInfo [j].sp_dev == sp_rdev)
X                {
X                    ++dupCount;
X                }
X            }
X
X            if (debug > 2)
X            {
X                printf ("dup: chk: %s %ld %ld dup: %d\n", diskInfo [i].name,
X                    sp_dev, sp_rdev, dupCount);
X            }
X
X            for (j = 0; dupCount > 0 && j < diCount; ++j)
X            {
X                if (diskInfo [j].sp_rdev == 0 &&
X                    diskInfo [j].sp_dev == sp_rdev)
X                {
X                    diskInfo [j].printFlag = DI_IGNORE;
X                    if (debug > 2)
X                    {
X                        printf ("chk: ignore: duplicate: %s\n",
X                                diskInfo [j].name);
X                    }
X                }
X            } /* duplicate check for each disk */
X        } /* if this is a printable disk */
X        else
X        {
X            if (debug > 2)
X            {
X                printf ("chk: dup: not checked: %s prnt: %d dev: %ld rdev: %ld\n",
X                        diskInfo [i].name, diskInfo [i].printFlag,
X                        diskInfo [i].sp_dev, diskInfo [i].sp_rdev);
X            }
X        }
X    } /* for each disk */
X
X        /* this loop gets the max string lengths */
X    for (i = 0; i < diCount; ++i)
X    {
X        if (diskInfo [i].printFlag == DI_OK || (flags & DI_F_ALL) == DI_F_ALL)
X        {
X            len = strlen (diskInfo [i].name);
X            if (len > maxMountString)
X            {
X                maxMountString = len;
X            }
X
X            len = strlen (diskInfo [i].special);
X            if (len > maxSpecialString)
X            {
X                maxSpecialString = len;
X            }
X
X            len = strlen (diskInfo [i].fsType);
X            if (len > maxTypeString)
X            {
X                maxTypeString = len;
X            }
X
X            len = strlen (diskInfo [i].options);
X            if (len > maxOptString)
X            {
X                maxOptString = len;
X            }
X
X            len = strlen (diskInfo [i].mountTime);
X            if (len > maxMntTimeString)
X            {
X                maxMntTimeString = len;
X            }
X        } /* if we are printing this item */
X    } /* for all disks */
X
X    sprintf (mountFormat, "%%-%d.%ds", maxMountString, maxMountString);
X    sprintf (specialFormat, "%%-%d.%ds", maxSpecialString,
X             maxSpecialString);
X    sprintf (typeFormat, "%%-%d.%ds", maxTypeString, maxTypeString);
X    sprintf (optFormat, "%%-%d.%ds", maxOptString, maxOptString);
X    sprintf (mTimeFormat, "%%-%d.%ds", maxMntTimeString, maxMntTimeString);
X
X    if (dispBlockSize <= DI_ONE_K)
X    {
X        sprintf (blockFormat, "%%%d.0f", width);
X    }
X    else
X    {
X        sprintf (blockFormat, "%%%d.1f", width);
X    }
X    sprintf (blockLabelFormat, "%%%ds", width);
X#if defined (HAS_64BIT_STATFS_FLDS)
X    sprintf (inodeFormat, "%%%dllu", inodeWidth);
X#else
X    sprintf (inodeFormat, "%%%dlu", inodeWidth);
X#endif
X    sprintf (inodeLabelFormat, "%%%ds", inodeWidth);
X}
X
X/*
X * usage
X *
X */
X
Xstatic void
X#if defined (CAN_PROTOTYPE)
Xusage (void)
X#else
Xusage ()
X#endif
X{
X    printf ("di ver $Revision$    Default Format: %s\n", DI_DEFAULT_FORMAT);
X         /*  12345678901234567890123456789012345678901234567890123456789012345678901234567890 */
X    printf ("Usage: di [-ant] [-f format] [-s sort-type] [-i ignore-fstyp-list]\n");
X    printf ("       [-I include-fstyp-list] [-w kbyte-width] [-W inode-width] [file [...]]\n");
X    printf ("   -a   : print all mounted devices; normally, those with 0 total blocks are\n");
X    printf ("          not printed.  e.g. /dev/proc, /dev/fd.\n");
X    printf ("   -d x : size to print blocks in (p - posix (512), k - kbytes,\n");
X    printf ("          m - megabytes, g - gigabytes, <x> - numeric size).\n");
X    printf ("   -f x : use format string <x>\n");
X    printf ("   -i x : ignore file system types in <x>\n");
X    printf ("   -I x : include only file system types in <x>\n");
X    printf ("   -l   : display local filesystems only\n");
X    printf ("   -n   : don't print header\n");
X    printf ("   -s t : sort type; n - no sort, s - by special device, r - reverse\n");
X    printf ("   -t   : print totals\n");
X    printf ("   -w n : use width <n> for kbytes\n");
X    printf ("   -W n : use width <n> for i-nodes\n");
X    printf (" Format string values:\n");
X    printf ("    m - mount point                     M - mount point, full length\n");
X    printf ("    b - total kbytes                    B - kbytes available for use\n");
X    printf ("    u - used kbytes                     c - calculated kbytes in use\n");
X    printf ("    f - kbytes free                     v - kbytes available\n");
X    printf ("    p - percentage not avail. for use   1 - percentage used\n");
X    printf ("    2 - percentage of user-available space in use.\n");
X    printf ("    i - total file slots (i-nodes)      U - used file slots\n");
X    printf ("    F - free file slots                 P - percentage file slots used\n");
X    printf ("    s - filesystem name                 S - filesystem name, full length\n");
X    printf ("    t - disk partition type             T - partition type, full length\n");
X}
X
X
Xstatic void
X#if defined (CAN_PROTOTYPE)
XprocessArgs (int argc, char *argv [])
X#else
XprocessArgs (argc, argv)
X    int         argc;
X    char        *argv [];
X#endif
X{
X    int         ch;
X
X
X    while ((ch = getopt (argc, argv, "Aad:f:hi:I:Flns:tw:W:x:")) != -1)
X    {
X        switch (ch)
X        {
X            case 'A':
X            {
X                formatString = DI_ALL_FORMAT;
X                flags |= DI_F_ALL | DI_F_DEBUG_HDR | DI_F_TOTAL;
X                flags &= ~ DI_F_NO_HEADER;
X                width = 10;
X                inodeWidth = 10;
X                break;
X            }
X
X            case 'a':
X            {
X                flags |= DI_F_ALL;
X                break;
X            }
X
X            case 'd':
X            {
X                switch (tolower (*optarg))
X                {
X                    case 'p':
X                    {
X                        dispBlockSize = DI_HALF_K;
X                        break;
X                    }
X
X                    case 'k':
X                    {
X                        dispBlockSize = DI_ONE_K;
X                        break;
X                    }
X
X                    case 'm':
X                    {
X                        dispBlockSize = DI_ONE_MEG;
X                        break;
X                    }
X
X                    case 'g':
X                    {
X                        dispBlockSize = DI_ONE_GIG;
X                        break;
X                    }
X
X                    default:
X                    {
X                        if (isdigit ((int) (*optarg)))
X                        {
X                            dispBlockSize = atof (optarg);
X                        }
X                        break;
X                    }
X                }
X                break;
X            }
X
X            case 'f':
X            {
X                formatString = optarg;
X                break;
X            }
X
X            case 'h':
X            {
X                usage ();
X                cleanup ();
X                exit (0);
X            }
X
X            case 'i':
X            {
X                parseList (&ignoreList, optarg);
X                break;
X            }
X
X            case 'I':
X            {
X                parseList (&includeList, optarg);
X                break;
X            }
X
X            case 'l':
X            {
X                flags |= DI_F_LOCAL_ONLY;
X                break;
X            }
X
X            case 'n':
X            {
X                flags |= DI_F_NO_HEADER;
X                break;
X            }
X
X            case 's':
X            {
X                switch (ch)
X                {
X                    case 's':
X                    {
X                        sortType = DI_SORT_SPECIAL;
X                        break;
X                    }
X
X                    case 'n':
X                    {
X                        sortType = DI_SORT_NONE;
X                        break;
X                    }
X
X                    case 'r':
X                    {
X                        sortOrder = DI_SORT_DESCENDING;
X                        break;
X                    }
X                }
X                break;
X            }
X
X            case 't':
X            {
X                flags |= DI_F_TOTAL;
X                break;
X            }
X
X            case 'w':
X            {
X                width = atoi (optarg);
X                break;
X            }
X
X            case 'W':
X            {
X                inodeWidth = atoi (optarg);
X                break;
X            }
X
X            case 'x':
X            {
X                debug = atoi (optarg);
X                break;
X            }
X
X            case '?':
X            {
X                usage ();
X                cleanup ();
X                exit (1);
X            }
X        }
X    }
X}
X
X    /* list is assumed to be global */
Xstatic void
X#if defined (CAN_PROTOTYPE)
XparseList (char ***list, char *str)
X#else
XparseList (list, str)
X    char        ***list;
X    char        *str;
X#endif
X{
X    char        *dstr;
X    char        *ptr;
X    char        **lptr;
X    int         count;
X    int         i;
X    int         len;
X
X    i = strlen (str);
X    dstr = (char *) malloc (i + 1);
X    if (dstr == (char *) NULL)
X    {
X        fprintf (stderr, "malloc failed in parseList() (1).  errno %d\n", errno);
X        cleanup ();
X        exit (1);
X    }
X
X    memcpy (dstr, str, i + 1);
X
X    ptr = strtok (dstr, DI_LIST_SEP);
X    count = 0;
X    while (ptr != (char *) NULL)
X    {
X        ++count;
X        ptr = strtok ((char *) NULL, DI_LIST_SEP);
X    }
X
X    *list = (char **) malloc ((count + 1) * sizeof (char *));
X    if (*list == (char **) NULL)
X    {
X        fprintf (stderr, "malloc failed in parseList() (2).  errno %d\n", errno);
X        cleanup ();
X        exit (1);
X    }
X
X    ptr = dstr;
X    lptr = *list;
X    for (i = 0; i < count; ++i)
X    {
X        len = strlen (ptr);
X        *lptr = (char *) malloc (len + 1);
X        if (*lptr == (char *) NULL)
X        {
X            fprintf (stderr, "malloc failed in parseList() (3).  errno %d\n",
X                    errno);
X            cleanup ();
X            exit (1);
X        }
X        strcpy (*lptr, ptr);
X        ptr += len + 1;
X        ++lptr;
X    }
X
X    *lptr = (char *) NULL;
X    free ((char *) dstr);
X}
X
X
Xstatic void
X#if defined (CAN_PROTOTYPE)
XcheckIgnoreList (DiskInfo *diskInfo)
X#else
XcheckIgnoreList (diskInfo)
X    DiskInfo        *diskInfo;
X#endif
X{
X    char            **ptr;
X
X        /* if the file system type is in the ignore list, skip it */
X    if (ignoreList != (char **) NULL)
X    {
X        ptr = ignoreList;
X        while (*ptr != (char *) NULL)
X        {
X            if (strcmp (*ptr, diskInfo->fsType) == 0)
X            {
X                diskInfo->printFlag = DI_IGNORE;
X                if (debug > 2)
X                {
X                    printf ("chkign: ignore: fstype %s match: %s\n", *ptr,
X                            diskInfo->name);
X                }
X                break;
X            }
X            ++ptr;
X        }
X    } /* if an ignore list was specified */
X}
X
Xstatic void
X#if defined (CAN_PROTOTYPE)
XcheckIncludeList (DiskInfo *diskInfo)
X#else
XcheckIncludeList (diskInfo)
X    DiskInfo        *diskInfo;
X#endif
X{
X    char            **ptr;
X
X        /* if the file system type is not in the include list, skip it */
X    if (includeList != (char **) NULL)
X    {
X        ptr = includeList;
X        while (*ptr != (char *) NULL)
X        {
X            if (strcmp (*ptr, diskInfo->fsType) == 0)
X            {
X                diskInfo->printFlag = DI_OK;
X                break;
X            }
X            else
X            {
X                diskInfo->printFlag = DI_IGNORE;
X                if (debug > 2)
X                {
X                    printf ("chkinc: ! include: fstype %s match: %s\n", *ptr,
X                            diskInfo->name);
X                }
X            }
X            ++ptr;
X        }
X    } /* if an include list was specified */
X}
X
X
X#if defined (HAS_FS_INFO)
X
X/*
X * getDiskEntries
X *
X * For BeOS.
X *
X */
X
Xstatic int
XgetDiskEntries (void)
X{
X    status_t        stat;
X    int             idx;
X    int32           count;
X    dev_t           dev;
X    char            buff [B_FILE_NAME_LENGTH];
X    fs_info         fsinfo;
X    double          mult;
X    node_ref        nref;
X    BDirectory      *dir;
X    BEntry          entry;
X    BPath           path;
X
X    count = 0;
X    while ((dev = next_dev (&count)) != B_BAD_VALUE)
X    {
X        if ((stat = fs_stat_dev (dev, &fsinfo)) == B_BAD_VALUE)
X        {
X            break;
X        }
X
X        idx = diCount;
X        ++diCount;
X        diskInfo = (DiskInfo *) Realloc ((char *) diskInfo,
X                sizeof (DiskInfo) * diCount);
X        memset ((char *) &diskInfo [idx], '\0', sizeof (DiskInfo));
X        diskInfo [idx].printFlag = DI_OK;
X        *buff = '\0';
X        nref.device = dev;
X        nref.node = fsinfo.root;
X        dir = new BDirectory (&nref);
X        stat = dir->GetEntry (&entry);
X        stat = entry.GetPath (&path);
X        strncpy (diskInfo [idx].name, path.Path (), DI_NAME_LEN);
X        strncpy (diskInfo [idx].special, fsinfo.device_name, DI_SPEC_NAME_LEN);
X        strncpy (diskInfo [idx].fsType, fsinfo.fsh_name, DI_TYPE_LEN);
X        diskInfo [idx].isLocal = TRUE;
X        mult = (double) (long) fsinfo.block_size / dispBlockSize;
X        diskInfo [idx].totalBlocks =
X                ((double) (_s_fs_size_t) fsinfo.total_blocks * mult);
X        diskInfo [idx].freeBlocks =
X                ((double) (_s_fs_size_t) fsinfo.free_blocks * mult);
X        diskInfo [idx].availBlocks =
X                ((double) (_s_fs_size_t) fsinfo.free_blocks * mult);
X        diskInfo [idx].totalInodes = fsinfo.total_nodes;
X        diskInfo [idx].freeInodes = fsinfo.free_nodes;
X        diskInfo [idx].availInodes = fsinfo.free_nodes;
X
X        checkIgnoreList (&diskInfo [idx]);
X        checkIncludeList (&diskInfo [idx]);
X
X        if (debug > 0)
X        {
X            printf ("mnt:%s - %s\n", diskInfo [idx].name,
X                    diskInfo [idx].special);
X            printf ("dev:%d fs:%s\n", dev, diskInfo [idx].fsType);
X        }
X        if (debug > 1)
X        {
X            printf ("%s: %s\n", diskInfo [idx].name, diskInfo [idx].fsType);
X            printf ("\tmult:%f\n", mult);
X            printf ("\tblocks: tot:%ld free:%ld\n",
X                    fsinfo.total_blocks, fsinfo.free_blocks);
X            printf ("\tinodes: tot:%ld free:%ld\n",
X                    fsinfo.total_nodes, fsinfo.free_nodes);
X        }
X    }
X    return 0;
X}
X
Xstatic void
XgetDiskInfo (void)
X{
X    return;
X}
X
X#endif
X
X#if defined (HAS_GETMNTENT) && ! defined (HAS_SETMNTENT)
X
X# define DFS_FS_TABLE        "/etc/dfs/fstypes"
X
X/*
X * getDiskEntries
X *
X * For SysV.4, we open the file and call getmntent () repeatedly.
X *
X */
X
Xstatic int
XgetDiskEntries ()
X{
X    FILE            *f;
X    int             idx;
X    int             i;
X    struct mnttab   mntEntry;
X    char            buff [80];
X    time_t          mtime;
X    char            *devp;   /* local ptr to dev entry */
X
X
X    if ((flags & DI_F_LOCAL_ONLY) == DI_F_LOCAL_ONLY)
X    {
X        i = remoteFileSystemCount;
X
X        if ((f = fopen (DFS_FS_TABLE, "r")) != (FILE *) NULL)
X        {
X            fgets (buff, 80, f);
X            if (debug > 1)
X            {
X                printf ("remote file system type: %s\n", buff);
X            }
X            sscanf (buff, "%s", remoteFileSystemTypes [i++]);
X            fclose (f);
X        }
X
X        remoteFileSystemCount = i;
X    }
X
X    if ((f = fopen (DI_MOUNT_FILE, "r")) == (FILE *) NULL)
X    {
X        fprintf (stderr, "Unable to open: %s errno %d\n", DI_MOUNT_FILE, errno);
X        return -1;
X    }
X
X    while (getmntent (f, &mntEntry) == 0)
X    {
X        idx = diCount;
X        ++diCount;
X        diskInfo = (DiskInfo *) Realloc ((char *) diskInfo,
X                sizeof (DiskInfo) * diCount);
X        memset ((char *) &diskInfo [idx], '\0', sizeof (DiskInfo));
X        diskInfo [idx].printFlag = DI_OK;
X
X        strncpy (diskInfo [idx].special, mntEntry.mnt_special,
X                DI_SPEC_NAME_LEN);
X        strncpy (diskInfo [idx].name, mntEntry.mnt_mountp, DI_NAME_LEN);
X# if defined (MNTOPT_IGNORE)
X        if (strstr (mntEntry.mnt_mntopts, MNTOPT_IGNORE) != (char *) NULL)
X# else
X        if (strstr (mntEntry.mnt_mntopts, "ignore") != (char *) NULL)
X# endif
X        {
X            diskInfo [idx].printFlag = DI_IGNORE;
X            if (debug > 2)
X            {
X                printf ("mnt: ignore: mntopt 'ignore': %s\n",
X                        diskInfo [idx].name);
X            }
X        }
X# if defined (MNTOPT_DEV)
X        sprintf (buff, "%s=", MNTOPT_DEV);
X        if ((devp = strstr (mntEntry.mnt_mntopts, buff)) != (char *) NULL)
X# else
X        if ((devp = strstr (mntEntry.mnt_mntopts, "dev=")) != (char *) NULL)
X# endif
X        {
X            if (devp != mntEntry.mnt_mntopts)
X            {
X                --devp;
X            }
X            *devp = 0;   /* point to preceeding comma and cut off */
X        }
X        strncpy (diskInfo [idx].options, mntEntry.mnt_mntopts, DI_OPT_LEN);
X        mtime = atol (mntEntry.mnt_time);
X        strncpy (diskInfo [idx].mountTime, ctime (&mtime), DI_MNT_TIME_LEN);
X
X            /* get the file system type now... */
X        strncpy (diskInfo [idx].fsType, mntEntry.mnt_fstype, DI_TYPE_LEN);
X
X        diskInfo [idx].isLocal = TRUE;
X        for (i = 0; i < remoteFileSystemCount; ++i)
X        {
X            if (strcmp (diskInfo [idx].fsType, remoteFileSystemTypes [i]) == 0)
X            {
X                diskInfo [idx].isLocal = FALSE;
X            }
X        }
X
X        checkIgnoreList (&diskInfo [idx]);
X        checkIncludeList (&diskInfo [idx]);
X
X        if (debug > 0)
X        {
X            printf ("mnt:%s - %s\n", diskInfo [idx].name,
X                    diskInfo [idx].special);
X        }
X    }
X
X    fclose (f);
X    return 0;
X}
X
X#endif /* HAS_GETMNTENT */
X
X#if ! defined (HAS_GETMNTENT) && ! defined (HAS_MNTCTL) && \
X        ! defined (HAS_GETMNTINFO) && ! defined (HAS_GETMNT) && \
X	! defined (HAS_GETDISKFREESPACE) && ! defined (HAS_FS_INFO)
X
X/*
X * getDiskEntries
X *
X * For SysV.3 we open the file and read it ourselves.
X *
X */
X
Xstatic int
XgetDiskEntries ()
X{
X    FILE             *f;
X    int              idx;
X    struct mnttab    mntEntry;
X
X
X    if ((f = fopen (DI_MOUNT_FILE, "r")) == (FILE *) NULL)
X    {
X        fprintf (stderr, "Unable to open: %s errno %d\n", DI_MOUNT_FILE, errno);
X        return -1;
X    }
X
X    while (fread ((char *) &mntEntry, sizeof (struct mnttab), 1, f) == 1)
X    {
X            /* xenix allows null mount table entries */
X            /* sco nfs background mounts are marked as "nothing" */
X        if (mntEntry.mt_filsys [0] &&
X                strcmp (mntEntry.mt_filsys, "nothing") != 0)
X        {
X            idx = diCount;
X            ++diCount;
X            diskInfo = (DiskInfo *) Realloc ((char *) diskInfo,
X                                             sizeof (DiskInfo) * diCount);
X            memset ((char *) &diskInfo [idx], '\0', sizeof (DiskInfo));
X            diskInfo [idx].printFlag = DI_OK;
X            diskInfo [idx].isLocal = TRUE;
X
X# if defined (COHERENT)
X                /* Coherent seems to have these fields reversed. oh well. */
X            strncpy (diskInfo [idx].name, mntEntry.mt_dev, DI_NAME_LEN);
X            strncpy (diskInfo [idx].special, mntEntry.mt_filsys, DI_SPEC_NAME_LEN);
X# else
X            strncpy (diskInfo [idx].special, mntEntry.mt_dev, DI_SPEC_NAME_LEN);
X            strncpy (diskInfo [idx].name, mntEntry.mt_filsys, DI_NAME_LEN);
X# endif
X            strncpy (diskInfo [idx].options, mntEntry.mnt_mntopts, DI_OPT_LEN);
X            strncpy (diskInfo [idx].mountTime, mntEntry.mnt_time,
X                    DI_MNT_TIME_LEN);
X        }
X
X        if (debug > 0)
X        {
X            printf ("mnt:%s - %s\n", diskInfo [idx].name,
X                    diskInfo [idx].special);
X        }
X    }
X
X    fclose (f);
X    return 0;
X}
X
X#endif /* Sys V.3 */
X
X#if defined (HAS_GETMNTENT) && defined (HAS_SETMNTENT) && \
X        defined (HAS_ENDMNTENT)
X
X/*
X * getDiskEntries
X *
X * SunOS supplies an open and close routine for the mount table.
X *
X */
X
Xstatic int
XgetDiskEntries ()
X{
X    FILE            *f;
X    int             idx;
X    struct mntent   *mntEntry;
X    char            *devp;   /* local ptr to dev entry */
X
X
X#if defined (HAS_SETMNTENT_ONE_ARG)
X    if ((f = setmntent (DI_MOUNT_FILE)) == (FILE *) NULL)
X#else
X    if ((f = setmntent (DI_MOUNT_FILE, "r")) == (FILE *) NULL)
X#endif
X    {
X        fprintf (stderr, "Unable to open: %s errno %d\n", DI_MOUNT_FILE, errno);
X        return -1;
X    }
X
X    while ((mntEntry = getmntent (f)) != (struct mntent *) NULL)
X    {
X        idx = diCount;
X        ++diCount;
X        diskInfo = (DiskInfo *) Realloc ((char *) diskInfo,
X                sizeof (DiskInfo) * diCount);
X        memset ((char *) &diskInfo [idx], '\0', sizeof (DiskInfo));
X        diskInfo [idx].printFlag = DI_OK;
X        diskInfo [idx].isLocal = TRUE;
X
X        strncpy (diskInfo [idx].special, mntEntry->mnt_fsname, DI_SPEC_NAME_LEN);
X        strncpy (diskInfo [idx].name, mntEntry->mnt_dir, DI_NAME_LEN);
X        strncpy (diskInfo [idx].fsType, mntEntry->mnt_type, DI_TYPE_LEN);
X
X        if (strcmp (mntEntry->mnt_type, MNTTYPE_IGNORE) == 0)
X        {
X            diskInfo [idx].printFlag = DI_IGNORE;
X            if (debug > 2)
X            {
X                printf ("mnt: ignore: mntopt 'ignore': %s\n",
X                        diskInfo [idx].name);
X            }
X        }
X
X        if ((devp = strstr (mntEntry->mnt_opts, "dev=")) != (char *) NULL)
X        {
X            if (devp != mntEntry->mnt_opts)
X            {
X                --devp;
X            }
X            *devp = 0;   /* point to preceeding comma and cut off */
X        }
X        strncpy (diskInfo [idx].options, mntEntry->mnt_opts, DI_OPT_LEN);
X
X        checkIgnoreList (&diskInfo [idx]);
X        checkIncludeList (&diskInfo [idx]);
X
X        if (debug > 0)
X        {
X            printf ("mnt:%s - %s : %s\n", diskInfo [idx].name,
X                    diskInfo [idx].special, diskInfo [idx].fsType);
X        }
X    }
X
X    endmntent (f);
X    return 0;
X}
X
X#endif /* HAS_GETMNTENT && HAS_SETMNTENT && HAS_ENDMNTENT */
X
X#if defined (HAS_GETMNTINFO)
X
X/*
X * getDiskEntries
X *
X * OSF/1 does this with a system call and library routine
X *
X *                  [mogul@wrl.dec.com (Jeffrey Mogul)]
X */
X
X#if defined (INITMOUNTNAMES)
Xstatic char *mnt_names [] = INITMOUNTNAMES;
X# define MNT_NUMTYPES (MOUNT_MAXTYPE + 1)
X#endif
X
X    /* osf/1 mount flags start w/M_ vs. MNT_     */
X    /* this saves us from lots of duplicate code */
X#if defined (M_RDONLY)
X# define MNT_RDONLY M_RDONLY
X#endif
X#if defined (M_SYNCHRONOUS)
X# define MNT_SYNCHRONOUS M_SYNCHRONOUS
X#endif
X#if defined (M_NOEXEC)
X# define MNT_NOEXEC M_NOEXEC
X#endif
X#if defined (M_NOSUID)
X# define MNT_NOSUID M_NOSUID
X#endif
X#if defined (M_NODEV)
X# define MNT_NODEV M_NODEV
X#endif
X#if defined (M_GRPID)
X# define MNT_GRPID M_GRPID
X#endif
X#if defined (M_EXPORTED)
X# define MNT_EXPORTED M_EXPORTED
X#endif
X#if defined (M_EXRDONLY)
X# define MNT_EXRDONLY M_EXRDONLY
X#endif
X#if defined (M_EXRDMOSTLY)
X# define MNT_EXRDMOSTLY M_EXRDMOSTLY
X#endif
X#if defined (M_SECURE)
X# define MNT_SECURE M_SECURE
X#endif
X#if defined (M_LOCAL)
X# define MNT_LOCAL M_LOCAL
X#endif
X#if defined (M_QUOTA)
X# define MNT_QUOTA M_QUOTA
X#endif
X
Xstatic int
XgetDiskEntries ()
X{
X    int             count;
X    int             idx;
X    int             len;
X    short           fstype;
X    struct statfs   *mntbufp;
X    double          mult;
X
X    count = getmntinfo (&mntbufp, MNT_WAIT);
X    if (count < 1)
X    {
X        fprintf (stderr, "Unable to do getmntinfo () errno %d\n", errno);
X        return -1;
X    }
X
X    diCount = count;
X    diskInfo = (DiskInfo *) malloc (sizeof (DiskInfo) * count);
X    if (diskInfo == (DiskInfo *) NULL)
X    {
X        fprintf (stderr, "malloc failed for diskInfo. errno %d\n", errno);
X        return -1;
X    }
X    memset ((char *) diskInfo, '\0', sizeof (DiskInfo) * count);
X
X    if (debug > 1)
X    {
X        printf ("type_len %d name_len %d spec_name_len %d\n", DI_TYPE_LEN,
X                DI_NAME_LEN, DI_SPEC_NAME_LEN);
X    }
X
X    for (idx = 0; idx < count; idx++)
X    {
X        diskInfo [idx].printFlag = DI_OK;
X        diskInfo [idx].isLocal = FALSE;
X#if defined (MNT_LOCAL)
X        if ((mntbufp [idx].f_flags & MNT_LOCAL) == MNT_LOCAL)
X        {
X            diskInfo [idx].isLocal = TRUE;
X        }
X#endif
X
X        if (diskInfo [idx].isLocal == FALSE &&
X                (flags & DI_F_LOCAL_ONLY) == DI_F_LOCAL_ONLY)
X        {
X            diskInfo [idx].printFlag = DI_IGNORE;
X            if (debug > 2)
X            {
X                printf ("mnt: ignore: remote: %s\n",
X                        diskInfo [idx].name);
X            }
X        }
X
X        strncpy (diskInfo [idx].special, mntbufp [idx].f_mntfromname,
X                DI_SPEC_NAME_LEN);
X        strncpy (diskInfo [idx].name, mntbufp [idx].f_mntonname, DI_NAME_LEN);
X
X        mult = 1.0;
X
X#  if defined (HAS_GETMNTINFO_FSIZE) /* 1.x */
X        mult = (double) mntbufp [idx].f_fsize / dispBlockSize;
X#  endif
X#  if defined (HAS_GETMNTINFO_BSIZE) /* 2.x */
X        mult = (double) mntbufp [idx].f_bsize / dispBlockSize;
X#  endif
X        diskInfo [idx].totalBlocks = ((double) (_s_fs_size_t) mntbufp [idx].f_blocks * mult);
X        diskInfo [idx].freeBlocks = ((double) (_s_fs_size_t) mntbufp [idx].f_bfree * mult);
X        diskInfo [idx].availBlocks = ((double) (_s_fs_size_t) mntbufp [idx].f_bavail * mult);
X
X        diskInfo [idx].totalInodes = mntbufp [idx].f_files;
X        diskInfo [idx].freeInodes = mntbufp [idx].f_ffree;
X        diskInfo [idx].availInodes = mntbufp [idx].f_ffree;
X
X        fstype = mntbufp [idx].f_type;
X# if ! defined (I_SYS_FSTYP) && ! defined (INITMOUNTNAMES) && \
X    ! defined (HAS_GETMNTINFO_FSTYPENAME)
X        if ((fstype >= 0) && (fstype <= MOUNT_MAXTYPE))
X        {
X            switch (fstype)
X            {
X#  if defined (MOUNT_NONE)
X                case MOUNT_NONE:         /* No Filesystem */
X                {
X                    strncpy (diskInfo [idx].fsType, "none", DI_TYPE_LEN);
X                    break;
X                }
X#  endif
X
X#  if defined (MOUNT_UFS)
X                case MOUNT_UFS:         /* UNIX "Fast" Filesystem */
X                {
X                    strncpy (diskInfo [idx].fsType, "ufs", DI_TYPE_LEN);
X                    break;
X                }
X#  endif
X
X#  if defined (MOUNT_NFS)
X                case MOUNT_NFS:         /* Network Filesystem */
X                {
X                    strncpy (diskInfo [idx].fsType, "nfs", DI_TYPE_LEN);
X                    break;
X                }
X#  endif
X
X#  if defined (MOUNT_MFS)
X                case MOUNT_MFS:         /* Memory Filesystem */
X                {
X                    strncpy (diskInfo [idx].fsType, "mfs", DI_TYPE_LEN);
X                    break;
X                }
X#  endif
X
X#  if defined (MOUNT_MSDOS)
X                case MOUNT_MSDOS:       /* MSDOS Filesystem */
X                {
X                    strncpy (diskInfo [idx].fsType, "msdos", DI_TYPE_LEN);
X                    break;
X                }
X#  endif
X
X#  if defined (MOUNT_LFS)
X                case MOUNT_LFS:
X                {
X                    strncpy (diskInfo [idx].fsType, "lfs", DI_TYPE_LEN);
X                    break;
X                }
X#  endif
X
X#  if defined (MOUNT_LOFS)
X                case MOUNT_LOFS:
X                {
X                    strncpy (diskInfo [idx].fsType, "lofs", DI_TYPE_LEN);
X                    break;
X                }
X#  endif
X
X#  if defined (MOUNT_FDESC)
X                case MOUNT_FDESC:
X                {
X                    strncpy (diskInfo [idx].fsType, "fdesc", DI_TYPE_LEN);
X                    break;
X                }
X#  endif
X
X#  if defined (MOUNT_PORTAL)
X                case MOUNT_PORTAL:
X                {
X                    strncpy (diskInfo [idx].fsType, "portal", DI_TYPE_LEN);
X                    break;
X                }
X#  endif
X
X#  if defined (MOUNT_NULL)
X                case MOUNT_NULL:
X                {
X                    strncpy (diskInfo [idx].fsType, "null", DI_TYPE_LEN);
X                    break;
X                }
X#  endif
X
X#  if defined (MOUNT_UMAP)
X                case MOUNT_UMAP:
X                {
X                    strncpy (diskInfo [idx].fsType, "umap", DI_TYPE_LEN);
X                    break;
X                }
X#  endif
X
X#  if defined (MOUNT_KERNFS)
X                case MOUNT_KERNFS:
X                {
X                    strncpy (diskInfo [idx].fsType, "kernfs", DI_TYPE_LEN);
X                    break;
X                }
X#  endif
X
X#  if defined (MOUNT_PROCFS)
X                case MOUNT_PROCFS:      /* proc filesystem */
X                {
X                    strncpy (diskInfo [idx].fsType, "pfs", DI_TYPE_LEN);
X                    break;
X                }
X#  endif
X
X#  if defined (MOUNT_AFS)
X                case MOUNT_AFS:
X                {
X                    strncpy (diskInfo [idx].fsType, "afs", DI_TYPE_LEN);
X                    break;
X                }
X#  endif
X
X#  if defined (MOUNT_ISOFS)
X                case MOUNT_ISOFS:       /* iso9660 cdrom */
X                {
X                    strncpy (diskInfo [idx].fsType, "iso9660fs", DI_TYPE_LEN);
X                    break;
X                }
X#  endif
X
X#  if defined (MOUNT_ISO9660) && ! defined (MOUNT_CD9660)
X                case MOUNT_ISO9660:       /* iso9660 cdrom */
X                {
X                    strncpy (diskInfo [idx].fsType, "iso9660", DI_TYPE_LEN);
X                    break;
X                }
X#  endif
X
X#  if defined (MOUNT_CD9660)
X                case MOUNT_CD9660:       /* iso9660 cdrom */
X                {
X                    strncpy (diskInfo [idx].fsType, "cd9660", DI_TYPE_LEN);
X                    break;
X                }
X#  endif
X
X#  if defined (MOUNT_UNION)
X                case MOUNT_UNION:
X                {
X                    strncpy (diskInfo [idx].fsType, "union", DI_TYPE_LEN);
X                    break;
X                }
X#  endif
X            } /* switch on mount type */
X        }
X# else
X#  if defined (HAS_GETMNTINFO_FSTYPENAME)
X        strncpy (diskInfo [idx].fsType, mntbufp [idx].f_fstypename, DI_TYPE_LEN);
X#  else
X            /* could use getvfsbytype here... */
X        if ((fstype >= 0) && (fstype < MNT_NUMTYPES))
X        {
X            strncpy (diskInfo [idx].fsType, mnt_names [fstype], DI_TYPE_LEN);
X        }
X        else
X        {
X            sprintf (diskInfo [idx].fsType, DI_UNKNOWN_FSTYPE, fstype);
X        }
X#  endif
X# endif /* has fs_types.h */
X
X#if defined (MNT_RDONLY)
X        if ((mntbufp [idx].f_flags & MNT_RDONLY) == MNT_RDONLY)
X        {
X            strcat (diskInfo [idx].options, "ro,");
X        }
X        else
X        {
X            strcat (diskInfo [idx].options, "rw,");
X        }
X#endif
X#if defined (MNT_SYNCHRONOUS)
X        if ((mntbufp [idx].f_flags & MNT_SYNCHRONOUS) == MNT_SYNCHRONOUS)
X        {
X            strcat (diskInfo [idx].options, "sync,");
X        }
X#endif
X#if defined (MNT_NOEXEC)
X        if ((mntbufp [idx].f_flags & MNT_NOEXEC) == MNT_NOEXEC)
X        {
X            strcat (diskInfo [idx].options, "noexec,");
X        }
X#endif
X#if defined (MNT_NOSUID)
X        if ((mntbufp [idx].f_flags & MNT_NOSUID) != MNT_NOSUID)
X        {
X            strcat (diskInfo [idx].options, "suid,");
X        }
X#endif
X#if defined (MNT_NODEV)
X        if ((mntbufp [idx].f_flags & MNT_NODEV) == MNT_NODEV)
X        {
X            strcat (diskInfo [idx].options, "nodev,");
X        }
X#endif
X#if defined (MNT_GRPID)
X        if ((mntbufp [idx].f_flags & MNT_GRPID) == MNT_GRPID)
X        {
X            strcat (diskInfo [idx].options, "grpid,");
X        }
X#endif
X#if defined (MNT_UNION)
X        if ((mntbufp [idx].f_flags & MNT_UNION) == MNT_UNION)
X        {
X            strcat (diskInfo [idx].options, "union,");
X        }
X#endif
X#if defined (MNT_ASYNC)
X        if ((mntbufp [idx].f_flags & MNT_ASYNC) == MNT_ASYNC)
X        {
X            strcat (diskInfo [idx].options, "async,");
X        }
X#endif
X#if defined (MNT_EXRDONLY)
X        if ((mntbufp [idx].f_flags & MNT_EXRDONLY) == MNT_EXRDONLY)
X        {
X            strcat (diskInfo [idx].options, "exported ro,");
X        }
X#endif
X#if defined (MNT_EXPORTED)
X        if ((mntbufp [idx].f_flags & MNT_EXPORTED) == MNT_EXPORTED)
X        {
X            strcat (diskInfo [idx].options, "exported,");
X        }
X#endif
X#if defined (MNT_EXRDMOSTLY)
X        if ((mntbufp [idx].f_flags & MNT_EXRDMOSTLY) == MNT_EXRDMOSTLY)
X        {
X                /* what's read-mostly ? */
X            strcat (diskInfo [idx].options, "exported read-mostly,");
X        }
X#endif
X#if defined (MNT_DEFEXPORTED)
X        if ((mntbufp [idx].f_flags & MNT_DEFEXPORTED) == MNT_DEFEXPORTED)
X        {
X                /* what's this ? */
X            strcat (diskInfo [idx].options, "exported world,");
X        }
X#endif
X#if defined (MNT_EXPORTANON)
X        if ((mntbufp [idx].f_flags & MNT_EXPORTANON) == MNT_EXPORTANON)
X        {
X            strcat (diskInfo [idx].options, "exported anon,");
X        }
X#endif
X#if defined (MNT_EXKERB)
X        if ((mntbufp [idx].f_flags & MNT_EXKERB) == MNT_EXKERB)
X        {
X            strcat (diskInfo [idx].options, "exported kerberos,");
X        }
X#endif
X#if defined (MNT_LOCAL)
X        if ((mntbufp [idx].f_flags & MNT_LOCAL) == MNT_LOCAL)
X        {
X            strcat (diskInfo [idx].options, "local,");
X        }
X#endif
X#if defined (MNT_QUOTA)
X        if ((mntbufp [idx].f_flags & MNT_QUOTA) == MNT_QUOTA)
X        {
X            strcat (diskInfo [idx].options, "quota,");
X        }
X#endif
X#if defined (MNT_ROOTFS)
X        if ((mntbufp [idx].f_flags & MNT_ROOTFS) == MNT_ROOTFS)
X        {
X            strcat (diskInfo [idx].options, "root,");
X        }
X#endif
X#if defined (MNT_USER)
X        if ((mntbufp [idx].f_flags & MNT_USER) == MNT_USER)
X        {
X            strcat (diskInfo [idx].options, "user,");
X        }
X#endif
X#if defined (MNT_SECURE)
X        if ((mntbufp [idx].f_flags & MNT_SECURE) == MNT_SECURE)
X        {
X            strcat (diskInfo [idx].options, "secure,");
X        }
X#endif
X
X        len = strlen (diskInfo [idx].options);
X        if (len > 0)
X        {
X            --len;
X        }
X        if (diskInfo [idx].options [len]==',')
X        {
X            diskInfo [idx].options [len] = '\0';
X        }
X
X        if (debug > 1)
X        {
X            printf ("%s: %s\n", diskInfo [idx].name, diskInfo [idx].fsType);
X            printf ("\tblocks: tot:%ld free:%ld avail:%ld\n",
X                    mntbufp [idx].f_blocks, mntbufp [idx].f_bfree,
X                    mntbufp [idx].f_bavail);
X            printf ("\tmult: %f\n", mult);
X# if defined (HAS_GETMNTINFO_FSIZE)
X            printf ("\tfsize:%ld \n", mntbufp [idx].f_fsize);
X            printf ("\tbsize:%ld \n", mntbufp [idx].f_bsize);
X# endif
X# if defined (HAS_GETMNTINFO_BSIZE)
X            printf ("\tbsize:%ld \n", mntbufp [idx].f_bsize);
X            printf ("\tiosize:%ld \n", mntbufp [idx].f_iosize);
X# endif
X            printf ("\tinodes: tot:%ld free:%ld\n",
X                    mntbufp [idx].f_files, mntbufp [idx].f_ffree);
X        }
X    }
X
X    free ((char *) mntbufp);  /* man page says this can't be freed. */
X                              /* is it ok to try?                   */
X    return 0;
X}
X
X/* this is a no-op; we have already done all the work */
Xstatic void
XgetDiskInfo ()
X{
X}
X
X#endif /* HAS_GETMNTINFO */
X
X#if defined (HAS_GETMNT)
X
X/*
X * getDiskEntries
X *
X * ULTRIX does this with a system call.  The system call allows one
X * to retrieve the information in a series of calls, but coding that
X * looks a little tricky; I just allocate a huge buffer and do it in
X * one shot.
X *
X *                  [mogul@wrl.dec.com (Jeffrey Mogul)]
X */
X
Xstatic int
XgetDiskEntries ()
X{
X    int             count;
X    int             bufsize;
X    int             idx;
X    short           fstype;
X    struct fs_data  *fsdbuf;
X    int             start;
X    int             len;
X
X
X    bufsize = NMOUNT * sizeof (struct fs_data);  /* enough for max # mounts */
X    fsdbuf = (struct fs_data *) malloc (bufsize);
X    if (fsdbuf == (struct fs_data *) NULL)
X    {
X        fprintf (stderr, "malloc (%d) for getmnt () failed errno %d\n",
X                 bufsize, errno);
X        return -1;
X    }
X
X    start = 0;
X    count = getmnt (&start, fsdbuf, bufsize, STAT_MANY, 0);
X    if (count < 1)
X    {
X        fprintf (stderr, "Unable to do getmnt () [= %d] errno %d\n",
X                 count, errno);
X        free ((char *) fsdbuf);
X        return -1;
X    }
X
X    diCount = count;
X    diskInfo = (DiskInfo *) malloc (sizeof (DiskInfo) * count);
X    if (diskInfo == (DiskInfo *) NULL)
X    {
X        fprintf (stderr, "malloc failed for diskInfo. errno %d\n", errno);
X        free ((char *) fsdbuf);
X        return -1;
X    }
X    memset ((char *) diskInfo, '\0', sizeof (DiskInfo) * count);
X
X    for (idx = 0; idx < count; idx++)
X    {
X        diskInfo [idx].printFlag = DI_OK;
X        diskInfo [idx].isLocal = TRUE;
X
X        if ((fsdbuf [idx].fd_req.flags & M_LOCAL) != M_LOCAL)
X        {
X            diskInfo [idx].isLocal = FALSE;
X        }
X
X        if (diskInfo [idx].isLocal == FALSE &&
X                (flags & DI_F_LOCAL_ONLY) == DI_F_LOCAL_ONLY)
X        {
X            diskInfo [idx].printFlag = DI_IGNORE;
X            if (debug > 2)
X            {
X                printf ("mnt: ignore: remote: %s\n",
X                        diskInfo [idx].name);
X            }
X        }
X
X        strncpy (diskInfo [idx].special, fsdbuf [idx].fd_devname, DI_SPEC_NAME_LEN);
X        strncpy (diskInfo [idx].name, fsdbuf [idx].fd_path, DI_NAME_LEN);
X
X            /* ULTRIX keeps these fields in units of 1K byte */
X        diskInfo [idx].totalBlocks = fsdbuf [idx].fd_btot;
X        diskInfo [idx].freeBlocks = fsdbuf [idx].fd_bfree;
X        diskInfo [idx].availBlocks = (int) fsdbuf [idx].fd_bfreen;
X
X        diskInfo [idx].totalInodes = fsdbuf [idx].fd_gtot;
X        diskInfo [idx].freeInodes = fsdbuf [idx].fd_gfree;
X        diskInfo [idx].availInodes = fsdbuf [idx].fd_gfree;
X
X        fstype = fsdbuf [idx].fd_fstype;
X        if (fstype == GT_UNKWN)
X        {
X            diskInfo [idx].printFlag = DI_IGNORE;
X            if (debug > 2)
X            {
X                printf ("mnt: ignore: disk type unknown: %s\n",
X                        diskInfo [idx].name);
X            }
X        }
X        else if ((fstype > 0) && (fstype < GT_NUMTYPES))
X        {
X            strncpy (diskInfo [idx].fsType, gt_names [fstype], DI_TYPE_LEN);
X        }
X        else
X        {
X            sprintf (diskInfo [idx].fsType, "Unknown fstyp %.2d", fstype);
X        }
X
X        if ((fsdbuf [idx].fd_req.flags & M_RONLY) == M_RONLY)
X        {
X            strcat (diskInfo [idx].options, "ro,");
X        }
X        else
X        {
X            strcat (diskInfo [idx].options, "rw,");
X        }
X        if ((fsdbuf [idx].fd_req.flags & M_NOSUID) != M_NOSUID)
X        {
X            strcat (diskInfo [idx].options, "suid,");
X        }
X        if ((fsdbuf [idx].fd_req.flags & M_QUOTA) == M_QUOTA)
X        {
X            strcat (diskInfo [idx].options, "quota,");
X        }
X        if ((fsdbuf [idx].fd_req.flags & M_LOCAL) != M_LOCAL)
X        {
X            strcat (diskInfo [idx].options, "remote,");
X        }
X        if ((fsdbuf [idx].fd_req.flags & M_NODEV) == M_NODEV)
X        {
X            strcat (diskInfo [idx].options, "nodev,");
X        }
X        if ((fsdbuf [idx].fd_req.flags & M_FORCE) == M_FORCE)
X        {
X            strcat (diskInfo [idx].options, "force,");
X        }
X        if ((fsdbuf [idx].fd_req.flags & M_SYNC) == M_SYNC)
X        {
X            strcat (diskInfo [idx].options, "sync,");
X        }
X        if ((fsdbuf [idx].fd_req.flags & M_NOCACHE) == M_NOCACHE)
X        {
X            strcat (diskInfo [idx].options, "nocache,");
X        }
X        if ((fsdbuf [idx].fd_req.flags & M_EXPORTED) == M_EXPORTED)
X        {
X            strcat (diskInfo [idx].options, "exported," );
X        }
X        if ((fsdbuf [idx].fd_req.flags & M_EXRONLY) == M_EXRONLY)
X        {
X            strcat (diskInfo [idx].options, "exported ro,");
X        }
X        if ((fsdbuf [idx].fd_req.flags & M_NOEXEC) == M_NOEXEC)
X        {
X            strcat (diskInfo [idx].options, "noexec,");
X        }
X
X        len = strlen (diskInfo [idx].options);
X        if (len > 0)
X        {
X            --len;
X        }
X        if (diskInfo [idx].options [len]==',')
X        {
X            diskInfo [idx].options [len] = '\0';
X        }
X
X        if (debug > 1)
X        {
X            printf ("%s: %s\n", diskInfo [idx].name, diskInfo [idx].fsType);
X            printf ("\tblocks: tot:%ld free:%ld avail:%ld\n",
X                    fsdbuf [idx].fd_btot, fsdbuf [idx].fd_bfree,
X                    (int) fsdbuf [idx].fd_bfreen);
X            printf ("\tinodes: tot:%ld free:%ld\n",
X                    fsdbuf [idx].fd_gtot, fsdbuf [idx].fd_gfree);
X        }
X    }
X
X    free ((char *) fsdbuf);
X    return 0;
X}
X
X/* this is a no-op; we have already done all the work */
Xstatic void
XgetDiskInfo ()
X{
X}
X
X#endif /* HAS_GETMNT */
X
X
X#if defined (HAS_MNTCTL)
X
X/*
X * getDiskEntries
X *
X * AIX V3.2 uses mntctl to find out about mounted file systems
X *
X */
X
X# define NUM_AIX_FSTYPES         6
Xstatic char *AIX_fsType [NUM_AIX_FSTYPES] =
X    { "oaix", "", "nfs", "jfs", "", "cdrom" };
X
X/*
X * from xfsm-1.80:
X *
X * MNT_AIX - "aix"
X * MNT_NFS - "nfs"
X * MNT_JFS - "jfs"
X * MNT_CDROM - "cdrom"
X * other - "user defined"
X *
X */
X
Xstatic int
XgetDiskEntries ()
X{
X    int             num;        /* number of vmount structs returned    */
X    char            *vmbuf;     /* buffer for vmount structs returned   */
X    int             vmbufsz;    /* size in bytes of vmbuf               */
X    int             i;          /* index for looping and stuff          */
X    char            *bufp;      /* pointer into vmbuf                   */
X    struct vmount   *vmtp;      /* pointer into vmbuf                   */
X    struct vfs_ent  *ve;        /* pointer for file system type entry   */
X    int             len;
X
X
X    i = 0;
X    vmbufsz = sizeof (struct vmount) * DI_FSMAGIC; /* initial vmount buffer */
X
X    do
X    {
X        if ((vmbuf = (char *) malloc (vmbufsz)) == (char *) NULL)
X        {
X            fprintf (stderr, "malloc (%d) for mntctl() failed errno %d\n",
X                    vmbufsz, errno);
X            return -1;
X        }
X
X        num = mntctl (MCTL_QUERY, vmbufsz, vmbuf);
X            /*
X             * vmbuf is too small, could happen for
X             * following reasons:
X             * - inital buffer is too small
X             * - newly mounted file system
X             */
X        if (num == 0)
X        {
X            memcpy (&vmbufsz, vmbuf, sizeof (vmbufsz)); /* see mntctl(2) */
X            if (debug > 0)
X            {
X                printf ("vmbufsz too small, new size: %d\n", vmbufsz);
X            }
X            free ((char *) vmbuf); /* free this last, it's still being used! */
X            ++i;
X        }
X    } while (num == 0 && i < DI_RETRY_COUNT);
X
X    if (i >= DI_RETRY_COUNT)
X    {
X        free ((char *) vmbuf);
X        fprintf (stderr, "unable to allocate adequate buffer for mntctl\n");
X        return -1;
X    }
X
X    switch (num)
X    {
X            /* error happened, probably null vmbuf */
X        case -1:
X        {
X            free ((char *) vmbuf);
X            fprintf (stderr,"%s errno %d\n", strerror (errno), errno);
X            return -1;
X        }
X
X            /* 'num' vmount structs returned in vmbuf */
X        default:
X        {
X            diCount = num;
X            diskInfo = (DiskInfo *) calloc (sizeof (DiskInfo), diCount);
X            if (diskInfo == (DiskInfo *) NULL)
X            {
X                fprintf (stderr, "malloc failed for diskInfo. errno %d\n", errno);
X                return -1;
X            }
X
X            bufp = vmbuf;
X            for (i = 0; i < num; i++)
X            {
X                vmtp = (struct vmount *) bufp;
X                diskInfo [i].printFlag = DI_OK;
X                diskInfo [i].isLocal = TRUE;
X
X                strncpy (diskInfo [i].special,
X                        (char *) vmt2dataptr (vmtp, VMT_OBJECT),
X                        DI_SPEC_NAME_LEN);
X                strncpy (diskInfo [i].name,
X                        (char *) vmt2dataptr (vmtp, VMT_STUB), DI_NAME_LEN);
X
X                ve = getvfsbytype (vmtp->vmt_gfstype);
X                if (ve == (struct vfs_ent *) NULL || *ve->vfsent_name == '\0')
X                {
X                    if (vmtp->vmt_gfstype >= 0 &&
X                            (vmtp->vmt_gfstype < NUM_AIX_FSTYPES))
X                    {
X                        strncpy (diskInfo [i].fsType,
X                                AIX_fsType [vmtp->vmt_gfstype], DI_TYPE_LEN);
X                    }
X                }
X                else
X                {
X                    strncpy (diskInfo [i].fsType, ve->vfsent_name, DI_TYPE_LEN);
X                }
X
X                if ((vmtp->vmt_flags & MNT_READONLY) == MNT_READONLY)
X                {
X                    strcat (diskInfo [i].options, "ro,");
X                }
X                else
X                {
X                    strcat (diskInfo [i].options, "rw,");
X                }
X                if ((vmtp->vmt_flags & MNT_NOSUID) != MNT_NOSUID)
X                {
X                    strcat (diskInfo [i].options, "suid,");
X                }
X                if ((vmtp->vmt_flags & MNT_REMOVABLE) == MNT_REMOVABLE)
X                {
X                    strcat (diskInfo [i].options, "removable,");
X                }
X                if ((vmtp->vmt_flags & MNT_DEVICE) == MNT_DEVICE)
X                {
X                    strcat (diskInfo [i].options, "device,");
X                }
X                if ((vmtp->vmt_flags & MNT_REMOTE) == MNT_REMOTE)
X                {
X                    strcat (diskInfo [i].options, "remote,");
X                    diskInfo [i].isLocal = FALSE;
X                }
X                if ((vmtp->vmt_flags & MNT_UNMOUNTING) == MNT_UNMOUNTING)
X                {
X                    strcat (diskInfo [i].options, "unmounting,");
X                }
X                if ((vmtp->vmt_flags & MNT_SYSV_MOUNT) == MNT_SYSV_MOUNT)
X                {
X                    strcat (diskInfo [i].options, "sysv mount,");
X                }
X                if ((vmtp->vmt_flags & MNT_NODEV) == MNT_NODEV)
X                {
X                    strcat (diskInfo [i].options, "nodev,");
X                }
X
X                    /* remove trailing comma */
X                len = strlen (diskInfo [i].options);
X                if (len > 0)
X                {
X                    --len;
X                }
X                if (diskInfo [i].options [len] == ',')
X                {
X                    diskInfo [i].options [len] = '\0';
X                }
X
X                strncpy (diskInfo [i].mountTime, ctime (&vmtp->vmt_time),
X                        DI_MNT_TIME_LEN);
X
X                if (diskInfo [i].isLocal == FALSE &&
X                        (flags & DI_F_LOCAL_ONLY) == DI_F_LOCAL_ONLY)
X                {
X                    diskInfo [i].printFlag = DI_IGNORE;
X                    if (debug > 2)
X                    {
X                        printf ("mnt: ignore: remote: %s\n",
X                                diskInfo [i].name);
X                    }
X                }
X
X                bufp += vmtp->vmt_length;
X            }
X
X            if (debug > 0)
X            {
X                printf ("mnt:%s - %s : %s\n", diskInfo [i].name,
X                        diskInfo [i].special, diskInfo [i].fsType);
X                printf ("\t%s\n", (char *) vmt2dataptr (vmtp, VMT_ARGS));
X            }
X
X            break;
X        } /* valid value returned */
X    } /* switch on num */
X}
X
X#endif  /* HAS_MNTCTL */
X
X
X#if defined (HAS_STATVFS)
X
X/*
X * getDiskInfo
X *
X * SysV.4.  statvfs () returns both the free and available blocks.
X *
X */
X
Xstatic void
XgetDiskInfo ()
X{
X    int             i;
X    double          mult;
X    struct statvfs  statBuf;
X
X    for (i = 0; i < diCount; ++i)
X    {
X        if (diskInfo [i].isLocal == FALSE &&
X                (flags & DI_F_LOCAL_ONLY) == DI_F_LOCAL_ONLY)
X        {
X            diskInfo [i].printFlag = DI_IGNORE;
X            if (debug > 2)
X            {
X                printf ("mnt: ignore: remote: %s\n",
X                        diskInfo [i].name);
X            }
X        }
X
X        if (diskInfo [i].printFlag == DI_OK || (flags & DI_F_ALL) == DI_F_ALL)
X        {
X            if (statvfs (diskInfo [i].name, &statBuf) == 0)
X            {
X                    /* data general DG/UX 5.4R3.00 sometime returns 0   */
X                    /* in the fragment size field.                      */
X                if (statBuf.f_frsize == 0 && statBuf.f_bsize != 0)
X                {
X                    mult = (double) (long) statBuf.f_bsize / dispBlockSize;
X                }
X                else
X                {
X                    mult = (double) (long) statBuf.f_frsize / dispBlockSize;
X                }
X
X                diskInfo [i].totalBlocks = ((double) (_s_fs_size_t) statBuf.f_blocks * mult);
X                diskInfo [i].freeBlocks = ((double) (_s_fs_size_t) statBuf.f_bfree * mult);
X                diskInfo [i].availBlocks = ((double) (_s_fs_size_t) statBuf.f_bavail * mult);
X
X                diskInfo [i].totalInodes = statBuf.f_files;
X                diskInfo [i].freeInodes = statBuf.f_ffree;
X                diskInfo [i].availInodes = statBuf.f_favail;
X
X#if defined (HAS_STATVFS_BASETYPE)
X                strncpy (diskInfo [i].fsType, statBuf.f_basetype, DI_TYPE_LEN);
X#endif
X
X                if (debug > 1)
X                {
X                    printf ("%s: %s\n", diskInfo [i].name, diskInfo [i].fsType);
X                    printf ("\tmult:%f\n", mult);
X                    printf ("\tbsize:%ld  frsize:%ld\n", statBuf.f_bsize,
X                            statBuf.f_frsize);
X#if defined (HAS_64BIT_STATFS_FLDS)
X                    printf ("\tblocks: tot:%llu free:%lld avail:%llu\n",
X                            statBuf.f_blocks, statBuf.f_bfree, statBuf.f_bavail);
X                    printf ("\tinodes: tot:%llu free:%lld avail:%llu\n",
X                            statBuf.f_files, statBuf.f_ffree, statBuf.f_favail);
X#else
X                    printf ("\tblocks: tot:%lu free:%ld avail:%lu\n",
X                            statBuf.f_blocks, statBuf.f_bfree, statBuf.f_bavail);
X                    printf ("\tinodes: tot:%lu free:%ld avail:%lu\n",
X                            statBuf.f_files, statBuf.f_ffree, statBuf.f_favail);
X#endif
X                }
X            }
X            else
X            {
X                fprintf (stderr, "statvfs: %s ", diskInfo [i].name);
X                perror ("");
X            }
X        }
X    } /* for each entry */
X}
X
X#endif /* HAS_STATVFS */
X
X
X#if defined (HAS_STATFS_BSD) && ! defined (HAS_STATVFS) && \
X        ! defined (HAS_GETMNTINFO) && ! defined (HAS_GETMNT)
X
X/*
X * getDiskInfo
X *
X * SunOS/BSD/Pyramid
X *
X */
X
Xstatic void
XgetDiskInfo ()
X{
X    int             i;
X    double          mult;
X    struct statfs   statBuf;
X
X    for (i = 0; i < diCount; ++i)
X    {
X        if (diskInfo [i].printFlag == DI_OK || (flags & DI_F_ALL) == DI_F_ALL)
X        {
X            if (statfs (diskInfo [i].name, &statBuf) == 0)
X            {
X                mult = (double) statBuf.f_bsize / dispBlockSize;
X                diskInfo [i].totalBlocks = ((double) (_s_fs_size_t) statBuf.f_blocks * mult);
X                diskInfo [i].freeBlocks = ((double) (_s_fs_size_t) statBuf.f_bfree * mult);
X                diskInfo [i].availBlocks = ((double) (_s_fs_size_t) statBuf.f_bavail * mult);
X
X                diskInfo [i].totalInodes = statBuf.f_files;
X                diskInfo [i].freeInodes = statBuf.f_ffree;
X                diskInfo [i].availInodes = statBuf.f_ffree;
X# if defined (HAS_SYSFS)
X                sysfs (GETFSTYP, statBuf.f_fstyp, diskInfo [i].fsType);
X# endif
X
X                if (debug > 1)
X                {
X                    printf ("%s: %s\n", diskInfo [i].name, diskInfo [i].fsType);
X                    printf ("\tmult:%f\n", mult);
X                    printf ("\tbsize:%ld\n", statBuf.f_bsize);
X                    printf ("\tblocks: tot:%ld free:%ld avail:%ld\n",
X                            statBuf.f_blocks, statBuf.f_bfree, statBuf.f_bavail);
X                    printf ("\tinodes: tot:%ld free:%ld\n",
X                            statBuf.f_files, statBuf.f_ffree);
X                }
X            } /* if we got the info */
X            else
X            {
X                fprintf (stderr, "statfs: %s ", diskInfo [i].name);
X                perror ("");
X            }
X        }
X    } /* for each entry */
X}
X
X#endif /* HAS_STATFS_BSD */
X
X#if defined (HAS_STATFS_SYSV3) && ! defined (HAS_STATVFS) && \
X        ! defined (HAS_GETMNTINFO) && ! defined (HAS_GETMNT)
X
X/*
X * getDiskInfo
X *
X * SysV.3.  We don't have available blocks; just set it to free blocks.
X * The sysfs () call is used to get the disk type name.
X *
X */
X
Xstatic void
XgetDiskInfo ()
X{
X    int             i;
X    double          mult;
X    struct statfs   statBuf;
X
X    for (i = 0; i < diCount; ++i)
X    {
X        if (diskInfo [i].printFlag == DI_OK || (flags & DI_F_ALL) == DI_F_ALL)
X        {
X            if (statfs (diskInfo [i].name, &statBuf, sizeof (statBuf), 0) == 0)
X            {
X# if defined (HAS_STATFS_FRSIZE)
X                if (statBuf.f_frsize == 0 && statBuf.f_bsize != 0)
X                {
X                    mult = (double) (long) statBuf.f_bsize / dispBlockSize;
X                }
X                else
X                {
X                    mult = (double) (long) statBuf.f_frsize / dispBlockSize;
X                }
X# else
X                mult = (double) UBSIZE / dispBlockSize;
X# endif
X                diskInfo [i].totalBlocks = ((double) (_s_fs_size_t) statBuf.f_blocks * mult);
X                diskInfo [i].freeBlocks = ((double) (_s_fs_size_t) statBuf.f_bfree * mult);
X                diskInfo [i].availBlocks = ((double) (_s_fs_size_t) statBuf.f_bfree * mult);
X
X                diskInfo [i].totalInodes = statBuf.f_files;
X                diskInfo [i].freeInodes = statBuf.f_ffree;
X                diskInfo [i].availInodes = statBuf.f_ffree;
X# if defined (HAS_SYSFS)
X                sysfs (GETFSTYP, statBuf.f_fstyp, diskInfo [i].fsType);
X# endif
X
X                if (debug > 1)
X                {
X                    printf ("%s: %s\n", diskInfo [i].name, diskInfo [i].fsType);
X                    printf ("\tmult:%f\n", mult);
X# if defined (HAS_STATFS_FRSIZE)
X                    printf ("\tbsize:%ld\n", statBuf.f_bsize);
X                    printf ("\tfrsize:%ld\n", statBuf.f_frsize);
X# else
X                    printf ("\tUBSIZE:%ld\n", UBSIZE);
X# endif
X                    printf ("\tblocks: tot:%ld free:%ld\n",
X                            statBuf.f_blocks, statBuf.f_bfree);
X                    printf ("\tinodes: tot:%ld free:%ld\n",
X                            statBuf.f_files, statBuf.f_ffree);
X                }
X            } /* if we got the info */
X            else
X            {
X                fprintf (stderr, "statfs: %s ", diskInfo [i].name);
X                perror ("");
X            }
X        }
X    } /* for each entry */
X}
X
X#endif /* HAS_STATFS_SYSV3 */
X
X
X#if defined (HAS_GETDISKFREESPACE)
X
X/*
X * getDiskInfo
X *
X * Windows
X *
X */
X
X# define NUM_MSDOS_FSTYPES          7
Xstatic char *MSDOS_diskType [NUM_MSDOS_FSTYPES] =
X    { "unknown", "", "removable", "fixed", "remote", "cdrom", "ramdisk" };
X# define MSDOS_BUFFER_SIZE          128
X# define BYTES_PER_LOGICAL_DRIVE    4
X
Xstatic int
XgetDiskEntries ()
X{
X    int             i;
X    int             diskflag;
X    int             rc;
X    char            *p;
X    char            buff [MSDOS_BUFFER_SIZE];
X
X
X    diskflag = DI_IGNORE;
X    rc = GetLogicalDriveStrings (MSDOS_BUFFER_SIZE, buff);
X    diCount = rc / BYTES_PER_LOGICAL_DRIVE;
X
X    diskInfo = (DiskInfo *) calloc (sizeof (DiskInfo), diCount);
X    if (diskInfo == (DiskInfo *) NULL)
X    {
X        fprintf (stderr, "malloc failed for diskInfo. errno %d\n", errno);
X        return -1;
X    }
X
X    for (i = 0; i < diCount; ++i)
X    {
X        p = buff + (BYTES_PER_LOGICAL_DRIVE * i);
X        strncpy (diskInfo [i].name, p, DI_NAME_LEN);
X        rc = GetDriveType (p);
X        diskInfo [i].printFlag = DI_OK;
X
X        if (rc == DRIVE_NO_ROOT_DIR)
X        {
X            diskInfo [i].printFlag = DI_BAD;
X        }
X
X            /* assume that any removable drives before the  */
X            /* first non-removable disk are floppies...     */
X        else if (rc == DRIVE_REMOVABLE)
X        {
X            diskInfo [i].printFlag = diskflag;
X        }
X        else
X        {
X            diskflag = DI_OK;
X        }
X
X        if (rc != DRIVE_REMOTE)
X        {
X            diskInfo [i].isLocal = TRUE;
X        }
X        /* strncpy (diskInfo [i].fsType, MSDOS_diskType [rc], DI_TYPE_LEN); */
X    } /* for each mounted drive */
X
X    return diCount;
X}
X
X/*
X * getDiskInfo
X *
X * Windows
X *
X */
X
Xstatic void
XgetDiskInfo ()
X{
X    int                 i;
X    int                 rc;
X    double              mult;
X    unsigned long       sectorspercluster;
X    unsigned long       bytespersector;
X    unsigned long       totalclusters;
X    unsigned long       freeclusters;
X    char                tbuff [MSDOS_BUFFER_SIZE];
X    char                volName [MSDOS_BUFFER_SIZE];
X    char                fsName [MSDOS_BUFFER_SIZE];
X    DWORD               serialNo;
X    DWORD               maxCompLen;
X    DWORD               fsFlags;
X
X
X    for (i = 0; i < diCount; ++i)
X    {
X        if (diskInfo [i].isLocal == FALSE &&
X                (flags & DI_F_LOCAL_ONLY) == DI_F_LOCAL_ONLY)
X        {
X            diskInfo [i].printFlag = DI_IGNORE;
X            if (debug > 2)
X            {
X                printf ("mnt: ignore: remote: %s\n",
X                        diskInfo [i].name);
X            }
X        }
X
X        if (diskInfo [i].printFlag == DI_OK || (flags & DI_F_ALL) == DI_F_ALL)
X        {
X            rc = GetVolumeInformation (diskInfo [i].name,
X                    volName, MSDOS_BUFFER_SIZE, &serialNo, &maxCompLen,
X                    &fsFlags, fsName, MSDOS_BUFFER_SIZE);
X            /* strcpy (tbuff, diskInfo [i].fsType); */
X            /* strcat (tbuff, " "); */
X            strncpy (diskInfo [i].fsType, fsName, DI_TYPE_LEN);
X            strncpy (diskInfo [i].special, volName, DI_SPEC_NAME_LEN);
X
X            rc = GetDiskFreeSpace (diskInfo [i].name,
X                    (LPDWORD) &sectorspercluster, (LPDWORD) &bytespersector,
X                    (LPDWORD) &freeclusters, (LPDWORD) &totalclusters);
X
X            if (rc > 0)
X            {
X                mult = (double) (sectorspercluster *
X                        bytespersector) / dispBlockSize;
X                diskInfo [i].totalBlocks = ((double) (_s_fs_size_t) totalclusters * mult);
X                diskInfo [i].freeBlocks = ((double) (_s_fs_size_t) freeclusters * mult);
X                diskInfo [i].availBlocks = ((double) (_s_fs_size_t) freeclusters * mult);
X
X                diskInfo [i].totalInodes = 0;
X                diskInfo [i].freeInodes = 0;
X                diskInfo [i].availInodes = 0;
X
X                if (debug > 1)
X                {
X                    printf ("%s: %s\n", diskInfo [i].name, diskInfo [i].fsType);
X                    printf ("\ts/c:%ld  b/s:%ld\n", sectorspercluster,
X                        bytespersector);
X                    printf ("\tmult:%f\n", mult);
X                    printf ("\tclusters: tot:%ld free:%ld\n",
X                        totalclusters, freeclusters);
X                }
X            }
X            else
X            {
X                diskInfo [i].printFlag = DI_BAD;
X                if (debug)
X                {
X                    printf ("disk %s; could not get disk space\n",
X                            diskInfo [i].name);
X                }
X            }
X        } /* if printable drive */
X    } /* for each mounted drive */
X}
X
X#endif /* HAS_GETDISKFREESPACE */
END_OF_FILE
if test 97566 -ne `wc -c <'di.c'`; then
    echo shar: \"'di.c'\" unpacked with wrong size!
fi
# end of 'di.c'
fi
echo shar: End of archive 2 \(of 3\).
cp /dev/null ark2isdone
MISSING=""
for I in 1 2 3 ; do
    if test ! -f ark${I}isdone ; then
	MISSING="${MISSING} ${I}"
    fi
done
if test "${MISSING}" = "" ; then
    echo You have unpacked all 3 archives.
    rm -f ark[1-9]isdone
else
    echo You still need to unpack the following archives:
    echo "        " ${MISSING}
fi
##  End of shell archive.
exit 0