/*
 * Copyright (c) 1998 by Sun Microsystems, Inc.
 * All rights reserved.
 */

/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
/*	  All Rights Reserved	*/

/*
 * Copyright (c) 1980 Regents of the University of California.
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <errno.h>
#include "dump.h"

static unsigned int timeout;		/* current timeout */
static char *attnmessage, *saveattn;	/* attention message */

#ifdef __STDC__
static void alarmcatch();
static int idatesort(const void *, const void *);
#else /* !__STDC__ */
static void alarmcatch();
static int idatesort();
#endif

#ifdef DEBUG
extern int xflag;
#endif

/*
 *	Query the operator; This fascist piece of code 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 time += 2 minutes we reprint the message, alerting others
 *	that dump needs attention.
 */
int
query(question)
	char	*question;
{
	int def = -1;

	while (def == -1)
		def = query_once(question, -1);
	return (def);
}

static int in_query_once;
static jmp_buf sjalarmbuf;

/* real simple check-sum */
static int
addem(s)
	char *s;
{
	int total = 0;

	if (s == (char *)NULL)
		return (total);
	while (*s)
		total += *s++;
	return (total);
}

int
query_once(question, def)
	char	*question;
	int	def;
{
	static char *lastmsg;
	static int lastmsgsum;
	int	msgsum;
	char	replybuffer[BUFSIZ];
	int	back;
	time32_t timeclockstate;
	pollfd_t pollset;
	struct sigvec sv;

	/* special hook to flush timeout cache */
	if (question == NULL) {
		lastmsg = (char *)NULL;
		lastmsgsum = 0;
		return (0);
	}

	attnmessage = question;
	/*
	 * Only reset the state if the message changed somehow
	 */
	msgsum = addem(question);
	if (lastmsg != question || lastmsgsum != msgsum) {
		timeout = 0;
		if (telapsed && tstart_writing)
			*telapsed += time((time_t *)0) - *tstart_writing;
		lastmsg = question;
		lastmsgsum = msgsum;
	}
	timeclockstate = timeclock((time_t)0);
	if (setjmp(sjalarmbuf) != 0) {
		if (def != -1) {
			if (def)
				msgtail(gettext("YES\n"));
			else
				msgtail(gettext("NO\n"));
		}
		back = def;
		goto done;
	}
	alarmcatch();
	in_query_once = 1;
	pollset.fd = -1;
	pollset.events = 0;
	pollset.revents = 0;
	if (isatty(fileno(stdin))) {
		pollset.fd = fileno(stdin);
		pollset.events = POLLIN | POLLPRI | POLLRDNORM | POLLRDBAND;
	} else {
		dumpabort();
		/*NOTREACHED*/
	}
	for (;;) {
		if (poll(&pollset, 1, -1) < 0) {
			if (errno == EINTR)
				continue;
			perror("poll(stdin)");
			dumpabort();
			/*NOTREACHED*/
		}
		if (pollset.revents == 0)
			continue;	/* sanity check */
		if (fgets(replybuffer, sizeof (replybuffer), stdin) == NULL) {
			if (ferror(stdin)) {
				clearerr(stdin);
				continue;
			} else {
				dumpabort();
				/*NOTREACHED*/
			}
		}
		timeout = 0;
		if (strcasecmp(replybuffer, gettext("yes\n")) == 0) {
			back = 1;
			lastmsg = (char *)NULL;
			lastmsgsum = 0;
			goto done;
		} else if (strcasecmp(replybuffer, gettext("no\n")) == 0) {
			back = 0;
			lastmsg = (char *)NULL;
			lastmsgsum = 0;
			goto done;
		} else {
			msg(gettext("\"yes\" or \"no\"?\n"));
			in_query_once = 0;
			alarmcatch();
			in_query_once = 1;
		}
	}
done:
	/*
	 * Turn off the alarm, and reset the signal to trap out..
	 */
	(void) alarm(0);
	attnmessage = NULL;
	sv.sv_handler = sigAbort;
	sv.sv_flags = SA_RESTART;
	(void) sigemptyset(&sv.sa_mask);
	(void) sigvec(SIGALRM, &sv, (struct sigvec *)0);
	if (tstart_writing)
		(void) time(tstart_writing);
	(void) timeclock(timeclockstate);
	in_query_once = 0;
	return (back);
}
/*
 *	Alert the console operator, and enable the alarm clock to
 *	sleep for time += 2 minutes in case nobody comes to satisfy dump
 *	If the alarm goes off while in the query_once for loop, we just
 *	longjmp back there and return the default answer.
 */
