xref: /titanic_44/usr/src/cmd/sendmail/aux/vacation.c (revision 91c7793e73e8fb0edb9c55f2828d2dfd8ff09994)

/*
 * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 *	Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T
 *	  All Rights Reserved
 */

/*
 *  Vacation
 *  Copyright (c) 1983  Eric P. Allman
 *  Berkeley, California
 *
 *  Copyright (c) 1983 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"

#ifndef lint
static char	SccsId[] = "%W%	%E% SMI";
#endif /* not lint */

#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <unistd.h>
#include <sysexits.h>
#include <pwd.h>
#include <ndbm.h>
#include <string.h>
#include <ctype.h>
#include <fcntl.h>
#include <strings.h>
#include <errno.h>

/*
 *  VACATION -- return a message to the sender when on vacation.
 *
 *	This program could be invoked as a message receiver
 *	when someone is on vacation.  It returns a message
 *	specified by the user to whoever sent the mail, taking
 *	care not to return a message too often to prevent
 *	"I am on vacation" loops.
 *
 *	For best operation, this program should run setuid to
 *	root or uucp or someone else that sendmail will believe
 *	a -f flag from.  Otherwise, the user must be careful
 *	to include a header on his .vacation.msg file.
 *
 *	Positional Parameters:
 *		the user to collect the vacation message from.
 *
 *	Flag Parameters:
 *		-I	initialize the database.
 *		-d	turn on debugging.
 *		-tT	set the timeout to T.  messages arriving more
 *			often than T will be ignored to avoid loops.
 *
 *	Side Effects:
 *		A message is sent back to the sender.
 *
 *	Author:
 *		Eric Allman
 *		UCB/INGRES
 */

#define	MAXLINE	256	/* max size of a line */

#define	ONEWEEK	(60L*60L*24L*7L)
#define	MsgFile "/.vacation.msg"
#define	FilterFile "/.vacation.filter"
#define	DbFileBase "/.vacation"
#define	_PATH_TMP	"/tmp/vacation.XXXXXX"

typedef int bool;

#define	FALSE	0
#define	TRUE	1

static time_t	Timeout = ONEWEEK;	/* timeout between notices per user */
static DBM	*db;
static bool	Debug = FALSE;
static bool	ListMode = FALSE;
static bool	AnswerAll = FALSE;	/* default: answer if in To:/Cc: only */
static char	*Subject = NULL;	/* subject in message header */
static char	*EncodedSubject = NULL;	/* subject in message header */
static char	Charset[MAXLINE];	/* for use in reply message */
static char	*AliasList[MAXLINE];	/* list of aliases to allow */
static int	AliasCount = 0;
static char	*myname;		/* name of person "on vacation" */
static char	*homedir;		/* home directory of said person */

extern time_t	convtime(char *, char);
extern bool	decode_rfc2047(char *, char *, char *);

static bool	ask(char *);
static bool	junkmail(char *);
static bool	filter_ok(char *, char *);
static bool	knows(char *);
static bool	sameword(char *, char *);
static char	*getfrom(char **);
static char	*newstr(char *);
static void	AutoInstall();
static void	initialize(char *);
static void	sendmessage(char *, char *, char *);
static void	setknows(char *);
static void	dumplist();

void	usrerr(const char *, ...);

