BSD 4_4 release

[unix-history] / usr / src / sbin / dump / optr.c

diff --git a/usr/src/sbin/dump/optr.c b/usr/src/sbin/dump/optr.c
index 136cc5b..afc9b8c 100644 (file)
--- a/usr/src/sbin/dump/optr.c
+++ b/usr/src/sbin/dump/optr.c
@@ -1,21 +1,73 @@
-static char *sccsid = "@(#)optr.c      1.3 (Berkeley) %G%";
+/*-
+ * Copyright (c) 1980, 1988, 1993
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *     This product includes software developed by the University of
+ *     California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifndef lint
+static char sccsid[] = "@(#)optr.c     8.1 (Berkeley) 6/5/93";
+#endif /* not lint */
+
+#include <sys/param.h>
+#include <sys/wait.h>
+#include <sys/time.h>
+
+#include <errno.h>
+#include <fstab.h>
+#include <grp.h>
+#include <signal.h>
+#include <stdio.h>
+#ifdef __STDC__
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#endif
+#include <tzfile.h>
+#ifdef __STDC__
+#include <unistd.h>
+#endif
+#include <utmp.h>
+#ifndef __STDC__
+#include <varargs.h>
+#endif
+

 #include "dump.h"
 #include "dump.h"

+#include "pathnames.h"
+
+void   alarmcatch __P((/* int, int */));
+int    datesort __P((const void *, const void *));
+static void sendmes __P((char *, char *));

 
 /*
 
 /*

- *     This is from /usr/include/grp.h
- *     That defined struct group, which conflicts
- *     with the struct group defined in param.h
- */
-struct Group { /* see getgrent(3) */
-       char    *gr_name;
-       char    *gr_passwd;
-       int     gr_gid;
-       char    **gr_mem;
-};
-struct Group *getgrnam();
-/*
- *     Query the operator; This fascist piece of code requires
- *     an exact response.
+ *     Query the operator; This previously-fascist piece of code
+ *     no longer requires an exact response.

  *     It is intended to protect dump aborting by inquisitive
  *     people banging on the console terminal to see what is
  *     happening which might cause dump to croak, destroying
  *     It is intended to protect dump aborting by inquisitive
  *     people banging on the console terminal to see what is
  *     happening which might cause dump to croak, destroying


@@ -24,74 +76,90 @@ struct      Group *getgrnam();
  *     Every 2 minutes we reprint the message, alerting others
  *     that dump needs attention.
  */
  *     Every 2 minutes we reprint the message, alerting others
  *     that dump needs attention.
  */