static void
#ifdef __STDC__
alarmcatch(void)
#else
alarmcatch()
#endif
{
	struct sigvec sv;

	if (in_query_once) {
		longjmp(sjalarmbuf, 1);
	}
	if (timeout) {
		msgtail("\n");
	}

	timeout += 120;
	msg(gettext("NEEDS ATTENTION: %s"), attnmessage);
	sv.sv_handler = alarmcatch;
	sv.sv_flags = SA_RESTART;
	(void) sigemptyset(&sv.sa_mask);
	(void) sigvec(SIGALRM, &sv, (struct sigvec *)0);
	(void) alarm(timeout);
}

/*
 *	Here if an inquisitive operator interrupts the dump program
 */
/*ARGSUSED*/
void
interrupt(sig)
	int	sig;
{
	if (!saveattn) {
		saveattn = attnmessage;
	}
	msg(gettext("Interrupt received.\n"));
	if (query(gettext(
	    "Do you want to abort dump?: (\"yes\" or \"no\") "))) {
		dumpabort();
		/*NOTREACHED*/
	}
	if (saveattn) {
		attnmessage = saveattn;
		saveattn = NULL;
		alarmcatch();
	}
}

/*
 *	We use wall(1) to do the actual broadcasting, so
 *	that we don't have to worry about duplicated code
 *	only getting fixed in one place.  This also saves
 *	us from having to worry about process groups,
 *	controlling terminals, and the like.
 */
void
broadcast(message)
	char	*message;
{
	time_t	clock;
	pid_t	pid;
	int	saverr;
	int	fildes[2];
	FILE	*wall;
	struct tm *localclock;

	if (!notify)
		return;

	if (pipe(fildes) < 0) {
		saverr = errno;
		msg(gettext("pipe: %s\n"), strerror(saverr));
		return;
	}

	switch (pid = fork()) {
	case -1:
		return;
	case 0:
		close(fildes[0]);
		if (dup2(fildes[1], 0) < 0) {
			saverr = errno;
			msg(gettext("dup2: %s\n"), strerror(saverr));
			exit(1);
		}
		execl("/usr/sbin/wall", "wall", "-g", OPGRENT, (char *)NULL);
		saverr = errno;
		msg(gettext("execl: %s\n"), strerror(saverr));
		exit(1);
	default:
		break;		/* parent */
	}

	close(fildes[1]);
	wall = fdopen(fildes[0], "r+");
	if (wall == (FILE *)NULL) {
		saverr = errno;
		msg(gettext("fdopen: %s\n"), strerror(saverr));
		return;
	}

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

	(void) fprintf(wall, gettext(
"\n\007\007\007Message from the dump program to all operators at \
%d:%02d ...\n\n%s"),
	    localclock->tm_hour, localclock->tm_min, message);
	fclose(wall);

	while (wait((int *)0) != pid) {
		continue;
		/*LINTED [empty loop body]*/
	}
}

/*
 *	print out an estimate of the amount of time left to do the dump
 */
#define	EST_SEC	600			/* every 10 minutes */
void
timeest(force, blkswritten)
	int force;
	int blkswritten;
{
	time_t tnow, deltat;
	char *msgp;

	if (tschedule == NULL)
		return;
	if (*tschedule == 0)
		*tschedule = time((time_t *)0) + EST_SEC;
	(void) time(&tnow);
	if ((force || tnow >= *tschedule) && blkswritten) {
		*tschedule = tnow + EST_SEC;
		if (!force && blkswritten < 50 * ntrec)
			return;
		deltat = (*telapsed + (tnow - *tstart_writing))
				* ((double)esize / blkswritten - 1.0);
		msgp = gettext("%3.2f%% done, finished in %d:%02d\n");
		msg(msgp, (blkswritten*100.0)/esize,
			deltat/3600, (deltat%3600)/60);
	}
}

#include <stdarg.h>