int
main(argc, argv)
	int argc;
	char **argv;
{
	char *from;
	char *p, *at, *c;
	struct passwd *pw;
	char *shortfrom;
	char buf[MAXLINE];
	char *message_file = MsgFile;
	char *db_file_base = DbFileBase;
	char *filter_file = FilterFile;
	char *sender;
	bool sender_oob = FALSE;
	bool initialize_only = FALSE;

	/* process arguments */
	while (--argc > 0 && (p = *++argv) != NULL && *p == '-')
	{
		switch (*++p)
		{
		    case 'a':	/* add this to list of acceptable aliases */
			AliasList[AliasCount++] = argv[1];
			if (argc > 0) {
				argc--; argv++;
			}
			break;

		    case 'd':	/* debug */
			Debug = TRUE;
			break;

		    case 'e':	/* alternate filter file */
			filter_file = argv[1];
			if (argc > 0) {
				argc--; argv++;
			}
			break;

		    case 'f':	/* alternate database file name base */
			db_file_base = argv[1];
			if (argc > 0) {
				argc--; argv++;
			}
			break;

		    case 'I':	/* initialize */
			initialize_only = TRUE;
			break;

		    case 'j':	/* answer all mail, even if not in To/Cc */
			AnswerAll = TRUE;
			break;

		    case 'l':	/* list all respondees */
			ListMode = TRUE;
			break;

		    case 'm':	/* alternate message file */
			message_file = argv[1];
			if (argc > 0) {
				argc--; argv++;
			}
			break;

		    case 's':	/* sender: use this instead of getfrom() */
			sender = argv[1];
			sender_oob = TRUE;
			if (argc > 0) {
				argc--; argv++;
			}
			break;

		    case 't':	/* set timeout */
			Timeout = convtime(++p, 'w');
			break;

		    default:
			usrerr("Unknown flag -%s", p);
			exit(EX_USAGE);
		}
	}

	if (initialize_only)
	{
		initialize(db_file_base);
		exit(EX_OK);
	}

	/* verify recipient argument */
	if (argc == 0 && !ListMode)
		AutoInstall();

	if (argc != 1 && !ListMode)
	{
		usrerr("Usage:\tvacation username\n\tvacation -I\n"
		    "\tvacation -l");
		exit(EX_USAGE);
	}

	myname = p;
	Charset[0] = '\0';

	/* find user's home directory */
	if (ListMode)
		pw = getpwuid(getuid());
	else
		pw = getpwnam(myname);
	if (pw == NULL)
	{
		usrerr("user %s look up failed, name services outage ?",
		    myname);
		exit(EX_TEMPFAIL);
	}
	homedir = newstr(pw->pw_dir);

	(void) snprintf(buf, sizeof (buf), "%s%s%s", homedir,
			(db_file_base[0] == '/') ? "" : "/", db_file_base);
	if (!(db = dbm_open(buf, O_RDWR, 0))) {
		usrerr("%s: %s\n", buf, strerror(errno));
		exit(EX_DATAERR);
	}

	if (ListMode) {
		dumplist();
		exit(EX_OK);
	}

	if (sender_oob)
	{
		at = strchr(sender, '@');
		if (at != NULL)
			for (c = at + 1; *c; c++)
				*c = (char)tolower((char)*c);
		from = sender;
		shortfrom = sender;
	}
	else
		/* read message from standard input (just from line) */
		from = getfrom(&shortfrom);

	/* check if junk mail or this person is already informed */
	if (!junkmail(shortfrom) && filter_ok(shortfrom, filter_file) &&
	    !knows(shortfrom))
	{
		/* mark this person as knowing */
		setknows(shortfrom);

		/* send the message back */
		(void) strlcpy(buf, homedir, sizeof (buf));
		if (message_file[0] != '/')
		    (void) strlcat(buf, "/", sizeof (buf));
		(void) strlcat(buf, message_file, sizeof (buf));
		if (Debug)
			printf("Sending %s to %s\n", buf, from);
		else
		{
			sendmessage(buf, from, myname);
			/*NOTREACHED*/
		}
	}
	while (fgets(buf, MAXLINE, stdin) != NULL)
		continue; /* drain input */
	return (EX_OK);
}

struct entry {
	time_t	when;
	long	when_size;
	char	*who;
	long	who_size;
	struct	entry *next;
	struct	entry *prev;
};

static void
dump_content(key_size, key_ptr, content_size, content_ptr)
	long key_size, content_size;
	char *key_ptr, *content_ptr;
{
	time_t then;

	if (content_size == sizeof (then)) {
		bcopy(content_ptr, (char *)&then, sizeof (then));
		(void) printf("%-53.40*s: %s", (int)key_size, key_ptr,
		    ctime(&then));
	} else {
		(void) fprintf(stderr, "content size error: %d\n",
		    (int)content_size);
	}
}

