xref: /titanic_52/usr/src/cmd/acct/wtmpfix.c (revision dd371263a80cf6b9c9c8f99983774cfdb1a0653c)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

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

/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

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

/*
 * wtmpfix - adjust wtmpx file and remove date changes.
 *	wtmpfix <wtmpx1 >wtmpx2
 *
 *	Can recover to some extent from wtmpx corruption.
 */

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/param.h>
#include "acctdef.h"
#include <utmpx.h>
#include <time.h>
#include <ctype.h>
#include <locale.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

#define	DAYEPOCH	(60 * 60 * 24)
#define	UTRSZ		(sizeof (struct futmpx)) /* file record size */

/*
 * The acctsh(1M) shell scripts startup(1M) and shutacct(1M) as well as the
 * runacct script each pass their own specific reason strings in the first
 * argument to acctwtmp(1M), to be propagated into ut_line fields.  Additional
 * reasons (RUNLVL_MSG, ..., DOWN_MSG), used by compiled code, are defined in
 * <utmp.h> as preprocessor constants.
 * For simplicity we predefine similar constants for the scripted strings
 * here, as no other compiled code uses those.
 * Moreover, we need a variant of RUNLVL_MSG without the "%c" at the end.
 * We shall use the fact that ut_line[RLVLMSG_LEN] will extract the char
 * in the %c position ('S', '2', ...).
 * Since all of these string constants are '\0' terminated, they can safely
 * be used with strcmp() even when ut_line is not.
 */
#define	RUN_LEVEL_MSG	"run-level "
#define	ACCTG_ON_MSG	"acctg on"
#define	ACCTG_OFF_MSG	"acctg off"
#define	RUNACCT_MSG	"runacct"

#define	RLVLMSG_LEN	(sizeof (RUN_LEVEL_MSG) - 1)

/*
 * Records encountered are classified as one of the following:  corrupted;
 * ok but devoid of interest to acctcon downstream;  ok and interesting;
 * or ok and even redundant enough to latch onto a new alignment whilst
 * recovering from a corruption.
 * The ordering among these four symbolic values is significant.
 */
typedef enum {
	INRANGE_ERR = -1,
	INRANGE_DROP,
	INRANGE_PASS,
	INRANGE_ALIGNED
} inrange_t;

/* input filenames and record numbers, for diagnostics only */
#define	STDIN_NAME	"<stdin>"
static char	*cur_input_name;
static off_t	recin;

static FILE	*Wtmpx, *Temp;

struct	dtab
{
	off_t	d_off1;		/* file offset start */
	off_t	d_off2;		/* file offset stop */
	time_t	d_adj;		/* time adjustment */
	struct dtab *d_ndp;	/* next record */
};

static struct	dtab	*Fdp;	/* list header */
static struct	dtab	*Ldp;	/* list trailer */

static time_t 	lastmonth, nextmonth;

static struct	futmpx	Ut, Ut2;

static int winp(FILE *, struct futmpx *);
static void mkdtab(off_t);
static void setdtab(off_t, struct futmpx *, struct futmpx *);
static void adjust(off_t, struct futmpx *);
static int invalid(char *);
static void scanfile(void);
static inrange_t inrange(void);
static void wcomplain(char *);

