[dump.git] / dump / optr.c

/*
 *	Ported to Linux's Second Extended File System as part of the
 *	dump and restore backup suit
 *	Remy Card <card@Linux.EU.Org>, 1994-1997
 *      Stelian Pop <pop@cybercable.fr>, 1999 
 *
 */

/*-
 * 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.
 *
 * $Id: optr.c,v 1.5 1999/10/11 13:31:11 stelian Exp $
 */

#include <sys/param.h>
#include <sys/wait.h>
#include <sys/time.h>

#include <errno.h>
#include <fstab.h>
#include <grp.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <unistd.h>
#include <utmp.h>
#include <sys/stat.h>

#ifdef __linux__
#include <linux/ext2_fs.h>
#include <ext2fs/ext2fs.h>
#include <bsdcompat.h>
#include <signal.h>
#endif

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

static	void alarmcatch __P((int));
int	datesort __P((const void *, const void *));
static	void sendmes __P((const char *, const char *));

/*
 *	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
 *	a large number of hours of work.
 *
 *	Every 2 minutes we reprint the message, alerting others
 *	that dump needs attention.
 */
static	int timeout;
static	const char *attnmessage;		/* attention message */

int
query(const char *question)
{
	char	replybuffer[64];
	int	back, errcount;
	FILE	*mytty;
	time_t	firstprompt, when_answered;

#ifdef __linux__
	(void)time4(&(firstprompt));
#else
	(void)time((time_t *)&(firstprompt));
#endif

	if ((mytty = fopen(_PATH_TTY, "r")) == NULL)
		quit("fopen on %s fails: %s\n", _PATH_TTY, strerror(errno));
	attnmessage = question;
	timeout = 0;
	alarmcatch(0);
	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 {
			(void) fprintf(stderr,
			    "  DUMP: \"Yes\" or \"No\"?\n");
			(void) fprintf(stderr,
			    "  DUMP: %s: (\"yes\" or \"no\") ", question);
		}
	} while (back < 0);

	/*
	 *	Turn off the alarm, and reset the signal to trap out..
	 */
	(void) alarm(0);
	if (signal(SIGALRM, sig) == SIG_IGN)
		signal(SIGALRM, SIG_IGN);
	(void) fclose(mytty);
#ifdef __linux__
	(void)time4(&(when_answered));
#else
	(void)time((time_t *)&(when_answered));
#endif
	/*
	 * Adjust the base for time estimates to ignore time we spent waiting
	 * for operator input.
	 */
	if ((tstart_writing != 0) && (when_answered != (time_t)-1) && (firstprompt != (time_t)-1))
		tstart_writing += (when_answered - firstprompt);
	return(back);
}

char lastmsg[BUFSIZ];

/*
 *	Alert the console operator, and enable the alarm clock to
 *	sleep for 2 minutes in case nobody comes to satisfy dump
 */
static void
alarmcatch(int signo)
{
	int save_errno = errno;
	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);
	(void) alarm(120);
	timeout = 1;
	errno = save_errno;
}

/*
 *	Here if an inquisitive operator interrupts the dump program
 */
void
interrupt(int signo)
{
	msg("Interrupt received.\n");
	if (query("Do you want to abort dump?"))
		dumpabort(0);
}

/*
 *	The following variables and routines manage alerting
 *	operators to the status of dump.
 *	This works much like wall(1) does.
 */
struct	group *gp;

/*
 *	Get the names from the group entry "operator" to notify.
 */
void
set_operators(void)
{
	if (!notify)		/*not going to notify*/
		return;
	gp = getgrnam(OPGRENT);
	(void) endgrent();
	if (gp == NULL) {
		msg("No group entry for %s.\n", OPGRENT);
		notify = 0;
		return;
	}
}

struct tm *localclock;

/*
 *	We fork a child to do the actual broadcasting, so
 *	that the process control groups are not messed up
 */