static void
dump_all_content(first)
	struct entry *first;
{
	struct entry *which;

	for (which = first; which != NULL; which = which->next) {
		dump_content(which->who_size, which->who, which->when_size,
		    (char *)&(which->when));
	}
}

static void
dumplist()
{
	datum content, key;
	struct entry *first = NULL, *last = NULL, *new_entry, *curr;

	for (key = dbm_firstkey(db); key.dptr != NULL; key = dbm_nextkey(db)) {
		content = dbm_fetch(db, key);
		new_entry = (struct entry *)malloc(sizeof (struct entry));
		if (new_entry == NULL)
			perror("out of memory");
		new_entry->next = NULL;
		new_entry->who = (char *)malloc(key.dsize);
		if (new_entry->who == NULL)
			perror("out of memory");
		new_entry->who_size = key.dsize;
		(void) strlcpy(new_entry->who, key.dptr, key.dsize);
		bcopy(content.dptr, (char *)&(new_entry->when),
		    sizeof (new_entry->when));
		new_entry->when_size = content.dsize;
		if (first == NULL) { /* => so is last */
			new_entry->prev = NULL;
			new_entry->next = NULL;
			first = new_entry;
			last = new_entry;
		} else {
			for (curr = first; curr != NULL &&
			    new_entry->when > curr->when; curr = curr->next)
				;
			if (curr == NULL) {
				last->next = new_entry;
				new_entry->prev = last;
				new_entry->next = NULL;
				last = new_entry;
			} else {
				new_entry->next = curr;
				new_entry->prev = curr->prev;
				if (curr->prev == NULL)
					first = new_entry;
				else
					curr->prev->next = new_entry;
				curr->prev = new_entry;
			}
		}
	}
	dump_all_content(first);
	dbm_close(db);
}

/*
 *  GETFROM -- read message from standard input and return sender
 *
 *	Parameters:
 *		none.
 *
 *	Returns:
 *		pointer to the sender address.
 *
 *	Side Effects:
 *		Reads first line from standard input.
 */

static char *
getfrom(shortp)
char **shortp;
{
	static char line[MAXLINE];
	char *p, *start, *at, *bang, *c;
	char saveat;

	/* read the from line */
	if (fgets(line, sizeof (line), stdin) == NULL ||
	    strncmp(line, "From ", 5) != NULL)
	{
		usrerr("No initial From line");
		exit(EX_PROTOCOL);
	}

	/* find the end of the sender address and terminate it */
	start = &line[5];
	p = strchr(start, ' ');
	if (p == NULL)
	{
		usrerr("Funny From line '%s'", line);
		exit(EX_PROTOCOL);
	}
	*p = '\0';

	/*
	 * Strip all but the rightmost UUCP host
	 * to prevent loops due to forwarding.
	 * Start searching leftward from the leftmost '@'.
	 *	a!b!c!d yields a short name of c!d
	 *	a!b!c!d@e yields a short name of c!d@e
	 *	e@a!b!c yields the same short name
	 */
#ifdef VDEBUG
printf("start='%s'\n", start);
#endif /* VDEBUG */
	*shortp = start;			/* assume whole addr */
	if ((at = strchr(start, '@')) == NULL)	/* leftmost '@' */
		at = p;				/* if none, use end of addr */
	saveat = *at;
	*at = '\0';
	if ((bang = strrchr(start, '!')) != NULL) {	/* rightmost '!' */
		char *bang2;
		*bang = '\0';
		/* 2nd rightmost '!' */
		if ((bang2 = strrchr(start, '!')) != NULL)
			*shortp = bang2 + 1;		/* move past ! */
		*bang = '!';
	}
	*at = saveat;
#ifdef VDEBUG
printf("place='%s'\n", *shortp);
#endif /* VDEBUG */
	for (c = at + 1; *c; c++)
		*c = (char)tolower((char)*c);

	/* return the sender address */
	return (start);
}