int
main(int argc, char **argv)
{
	time_t tloc;
	struct tm *tmp;
	int year;
	int month;
	off_t rectmpin;

	(void) setlocale(LC_ALL, "");
	setbuf(stdout, NULL);

	(void) time(&tloc);
	tmp = localtime(&tloc);
	year = tmp->tm_year;
	month = tmp->tm_mon + 1;
	lastmonth = ((year + 1900 - 1970) * 365 +
	    (month - 1) * 30) * DAYEPOCH;
	nextmonth = ((year + 1900 - 1970) * 365 +
	    (month + 1) * 30) * DAYEPOCH;

	if (argc < 2) {
		argv[argc] = "-";
		argc++;
	}

	/*
	 * Almost all system call failures in this program are unrecoverable
	 * and therefore fatal.  Typical causes might be lack of memory or
	 * of space in a filesystem.  If necessary, the system administrator
	 * can invoke /usr/lib/acct/runacct interactively after making room
	 * to complete the remaining phases of last night's accounting.
	 */
	if ((Temp = tmpfile()) == NULL) {
		perror("Cannot create temporary file");
		return (EXIT_FAILURE);
	}

	while (--argc > 0) {
		argv++;
		if (strcmp(*argv, "-") == 0) {
			Wtmpx = stdin;
			cur_input_name = STDIN_NAME;
		} else if ((Wtmpx = fopen(*argv, "r")) == NULL) {
			(void) fprintf(stderr, "Cannot open %s: %s\n",
			    *argv, strerror(errno));
			return (EXIT_FAILURE);
		} else {
			cur_input_name = *argv;
		}
		/*
		 * Filter records reading from current input stream Wtmpx,
		 * writing to Temp.
		 */
		scanfile();

		if (Wtmpx != stdin)
			(void) fclose(Wtmpx);
	}
	/* flush and rewind Temp for readback */
	if (fflush(Temp) != 0) {
		perror("<temporary file>: fflush");
		return (EXIT_FAILURE);
	}
	if (fseeko(Temp, (off_t)0L, SEEK_SET) != 0) {
		perror("<temporary file>: seek");
		return (EXIT_FAILURE);
	}
	/* second pass: apply time adjustments */
	rectmpin = 0;
	while (winp(Temp, &Ut)) {
		adjust(rectmpin, &Ut);
		rectmpin += UTRSZ;
		if (fwrite(&Ut, UTRSZ, 1, stdout) < 1) {
			perror("<stdout>: fwrite");
			return (EXIT_FAILURE);
		}
	}
	(void) fclose(Temp);
	/*
	 * Detect if we've run out of space (say) and exit unsuccessfully
	 * so that downstream accounting utilities won't start processing an
	 * incomplete tmpwtmp file.
	 */
	if (fflush(stdout) != 0) {
		perror("<stdout>: fflush");
		return (EXIT_FAILURE);
	}
	return (EXIT_SUCCESS);
}

static int
winp(FILE *f, struct futmpx *w)
{
	if (fread(w, (size_t)UTRSZ, (size_t)1, f) != 1)
		return (0);
	if ((w->ut_type >= EMPTY) && (w->ut_type <= UTMAXTYPE))
		return (1);
	else {
		(void) fprintf(stderr, "Bad temp file at offset %lld\n",
		    (longlong_t)(ftell(f) - UTRSZ));
		/*
		 * If input was corrupt, neither ut_line nor ut_user can be
		 * relied on to be \0-terminated.  Even fixing the precision
		 * does not entirely guard against this.
		 */
		(void) fprintf(stderr,
		    "ut_line \"%-12.12s\" ut_user \"%-8.8s\" ut_xtime %ld\n",
		    w->ut_line, w->ut_user, (long)w->ut_xtime);
		exit(EXIT_FAILURE);
	}
	/* NOTREACHED */
}

static void
mkdtab(off_t p)
{

	struct dtab *dp;

	dp = Ldp;
	if (dp == NULL) {
		dp = calloc(sizeof (struct dtab), 1);
		if (dp == NULL) {
			(void) fprintf(stderr, "out of memory\n");
			exit(EXIT_FAILURE);
		}
		Fdp = Ldp = dp;
	}
	dp->d_off1 = p;
}

static void
setdtab(off_t p, struct futmpx *w1, struct futmpx *w2)
{
	struct dtab *dp;

	if ((dp = Ldp) == NULL) {
		(void) fprintf(stderr, "no dtab\n");
		exit(EXIT_FAILURE);
	}
	dp->d_off2 = p;
	dp->d_adj = w2->ut_xtime - w1->ut_xtime;
	if ((Ldp = calloc(sizeof (struct dtab), 1)) == NULL) {
		(void) fprintf(stderr, "out of memory\n");
		exit(EXIT_FAILURE);
	}
	Ldp->d_off1 = dp->d_off1;
	dp->d_ndp = Ldp;
}

static void
adjust(off_t p, struct futmpx *w)
{

	off_t pp;
	struct dtab *dp;

	pp = p;

	for (dp = Fdp; dp != NULL; dp = dp->d_ndp) {
		if (dp->d_adj == 0)
			continue;
		if (pp >= dp->d_off1 && pp <= dp->d_off2)
			w->ut_xtime += dp->d_adj;
	}
}

/*
 * invalid() determines whether the name field adheres to the criteria
 * set forth in acctcon1.  If returns VALID if the name is ok, or
 * INVALID if the name violates conventions.
 */