/* VARARGS1 */
void
msg(const char *fmt, ...)
{
	char buf[1024], *cp;
	size_t size;
	va_list args;

	va_start(args, fmt);
	(void) strcpy(buf, "  DUMP: ");
	cp = &buf[strlen(buf)];
#ifdef TDEBUG
	(void) sprintf(cp, "pid=%d ", getpid());
	cp = &buf[strlen(buf)];
#endif
	/* don't need -1, vsnprintf does it right */
	/* LINTED pointer arithmetic result fits in size_t */
	size = ((size_t)sizeof (buf)) - (size_t)(cp - buf);
	(void) vsnprintf(cp, size, fmt, args);
	(void) fputs(buf, stderr);
	(void) fflush(stdout);
	(void) fflush(stderr);
	va_end(args);
}

/* VARARGS1 */
void
msgtail(const char *fmt, ...)
{
	va_list args;

	va_start(args, fmt);
	(void) vfprintf(stderr, fmt, args);
	va_end(args);
}

#define	MINUTES(x)	((x) * 60)

/*
 *	Tell the operator what has to be done;
 *	we don't actually do it
 */
void
lastdump(arg)		/* w ==> just what to do; W ==> most recent dumps */
	int	arg;
{
	char *lastname;
	char *date;
	int i;
	time_t tnow, ddate;
	struct mntent *dt;
	int dumpme = 0;
	struct idates *itwalk;

	(void) time(&tnow);
	mnttabread();		/* /etc/fstab input */
	inititimes();		/* /etc/dumpdates input */

	/* Don't use msg(), this isn't a tell-the-world kind of thing */
	if (arg == 'w')
		(void) fprintf(stdout, gettext("Dump these file systems:\n"));
	else
		(void) fprintf(stdout, gettext(
		    "Last dump(s) done (Dump '>' file systems):\n"));

	if (idatev != NULL) {
		qsort((char *)idatev, nidates, sizeof (*idatev), idatesort);
		lastname = "??";
		ITITERATE(i, itwalk) {
			if (strncmp(lastname, itwalk->id_name,
			    sizeof (itwalk->id_name)) == 0)
				continue;
			/* must be ctime(), per ufsdump(4) */
			ddate = itwalk->id_ddate;
			date = (char *)ctime(&ddate);
			date[16] = '\0';	/* blow away seconds and year */
			lastname = itwalk->id_name;
			dt = mnttabsearch(itwalk->id_name, 0);
			if ((time_t)(itwalk->id_ddate) < (tnow - DAY)) {
				dumpme = 1;
			}

			if ((arg == 'w') && dumpme) {
				/*
				 * Handle the w option: print out file systems
				 * which haven't been backed up within a day.
				 */
				(void) printf(gettext("%8s\t(%6s)\n"),
				    itwalk->id_name, dt ? dt->mnt_dir : "");
			}
			if (arg == 'W') {
				/*
				 * Handle the W option: print out ALL
				 * filesystems including recent dump dates and
				 * dump levels.  Mark the backup-needing
				 * filesystems with a >.
				 */
				(void) printf(gettext(
			    "%c %8s\t(%6s) Last dump: Level %c, Date %s\n"),
				    dumpme ? '>' : ' ',
				    itwalk->id_name,
				    dt ? dt->mnt_dir : "",
				    (uchar_t)itwalk->id_incno,
				    date);
			}
			dumpme = 0;
		}
	}
}

static int
idatesort(v1, v2)
#ifdef __STDC__
	const void *v1;
	const void *v2;
#else
	void *v1;
	void *v2;
#endif
{
	struct idates **p1 = (struct idates **)v1;
	struct idates **p2 = (struct idates **)v2;
	int diff;

	diff = strcoll((*p1)->id_name, (*p2)->id_name);
	if (diff == 0) {
		/*
		 * Time may eventually become unsigned, so can't
		 * rely on subtraction to give a useful result.
		 * Note that we are sorting dates into reverse
		 * order, so that we will report based on the
		 * most-recent record for a particular filesystem.
		 */
		if ((*p1)->id_ddate > (*p2)->id_ddate)
			diff = -1;
		else if ((*p1)->id_ddate < (*p2)->id_ddate)
			diff = 1;
	}
	return (diff);
}