/*
 *  JUNKMAIL -- read the header and tell us if this is junk/bulk mail.
 *
 *	Parameters:
 *		from -- the Return-Path of the sender.  We assume that
 *			anything from "*-REQUEST@*" is bulk mail.
 *
 *	Returns:
 *		TRUE -- if this is junk or bulk mail (that is, if the
 *			sender shouldn't receive a response).
 *		FALSE -- if the sender deserves a response.
 *
 *	Side Effects:
 *		May read the header from standard input.  When this
 *		returns the position on stdin is undefined.
 */

static bool
junkmail(from)
	char *from;
{
	register char *p;
	char buf[MAXLINE+1];
	bool inside, onlist;

	/* test for inhuman sender */
	p = strrchr(from, '@');
	if (p != NULL)
	{
		*p = '\0';
		if (sameword(&p[-8],  "-REQUEST") ||
		    sameword(&p[-10], "Postmaster") ||
		    sameword(&p[-13], "MAILER-DAEMON"))
		{
			*p = '@';
			return (TRUE);
		}
		*p = '@';
	}

#define	Delims " \n\t:,:;()<>@!"

	/* read the header looking for "interesting" lines */
	inside = FALSE;
	onlist = FALSE;
	while (fgets(buf, MAXLINE, stdin) != NULL && buf[0] != '\n')
	{
		if (buf[0] != ' ' && buf[0] != '\t' && strchr(buf, ':') == NULL)
			return (FALSE);			/* no header found */

		p = strtok(buf, Delims);
		if (p == NULL)
			continue;

		if (sameword(p, "To") || sameword(p, "Cc"))
		{
			inside = TRUE;
			p = strtok((char *)NULL, Delims);
			if (p == NULL)
				continue;

		} else				/* continuation line? */
		    if (inside)
			inside =  (buf[0] == ' ' || buf[0] == '\t');

		if (inside) {
		    int i;

		    do {
			if (sameword(p, myname))
				onlist = TRUE;		/* I am on the list */

			for (i = 0; i < AliasCount; i++)
			    if (sameword(p, AliasList[i]))
				onlist = TRUE;		/* alias on list */

		    } while (p = strtok((char *)NULL, Delims));
		    continue;
		}

		if (sameword(p, "Precedence"))
		{
			/* find the value of this field */
			p = strtok((char *)NULL, Delims);
			if (p == NULL)
				continue;

			/* see if it is "junk" or "bulk" */
			p[4] = '\0';
			if (sameword(p, "junk") || sameword(p, "bulk"))
				return (TRUE);
		}

		if (sameword(p, "Subject"))
		{
			char *decoded_subject;

			Subject = newstr(buf+9);
			if (p = strrchr(Subject, '\n'))
				*p = '\0';
			EncodedSubject = newstr(Subject);
			decoded_subject = newstr(Subject);
			if (decode_rfc2047(Subject, decoded_subject, Charset))
				Subject = decoded_subject;
			else
				Charset[0] = '\0';
			if (Debug)
				printf("Subject=%s\n", Subject);
		}
	}
	if (AnswerAll)
		return (FALSE);
	else
		return (!onlist);
}

/*
 *  FILTER_OK -- see if the Return-Path is in the filter file.
 *		 Note that a non-existent filter file means everything
 *		 is OK, but an empty file means nothing is OK.
 *
 *	Parameters:
 *		from -- the Return-Path of the sender.
 *
 *	Returns:
 *		TRUE -- if this is in the filter file
 *			(sender should receive a response).
 *		FALSE -- if the sender does not deserve a response.
 */