static int
invalid(char *name)
{
	int	i;

	for (i = 0; i < NSZ; i++) {
		if (name[i] == '\0')
			return (VALID);
		if (! (isalnum(name[i]) || (name[i] == '$') ||
		    (name[i] == ' ') || (name[i] == '.') ||
		    (name[i] == '_') || (name[i] == '-'))) {
			return (INVALID);
		}
	}
	return (VALID);
}

/*
 * scanfile:
 * 1)  	reads the current input file
 * 2)   filters for process records in time range of interest and for
 *      other types of records deemed interesting to acctcon downstream
 * 3)   picks up time changes with setdtab() if in multiuser mode, which
 *      will be applied when the temp file is read back
 * 4)   changes bad login names to INVALID
 * 5)   recovers from common cases of wtmpx corruption (loss of record
 *      alignment).
 * All of the static globals are used directly or indirectly.
 *
 * When wtmpfix is asked to process several input files in succession,
 * some state needs to be preserved from one scanfile() invocation to the
 * next.  Aside from the temp file position, we remember whether we were
 * in multi-user mode or not.  Absent evidence to the contrary, we begin
 * processing assuming multi-user mode, because runacct's wtmpx rotation
 * normally gives us a file recently initialized by utmp2wtmp(1M) with no
 * older RUN_LVL records surviving.
 */