-int    timeout;
-char   *attnmessage;           /* attemtion message */
+static int timeout;
+static char *attnmessage;              /* attention message */
+
+int

 query(question)
        char    *question;
 {
        char    replybuffer[64];
 query(question)
        char    *question;
 {
        char    replybuffer[64];

-       int     back;
+       int     back, errcount;

        FILE    *mytty;
 
        FILE    *mytty;
 

-       if ( (mytty = fopen("/dev/tty", "r")) == NULL){
-               msg("fopen on /dev/tty fails\n");
-               abort();
-       }
+       if ((mytty = fopen(_PATH_TTY, "r")) == NULL)
+               quit("fopen on %s fails: %s\n", _PATH_TTY, strerror(errno));

        attnmessage = question;
        timeout = 0;
        alarmcatch();
        attnmessage = question;
        timeout = 0;
        alarmcatch();

-       for(;;){
-               if ( fgets(replybuffer, 63, mytty) == NULL){
-                       if (ferror(mytty)){
-                               clearerr(mytty);
-                               continue;
-                       }
-               } else if ( (strcmp(replybuffer, "yes\n") == 0) ||
-                           (strcmp(replybuffer, "Yes\n") == 0)){
-                               back = 1;
-                               goto done;
-               } else if ( (strcmp(replybuffer, "no\n") == 0) ||
-                           (strcmp(replybuffer, "No\n") == 0)){
-                               back = 0;
-                               goto done;
+       back = -1;
+       errcount = 0;
+       do {
+               if (fgets(replybuffer, 63, mytty) == NULL) {
+                       clearerr(mytty);
+                       if (++errcount > 30)    /* XXX  ugly */
+                               quit("excessive operator query failures\n");
+               } else if (replybuffer[0] == 'y' || replybuffer[0] == 'Y') {
+                       back = 1;
+               } else if (replybuffer[0] == 'n' || replybuffer[0] == 'N') {
+                       back = 0;

                } else {
                } else {

-                       msg("\"Yes\" or \"No\" ONLY!\n");
-                       alarmcatch();
+                       (void) fprintf(stderr,
+                           "  DUMP: \"Yes\" or \"No\"?\n");
+                       (void) fprintf(stderr,
+                           "  DUMP: %s: (\"yes\" or \"no\") ", question);

                }
                }

-       }
-    done:
+       } while (back < 0);
+

        /*
         *      Turn off the alarm, and reset the signal to trap out..
         */
        /*
         *      Turn off the alarm, and reset the signal to trap out..
         */

-       alarm(0);
-       if (signal(SIGALRM, sigalrm) == SIG_IGN)
+       (void) alarm(0);
+       if (signal(SIGALRM, sig) == SIG_IGN)

                signal(SIGALRM, SIG_IGN);
                signal(SIGALRM, SIG_IGN);

-       fclose(mytty);
+       (void) fclose(mytty);

        return(back);
 }
        return(back);
 }

+
+char lastmsg[100];
+

 /*
  *     Alert the console operator, and enable the alarm clock to
  *     sleep for 2 minutes in case nobody comes to satisfy dump
  */
 /*
  *     Alert the console operator, and enable the alarm clock to
  *     sleep for 2 minutes in case nobody comes to satisfy dump
  */

+void

 alarmcatch()
 {
 alarmcatch()
 {

-       if (timeout)
-               msgtail("\n");
-       msg("NEEDS ATTENTION: %s: (\"yes\" or \"no\") ",
-               attnmessage);
+       if (notify == 0) {
+               if (timeout == 0)
+                       (void) fprintf(stderr,
+                           "  DUMP: %s: (\"yes\" or \"no\") ",
+                           attnmessage);
+               else
+                       msgtail("\7\7");
+       } else {
+               if (timeout) {
+                       msgtail("\n");
+                       broadcast("");          /* just print last msg */
+               }
+               (void) fprintf(stderr,"  DUMP: %s: (\"yes\" or \"no\") ",
+                   attnmessage);
+       }

        signal(SIGALRM, alarmcatch);
        signal(SIGALRM, alarmcatch);

-       alarm(120);
+       (void) alarm(120);

        timeout = 1;
 }
        timeout = 1;
 }

+

 /*
  *     Here if an inquisitive operator interrupts the dump program
  */
 /*
  *     Here if an inquisitive operator interrupts the dump program
  */