static bool
filter_ok(from, filter_file)
	char *from;
	char *filter_file;
{
	char file[MAXLINE];
	char line[MAXLINE];
	char *match_start;
	size_t line_len, from_len;
	bool result = FALSE;
	bool negated = FALSE;
	FILE *f;

	from_len = strlen(from);
	(void) strlcpy(file, homedir, sizeof (file));
	if (filter_file[0] != '/')
	    (void) strlcat(file, "/", sizeof (file));
	(void) strlcat(file, filter_file, sizeof (file));
	f = fopen(file, "r");
	if (f == NULL) {
		/*
		 * If the file does not exist, then there is no filter to
		 * apply, so we simply return TRUE.
		 */
		if (Debug)
			(void) printf("%s does not exist, filter ok.\n",
			    file);
		return (TRUE);
	}
	while (fgets(line, MAXLINE, f)) {
		line_len = strlen(line);
		/* zero out trailing newline */
		if (line[line_len - 1] == '\n')
			line[--line_len] = '\0';
		/* skip blank lines */
		if (line_len == 0)
			continue;
		/* skip comment lines */
		if (line[0] == '#')
			continue;
		if (line[0] == '!') {
			negated = TRUE;
			match_start = &line[1];
			line_len--;
		} else {
			negated = FALSE;
			match_start = &line[0];
		}
		if (strchr(line, '@') != NULL) {
			/* @ => full address */
			if (strcasecmp(match_start, from) == 0) {
				result = TRUE;
				if (Debug)
					(void) printf("filter match on %s\n",
					    line);
				break;
			}
		} else {
			/* no @ => domain */
			if (from_len <= line_len)
				continue;
			/*
			 * Make sure the last part of from is the domain line
			 * and that the character immediately preceding is an
			 * '@' or a '.', otherwise we could get false positives
			 * from e.g. twinsun.com for sun.com .
			 */
			if (strncasecmp(&from[from_len - line_len],
			    match_start, line_len) == 0 &&
			    (from[from_len - line_len -1] == '@' ||
			    from[from_len - line_len -1] == '.')) {
				result = TRUE;
				if (Debug)
					(void) printf("filter match on %s\n",
					    line);
				break;
			}
		}
	}
	(void) fclose(f);
	if (Debug && !result)
		(void) printf("no filter match\n");
	return (!negated && result);
}

/*
 *  KNOWS -- predicate telling if user has already been informed.
 *
 *	Parameters:
 *		user -- the user who sent this message.
 *
 *	Returns:
 *		TRUE if 'user' has already been informed that the
 *			recipient is on vacation.
 *		FALSE otherwise.
 *
 *	Side Effects:
 *		none.
 */

static bool
knows(user)
	char *user;
{
	datum key, data;
	time_t now, then;

	(void) time(&now);
	key.dptr = user;
	key.dsize = strlen(user) + 1;
	data = dbm_fetch(db, key);
	if (data.dptr == NULL)
		return (FALSE);

	bcopy(data.dptr, (char *)&then, sizeof (then));
	if (then + Timeout < now)
		return (FALSE);
	if (Debug)
		printf("User %s already knows\n", user);
	return (TRUE);
}

/*
 *  SETKNOWS -- set that this user knows about the vacation.
 *
 *	Parameters:
 *		user -- the user who should be marked.
 *
 *	Returns:
 *		none.
 *
 *	Side Effects:
 *		The dbm file is updated as appropriate.
 */

static void
setknows(user)
	char *user;
{
	datum key, data;
	time_t now;

	key.dptr = user;
	key.dsize = strlen(user) + 1;
	(void) time(&now);
	data.dptr = (char *)&now;
	data.dsize = sizeof (now);
	dbm_store(db, key, data, DBM_REPLACE);
}

static bool
any8bitchars(line)
	char *line;
{
	char *c;

	for (c = line; *c; c++)
		if (*c & 0x80)
			return (TRUE);
	return (FALSE);
}

/*
 *  SENDMESSAGE -- send a message to a particular user.
 *
 *	Parameters:
 *		msgf -- filename containing the message.
 *		user -- user who should receive it.
 *
 *	Returns:
 *		none.
 *
 *	Side Effects:
 *		sends mail to 'user' using /usr/lib/sendmail.
 */