static void
scanfile()
{
	struct stat Wtstat;
	off_t residue = 0;	/* input file size mod UTRSZ */
	/*
	 * lastok will be the offset of the beginning of the most recent
	 * manifestly plausible and interesting input record in the current
	 * input file, if any.
	 * An invariant at loop entry is -UTRSZ <= lastok <= recin - UTRSZ.
	 */
	off_t lastok = -(off_t)UTRSZ;
	static off_t rectmp;	/* current temp file position */
	static boolean_t multimode = B_TRUE; /* multi-user RUN_LVL in force */
	inrange_t is_ok;	/* caches inrange() result */
	/*
	 * During normal operation, records are of interest and copied to
	 * the output when is_ok >= INRANGE_PASS, ignored and dropped when
	 * is_ok == INRANGE_DROP, and evidence of corruption otherwise.
	 * While we are trying to recover from a corruption and hunting for
	 * records with sufficient redundancy to confirm that we have reached
	 * proper alignment again, we'll want is_ok >= INRANGE_ALIGNED.
	 * The value of want_ok is the minimum inrange() result of current
	 * interest.  It is raised to INRANGE_ALIGNED during ongoing recovery
	 * and dropped back to INRANGE_PASS when we have recovered alignment.
	 */
	inrange_t want_ok = INRANGE_PASS;
	boolean_t recovered = B_FALSE; /* true after a successful recovery */
	int n;

	if (fstat(fileno(Wtmpx), &Wtstat) == -1) {
		(void) fprintf(stderr,
		    "Cannot stat %s (will read sequentially): %s\n",
		    cur_input_name, strerror(errno));
	} else if ((Wtstat.st_mode & S_IFMT) == S_IFREG) {
		residue = Wtstat.st_size % UTRSZ;
	}

	/* if residue != 0, part of the file may be misaligned */
	for (recin = 0;
	    ((n = fread(&Ut, (size_t)UTRSZ, (size_t)1, Wtmpx)) > 0) ||
	    (residue > 0);
	    recin += UTRSZ) {
		if (n == 0) {
			/*
			 * Implying residue > 0 and want_ok == INRANGE_PASS.
			 * It isn't worth telling an I/O error from EOF here.
			 * But one case is worth catching to avoid issuing a
			 * confusing message below.  When the previous record
			 * had been ok, we just drop the current truncated
			 * record and bail out of the loop -- no seeking back.
			 */
			if (lastok == recin - UTRSZ) {
				wcomplain("file ends in mid-record, "
				    "final partial record dropped");
				break;
			} else {
				wcomplain("file ends in mid-record");
				/* handled below like a corrupted record */
				is_ok = INRANGE_ERR;
			}
		} else
			is_ok = inrange();

		/* alignment recovery logic */
		if ((residue > 0) && (is_ok == INRANGE_ERR)) {
			/*
			 * "Let's go back to the last place where we knew
			 * where we were..."
			 * In fact, if the last record had been fine and we
			 * know there's at least one whole record ahead, we
			 * might move forward here  (by residue bytes, less
			 * than one record's worth).  In any case, we align
			 * ourselves to an integral number of records before
			 * the end of the file.
			 */
			wcomplain("suspecting misaligned records, "
			    "repositioning");
			recin = lastok + UTRSZ + residue;
			residue = 0;
			if (fseeko(Wtmpx, recin, SEEK_SET) != 0) {
				(void) fprintf(stderr, "%s: seek: %s\n",
				    cur_input_name, strerror(errno));
				exit(EXIT_FAILURE);
			}
			wcomplain("starting re-scan");
			/*
			 * While want_ok is elevated, only unequivocal records
			 * with inrange() == INRANGE_ALIGNED will be admitted
			 * to latch onto the tentative new alignment.
			 */
			want_ok = INRANGE_ALIGNED;
			/*
			 * Compensate for the loop continuation.  Doing
			 * it this way gets the correct offset reported
			 * in the re-scan message above.
			 */
			recin -= UTRSZ;
			continue;
		}
		/* assert: residue == 0 or is_ok >= INRANGE_DROP here */
		if (is_ok < want_ok)
			/* record of no further interest */
			continue;
		if (want_ok == INRANGE_ALIGNED) {
			wcomplain("now recognizing aligned records again");
			want_ok = INRANGE_PASS;
			recovered = B_TRUE;
		}
		/*
		 * lastok must track recin whenever the current record is
		 * being processed and written out to our temp file, to avoid
		 * reprocessing any bits already done when we readjust our
		 * alignment.
		 */
		lastok = recin;

		/* now we have a good wtmpx record, do more processing */

		if (rectmp == 0 || Ut.ut_type == BOOT_TIME)
			mkdtab(rectmp);
		if (Ut.ut_type == RUN_LVL) {
			/* inrange() already checked the "run-level " part */
			if (Ut.ut_line[RLVLMSG_LEN] == 'S')
				multimode = B_FALSE;
			else if ((Ut.ut_line[RLVLMSG_LEN] == '2') ||
			    (Ut.ut_line[RLVLMSG_LEN] == '3') ||
			    (Ut.ut_line[RLVLMSG_LEN] == '4'))
				multimode = B_TRUE;
		}
		if (invalid(Ut.ut_name) == INVALID) {
			(void) fprintf(stderr,
			    "wtmpfix: logname \"%*.*s\" changed "
			    "to \"INVALID\"\n", OUTPUT_NSZ,
			    OUTPUT_NSZ, Ut.ut_name);
			(void) strncpy(Ut.ut_name, "INVALID", NSZ);
		}
		/*
		 * Special case: OLD_TIME should be immediately followed by
		 * NEW_TIME.
		 * We make no attempt at alignment recovery between these
		 * two: if there's junk at this point in the input, then
		 * a NEW_TIME seen after the junk probably won't be the one
		 * we are looking for.
		 */
		if (Ut.ut_type == OLD_TIME) {
			/*
			 * Make recin refer to the expected NEW_TIME.
			 * Loop continuation will increment it again
			 * for the record we're about to read now.
			 */
			recin += UTRSZ;
			if (!fread(&Ut2, (size_t)UTRSZ, (size_t)1, Wtmpx)) {
				wcomplain("input truncated after OLD_TIME - "
				    "giving up");
				exit(EXIT_FAILURE);
			}
			/*
			 * Rudimentary NEW_TIME sanity check.  Not as thorough
			 * as in inrange(), but then we have redundancy from
			 * context here, since we're just after a plausible
			 * OLD_TIME record.
			 */
			if ((Ut2.ut_type != NEW_TIME) ||
			    (strcmp(Ut2.ut_line, NTIME_MSG) != 0)) {
				wcomplain("NEW_TIME expected but missing "
				    "after OLD_TIME - giving up");
				exit(EXIT_FAILURE);
			}
			lastok = recin;
			if (multimode == B_TRUE)
				setdtab(rectmp, &Ut, &Ut2);
			rectmp += 2 * UTRSZ;
			if ((fwrite(&Ut, UTRSZ, 1, Temp) < 1) ||
			    (fwrite(&Ut2, UTRSZ, 1, Temp) < 1)) {
				perror("<temporary file>: fwrite");
				exit(EXIT_FAILURE);
			}
			continue;
		}
		if (fwrite(&Ut, UTRSZ, 1, Temp) < 1) {
			perror("<temporary file>: fwrite");
			exit(EXIT_FAILURE);
		}
		rectmp += UTRSZ;
	}
	if (want_ok == INRANGE_ALIGNED) {
		wcomplain("EOF reached without recognizing another aligned "
		    "record with certainty. This file may need to be "
		    "repaired by hand.\n");
	} else if (recovered == B_TRUE) {
		/*
		 * There may have been a number of wcomplain() messages
		 * since we reported about the re-scan, so it bears repeating
		 * at the end that not all was well.
		 */
		wcomplain("EOF reached after recovering from corruption "
		    "in the middle of the file.  This file may need to be "
		    "repaired by hand.\n");
	}
}