-interrupt()
+void
+interrupt(signo)
+       int signo;

 {
 {

-       msg("Interrupt received. Do >>>YOU<<< know what are you doing?\n");
-       if (query("Do you really want to abort dump?"))
-               dumpabort();
-       signal(SIGINT, interrupt);
+       msg("Interrupt received.\n");
+       if (query("Do you want to abort dump?"))
+               dumpabort(0);

 }
 
 /*
 }
 
 /*


@@ -99,42 +167,44 @@ interrupt()
  *     operators to the status of dump.
  *     This works much like wall(1) does.
  */
  *     operators to the status of dump.
  *     This works much like wall(1) does.
  */

-struct Group *gp;
+struct group *gp;

 
 /*
  *     Get the names from the group entry "operator" to notify.
  */    
 
 /*
  *     Get the names from the group entry "operator" to notify.
  */    

+void

 set_operators()
 {
        if (!notify)            /*not going to notify*/
                return;
        gp = getgrnam(OPGRENT);
 set_operators()
 {
        if (!notify)            /*not going to notify*/
                return;
        gp = getgrnam(OPGRENT);

-       endgrent();
-       if (gp == (struct Group *)0){
-               msg("No entry in /etc/group for %s.\n",
-                       OPGRENT);
+       (void) endgrent();
+       if (gp == NULL) {
+               msg("No group entry for %s.\n", OPGRENT);

                notify = 0;
                return;
        }
 }
 
                notify = 0;
                return;
        }
 }
 

-struct tm *localtime();

 struct tm *localclock;
 
 /*
  *     We fork a child to do the actual broadcasting, so
  *     that the process control groups are not messed up
  */
 struct tm *localclock;
 
 /*
  *     We fork a child to do the actual broadcasting, so
  *     that the process control groups are not messed up
  */

+void

 broadcast(message)
        char    *message;
 {
        time_t          clock;
        FILE    *f_utmp;
        struct  utmp    utmp;
 broadcast(message)
        char    *message;
 {
        time_t          clock;
        FILE    *f_utmp;
        struct  utmp    utmp;

-       int     nusers;

        char    **np;
        int     pid, s;
 
        char    **np;
        int     pid, s;
 

+       if (!notify || gp == NULL)
+               return;
+

        switch (pid = fork()) {
        case -1:
                return;
        switch (pid = fork()) {
        case -1:
                return;


@@ -146,24 +216,20 @@ broadcast(message)
                return;
        }
 
                return;
        }
 

-       if (!notify || gp == 0)
-               return;
-       clock = time(0);
+       clock = time((time_t *)0);

        localclock = localtime(&clock);
 
        localclock = localtime(&clock);
 

-       if((f_utmp = fopen("/etc/utmp", "r")) == NULL) {
-               msg("Cannot open /etc/utmp\n");
+       if ((f_utmp = fopen(_PATH_UTMP, "r")) == NULL) {
+               msg("Cannot open %s: %s\n", _PATH_UTMP, strerror(errno));

                return;
        }
 
                return;
        }
 

-       nusers = 0;
-       while (!feof(f_utmp)){
-               if (fread(&utmp, sizeof (struct utmp), 1, f_utmp) != 1)
+       while (!feof(f_utmp)) {
+               if (fread((char *) &utmp, sizeof (struct utmp), 1, f_utmp) != 1)

                        break;
                if (utmp.ut_name[0] == 0)
                        continue;
                        break;
                if (utmp.ut_name[0] == 0)
                        continue;

-               nusers++;
-               for (np = gp->gr_mem; *np; np++){
+               for (np = gp->gr_mem; *np; np++) {

                        if (strncmp(*np, utmp.ut_name, sizeof(utmp.ut_name)) != 0)
                                continue;
                        /*
                        if (strncmp(*np, utmp.ut_name, sizeof(utmp.ut_name)) != 0)
                                continue;
                        /*


@@ -172,42 +238,50 @@ broadcast(message)
                        if (strncmp(utmp.ut_line, DIALUP, strlen(DIALUP)) == 0)
                                continue;
 #ifdef DEBUG
                        if (strncmp(utmp.ut_line, DIALUP, strlen(DIALUP)) == 0)
                                continue;
 #ifdef DEBUG

-                       msg("Message to %s at %s\n",
-                               utmp.ut_name, utmp.ut_line);
-#endif DEBUG
+                       msg("Message to %s at %s\n", *np, utmp.ut_line);
+#endif

                        sendmes(utmp.ut_line, message);
                }
        }
                        sendmes(utmp.ut_line, message);
                }
        }

-       fclose(f_utmp);
+       (void) fclose(f_utmp);

        Exit(0);        /* the wait in this same routine will catch this */
        /* NOTREACHED */
 }
 
        Exit(0);        /* the wait in this same routine will catch this */
        /* NOTREACHED */
 }
 

+static void

 sendmes(tty, message)
 sendmes(tty, message)

-char *tty, *message;
+       char *tty, *message;

 {
        char t[50], buf[BUFSIZ];
        register char *cp;
 {
        char t[50], buf[BUFSIZ];
        register char *cp;

-       register int c, ch;
-       int     msize;
+       int lmsg = 1;

        FILE *f_tty;
 
        FILE *f_tty;
 

-       msize = strlen(message);
-       strcpy(t, "/dev/");
-       strcat(t, tty);
+       (void) strcpy(t, _PATH_DEV);
+       (void) strcat(t, tty);

 
 

-       if((f_tty = fopen(t, "w")) != NULL) {
+       if ((f_tty = fopen(t, "w")) != NULL) {

                setbuf(f_tty, buf);
                setbuf(f_tty, buf);

-               fprintf(f_tty, "\n\a\a\aMessage from the dump program to all operators at %d:%02d ...\r\n\n"
-                      ,localclock->tm_hour
-                      ,localclock->tm_min);
-               for (cp = message, c = msize; c-- > 0; cp++) {
-                       ch = *cp;
-                       if (ch == '\n')
-                               putc('\r', f_tty);
-                       putc(ch, f_tty);
+               (void) fprintf(f_tty,
+                   "\n\
+\7\7\7Message from the dump program to all operators at %d:%02d ...\r\n\n\
+DUMP: NEEDS ATTENTION: ",
+                   localclock->tm_hour, localclock->tm_min);
+               for (cp = lastmsg; ; cp++) {
+                       if (*cp == '\0') {
+                               if (lmsg) {
+                                       cp = message;
+                                       if (*cp == '\0')
+                                               break;
+                                       lmsg = 0;
+                               } else
+                                       break;
+                       }
+                       if (*cp == '\n')
+                               (void) putc('\r', f_tty);
+                       (void) putc(*cp, f_tty);

                }
                }

-               fclose(f_tty);
+               (void) fclose(f_tty);

        }
 }
 
        }
 }
 


@@ -217,192 +291,245 @@ char *tty, *message;
 
 time_t tschedule = 0;
 
 
 time_t tschedule = 0;
 

+void

 timeest()
 {
        time_t  tnow, deltat;
 
 timeest()
 {
        time_t  tnow, deltat;
 

-       time (&tnow);
-       if (tnow >= tschedule){
+       (void) time((time_t *) &tnow);
+       if (tnow >= tschedule) {

                tschedule = tnow + 300;
                if (blockswritten < 500)
                        return; 
                deltat = tstart_writing - tnow +
                tschedule = tnow + 300;
                if (blockswritten < 500)
                        return; 
                deltat = tstart_writing - tnow +

-                       (((1.0*(tnow - tstart_writing))/blockswritten) * esize);
+                       (1.0 * (tnow - tstart_writing))
+                       / blockswritten * tapesize;

                msg("%3.2f%% done, finished in %d:%02d\n",
                msg("%3.2f%% done, finished in %d:%02d\n",

-                       (blockswritten*100.0)/esize,
-                       deltat/3600, (deltat%3600)/60);
+                       (blockswritten * 100.0) / tapesize,
+                       deltat / 3600, (deltat % 3600) / 60);

        }
 }
 
        }
 }
 

-int blocksontape()
+void
+#if __STDC__
+msg(const char *fmt, ...)
+#else
+msg(fmt, va_alist)
+       char *fmt;
+       va_dcl
+#endif

 {
 {

-       /*
-        *      esize: total number of blocks estimated over all reels
-        *      blockswritten:  blocks actually written, over all reels
-        *      etapes: estimated number of tapes to write
-        *
-        *      tsize:  blocks can write on this reel
-        *      asize:  blocks written on this reel
-        *      tapeno: number of tapes written so far
-        */
-       if (tapeno == etapes)
-               return(esize - (etapes - 1)*tsize);
-       return(tsize);
+       va_list ap;
+
+       (void) fprintf(stderr,"  DUMP: ");
+#ifdef TDEBUG
+       (void) fprintf(stderr, "pid=%d ", getpid());
+#endif
+#if __STDC__
+       va_start(ap, fmt);
+#else
+       va_start(ap);
+#endif
+       (void) vfprintf(stderr, fmt, ap);
+       (void) fflush(stdout);
+       (void) fflush(stderr);
+       (void) vsprintf(lastmsg, fmt, ap);
+       va_end(ap);

 }
 
 }
 

-       /* VARARGS1 */
-       /* ARGSUSED */
-msg(fmt, a1, a2, a3, a4, a5)
-       char    *fmt;
+void
+#if __STDC__
+msgtail(const char *fmt, ...)
+#else
+msgtail(fmt, va_alist)
+       char *fmt;
+       va_dcl
+#endif

 {
 {

-       fprintf(stderr,"  DUMP: ");
-#ifdef TDEBUG
-       fprintf(stderr,"pid=%d ", getpid());
+       va_list ap;
+#if __STDC__
+       va_start(ap, fmt);
+#else
+       va_start(ap);

 #endif
 #endif

-       fprintf(stderr, fmt, a1, a2, a3, a4, a5);
-       fflush(stdout);
-       fflush(stderr);
+       (void) vfprintf(stderr, fmt, ap);
+       va_end(ap);

 }
 
 }
 

-       /* VARARGS1 */
-       /* ARGSUSED */
-msgtail(fmt, a1, a2, a3, a4, a5)
-       char    *fmt;
+void
+#if __STDC__
+quit(const char *fmt, ...)
+#else
+quit(fmt, va_alist)
+       char *fmt;
+       va_dcl
+#endif

 {
 {

-       fprintf(stderr, fmt, a1, a2, a3, a4, a5);
+       va_list ap;
+
+       (void) fprintf(stderr,"  DUMP: ");
+#ifdef TDEBUG
+       (void) fprintf(stderr, "pid=%d ", getpid());
+#endif
+#if __STDC__
+       va_start(ap, fmt);
+#else
+       va_start(ap);
+#endif
+       (void) vfprintf(stderr, fmt, ap);
+       va_end(ap);
+       (void) fflush(stdout);
+       (void) fflush(stderr);
+       dumpabort(0);

 }
 }

+

 /*
  *     Tell the operator what has to be done;
  *     we don't actually do it
  */
 
 /*
  *     Tell the operator what has to be done;
  *     we don't actually do it
  */
 

+struct fstab *
+allocfsent(fs)
+       register struct fstab *fs;
+{
+       register struct fstab *new;
+
+       new = (struct fstab *)malloc(sizeof (*fs));
+       if (new == NULL ||
+           (new->fs_file = strdup(fs->fs_file)) == NULL ||
+           (new->fs_type = strdup(fs->fs_type)) == NULL ||
+           (new->fs_spec = strdup(fs->fs_spec)) == NULL)
+               quit("%s\n", strerror(errno));
+       new->fs_passno = fs->fs_passno;
+       new->fs_freq = fs->fs_freq;
+       return (new);
+}
+
+struct pfstab {
+       struct  pfstab *pf_next;
+       struct  fstab *pf_fstab;
+};
+
+static struct pfstab *table;
+
+void

 getfstab()
 {
 getfstab()
 {

-       register        struct  fstab   *dt;
-                       struct  fstab   *fsp;
+       register struct fstab *fs;
+       register struct pfstab *pf;

 
 

-       nfstab = 0;

        if (setfsent() == 0) {
        if (setfsent() == 0) {

-               msg("Can't open %s for dump table information.\n", FSTAB);
-       } else {
-               for (nfstab = 0, dt = fstab; nfstab < MAXFSTAB;){
-                       if ( (fsp = getfsent()) == 0)
-                               break;
-                       if (   (strcmp(fsp->fs_type, FSTAB_RW) == 0)
-                           || (strcmp(fsp->fs_type, FSTAB_RO) == 0) ){
-                               *dt = *fsp;
-                               nfstab++; 
-                               dt++;
-                       }
-               }
-               endfsent();
+               msg("Can't open %s for dump table information: %s\n",
+                   _PATH_FSTAB, strerror(errno));
+               return;
+       }
+       while ((fs = getfsent()) != NULL) {
+               if (strcmp(fs->fs_type, FSTAB_RW) &&
+                   strcmp(fs->fs_type, FSTAB_RO) &&
+                   strcmp(fs->fs_type, FSTAB_RQ))
+                       continue;
+               fs = allocfsent(fs);
+               if ((pf = (struct pfstab *)malloc(sizeof (*pf))) == NULL)
+                       quit("%s\n", strerror(errno));
+               pf->pf_fstab = fs;
+               pf->pf_next = table;
+               table = pf;

        }
        }

+       (void) endfsent();

 }
 
 /*
 }
 
 /*

- *     Search in the fstab for a file name.
- *     This file name can be either the special or the path file name.
+ * Search in the fstab for a file name.
+ * This file name can be either the special or the path file name.

  *
  *

- *     The entries in the fstab are the BLOCK special names, not the
- *     character special names.
- *     The caller of fstabsearch assures that the character device
- *     is dumped (that is much faster)
+ * The entries in the fstab are the BLOCK special names, not the
+ * character special names.
+ * The caller of fstabsearch assures that the character device
+ * is dumped (that is much faster)

  *
  *

- *     The file name can omit the leading '/'.
+ * The file name can omit the leading '/'.

  */
  */

-struct fstab   *fstabsearch(key)
-       char    *key;
+struct fstab *
+fstabsearch(key)
+       char *key;

 {
 {

-       register        struct  fstab *dt;
-                       int     i;
-                       int     keylength;
-                       char    *rawname();
-
-       keylength = min(strlen(key), sizeof (dt->fs_file));
-       for (i = 0, dt = fstab; i < nfstab; i++, dt++){
-               if (strncmp(dt->fs_file, key, keylength) == 0)
-                       return(dt);
-               if (strncmp(dt->fs_spec, key, keylength) == 0)
-                       return(dt);
-               if (strncmp(rawname(dt->fs_spec), key, keylength) == 0)
-                       return(dt);
-
-               if (key[0] != '/'){
-                       if (   (dt->fs_spec[0] == '/')
-                           && (strncmp(dt->fs_spec+1, key, keylength) == 0))
-                               return(dt);
-                       if (   (dt->fs_file[0] == '/')
-                           && (strncmp(dt->fs_file+1, key, keylength) == 0))
-                               return(dt);
+       register struct pfstab *pf;
+       register struct fstab *fs;
+
+       for (pf = table; pf != NULL; pf = pf->pf_next) {
+               fs = pf->pf_fstab;
+               if (strcmp(fs->fs_file, key) == 0 ||
+                   strcmp(fs->fs_spec, key) == 0 ||
+                   strcmp(rawname(fs->fs_spec), key) == 0)
+                       return (fs);
+               if (key[0] != '/') {
+                       if (*fs->fs_spec == '/' &&
+                           strcmp(fs->fs_spec + 1, key) == 0)
+                               return (fs);
+                       if (*fs->fs_file == '/' &&
+                           strcmp(fs->fs_file + 1, key) == 0)
+                               return (fs);

                }
        }
                }
        }

-       return(0);
+       return (NULL);

 }
 
 /*
  *     Tell the operator what to do
  */
 }
 
 /*
  *     Tell the operator what to do
  */

+void

 lastdump(arg)
 lastdump(arg)

-       char    arg;            /* w ==> just what to do; W ==> most recent dumps */
+       char    arg;    /* w ==> just what to do; W ==> most recent dumps */

 {
 {

-                       char    *lastname;
-                       char    *date;
-       register        int     i;
-                       time_t  tnow;
-       register        struct  fstab   *dt;
-                       int     dumpme;
-       register        struct  idates  *itwalk;
-
-       int     idatesort();
-
-       time(&tnow);
+       register int i;
+       register struct fstab *dt;
+       register struct dumpdates *dtwalk;
+       char *lastname, *date;
+       int dumpme;
+       time_t tnow;
+
+       (void) time(&tnow);

        getfstab();             /* /etc/fstab input */
        getfstab();             /* /etc/fstab input */

-       inititimes();           /* /etc/dumpdates input */
-       qsort(idatev, nidates, sizeof(struct idates *), idatesort);
+       initdumptimes();        /* /etc/dumpdates input */
+       qsort((char *) ddatev, nddates, sizeof(struct dumpdates *), datesort);

 
        if (arg == 'w')
 
        if (arg == 'w')

-               fprintf(stdout, "Dump these file systems:\n");
+               (void) printf("Dump these file systems:\n");

        else
        else

-               fprintf(stdout, "Last dump(s) done (Dump '>' file systems):\n");
+               (void) printf("Last dump(s) done (Dump '>' file systems):\n");

        lastname = "??";
        lastname = "??";

-       ITITERATE(i, itwalk){
-               if (strncmp(lastname, itwalk->id_name, sizeof(itwalk->id_name)) == 0)
+       ITITERATE(i, dtwalk) {
+               if (strncmp(lastname, dtwalk->dd_name,
+                   sizeof(dtwalk->dd_name)) == 0)

                        continue;
                        continue;

-               date = (char *)ctime(&itwalk->id_ddate);
-               date[16] = '\0';                /* blast away seconds and year */
-               lastname = itwalk->id_name;
-               dt = fstabsearch(itwalk->id_name);
-               dumpme = (  (dt != 0)
-                        && (dt->fs_freq != 0)
-                        && (itwalk->id_ddate < tnow - (dt->fs_freq*DAY)));
-               if ( (arg != 'w') || dumpme)
-                 fprintf(stdout,"%c %8s\t(%6s) Last dump: Level %c, Date %s\n",
-                       dumpme && (arg != 'w') ? '>' : ' ',
-                       itwalk->id_name,
-                       dt ? dt->fs_file : 0,
-                       itwalk->id_incno,
-                       date
-                   );
+               date = (char *)ctime(&dtwalk->dd_ddate);
+               date[16] = '\0';        /* blast away seconds and year */
+               lastname = dtwalk->dd_name;
+               dt = fstabsearch(dtwalk->dd_name);
+               dumpme = (dt != NULL &&
+                   dt->fs_freq != 0 &&
+                   dtwalk->dd_ddate < tnow - (dt->fs_freq * SECSPERDAY));
+               if (arg != 'w' || dumpme)
+                       (void) printf(
+                           "%c %8s\t(%6s) Last dump: Level %c, Date %s\n",
+                           dumpme && (arg != 'w') ? '>' : ' ',
+                           dtwalk->dd_name,
+                           dt ? dt->fs_file : "",
+                           dtwalk->dd_level,
+                           date);

        }
 }
 
        }
 }
 

-int    idatesort(p1, p2)
-       struct  idates  **p1, **p2;
+int
+datesort(a1, a2)
+       const void *a1, *a2;

 {
 {

-       int     diff;
+       struct dumpdates *d1 = *(struct dumpdates **)a1;
+       struct dumpdates *d2 = *(struct dumpdates **)a2;
+       int diff;

 
 

-       diff = strncmp((*p1)->id_name, (*p2)->id_name, sizeof((*p1)->id_name));
+       diff = strncmp(d1->dd_name, d2->dd_name, sizeof(d1->dd_name));

        if (diff == 0)
        if (diff == 0)

-               return ((*p2)->id_ddate - (*p1)->id_ddate);
-       else
-               return (diff);
-}
-
-int max(a,b)
-{
-       return(a>b?a:b);
-}
-int min(a,b)
-{
-       return(a<b?a:b);
+               return (d2->dd_ddate - d1->dd_ddate);
+       return (diff);

 }
 }