static void
sendmessage(msgf, user, myname)
	char *msgf;
	char *user;
	char *myname;
{
	FILE *f, *fpipe, *tmpf;
	char line[MAXLINE];
	char *p, *tmpf_name;
	int i, pipefd[2], tmpfd;
	bool seen8bitchars = FALSE;
	bool in_header = TRUE;

	/* find the message to send */
	f = fopen(msgf, "r");
	if (f == NULL)
	{
		f = fopen("/etc/mail/vacation.def", "r");
		if (f == NULL)
			usrerr("No message to send");
			exit(EX_OSFILE);
	}

	if (pipe(pipefd) < 0) {
		usrerr("pipe() failed");
		exit(EX_OSERR);
	}
	i = fork();
	if (i < 0) {
		usrerr("fork() failed");
		exit(EX_OSERR);
	}
	if (i == 0) {
		dup2(pipefd[0], 0);
		close(pipefd[0]);
		close(pipefd[1]);
		fclose(f);
		execl("/usr/lib/sendmail", "sendmail", "-eq", "-f", myname,
			"--", user, NULL);
		usrerr("can't exec /usr/lib/sendmail");
		exit(EX_OSERR);
	}
	close(pipefd[0]);
	fpipe = fdopen(pipefd[1], "w");
	if (fpipe == NULL) {
		usrerr("fdopen() failed");
		exit(EX_OSERR);
	}
	fprintf(fpipe, "To: %s\n", user);
	fputs("Auto-Submitted: auto-replied\n", fpipe);
	fputs("X-Mailer: vacation %I%\n", fpipe);

	/*
	 * We used to write directly to the pipe.  But now we need to know
	 * what character set to use, and we need to examine the entire
	 * message to determine this.  So write to a temp file first.
	 */
	tmpf_name = strdup(_PATH_TMP);
	if (tmpf_name == NULL) {
		usrerr("newstr: cannot alloc memory");
		exit(EX_OSERR);
	}
	tmpfd = -1;
	tmpfd = mkstemp(tmpf_name);
	if (tmpfd == -1) {
		usrerr("can't open temp file %s", tmpf_name);
		exit(EX_OSERR);
	}
	tmpf = fdopen(tmpfd, "w");
	if (tmpf == NULL) {
		usrerr("can't open temp file %s", tmpf_name);
		exit(EX_OSERR);
	}
	while (fgets(line, MAXLINE, f)) {
		/*
		 * Check for a line with no ':' character.  If it's just \n,
		 * we're at the end of the headers and all is fine.  Or if
		 * it starts with white-space, then it's a continuation header.
		 * Otherwise, it's the start of the body, which means the
		 * header/body separator was skipped.  So output it.
		 */
		if (in_header && line[0] != '\0' && strchr(line, ':') == NULL) {
			if (line[0] == '\n')
				in_header = FALSE;
			else if (!isspace(line[0])) {
				in_header = FALSE;
				fputs("\n", tmpf);
			}
		}
		p = strchr(line, '$');
		if (p && strncmp(p, "$SUBJECT", 8) == 0) {
			*p = '\0';
			seen8bitchars |= any8bitchars(line);
			fputs(line, tmpf);
			if (Subject) {
				if (in_header)
					fputs(EncodedSubject, tmpf);
				else {
					seen8bitchars |= any8bitchars(Subject);
					fputs(Subject, tmpf);
				}
			}
			seen8bitchars |= any8bitchars(p+8);
			fputs(p+8, tmpf);
			continue;
		}
		seen8bitchars |= any8bitchars(line);
		fputs(line, tmpf);
	}
	fclose(f);
	fclose(tmpf);

	/*
	 * If we haven't seen a funky Subject with Charset, use the default.
	 * If we have and it's us-ascii, 8-bit chars in the message file will
	 * still result in iso-8859-1.
	 */
	if (Charset[0] == '\0')
		(void) strlcpy(Charset, (seen8bitchars) ? "iso-8859-1" :
		    "us-ascii", sizeof (Charset));
	else if ((strcasecmp(Charset, "us-ascii") == 0) && seen8bitchars)
		(void) strlcpy(Charset, "iso-8859-1", sizeof (Charset));
	if (Debug)
		printf("Charset is %s\n", Charset);
	fprintf(fpipe, "Content-Type: text/plain; charset=%s\n", Charset);
	fputs("Mime-Version: 1.0\n", fpipe);

	/*
	 * Now read back in from the temp file and write to the pipe.
	 */
	tmpf = fopen(tmpf_name, "r");
	if (tmpf == NULL) {
		usrerr("can't open temp file %s", tmpf_name);
		exit(EX_OSERR);
	}
	while (fgets(line, MAXLINE, tmpf))
		fputs(line, fpipe);
	fclose(fpipe);
	fclose(tmpf);
	(void) unlink(tmpf_name);
	free(tmpf_name);
}