/*
 * inrange: inspect what we hope to be one wtmpx record.
 * Globals:  Ut, lastmonth, nextmonth;  recin, cur_input_name (diagnostics)
 * Return values:
 * INRANGE_ERR     -- an inconsistency was detected, input file corrupted
 * INRANGE_DROP    -- Ut appears consistent but isn't of interest
 *                    (of process type and outside the time range we want)
 * INRANGE_PASS    -- Ut appears consistent and this record is of interest
 * INRANGE_ALIGNED -- same, and it is also redundant enough to be sure
 *                    that we're correctly aligned on record boundaries
 */
#define	UNEXPECTED_UT_PID \
	(Ut.ut_pid != 0) || \
	(Ut.ut_exit.e_termination != 0) || \
	(Ut.ut_exit.e_exit != 0)

static inrange_t
inrange()
{
	/* pid_t is signed so that fork() can return -1.  Exploit this. */
	if (Ut.ut_pid < 0) {
		wcomplain("negative pid");
		return (INRANGE_ERR);
	}

	/* the legal values for ut_type are enumerated in <utmp.h> */
	switch (Ut.ut_type) {
	case EMPTY:
		if (UNEXPECTED_UT_PID) {
			wcomplain("nonzero pid or status in EMPTY record");
			return (INRANGE_ERR);
		}
		/*
		 * We'd like to have Ut.ut_user[0] == '\0' here, but sadly
		 * this isn't always so, so we can't rely on it.
		 */
		return (INRANGE_DROP);
	case RUN_LVL:
		/* ut_line must have come from the RUNLVL_MSG pattern */
		if (strncmp(Ut.ut_line, RUN_LEVEL_MSG, RLVLMSG_LEN) != 0) {
			wcomplain("RUN_LVL record doesn't say `"
			    RUN_LEVEL_MSG "'");
			return (INRANGE_ERR);
		}
		/*
		 * The ut_pid, termination, and exit status fields have
		 * special meaning in this case, and none of them is
		 * suitable for checking.  And we won't insist on ut_user
		 * to always be an empty string.
		 */
		return (INRANGE_ALIGNED);
	case BOOT_TIME:
		if (UNEXPECTED_UT_PID) {
			wcomplain("nonzero pid or status in BOOT_TIME record");
			return (INRANGE_ERR);
		}
		if (strcmp(Ut.ut_line, BOOT_MSG) != 0) {
			wcomplain("BOOT_TIME record doesn't say `"
			    BOOT_MSG "'");
			return (INRANGE_ERR);
		}
		return (INRANGE_ALIGNED);
	case OLD_TIME:
		if (UNEXPECTED_UT_PID) {
			wcomplain("nonzero pid or status in OLD_TIME record");
			return (INRANGE_ERR);
		}
		if (strcmp(Ut.ut_line, OTIME_MSG) != 0) {
			wcomplain("OLD_TIME record doesn't say `"
			    OTIME_MSG "'");
			return (INRANGE_ERR);
		}
		return (INRANGE_ALIGNED);
	case NEW_TIME:
		/*
		 * We don't actually expect to see any here.  If they follow
		 * an OLD_TIME record as they should, they'll be handled on
		 * the fly in scanfile().  But we might still run into one
		 * if the input is somehow corrupted.
		 */
		if (UNEXPECTED_UT_PID) {
			wcomplain("nonzero pid or status in NEW_TIME record");
			return (INRANGE_ERR);
		}
		if (strcmp(Ut.ut_line, NTIME_MSG) != 0) {
			wcomplain("NEW_TIME record doesn't say `"
			    NTIME_MSG "'");
			return (INRANGE_ERR);
		}
		return (INRANGE_ALIGNED);

	/* the four *_PROCESS ut_types have a lot in common */
	case USER_PROCESS:
		/*
		 * Catch two special cases first: psradm records have no id
		 * and no pid, while root login over FTP may not have a
		 * valid ut_user and may have garbage in ut_id[3].
		 */
		if ((strcmp(Ut.ut_user, "psradm") == 0) &&
		    (Ut.ut_id[0] == '\0') &&
		    (Ut.ut_pid > 0)) {
			if ((Ut.ut_xtime > lastmonth) &&
			    (Ut.ut_xtime < nextmonth)) {
				return (INRANGE_ALIGNED);
			} else {
				return (INRANGE_DROP);
			}
		}
		if ((Ut.ut_user[0] == '\0') &&
		    (strncmp(Ut.ut_id, "ftp", 3) == 0) &&
		    (strncmp(Ut.ut_line, "ftp", 3) == 0)) {
			if ((Ut.ut_xtime > lastmonth) &&
			    (Ut.ut_xtime < nextmonth)) {
				return (INRANGE_ALIGNED);
			} else {
				return (INRANGE_DROP);
			}
		}
		/* FALLTHROUGH */
	case LOGIN_PROCESS:
		if (Ut.ut_user[0] == '\0') {
			wcomplain("missing username in process record");
			return (INRANGE_ERR);
		}
		/* FALLTHROUGH */
	case INIT_PROCESS:
		/*
		 * INIT_PROCESS and DEAD_PROCESS records can come with an
		 * empty ut_user in degenerate cases (e.g. syntax errors
		 * like a comment-only process field in /etc/inittab).
		 * But in an INIT_PROCESS, LOGIN_PROCESS, or USER_PROCESS
		 * record, we expect a respectable ut_pid.
		 */
		if (Ut.ut_pid == 0) {
			wcomplain("null pid in process record");
			return (INRANGE_ERR);
		}
		/* FALLTHROUGH */
	case DEAD_PROCESS:
		/*
		 * DEAD_PROCESS records with a null ut_pid can be produced
		 * by gnome-terminal (normally seen in utmpx only, but they
		 * can leak into wtmpx in rare circumstances).
		 * Unfortunately, ut_id can't be relied on to contain
		 * anything in particular.  (E.g., sshd might leave it
		 * 0-initialized.)  This leaves almost no verifiable
		 * redundancy here beyond the ut_type.
		 * At least we insist on a reasonable timestamp.
		 */
		if (Ut.ut_xtime <= 0) {
			wcomplain("non-positive time in process record");
			return (INRANGE_ERR);
		}
		if ((Ut.ut_xtime > lastmonth) &&
		    (Ut.ut_xtime < nextmonth)) {
			return (INRANGE_PASS);
		} else {
			return (INRANGE_DROP);
		}
	case ACCOUNTING:
		/*
		 * If we recognize one of the three reason strings passed
		 * by the /usr/lib/acct shell scripts to acctwtmp, we
		 * exploit the available redundancy they offer.  But
		 * acctwtmp could have been invoked by custom scripts or
		 * interactively with other reason strings in the first
		 * argument, so anything we don't recognize does not
		 * constitute evidence for corruption.
		 */
		if ((strcmp(Ut.ut_line, RUNACCT_MSG) != 0) &&
		    (strcmp(Ut.ut_line, ACCTG_ON_MSG) != 0) &&
		    (strcmp(Ut.ut_line, ACCTG_OFF_MSG) != 0)) {
			return (INRANGE_DROP);
		}
		return (INRANGE_ALIGNED);
	case DOWN_TIME:
		if (UNEXPECTED_UT_PID) {
			wcomplain("nonzero pid or status in DOWN_TIME record");
			return (INRANGE_ERR);
		}
		if (strcmp(Ut.ut_line, DOWN_MSG) != 0) {
			wcomplain("DOWN_TIME record doesn't say `"
			    DOWN_MSG "'");
			return (INRANGE_ERR);
		}
		return (INRANGE_ALIGNED);
	default:
		wcomplain("ut_type out of range");
		return (INRANGE_ERR);
	}
	/* NOTREACHED */
}

static void
wcomplain(char *msg)
{
	(void) fprintf(stderr, "%s: offset %lld: %s\n", cur_input_name,
	    (longlong_t)recin, msg);
}