void
broadcast(const char *message)
{
	time_t		clock;
	FILE	*f_utmp;
	struct	utmp	utmp;
	char	**np;
	int	pid, s;

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

	switch (pid = fork()) {
	case -1:
		return;
	case 0:
		break;
	default:
		while (wait(&s) != pid)
			continue;
		return;
	}

	clock = time((time_t *)0);
	localclock = localtime(&clock);

	if ((f_utmp = fopen(_PATH_UTMP, "r")) == NULL) {
		msg("Cannot open %s: %s\n", _PATH_UTMP, strerror(errno));
		return;
	}

	while (!feof(f_utmp)) {
		if (fread((char *) &utmp, sizeof (struct utmp), 1, f_utmp) != 1)
			break;
		if (utmp.ut_name[0] == 0)
			continue;
		for (np = gp->gr_mem; *np; np++) {
			if (strncmp(*np, utmp.ut_name, sizeof(utmp.ut_name)) != 0)
				continue;
			/*
			 *	Do not send messages to operators on dialups
			 */
			if (strncmp(utmp.ut_line, DIALUP, strlen(DIALUP)) == 0)
				continue;
#ifdef DEBUG
			msg("Message to %s at %s\n", *np, utmp.ut_line);
#endif
			sendmes(utmp.ut_line, message);
		}
	}
	(void) fclose(f_utmp);
	Exit(0);	/* the wait in this same routine will catch this */
	/* NOTREACHED */
}

static void
sendmes(const char *tty, const char *message)
{
	char t[MAXPATHLEN], buf[BUFSIZ];
	register const char *cp;
	int lmsg = 1;
	FILE *f_tty;

	(void) strcpy(t, _PATH_DEV);
	(void) strncat(t, tty, sizeof t - strlen(_PATH_DEV) - 1);

	if ((f_tty = fopen(t, "w")) != NULL) {
		setbuf(f_tty, buf);
		(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 && *cp != '\0'))
						break;
					lmsg = 0;
				} else
					break;
			}
			if (*cp == '\n')
				(void) putc('\r', f_tty);
			(void) putc(*cp, f_tty);
		}
		(void) fclose(f_tty);
	}
}

/*
 *	print out an estimate of the amount of time left to do the dump
 */

time_t	tschedule = 0;

void
timeest(void)
{
	time_t	tnow, deltat;

#ifdef __linux__
	(void) time4(&tnow);
#else
	(void) time((time_t *) &tnow);
#endif
	if (tnow >= tschedule) {
		tschedule = tnow + 300;
		if (blockswritten < 500)
			return;
		deltat = tstart_writing - tnow +
			(1.0 * (tnow - tstart_writing))
			/ blockswritten * tapesize;
		msg("%3.2f%% done, finished in %d:%02d\n",
			(blockswritten * 100.0) / tapesize,
			deltat / 3600, (deltat % 3600) / 60);
	}
}

void
#ifdef __STDC__
msg(const char *fmt, ...)
#else
msg(fmt, va_alist)
	char *fmt;
	va_dcl
#endif
{
	va_list ap;

	(void) fprintf(stderr,"  DUMP: ");
#ifdef TDEBUG
	(void) fprintf(stderr, "pid=%d ", getpid());
#endif
#ifdef __STDC__
	va_start(ap, fmt);
#else
	va_start(ap);
#endif
	(void) vfprintf(stderr, fmt, ap);
	(void) fflush(stdout);
	(void) fflush(stderr);
	(void) vsnprintf(lastmsg, sizeof(lastmsg), fmt, ap);
	va_end(ap);
}

void
#ifdef __STDC__
msgtail(const char *fmt, ...)
#else
msgtail(fmt, va_alist)
	char *fmt;
	va_dcl
#endif
{
	va_list ap;
#ifdef __STDC__
	va_start(ap, fmt);
#else
	va_start(ap);
#endif
	(void) vfprintf(stderr, fmt, ap);
	va_end(ap);
}

void
#ifdef __STDC__
quit(const char *fmt, ...)
#else
quit(fmt, va_alist)
	char *fmt;
	va_dcl