/*
 *  INITIALIZE -- initialize the database before leaving for vacation
 *
 *	Parameters:
 *		none.
 *
 *	Returns:
 *		none.
 *
 *	Side Effects:
 *		Initializes the files .vacation.{pag,dir} in the
 *		caller's home directory.
 */

static void
initialize(db_file_base)
	char *db_file_base;
{
	char *homedir;
	char buf[MAXLINE];
	DBM *db;

	setgid(getgid());
	setuid(getuid());
	homedir = getenv("HOME");
	if (homedir == NULL) {
		usrerr("No home!");
		exit(EX_NOUSER);
	}
	(void) snprintf(buf, sizeof (buf), "%s%s%s", homedir,
		(db_file_base[0] == '/') ? "" : "/", db_file_base);

	if (!(db = dbm_open(buf, O_WRONLY|O_CREAT|O_TRUNC, 0644))) {
		usrerr("%s: %s\n", buf, strerror(errno));
		exit(EX_DATAERR);
	}
	dbm_close(db);
}

/*
 *  USRERR -- print user error
 *
 *	Parameters:
 *		f -- format.
 *
 *	Returns:
 *		none.
 *
 *	Side Effects:
 *		none.
 */

/* PRINTFLIKE1 */
void
usrerr(const char *f, ...)
{
	va_list alist;

	va_start(alist, f);
	(void) fprintf(stderr, "vacation: ");
	(void) vfprintf(stderr, f, alist);
	(void) fprintf(stderr, "\n");
	va_end(alist);
}

/*
 *  NEWSTR -- copy a string
 *
 *	Parameters:
 *		s -- the string to copy.
 *
 *	Returns:
 *		A copy of the string.
 *
 *	Side Effects:
 *		none.
 */

static char *
newstr(s)
	char *s;
{
	char *p;
	size_t s_sz = strlen(s);

	p = malloc(s_sz + 1);
	if (p == NULL)
	{
		usrerr("newstr: cannot alloc memory");
		exit(EX_OSERR);
	}
	(void) strlcpy(p, s, s_sz + 1);
	return (p);
}

/*
 *  SAMEWORD -- return TRUE if the words are the same
 *
 *	Ignores case.
 *
 *	Parameters:
 *		a, b -- the words to compare.
 *
 *	Returns:
 *		TRUE if a & b match exactly (modulo case)
 *		FALSE otherwise.
 *
 *	Side Effects:
 *		none.
 */

static bool
sameword(a, b)
	register char *a, *b;
{
	char ca, cb;

	do
	{
		ca = *a++;
		cb = *b++;
		if (isascii(ca) && isupper(ca))
			ca = ca - 'A' + 'a';
		if (isascii(cb) && isupper(cb))
			cb = cb - 'A' + 'a';
	} while (ca != '\0' && ca == cb);
	return (ca == cb);
}

/*
 * When invoked with no arguments, we fall into an automatic installation
 * mode, stepping the user through a default installation.
 */