#endif
{
	va_list ap;

	(void) fprintf(stderr,"  DUMP: ");
#ifdef TDEBUG
	(void) fprintf(stderr, "pid=%d ", getpid());
#endif
#ifdef __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
 */

static struct fstab *
allocfsent(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(void)
{
	register struct fstab *fs;
	register struct pfstab *pf;

	if (setfsent() == 0) {
		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.
 *
 * 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 '/'.
 */
struct fstab *
fstabsearch(const char *key)
{
	register struct pfstab *pf;
	register struct fstab *fs;
	char *rn;

	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)
			return (fs);
		rn = rawname(fs->fs_spec);
		if (rn != NULL && strcmp(rn, 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 (NULL);
}

#ifdef	__linux__
struct fstab *
fstabsearchdir(const char *key, char *directory)
{
	register struct pfstab *pf;
	register struct fstab *fs;
	register struct fstab *found_fs = NULL;
	unsigned int size = 0;
	struct stat buf;

	if (stat(key, &buf) == 0 && S_ISBLK(buf.st_mode))
		return NULL;

	for (pf = table; pf != NULL; pf = pf->pf_next) {
		fs = pf->pf_fstab;
		if (strlen(fs->fs_file) > size &&
		    strlen(key) > strlen(fs->fs_file) + 2 &&
		    strncmp(fs->fs_file, key, strlen(fs->fs_file)) == 0 &&
		    (key[strlen(fs->fs_file)] == '/' ||
		     fs->fs_file[strlen(fs->fs_file) - 1] == '/')) {
			found_fs = fs;
			size = strlen(fs->fs_file);
		}
	}
	if (found_fs != NULL) {
		/*
		 * Ok, we have found a fstab entry which matches the argument
		 * We have to split the argument name into:
		 * - a device name (from the fstab entry)
		 * - a directory name on this device
		 */
		strcpy(directory, key + size);
	}
	return(found_fs);
}
#endif

/*
 *	Tell the operator what to do
 */
void
lastdump(char arg) /* w ==> just what to do; W ==> most recent dumps */
{
	register int i;
	register struct fstab *dt;
	register struct dumpdates *dtwalk=NULL;
	char *lastname, *date;
	int dumpme;
	time_t tnow;

	(void) time(&tnow);
	getfstab();		/* /etc/fstab input */
	initdumptimes(0);	/* dumpdates input */
	if (ddatev != NULL) {
		qsort((char *) ddatev, nddates, sizeof(struct dumpdates *), datesort);

		if (arg == 'w')
			(void) printf("Dump these file systems:\n");
		else
			(void) printf("Last dump(s) done (Dump '>' file systems):\n");
		lastname = "??";
		ITITERATE(i, dtwalk) {
			if (strncmp(lastname, dtwalk->dd_name,
		    		sizeof(dtwalk->dd_name)) == 0)
				continue;
			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 * 86400));
			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
datesort(const void *a1, const void *a2)
{
	struct dumpdates *d1 = *(struct dumpdates **)a1;
	struct dumpdates *d2 = *(struct dumpdates **)a2;
	int diff;

	diff = strncmp(d1->dd_name, d2->dd_name, sizeof(d1->dd_name));
	if (diff == 0)
		return (d2->dd_ddate - d1->dd_ddate);
	return (diff);
}
Commit	Line	Data
1227625a SP	1	/*
	2	* Ported to Linux's Second Extended File System as part of the
	3	* dump and restore backup suit
b45f51d6 SP	4	* Remy Card <card@Linux.EU.Org>, 1994-1997
b45f51d6 SP	5	* Stelian Pop <pop@cybercable.fr>, 1999
1227625a SP	6	*
	7	*/
	8
	9	/*-
	10	* Copyright (c) 1980, 1988, 1993
	11	* The Regents of the University of California. All rights reserved.
	12	*
	13	* Redistribution and use in source and binary forms, with or without
	14	* modification, are permitted provided that the following conditions
	15	* are met:
	16	* 1. Redistributions of source code must retain the above copyright
	17	* notice, this list of conditions and the following disclaimer.
	18	* 2. Redistributions in binary form must reproduce the above copyright
	19	* notice, this list of conditions and the following disclaimer in the
	20	* documentation and/or other materials provided with the distribution.
	21	* 3. All advertising materials mentioning features or use of this software
	22	* must display the following acknowledgement:
	23	* This product includes software developed by the University of
	24	* California, Berkeley and its contributors.
	25	* 4. Neither the name of the University nor the names of its contributors
	26	* may be used to endorse or promote products derived from this software
	27	* without specific prior written permission.
	28	*
	29	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	30	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	31	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	32	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	33	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	34	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	35	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	36	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	37	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	38	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	39	* SUCH DAMAGE.
ec387a12 SP	40	*
ec387a12 SP	41	* $Id: optr.c,v 1.5 1999/10/11 13:31:11 stelian Exp $
1227625a SP	42	*/
1227625a SP	43
1227625a SP	44	#include <sys/param.h>
	45	#include <sys/wait.h>
	46	#include <sys/time.h>
	47
	48	#include <errno.h>
	49	#include <fstab.h>
	50	#include <grp.h>
1227625a	51	#include <stdio.h>
1227625a SP	52	#include <stdlib.h>
	53	#include <string.h>
	54	#include <stdarg.h>
1227625a	55	#include <unistd.h>
1227625a	56	#include <utmp.h>
8d4197bb	57	#include <sys/stat.h>
1227625a SP	58
	59	#ifdef __linux__
	60	#include <linux/ext2_fs.h>
	61	#include <ext2fs/ext2fs.h>
	62	#include <bsdcompat.h>
b45f51d6	63	#include <signal.h>
1227625a SP	64	#endif
	65
	66	#include "dump.h"
	67	#include "pathnames.h"
	68
ddd2ef55	69	static void alarmcatch __P((int));
1227625a	70	int datesort __P((const void , const void ));
ddd2ef55	71	static void sendmes __P((const char , const char ));
1227625a SP	72
	73	/*
	74	* Query the operator; This previously-fascist piece of code
	75	* no longer requires an exact response.
	76	* It is intended to protect dump aborting by inquisitive
	77	* people banging on the console terminal to see what is
	78	* happening which might cause dump to croak, destroying
	79	* a large number of hours of work.
	80	*
	81	* Every 2 minutes we reprint the message, alerting others
	82	* that dump needs attention.
	83	*/
	84	static int timeout;
ddd2ef55	85	static const char attnmessage; / attention message */
1227625a SP	86
1227625a SP	87	int
ddd2ef55	88	query(const char *question)
1227625a SP	89	{
	90	char replybuffer[64];
	91	int back, errcount;
	92	FILE *mytty;
ddd2ef55 SP	93	time_t firstprompt, when_answered;
ddd2ef55 SP	94
8d4197bb SP	95	#ifdef __linux__
	96	(void)time4(&(firstprompt));
	97	#else
	98	(void)time((time_t *)&(firstprompt));
	99	#endif
1227625a SP	100
	101	if ((mytty = fopen(_PATH_TTY, "r")) == NULL)
	102	quit("fopen on %s fails: %s\n", _PATH_TTY, strerror(errno));
	103	attnmessage = question;
	104	timeout = 0;
ddd2ef55	105	alarmcatch(0);
1227625a SP	106	back = -1;
	107	errcount = 0;
	108	do {
	109	if (fgets(replybuffer, 63, mytty) == NULL) {
	110	clearerr(mytty);
	111	if (++errcount > 30) /* XXX ugly */
	112	quit("excessive operator query failures\n");
	113	} else if (replybuffer[0] == 'y' \|\| replybuffer[0] == 'Y') {
	114	back = 1;
	115	} else if (replybuffer[0] == 'n' \|\| replybuffer[0] == 'N') {
	116	back = 0;
	117	} else {
	118	(void) fprintf(stderr,
	119	" DUMP: \"Yes\" or \"No\"?\n");
	120	(void) fprintf(stderr,
	121	" DUMP: %s: (\"yes\" or \"no\") ", question);
	122	}
	123	} while (back < 0);
	124
	125	/*
	126	* Turn off the alarm, and reset the signal to trap out..
	127	*/
	128	(void) alarm(0);
	129	if (signal(SIGALRM, sig) == SIG_IGN)
	130	signal(SIGALRM, SIG_IGN);
	131	(void) fclose(mytty);
8d4197bb SP	132	#ifdef __linux__
	133	(void)time4(&(when_answered));
	134	#else
	135	(void)time((time_t *)&(when_answered));
	136	#endif
ddd2ef55 SP	137	/*
	138	* Adjust the base for time estimates to ignore time we spent waiting
	139	* for operator input.
	140	*/
8d4197bb	141	if ((tstart_writing != 0) && (when_answered != (time_t)-1) && (firstprompt != (time_t)-1))
ddd2ef55	142	tstart_writing += (when_answered - firstprompt);
1227625a SP	143	return(back);
	144	}
	145
ddd2ef55	146	char lastmsg[BUFSIZ];
1227625a SP	147
	148	/*
	149	* Alert the console operator, and enable the alarm clock to
	150	* sleep for 2 minutes in case nobody comes to satisfy dump
	151	*/
ddd2ef55 SP	152	static void
ddd2ef55 SP	153	alarmcatch(int signo)
1227625a	154	{
ddd2ef55	155	int save_errno = errno;
1227625a SP	156	if (notify == 0) {
	157	if (timeout == 0)
	158	(void) fprintf(stderr,
	159	" DUMP: %s: (\"yes\" or \"no\") ",
	160	attnmessage);
	161	else
	162	msgtail("\7\7");
	163	} else {
	164	if (timeout) {
	165	msgtail("\n");
	166	broadcast(""); /* just print last msg */
	167	}
	168	(void) fprintf(stderr," DUMP: %s: (\"yes\" or \"no\") ",
	169	attnmessage);
	170	}
	171	signal(SIGALRM, alarmcatch);
	172	(void) alarm(120);
	173	timeout = 1;
ddd2ef55	174	errno = save_errno;
1227625a SP	175	}
	176
	177	/*
	178	* Here if an inquisitive operator interrupts the dump program
	179	*/
	180	void
ddd2ef55	181	interrupt(int signo)
1227625a SP	182	{
	183	msg("Interrupt received.\n");
	184	if (query("Do you want to abort dump?"))
	185	dumpabort(0);
	186	}
	187
	188	/*
	189	* The following variables and routines manage alerting
	190	* operators to the status of dump.
	191	* This works much like wall(1) does.
	192	*/
	193	struct group *gp;
	194
	195	/*
	196	* Get the names from the group entry "operator" to notify.
b45f51d6	197	*/
1227625a	198	void
ddd2ef55	199	set_operators(void)
1227625a SP	200	{
	201	if (!notify) /not going to notify/
	202	return;
	203	gp = getgrnam(OPGRENT);
	204	(void) endgrent();
	205	if (gp == NULL) {
	206	msg("No group entry for %s.\n", OPGRENT);
	207	notify = 0;
	208	return;
	209	}
	210	}
	211
	212	struct tm *localclock;
	213
	214	/*
	215	* We fork a child to do the actual broadcasting, so
	216	* that the process control groups are not messed up
	217	*/
	218	void
ddd2ef55	219	broadcast(const char *message)
1227625a SP	220	{
	221	time_t clock;
	222	FILE *f_utmp;
	223	struct utmp utmp;
	224	char **np;
	225	int pid, s;
	226
	227	if (!notify \|\| gp == NULL)
	228	return;
	229
	230	switch (pid = fork()) {
	231	case -1:
	232	return;
	233	case 0:
	234	break;
	235	default:
	236	while (wait(&s) != pid)
	237	continue;
	238	return;
	239	}
	240
	241	clock = time((time_t *)0);
	242	localclock = localtime(&clock);
	243
	244	if ((f_utmp = fopen(_PATH_UTMP, "r")) == NULL) {
	245	msg("Cannot open %s: %s\n", _PATH_UTMP, strerror(errno));
	246	return;
	247	}
	248
	249	while (!feof(f_utmp)) {
	250	if (fread((char *) &utmp, sizeof (struct utmp), 1, f_utmp) != 1)
	251	break;
	252	if (utmp.ut_name[0] == 0)
	253	continue;
	254	for (np = gp->gr_mem; *np; np++) {
	255	if (strncmp(*np, utmp.ut_name, sizeof(utmp.ut_name)) != 0)
	256	continue;
	257	/*
	258	* Do not send messages to operators on dialups
	259	*/
	260	if (strncmp(utmp.ut_line, DIALUP, strlen(DIALUP)) == 0)
	261	continue;
	262	#ifdef DEBUG
	263	msg("Message to %s at %s\n", *np, utmp.ut_line);
	264	#endif
	265	sendmes(utmp.ut_line, message);
	266	}
	267	}
	268	(void) fclose(f_utmp);
	269	Exit(0); /* the wait in this same routine will catch this */
	270	/* NOTREACHED */
	271	}
	272
	273	static void
ddd2ef55	274	sendmes(const char tty, const char message)
1227625a	275	{
b45f51d6	276	char t[MAXPATHLEN], buf[BUFSIZ];
ddd2ef55	277	register const char *cp;
1227625a SP	278	int lmsg = 1;
	279	FILE *f_tty;
	280
	281	(void) strcpy(t, _PATH_DEV);
b45f51d6	282	(void) strncat(t, tty, sizeof t - strlen(_PATH_DEV) - 1);
1227625a SP	283
	284	if ((f_tty = fopen(t, "w")) != NULL) {
	285	setbuf(f_tty, buf);
	286	(void) fprintf(f_tty,
	287	"\n\
	288	\7\7\7Message from the dump program to all operators at %d:%02d ...\r\n\n\
	289	DUMP: NEEDS ATTENTION: ",
	290	localclock->tm_hour, localclock->tm_min);
	291	for (cp = lastmsg; ; cp++) {
	292	if (*cp == '\0') {
	293	if (lmsg) {
	294	cp = message;
ddd2ef55	295	if (!(cp && *cp != '\0'))
1227625a SP	296	break;
	297	lmsg = 0;
	298	} else
	299	break;
	300	}
	301	if (*cp == '\n')
	302	(void) putc('\r', f_tty);
	303	(void) putc(*cp, f_tty);
	304	}
	305	(void) fclose(f_tty);
	306	}
	307	}
	308
	309	/*
	310	* print out an estimate of the amount of time left to do the dump
	311	*/
	312
	313	time_t tschedule = 0;
	314
	315	void
ddd2ef55	316	timeest(void)
1227625a SP	317	{
	318	time_t tnow, deltat;
	319
8d4197bb SP	320	#ifdef __linux__
	321	(void) time4(&tnow);
	322	#else
1227625a	323	(void) time((time_t *) &tnow);
8d4197bb	324	#endif
1227625a SP	325	if (tnow >= tschedule) {
	326	tschedule = tnow + 300;
	327	if (blockswritten < 500)
b45f51d6	328	return;
1227625a SP	329	deltat = tstart_writing - tnow +
	330	(1.0 * (tnow - tstart_writing))
	331	/ blockswritten * tapesize;
	332	msg("%3.2f%% done, finished in %d:%02d\n",
	333	(blockswritten * 100.0) / tapesize,
	334	deltat / 3600, (deltat % 3600) / 60);
	335	}
	336	}
	337
	338	void
ddd2ef55	339	#ifdef __STDC__
1227625a SP	340	msg(const char *fmt, ...)
	341	#else
	342	msg(fmt, va_alist)
	343	char *fmt;
	344	va_dcl
	345	#endif
	346	{
	347	va_list ap;
	348
	349	(void) fprintf(stderr," DUMP: ");
	350	#ifdef TDEBUG
	351	(void) fprintf(stderr, "pid=%d ", getpid());
	352	#endif
ddd2ef55	353	#ifdef __STDC__
1227625a SP	354	va_start(ap, fmt);
	355	#else
	356	va_start(ap);
	357	#endif
	358	(void) vfprintf(stderr, fmt, ap);
	359	(void) fflush(stdout);
	360	(void) fflush(stderr);
ddd2ef55	361	(void) vsnprintf(lastmsg, sizeof(lastmsg), fmt, ap);
1227625a SP	362	va_end(ap);
	363	}
	364
	365	void
ddd2ef55	366	#ifdef __STDC__
1227625a SP	367	msgtail(const char *fmt, ...)
	368	#else
	369	msgtail(fmt, va_alist)
	370	char *fmt;
	371	va_dcl
	372	#endif
	373	{
	374	va_list ap;
ddd2ef55	375	#ifdef __STDC__
1227625a SP	376	va_start(ap, fmt);
	377	#else
	378	va_start(ap);
	379	#endif
	380	(void) vfprintf(stderr, fmt, ap);
	381	va_end(ap);
	382	}
	383
	384	void
ddd2ef55	385	#ifdef __STDC__
1227625a SP	386	quit(const char *fmt, ...)
	387	#else
	388	quit(fmt, va_alist)
	389	char *fmt;
	390	va_dcl
	391	#endif
	392	{
	393	va_list ap;
	394
	395	(void) fprintf(stderr," DUMP: ");
	396	#ifdef TDEBUG
	397	(void) fprintf(stderr, "pid=%d ", getpid());
	398	#endif
ddd2ef55	399	#ifdef __STDC__
1227625a SP	400	va_start(ap, fmt);
	401	#else
	402	va_start(ap);
	403	#endif
	404	(void) vfprintf(stderr, fmt, ap);
	405	va_end(ap);
	406	(void) fflush(stdout);
	407	(void) fflush(stderr);
	408	dumpabort(0);
	409	}
	410
	411	/*
	412	* Tell the operator what has to be done;
	413	* we don't actually do it
	414	*/
	415
ddd2ef55 SP	416	static struct fstab *
ddd2ef55 SP	417	allocfsent(struct fstab *fs)
1227625a SP	418	{
	419	register struct fstab *new;
	420
	421	new = (struct fstab )malloc(sizeof (fs));
	422	if (new == NULL \|\|
	423	(new->fs_file = strdup(fs->fs_file)) == NULL \|\|
	424	(new->fs_type = strdup(fs->fs_type)) == NULL \|\|
	425	(new->fs_spec = strdup(fs->fs_spec)) == NULL)
	426	quit("%s\n", strerror(errno));
	427	new->fs_passno = fs->fs_passno;
	428	new->fs_freq = fs->fs_freq;
	429	return (new);
	430	}
	431
	432	struct pfstab {
	433	struct pfstab *pf_next;
	434	struct fstab *pf_fstab;
	435	};
	436
	437	static struct pfstab *table;
	438
	439	void
ddd2ef55	440	getfstab(void)
1227625a SP	441	{
	442	register struct fstab *fs;
	443	register struct pfstab *pf;
	444
	445	if (setfsent() == 0) {
	446	msg("Can't open %s for dump table information: %s\n",
	447	_PATH_FSTAB, strerror(errno));
	448	return;
	449	}
	450	while ((fs = getfsent()) != NULL) {
	451	if (strcmp(fs->fs_type, FSTAB_RW) &&
	452	strcmp(fs->fs_type, FSTAB_RO) &&
	453	strcmp(fs->fs_type, FSTAB_RQ))
	454	continue;
	455	fs = allocfsent(fs);
	456	if ((pf = (struct pfstab )malloc(sizeof (pf))) == NULL)
	457	quit("%s\n", strerror(errno));
	458	pf->pf_fstab = fs;
	459	pf->pf_next = table;
	460	table = pf;
	461	}
	462	(void) endfsent();
	463	}
	464
	465	/*
	466	* Search in the fstab for a file name.
	467	* This file name can be either the special or the path file name.
	468	*
	469	* The entries in the fstab are the BLOCK special names, not the
	470	* character special names.
	471	* The caller of fstabsearch assures that the character device
	472	* is dumped (that is much faster)
	473	*
	474	* The file name can omit the leading '/'.
	475	*/
	476	struct fstab *
ddd2ef55	477	fstabsearch(const char *key)
1227625a SP	478	{
	479	register struct pfstab *pf;
	480	register struct fstab *fs;
	481	char *rn;
	482
	483	for (pf = table; pf != NULL; pf = pf->pf_next) {
	484	fs = pf->pf_fstab;
	485	if (strcmp(fs->fs_file, key) == 0 \|\|
	486	strcmp(fs->fs_spec, key) == 0)
	487	return (fs);
	488	rn = rawname(fs->fs_spec);
	489	if (rn != NULL && strcmp(rn, key) == 0)
	490	return (fs);
	491	if (key[0] != '/') {
	492	if (*fs->fs_spec == '/' &&
	493	strcmp(fs->fs_spec + 1, key) == 0)
	494	return (fs);
	495	if (*fs->fs_file == '/' &&
	496	strcmp(fs->fs_file + 1, key) == 0)
	497	return (fs);
	498	}
	499	}
	500	return (NULL);
	501	}
	502
	503	#ifdef __linux__
	504	struct fstab *
ddd2ef55	505	fstabsearchdir(const char key, char directory)
1227625a SP	506	{
	507	register struct pfstab *pf;
	508	register struct fstab *fs;
	509	register struct fstab *found_fs = NULL;
	510	unsigned int size = 0;
8d4197bb SP	511	struct stat buf;
	512
	513	if (stat(key, &buf) == 0 && S_ISBLK(buf.st_mode))
	514	return NULL;
1227625a SP	515
	516	for (pf = table; pf != NULL; pf = pf->pf_next) {
	517	fs = pf->pf_fstab;
	518	if (strlen(fs->fs_file) > size &&
	519	strlen(key) > strlen(fs->fs_file) + 2 &&
	520	strncmp(fs->fs_file, key, strlen(fs->fs_file)) == 0 &&
	521	(key[strlen(fs->fs_file)] == '/' \|\|
	522	fs->fs_file[strlen(fs->fs_file) - 1] == '/')) {
	523	found_fs = fs;
	524	size = strlen(fs->fs_file);
	525	}
	526	}
	527	if (found_fs != NULL) {
	528	/*
	529	* Ok, we have found a fstab entry which matches the argument
	530	* We have to split the argument name into:
	531	* - a device name (from the fstab entry)
	532	* - a directory name on this device
	533	*/
	534	strcpy(directory, key + size);
	535	}
	536	return(found_fs);
	537	}
	538	#endif
	539
	540	/*
	541	* Tell the operator what to do
	542	*/
	543	void
ddd2ef55	544	lastdump(char arg) /* w ==> just what to do; W ==> most recent dumps */
1227625a SP	545	{
	546	register int i;
	547	register struct fstab *dt;
8d4197bb	548	register struct dumpdates *dtwalk=NULL;
1227625a SP	549	char lastname, date;
	550	int dumpme;
	551	time_t tnow;
	552
	553	(void) time(&tnow);
	554	getfstab(); /* /etc/fstab input */
8d4197bb SP	555	initdumptimes(0); /* dumpdates input */
	556	if (ddatev != NULL) {
	557	qsort((char ) ddatev, nddates, sizeof(struct dumpdates ), datesort);
	558
	559	if (arg == 'w')
	560	(void) printf("Dump these file systems:\n");
	561	else
	562	(void) printf("Last dump(s) done (Dump '>' file systems):\n");
	563	lastname = "??";
	564	ITITERATE(i, dtwalk) {
	565	if (strncmp(lastname, dtwalk->dd_name,
	566	sizeof(dtwalk->dd_name)) == 0)
	567	continue;
	568	date = (char *)ctime(&dtwalk->dd_ddate);
	569	date[16] = '\0'; /* blast away seconds and year */
	570	lastname = dtwalk->dd_name;
	571	dt = fstabsearch(dtwalk->dd_name);
	572	dumpme = (dt != NULL &&
	573	dt->fs_freq != 0 &&
	574	dtwalk->dd_ddate < tnow - (dt->fs_freq * 86400));
	575	if (arg != 'w' \|\| dumpme)
	576	(void) printf(
	577	"%c %8s\t(%6s) Last dump: Level %c, Date %s\n",
	578	dumpme && (arg != 'w') ? '>' : ' ',
	579	dtwalk->dd_name,
	580	dt ? dt->fs_file : "",
	581	dtwalk->dd_level,
	582	date);
	583	}
1227625a SP	584	}
	585	}
	586
	587	int
ddd2ef55	588	datesort(const void a1, const void a2)
1227625a SP	589	{
	590	struct dumpdates d1 = (struct dumpdates **)a1;
	591	struct dumpdates d2 = (struct dumpdates **)a2;
	592	int diff;
	593
	594	diff = strncmp(d1->dd_name, d2->dd_name, sizeof(d1->dd_name));
	595	if (diff == 0)
	596	return (d2->dd_ddate - d1->dd_ddate);
	597	return (diff);
	598	}