static void
AutoInstall()
{
	char file[MAXLINE];
	char forward[MAXLINE];
	char cmd[MAXLINE];
	char line[MAXLINE];
	char *editor;
	FILE *f;
	struct passwd *pw;
	extern mode_t umask(mode_t cmask);

	umask(022);
	pw = getpwuid(getuid());
	if (pw == NULL) {
		usrerr("User ID unknown");
		exit(EX_NOUSER);
	}
	myname = strdup(pw->pw_name);
	if (myname == NULL) {
		usrerr("Out of memory");
		exit(EX_OSERR);
	}
	homedir = getenv("HOME");
	if (homedir == NULL) {
		usrerr("Home directory unknown");
		exit(EX_NOUSER);
	}

	printf("This program can be used to answer your mail automatically\n");
	printf("when you go away on vacation.\n");
	(void) strlcpy(file, homedir, sizeof (file));
	(void) strlcat(file, MsgFile, sizeof (file));
	do {
		f = fopen(file, "r");
		if (f) {
			printf("You have a message file in %s.\n", file);
			if (ask("Would you like to see it")) {
				(void) snprintf(cmd, sizeof (cmd),
				    "/usr/bin/more %s", file);
				system(cmd);
			}
			if (ask("Would you like to edit it"))
				f = NULL;
		} else {
			printf("You need to create a message file"
			    " in %s first.\n", file);
			f = fopen(file, "w");
			if (f == NULL) {
				usrerr("Cannot open %s", file);
				exit(EX_CANTCREAT);
			}
			fprintf(f, "Subject: away from my mail\n");
			fprintf(f, "\nI will not be reading my mail"
			    " for a while.\n");
			fprintf(f, "Your mail regarding \"$SUBJECT\" will"
			    " be read when I return.\n");
			fclose(f);
			f = NULL;
		}
		if (f == NULL) {
			editor = getenv("VISUAL");
			if (editor == NULL)
				editor = getenv("EDITOR");
			if (editor == NULL)
				editor = "/usr/bin/vi";
			(void) snprintf(cmd, sizeof (cmd), "%s %s", editor,
			    file);
			printf("Please use your editor (%s)"
			    " to edit this file.\n", editor);
			system(cmd);
		}
	} while (f == NULL);
	fclose(f);
	(void) strlcpy(forward, homedir, sizeof (forward));
	(void) strlcat(forward, "/.forward", sizeof (forward));
	f = fopen(forward, "r");
	if (f) {
		printf("You have a .forward file"
		    " in your home directory containing:\n");
		while (fgets(line, MAXLINE, f))
			printf("    %s", line);
		fclose(f);
		if (!ask("Would you like to remove it and"
		    " disable the vacation feature"))
			exit(EX_OK);
		if (unlink(forward))
			perror("Error removing .forward file:");
		else
			printf("Back to normal reception of mail.\n");
		exit(EX_OK);
	}

	printf("To enable the vacation feature"
	    " a \".forward\" file is created.\n");
	if (!ask("Would you like to enable the vacation feature")) {
		printf("OK, vacation feature NOT enabled.\n");
		exit(EX_OK);
	}
	f = fopen(forward, "w");
	if (f == NULL) {
		perror("Error opening .forward file");
		exit(EX_CANTCREAT);
	}
	fprintf(f, "\\%s, \"|/usr/bin/vacation %s\"\n", myname, myname);
	fclose(f);
	printf("Vacation feature ENABLED."
	    " Please remember to turn it off when\n");
	printf("you get back from vacation. Bon voyage.\n");

	initialize(DbFileBase);
	exit(EX_OK);
}


/*
 * Ask the user a question until we get a reasonable answer
 */

static bool
ask(prompt)
	char *prompt;
{
	char line[MAXLINE];
	char *res;

	for (;;) {
		printf("%s? ", prompt);
		fflush(stdout);
		res = fgets(line, sizeof (line), stdin);
		if (res == NULL)
			return (FALSE);
		if (res[0] == 'y' || res[0] == 'Y')
			return (TRUE);
		if (res[0] == 'n' || res[0] == 'N')
			return (FALSE);
		printf("Please reply \"yes\" or \"no\" (\'y\' or \'n\')\n");
	}
}