Paul Vixie's cron, version 3.0. Munged into bmake format. If this goes

well, expect our two seperate directories for cron and crontab to go away
shortly.
Submitted by:	jkh

35 files changed, 6147 insertions, 0 deletions

diff --git a/usr.sbin/cron/Makefile b/usr.sbin/cron/Makefile
new file mode 100644
index 000000000000..1131cff7b17f
--- /dev/null
+++ b/usr.sbin/cron/Makefile
@@ -0,0 +1,3 @@
+SUBDIR=	lib cron crontab
+
+.include <bsd.subdir.mk>
diff --git a/usr.sbin/cron/cron/Makefile b/usr.sbin/cron/cron/Makefile
new file mode 100644
index 000000000000..6eb220d005a3
--- /dev/null
+++ b/usr.sbin/cron/cron/Makefile
@@ -0,0 +1,8 @@
+PROG=	cron
+SRCS=	cron.c database.c do_command.c job.c user.c popen.c
+MAN3=	bitstring.3
+MAN8=	cron.8
+
+LDADD+=	-L${.CURDIR}/../lib -lcron
+
+.include <bsd.prog.mk>
diff --git a/usr.sbin/cron/cron/bitstring.3 b/usr.sbin/cron/cron/bitstring.3
new file mode 100644
index 000000000000..efe9ae3c116e
--- /dev/null
+++ b/usr.sbin/cron/cron/bitstring.3
@@ -0,0 +1,168 @@
+.\" Copyright (c) 1989 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Paul Vixie.
+.\"
+.\" Redistribution and use in source and binary forms are permitted
+.\" provided that the above copyright notice and this paragraph are
+.\" duplicated in all such forms and that any documentation,
+.\" advertising materials, and other materials related to such
+.\" distribution and use acknowledge that the software was developed
+.\" by the University of California, Berkeley.  The name of the
+.\" University may not be used to endorse or promote products derived
+.\" from this software without specific prior written permission.
+.\" THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+.\" IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+.\" WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+.\"
+.\"	@(#)bitstring.3	5.1 (Berkeley) 12/13/89
+.\"
+.TH BITSTRING 3  "December 13, 1989"
+.UC 4
+.SH NAME
+bit_alloc, bit_clear, bit_decl, bit_ffs, bit_nclear, bit_nset,
+bit_set, bitstr_size, bit_test \- bit-string manipulation macros
+.SH SYNOPSIS
+.ft B
+.nf
+#include <bitstring.h>
+
+name = bit_alloc(nbits)
+bitstr_t *name;
+int nbits;
+
+bit_decl(name, nbits)
+bitstr_t name;
+int nbits;
+
+bit_clear(name, bit)
+bitstr_t name;
+int bit;
+
+bit_ffc(name, nbits, value)
+bitstr_t name;
+int nbits, *value;
+
+bit_ffs(name, nbits, value)
+bitstr_t name;
+int nbits, *value;
+
+bit_nclear(name, start, stop)
+bitstr_t name;
+int start, stop;
+
+bit_nset(name, start, stop)
+bitstr_t name;
+int start, stop;
+
+bit_set(name, bit)
+bitstr_t name;
+int bit;
+
+bitstr_size(nbits)
+int nbits;
+
+bit_test(name, bit)
+bitstr_t name;
+int bit;
+.fi
+.ft R
+.SH DESCRIPTION
+These macros operate on strings of bits.
+.PP
+.I Bit_alloc
+returns a pointer of type
+.I bitstr_t\ *
+to sufficient space to store
+.I nbits
+bits, or NULL if no space is available.
+.PP
+.I Bit_decl
+is a macro for allocating sufficient space to store
+.I nbits
+bits on the stack.
+.PP
+.I Bitstr_size
+returns the number of elements of type
+.I bitstr_t
+necessary to store
+.I nbits
+bits.
+This is useful for copying bit strings.
+.PP
+.I Bit_clear
+and
+.I bit_set
+clear or set the zero-based numbered bit
+.IR bit ,
+in the bit string
+.IR name .
+.PP
+.I Bit_nset
+and
+.I bit_nclear
+set or clear the zero-based numbered bits from
+.I start
+to
+.I stop
+in the bit string
+.IR name .
+.PP
+.I Bit_test
+evaluates to zero if the zero-based numbered bit
+.I bit
+of bit string
+.I name
+is set, and non-zero otherwise.
+.PP
+.I Bit_ffs
+sets
+.I *value
+to the zero-based number of the first bit set in the array of
+.I nbits
+bits referenced by
+.IR name .
+If no bits are set,
+.I *value
+is set to -1.
+.PP
+.I Bit_ffc
+sets
+.I *value
+to the zero-based number of the first bit not set in the array of
+.I nbits
+bits referenced by
+.IR name .
+If all bits are set,
+.I value
+is set to -1.
+.SH EXAMPLE
+.nf
+.in +5
+#include <limits.h>
+#include <bitstring.h>
+
+...
+#define	LPR_BUSY_BIT		0
+#define	LPR_FORMAT_BIT		1
+#define	LPR_DOWNLOAD_BIT	2
+...
+#define	LPR_AVAILABLE_BIT	9
+#define	LPR_MAX_BITS		10
+
+make_lpr_available()
+{
+	bitstr_t bit_decl(bitlist, LPR_MAX_BITS);
+	...
+	bit_nclear(bitlist, 0, LPR_MAX_BITS - 1);
+	...
+	if (!bit_test(bitlist, LPR_BUSY_BIT)) {
+		bit_clear(bitlist, LPR_FORMAT_BIT);
+		bit_clear(bitlist, LPR_DOWNLOAD_BIT);
+		bit_set(bitlist, LPR_AVAILABLE_BIT);
+	}
+}
+.fi
+.SH "SEE ALSO"
+malloc(3)
diff --git a/usr.sbin/cron/cron/bitstring.h b/usr.sbin/cron/cron/bitstring.h
new file mode 100644
index 000000000000..d054de3c51c1
--- /dev/null
+++ b/usr.sbin/cron/cron/bitstring.h
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) 1989 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Paul Vixie.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *	@(#)bitstring.h	5.2 (Berkeley) 4/4/90
+ */
+
+typedef	unsigned char bitstr_t;
+
+/* internal macros */
+				/* byte of the bitstring bit is in */
+#define	_bit_byte(bit) \
+	((bit) >> 3)
+
+				/* mask for the bit within its byte */
+#define	_bit_mask(bit) \
+	(1 << ((bit)&0x7))
+
+/* external macros */
+				/* bytes in a bitstring of nbits bits */
+#define	bitstr_size(nbits) \
+	((((nbits) - 1) >> 3) + 1)
+
+				/* allocate a bitstring */
+#define	bit_alloc(nbits) \
+	(bitstr_t *)malloc(1, \
+	    (unsigned int)bitstr_size(nbits) * sizeof(bitstr_t))
+
+				/* allocate a bitstring on the stack */
+#define	bit_decl(name, nbits) \
+	(name)[bitstr_size(nbits)]
+
+				/* is bit N of bitstring name set? */
+#define	bit_test(name, bit) \
+	((name)[_bit_byte(bit)] & _bit_mask(bit))
+
+				/* set bit N of bitstring name */
+#define	bit_set(name, bit) \
+	(name)[_bit_byte(bit)] |= _bit_mask(bit)
+
+				/* clear bit N of bitstring name */
+#define	bit_clear(name, bit) \
+	(name)[_bit_byte(bit)] &= ~_bit_mask(bit)
+
+				/* clear bits start ... stop in bitstring */
+#define	bit_nclear(name, start, stop) { \
+	register bitstr_t *_name = name; \
+	register int _start = start, _stop = stop; \
+	register int _startbyte = _bit_byte(_start); \
+	register int _stopbyte = _bit_byte(_stop); \
+	if (_startbyte == _stopbyte) { \
+		_name[_startbyte] &= ((0xff >> (8 - (_start&0x7))) | \
+				      (0xff << ((_stop&0x7) + 1))); \
+	} else { \
+		_name[_startbyte] &= 0xff >> (8 - (_start&0x7)); \
+		while (++_startbyte < _stopbyte) \
+			_name[_startbyte] = 0; \
+		_name[_stopbyte] &= 0xff << ((_stop&0x7) + 1); \
+	} \
+}
+
+				/* set bits start ... stop in bitstring */
+#define	bit_nset(name, start, stop) { \
+	register bitstr_t *_name = name; \
+	register int _start = start, _stop = stop; \
+	register int _startbyte = _bit_byte(_start); \
+	register int _stopbyte = _bit_byte(_stop); \
+	if (_startbyte == _stopbyte) { \
+		_name[_startbyte] |= ((0xff << (_start&0x7)) & \
+				    (0xff >> (7 - (_stop&0x7)))); \
+	} else { \
+		_name[_startbyte] |= 0xff << ((_start)&0x7); \
+		while (++_startbyte < _stopbyte) \
+	    		_name[_startbyte] = 0xff; \
+		_name[_stopbyte] |= 0xff >> (7 - (_stop&0x7)); \
+	} \
+}
+
+				/* find first bit clear in name */
+#define	bit_ffc(name, nbits, value) { \
+	register bitstr_t *_name = name; \
+	register int _byte, _nbits = nbits; \
+	register int _stopbyte = _bit_byte(_nbits), _value = -1; \
+	for (_byte = 0; _byte <= _stopbyte; ++_byte) \
+		if (_name[_byte] != 0xff) { \
+			_value = _byte << 3; \
+			for (_stopbyte = _name[_byte]; (_stopbyte&0x1); \
+			    ++_value, _stopbyte >>= 1); \
+			break; \
+		} \
+	*(value) = _value; \
+}
+
+				/* find first bit set in name */
+#define	bit_ffs(name, nbits, value) { \
+	register bitstr_t *_name = name; \
+	register int _byte, _nbits = nbits; \
+	register int _stopbyte = _bit_byte(_nbits), _value = -1; \
+	for (_byte = 0; _byte <= _stopbyte; ++_byte) \
+		if (_name[_byte]) { \
+			_value = _byte << 3; \
+			for (_stopbyte = _name[_byte]; !(_stopbyte&0x1); \
+			    ++_value, _stopbyte >>= 1); \
+			break; \
+		} \
+	*(value) = _value; \
+}
diff --git a/usr.sbin/cron/cron/compat.h b/usr.sbin/cron/cron/compat.h
new file mode 100644
index 000000000000..528c6d3d9a23
--- /dev/null
+++ b/usr.sbin/cron/cron/compat.h
@@ -0,0 +1,137 @@
+/* Copyright 1993,1994 by Paul Vixie
+ * All rights reserved
+ *
+ * Distribute freely, except: don't remove my name from the source or
+ * documentation (don't take credit for my work), mark your changes (don't
+ * get me blamed for your possible bugs), don't alter or remove this
+ * notice.  May be sold if buildable source is provided to buyer.  No
+ * warrantee of any kind, express or implied, is included with this
+ * software; use at your own risk, responsibility for damages (if any) to
+ * anyone resulting from the use of this software rests entirely with the
+ * user.
+ *
+ * Send bug reports, bug fixes, enhancements, requests, flames, etc., and
+ * I'll try to keep a version up to date.  I can be reached as follows:
+ * Paul Vixie          <paul@vix.com>          uunet!decwrl!vixie!paul
+ */
+
+/*
+ * $Id: compat.h,v 1.8 1994/01/15 20:43:43 vixie Exp $
+ */
+
+#ifndef __P
+# ifdef __STDC__
+#  define __P(x) x
+# else
+#  define __P(x) ()
+#  define const
+# endif
+#endif
+
+#if defined(UNIXPC) || defined(unixpc)
+# define UNIXPC 1
+# define ATT 1
+#endif
+
+#if defined(hpux) || defined(_hpux) || defined(__hpux)
+# define HPUX 1
+# define seteuid(e) setresuid(-1,e,-1)
+# define setreuid(r,e)	setresuid(r,e,-1)
+#endif
+
+#if defined(_IBMR2)
+# define AIX 1
+#endif
+
+#if defined(__convex__)
+# define CONVEX 1
+#endif
+
+#if defined(sgi) || defined(_sgi) || defined(__sgi)
+# define IRIX 1
+/* IRIX 4 hdrs are broken: one cannot #include both <stdio.h>
+ * and <stdlib.h> because they disagree on system(), perror().
+ * Therefore we must zap the "const" keyword BEFORE including
+ * either of them.
+ */
+# define const
+#endif
+
+#if defined(_UNICOS)
+# define UNICOS 1
+#endif
+
+#ifndef POSIX
+# if (BSD >= 199103) || defined(__linux) || defined(ultrix) || defined(AIX) ||\
+	defined(HPUX) || defined(CONVEX) || defined(IRIX)
+#  define POSIX
+# endif
+#endif
+
+#ifndef BSD
+# if defined(ultrix)
+#  define BSD 198902
+# endif
+#endif
+
+/*****************************************************************/
+
+#if !defined(BSD) && !defined(HPUX) && !defined(CONVEX) && !defined(__linux)
+# define NEED_VFORK
+#endif
+
+#if (!defined(BSD) || (BSD < 198902)) && !defined(__linux) && \
+	!defined(IRIX) && !defined(NeXT) && !defined(HPUX)
+# define NEED_STRCASECMP
+#endif
+
+#if (!defined(BSD) || (BSD < 198911)) && !defined(__linux) &&\
+	!defined(IRIX) && !defined(UNICOS) && !defined(HPUX)
+# define NEED_STRDUP
+#endif
+
+#if (!defined(BSD) || (BSD < 198911)) && !defined(POSIX) && !defined(NeXT)
+# define NEED_STRERROR
+#endif
+
+#if defined(HPUX) || defined(AIX) || defined(UNIXPC)
+# define NEED_FLOCK
+#endif
+
+#ifndef POSIX
+# define NEED_SETSID
+#endif
+
+#if (defined(POSIX) && !defined(BSD)) && !defined(__linux)
+# define NEED_GETDTABLESIZE
+#endif
+
+#if (BSD >= 199103)
+# define HAVE_SAVED_UIDS
+#endif
+
+#if !defined(ATT) && !defined(__linux) && !defined(IRIX) && !defined(UNICOS)
+# define USE_SIGCHLD
+#endif
+
+#if !defined(AIX) && !defined(UNICOS)
+# define SYS_TIME_H 1
+#else
+# define SYS_TIME_H 0
+#endif
+
+#if defined(BSD) && !defined(POSIX)
+# define USE_UTIMES
+#endif
+
+#if defined(AIX) || defined(HPUX) || defined(IRIX)
+# define NEED_SETENV
+#endif
+
+#if !defined(UNICOS) && !defined(UNIXPC)
+# define HAS_FCHOWN
+#endif
+
+#if !defined(UNICOS) && !defined(UNIXPC)
+# define HAS_FCHMOD
+#endif
diff --git a/usr.sbin/cron/cron/config.h b/usr.sbin/cron/cron/config.h
new file mode 100644
index 000000000000..7a8e2fc0eb08
--- /dev/null
+++ b/usr.sbin/cron/cron/config.h
@@ -0,0 +1,86 @@
+/* Copyright 1988,1990,1993,1994 by Paul Vixie
+ * All rights reserved
+ *
+ * Distribute freely, except: don't remove my name from the source or
+ * documentation (don't take credit for my work), mark your changes (don't
+ * get me blamed for your possible bugs), don't alter or remove this
+ * notice.  May be sold if buildable source is provided to buyer.  No
+ * warrantee of any kind, express or implied, is included with this
+ * software; use at your own risk, responsibility for damages (if any) to
+ * anyone resulting from the use of this software rests entirely with the
+ * user.
+ *
+ * Send bug reports, bug fixes, enhancements, requests, flames, etc., and
+ * I'll try to keep a version up to date.  I can be reached as follows:
+ * Paul Vixie          <paul@vix.com>          uunet!decwrl!vixie!paul
+ */
+
+/* config.h - configurables for Vixie Cron
+ *
+ * $Id: config.h,v 2.6 1994/01/15 20:43:43 vixie Exp $
+ */
+
+#if !defined(_PATH_SENDMAIL)
+# define _PATH_SENDMAIL "/usr/lib/sendmail"
+#endif /*SENDMAIL*/
+
+/*
+ * these are site-dependent
+ */
+
+#ifndef DEBUGGING
+#define DEBUGGING 1	/* 1 or 0 -- do you want debugging code built in? */
+#endif
+
+			/*
+			 * choose one of these MAILCMD commands.  I use
+			 * /bin/mail for speed; it makes biff bark but doesn't
+			 * do aliasing.  /usr/lib/sendmail does aliasing but is
+			 * a hog for short messages.  aliasing is not needed
+			 * if you make use of the MAILTO= feature in crontabs.
+			 * (hint: MAILTO= was added for this reason).
+			 */
+
+#define MAILCMD _PATH_SENDMAIL					/*-*/
+#define MAILARGS "%s -FCronDaemon -odi -oem -or0s %s"		/*-*/
+			/* -Fx	 = set full-name of sender
+			 * -odi	 = Option Deliverymode Interactive
+			 * -oem	 = Option Errors Mailedtosender
+			 * -or0s = Option Readtimeout -- don't time out
+			 */
+
+/* #define MAILCMD "/bin/mail"			/*-*/
+/* #define MAILARGS "%s -d  %s"			/*-*/
+			/* -d = undocumented but common flag: deliver locally?
+			 */
+
+/* #define MAILCMD "/usr/mmdf/bin/submit"	/*-*/
+/* #define MAILARGS "%s -mlrxto %s"		/*-*/
+
+/* #define MAIL_DATE				/*-*/
+			/* should we include an ersatz Date: header in
+			 * generated mail?  if you are using sendmail
+			 * for MAILCMD, it is better to let sendmail
+			 * generate the Date: header.
+			 */
+
+			/* if ALLOW_FILE and DENY_FILE are not defined or are
+			 * defined but neither exists, should crontab(1) be
+			 * usable only by root?
+			 */
+/*#define ALLOW_ONLY_ROOT			/*-*/
+
+			/* if you want to use syslog(3) instead of appending
+			 * to CRONDIR/LOG_FILE (/var/cron/log, e.g.), define
+			 * SYSLOG here.  Note that quite a bit of logging
+			 * info is written, and that you probably don't want
+			 * to use this on 4.2bsd since everything goes in
+			 * /usr/spool/mqueue/syslog.  On 4.[34]bsd you can
+			 * tell /etc/syslog.conf to send cron's logging to
+			 * a separate file.
+			 *
+			 * Note that if this and LOG_FILE in "pathnames.h"
+			 * are both defined, then logging will go to both
+			 * places.
+			 */
+#define SYSLOG	 			/*-*/
diff --git a/usr.sbin/cron/cron/cron.8 b/usr.sbin/cron/cron/cron.8
new file mode 100644
index 000000000000..1d6dcdad70f3
--- /dev/null
+++ b/usr.sbin/cron/cron/cron.8
@@ -0,0 +1,61 @@
+.\"/* Copyright 1988,1990,1993 by Paul Vixie
+.\" * All rights reserved
+.\" *
+.\" * Distribute freely, except: don't remove my name from the source or
+.\" * documentation (don't take credit for my work), mark your changes (don't
+.\" * get me blamed for your possible bugs), don't alter or remove this
+.\" * notice.  May be sold if buildable source is provided to buyer.  No
+.\" * warrantee of any kind, express or implied, is included with this
+.\" * software; use at your own risk, responsibility for damages (if any) to
+.\" * anyone resulting from the use of this software rests entirely with the
+.\" * user.
+.\" *
+.\" * Send bug reports, bug fixes, enhancements, requests, flames, etc., and
+.\" * I'll try to keep a version up to date.  I can be reached as follows:
+.\" * Paul Vixie          <paul@vix.com>          uunet!decwrl!vixie!paul
+.\" */
+.\" 
+.\" $Id: cron.8,v 2.2 1993/12/28 08:34:43 vixie Exp $
+.\" 
+.TH CRON 8 "20 December 1993"
+.UC 4
+.SH NAME
+cron \- daemon to execute scheduled commands (Vixie Cron)
+.SH SYNOPSIS
+cron
+.SH DESCRIPTION
+.I Cron
+should be started from /etc/rc or /etc/rc.local.  It will return immediately,
+so you don't need to start it with '&'.
+.PP
+.I Cron
+searches /var/cron/tabs for crontab files which are named after accounts in
+/etc/passwd; crontabs found are loaded into memory.
+.I Cron
+also searches for /etc/crontab which is in a different format (see
+.IR crontab(5)).
+.I Cron
+then wakes up every minute, examining all stored crontabs, checking each
+command to see if it should be run in the current minute.  When executing
+commands, any output is mailed to the owner of the crontab (or to the user
+named in the MAILTO environment variable in the crontab, if such exists).
+.PP
+Additionally,
+.I cron
+checks each minute to see if its spool directory's modtime (or the modtime
+on
+.IR /etc/crontab)
+has changed, and if it has,
+.I cron
+will then examine the modtime on all crontabs and reload those which have
+changed.  Thus
+.I cron
+need not be restarted whenever a crontab file is modified.  Note that the
+.IR Crontab (1)
+command updates the modtime of the spool directory whenever it changes a
+crontab.
+.SH "SEE ALSO"
+crontab(1), crontab(5)
+.SH AUTHOR
+.nf
+Paul Vixie <paul@vix.com>
diff --git a/usr.sbin/cron/cron/cron.c b/usr.sbin/cron/cron/cron.c
new file mode 100644
index 000000000000..624c37ac342d
--- /dev/null
+++ b/usr.sbin/cron/cron/cron.c
@@ -0,0 +1,301 @@
+/* Copyright 1988,1990,1993,1994 by Paul Vixie
+ * All rights reserved
+ *
+ * Distribute freely, except: don't remove my name from the source or
+ * documentation (don't take credit for my work), mark your changes (don't
+ * get me blamed for your possible bugs), don't alter or remove this
+ * notice.  May be sold if buildable source is provided to buyer.  No
+ * warrantee of any kind, express or implied, is included with this
+ * software; use at your own risk, responsibility for damages (if any) to
+ * anyone resulting from the use of this software rests entirely with the
+ * user.
+ *
+ * Send bug reports, bug fixes, enhancements, requests, flames, etc., and
+ * I'll try to keep a version up to date.  I can be reached as follows:
+ * Paul Vixie          <paul@vix.com>          uunet!decwrl!vixie!paul
+ */
+
+#if !defined(lint) && !defined(LINT)
+static char rcsid[] = "$Id: cron.c,v 2.11 1994/01/15 20:43:43 vixie Exp $";
+#endif
+
+
+#define	MAIN_PROGRAM
+
+
+#include "cron.h"
+#include <sys/signal.h>
+#if SYS_TIME_H
+# include <sys/time.h>
+#else
+# include <time.h>
+#endif
+
+
+static	void	usage __P((void)),
+		run_reboot_jobs __P((cron_db *)),
+		cron_tick __P((cron_db *)),
+		cron_sync __P((void)),
+		cron_sleep __P((void)),
+#ifdef USE_SIGCHLD
+		sigchld_handler __P((int)),
+#endif
+		sighup_handler __P((int)),
+		parse_args __P((int c, char *v[]));
+
+
+static void
+usage() {
+	fprintf(stderr, "usage:  %s [-x debugflag[,...]]\n", ProgramName);
+	exit(ERROR_EXIT);
+}
+
+
+int
+main(argc, argv)
+	int	argc;
+	char	*argv[];
+{
+	cron_db	database;
+
+	ProgramName = argv[0];
+
+#if defined(BSD)
+	setlinebuf(stdout);
+	setlinebuf(stderr);
+#endif
+
+	parse_args(argc, argv);
+
+#ifdef USE_SIGCHLD
+	(void) signal(SIGCHLD, sigchld_handler);
+#else
+	(void) signal(SIGCLD, SIG_IGN);
+#endif
+	(void) signal(SIGHUP, sighup_handler);
+
+	acquire_daemonlock(0);
+	set_cron_uid();
+	set_cron_cwd();
+
+#if defined(POSIX)
+	setenv("PATH", _PATH_DEFPATH, 1);
+#endif
+
+	/* if there are no debug flags turned on, fork as a daemon should.
+	 */
+# if DEBUGGING
+	if (DebugFlags) {
+# else
+	if (0) {
+# endif
+		(void) fprintf(stderr, "[%d] cron started\n", getpid());
+	} else {
+		switch (fork()) {
+		case -1:
+			log_it("CRON",getpid(),"DEATH","can't fork");
+			exit(0);
+			break;
+		case 0:
+			/* child process */
+			log_it("CRON",getpid(),"STARTUP","fork ok");
+			(void) setsid();
+			break;
+		default:
+			/* parent process should just die */
+			_exit(0);
+		}
+	}
+
+	acquire_daemonlock(0);
+	database.head = NULL;
+	database.tail = NULL;
+	database.mtime = (time_t) 0;
+	load_database(&database);
+	run_reboot_jobs(&database);
+	cron_sync();
+	while (TRUE) {
+# if DEBUGGING
+		if (!(DebugFlags & DTEST))
+# endif /*DEBUGGING*/
+			cron_sleep();
+
+		load_database(&database);
+
+		/* do this iteration
+		 */
+		cron_tick(&database);
+
+		/* sleep 1 minute
+		 */
+		TargetTime += 60;
+	}
+}
+
+
+static void
+run_reboot_jobs(db)
+	cron_db *db;
+{
+	register user		*u;
+	register entry		*e;
+
+	for (u = db->head;  u != NULL;  u = u->next) {
+		for (e = u->crontab;  e != NULL;  e = e->next) {
+			if (e->flags & WHEN_REBOOT) {
+				job_add(e, u);
+			}
+		}
+	}
+	(void) job_runqueue();
+}
+
+
+static void
+cron_tick(db)
+	cron_db	*db;
+{
+ 	register struct tm	*tm = localtime(&TargetTime);
+	register int		minute, hour, dom, month, dow;
+	register user		*u;
+	register entry		*e;
+
+	/* make 0-based values out of these so we can use them as indicies
+	 */
+	minute = tm->tm_min -FIRST_MINUTE;
+	hour = tm->tm_hour -FIRST_HOUR;
+	dom = tm->tm_mday -FIRST_DOM;
+	month = tm->tm_mon +1 /* 0..11 -> 1..12 */ -FIRST_MONTH;
+	dow = tm->tm_wday -FIRST_DOW;
+
+	Debug(DSCH, ("[%d] tick(%d,%d,%d,%d,%d)\n",
+		getpid(), minute, hour, dom, month, dow))
+
+	/* the dom/dow situation is odd.  '* * 1,15 * Sun' will run on the
+	 * first and fifteenth AND every Sunday;  '* * * * Sun' will run *only*
+	 * on Sundays;  '* * 1,15 * *' will run *only* the 1st and 15th.  this
+	 * is why we keep 'e->dow_star' and 'e->dom_star'.  yes, it's bizarre.
+	 * like many bizarre things, it's the standard.
+	 */
+	for (u = db->head;  u != NULL;  u = u->next) {
+		for (e = u->crontab;  e != NULL;  e = e->next) {
+			Debug(DSCH|DEXT, ("user [%s:%d:%d:...] cmd=\"%s\"\n",
+					  env_get("LOGNAME", e->envp),
+					  e->uid, e->gid, e->cmd))
+			if (bit_test(e->minute, minute)
+			 && bit_test(e->hour, hour)
+			 && bit_test(e->month, month)
+			 && ( ((e->flags & DOM_STAR) || (e->flags & DOW_STAR))
+			      ? (bit_test(e->dow,dow) && bit_test(e->dom,dom))
+			      : (bit_test(e->dow,dow) || bit_test(e->dom,dom))
+			    )
+			   ) {
+				job_add(e, u);
+			}
+		}
+	}
+}
+
+
+/* the task here is to figure out how long it's going to be until :00 of the
+ * following minute and initialize TargetTime to this value.  TargetTime
+ * will subsequently slide 60 seconds at a time, with correction applied
+ * implicitly in cron_sleep().  it would be nice to let cron execute in
+ * the "current minute" before going to sleep, but by restarting cron you
+ * could then get it to execute a given minute's jobs more than once.
+ * instead we have the chance of missing a minute's jobs completely, but
+ * that's something sysadmin's know to expect what with crashing computers..
+ */
+static void
+cron_sync() {
+ 	register struct tm	*tm;
+
+	TargetTime = time((time_t*)0);
+	tm = localtime(&TargetTime);
+	TargetTime += (60 - tm->tm_sec);
+}
+
+
+static void
+cron_sleep() {
+	register int	seconds_to_wait;
+
+	do {
+		seconds_to_wait = (int) (TargetTime - time((time_t*)0));
+		Debug(DSCH, ("[%d] TargetTime=%ld, sec-to-wait=%d\n",
+			getpid(), TargetTime, seconds_to_wait))
+
+		/* if we intend to sleep, this means that it's finally
+		 * time to empty the job queue (execute it).
+		 *
+		 * if we run any jobs, we'll probably screw up our timing,
+		 * so go recompute.
+		 *
+		 * note that we depend here on the left-to-right nature
+		 * of &&, and the short-circuiting.
+		 */
+	} while (seconds_to_wait > 0 && job_runqueue());
+
+	while (seconds_to_wait > 0) {
+		Debug(DSCH, ("[%d] sleeping for %d seconds\n",
+			getpid(), seconds_to_wait))
+		seconds_to_wait = (int) sleep((unsigned int) seconds_to_wait);
+	}
+}
+
+
+#ifdef USE_SIGCHLD
+static void
+sigchld_handler(x) {
+	WAIT_T		waiter;
+	PID_T		pid;
+
+	for (;;) {
+#ifdef POSIX
+		pid = waitpid(-1, &waiter, WNOHANG);
+#else
+		pid = wait3(&waiter, WNOHANG, (struct rusage *)0);
+#endif
+		switch (pid) {
+		case -1:
+			Debug(DPROC,
+				("[%d] sigchld...no children\n", getpid()))
+			return;
+		case 0:
+			Debug(DPROC,
+				("[%d] sigchld...no dead kids\n", getpid()))
+			return;
+		default:
+			Debug(DPROC,
+				("[%d] sigchld...pid #%d died, stat=%d\n",
+				getpid(), pid, WEXITSTATUS(waiter)))
+		}
+	}
+}
+#endif /*USE_SIGCHLD*/
+
+
+static void
+sighup_handler(x) {
+	log_close();
+}
+
+
+static void
+parse_args(argc, argv)
+	int	argc;
+	char	*argv[];
+{
+	int	argch;
+
+	while (EOF != (argch = getopt(argc, argv, "x:"))) {
+		switch (argch) {
+		default:
+			usage();
+		case 'x':
+			if (!set_debug_flags(optarg))
+				usage();
+			break;
+		}
+	}
+}
diff --git a/usr.sbin/cron/cron/cron.h b/usr.sbin/cron/cron/cron.h
new file mode 100644
index 000000000000..ebe45c7fb538
--- /dev/null
+++ b/usr.sbin/cron/cron/cron.h
@@ -0,0 +1,277 @@
+/* Copyright 1988,1990,1993,1994 by Paul Vixie
+ * All rights reserved
+ *
+ * Distribute freely, except: don't remove my name from the source or
+ * documentation (don't take credit for my work), mark your changes (don't
+ * get me blamed for your possible bugs), don't alter or remove this
+ * notice.  May be sold if buildable source is provided to buyer.  No
+ * warrantee of any kind, express or implied, is included with this
+ * software; use at your own risk, responsibility for damages (if any) to
+ * anyone resulting from the use of this software rests entirely with the
+ * user.
+ *
+ * Send bug reports, bug fixes, enhancements, requests, flames, etc., and
+ * I'll try to keep a version up to date.  I can be reached as follows:
+ * Paul Vixie          <paul@vix.com>          uunet!decwrl!vixie!paul
+ */
+
+/* cron.h - header for vixie's cron
+ *
+ * $Id: cron.h,v 2.10 1994/01/15 20:43:43 vixie Exp $
+ *
+ * vix 14nov88 [rest of log is in RCS]
+ * vix 14jan87 [0 or 7 can be sunday; thanks, mwm@berkeley]
+ * vix 30dec86 [written]
+ */
+
+/* reorder these #include's at your peril */
+
+#include <sys/types.h>
+#include <sys/param.h>
+#include "compat.h"
+
+#include <stdio.h>
+#include <ctype.h>
+#include <bitstring.h>
+#include <pwd.h>
+#include <sys/wait.h>
+
+#include "pathnames.h"
+#include "config.h"
+#include "externs.h"
+
+	/* these are really immutable, and are
+	 *   defined for symbolic convenience only
+	 * TRUE, FALSE, and ERR must be distinct
+	 * ERR must be < OK.
+	 */
+#define TRUE		1
+#define FALSE		0
+	/* system calls return this on success */
+#define OK		0
+	/*   or this on error */
+#define ERR		(-1)
+
+	/* turn this on to get '-x' code */
+#ifndef DEBUGGING
+#define DEBUGGING	FALSE
+#endif
+
+#define READ_PIPE	0	/* which end of a pipe pair do you read? */
+#define WRITE_PIPE	1	/*   or write to? */
+#define STDIN		0	/* what is stdin's file descriptor? */
+#define STDOUT		1	/*   stdout's? */
+#define STDERR		2	/*   stderr's? */
+#define ERROR_EXIT	1	/* exit() with this will scare the shell */
+#define	OK_EXIT		0	/* exit() with this is considered 'normal' */
+#define	MAX_FNAME	100	/* max length of internally generated fn */
+#define	MAX_COMMAND	1000	/* max length of internally generated cmd */
+#define	MAX_ENVSTR	1000	/* max length of envvar=value\0 strings */
+#define	MAX_TEMPSTR	100	/* obvious */
+#define	MAX_UNAME	20	/* max length of username, should be overkill */
+#define	ROOT_UID	0	/* don't change this, it really must be root */
+#define	ROOT_USER	"root"	/* ditto */
+
+				/* NOTE: these correspond to DebugFlagNames,
+				 *	defined below.
+				 */
+#define	DEXT		0x0001	/* extend flag for other debug masks */
+#define	DSCH		0x0002	/* scheduling debug mask */
+#define	DPROC		0x0004	/* process control debug mask */
+#define	DPARS		0x0008	/* parsing debug mask */
+#define	DLOAD		0x0010	/* database loading debug mask */
+#define	DMISC		0x0020	/* misc debug mask */
+#define	DTEST		0x0040	/* test mode: don't execute any commands */
+#define	DBIT		0x0080	/* bit twiddling shown (long) */
+
+#define	CRON_TAB(u)	"%s/%s", SPOOL_DIR, u
+#define	REG		register
+#define	PPC_NULL	((char **)NULL)
+
+#ifndef MAXHOSTNAMELEN
+#define MAXHOSTNAMELEN 64
+#endif
+
+#define	Skip_Blanks(c, f) \
+			while (c == '\t' || c == ' ') \
+				c = get_char(f);
+
+#define	Skip_Nonblanks(c, f) \
+			while (c!='\t' && c!=' ' && c!='\n' && c != EOF) \
+				c = get_char(f);
+
+#define	Skip_Line(c, f) \
+			do {c = get_char(f);} while (c != '\n' && c != EOF);
+
+#if DEBUGGING
+# define Debug(mask, message) \
+			if ( (DebugFlags & (mask) ) == (mask) ) \
+				printf message;
+#else /* !DEBUGGING */
+# define Debug(mask, message) \
+			;
+#endif /* DEBUGGING */
+
+#define	MkLower(ch)	(isupper(ch) ? tolower(ch) : ch)
+#define	MkUpper(ch)	(islower(ch) ? toupper(ch) : ch)
+#define	Set_LineNum(ln)	{Debug(DPARS|DEXT,("linenum=%d\n",ln)); \
+			 LineNumber = ln; \
+			}
+
+#define	FIRST_MINUTE	0
+#define	LAST_MINUTE	59
+#define	MINUTE_COUNT	(LAST_MINUTE - FIRST_MINUTE + 1)
+
+#define	FIRST_HOUR	0
+#define	LAST_HOUR	23
+#define	HOUR_COUNT	(LAST_HOUR - FIRST_HOUR + 1)
+
+#define	FIRST_DOM	1
+#define	LAST_DOM	31
+#define	DOM_COUNT	(LAST_DOM - FIRST_DOM + 1)
+
+#define	FIRST_MONTH	1
+#define	LAST_MONTH	12
+#define	MONTH_COUNT	(LAST_MONTH - FIRST_MONTH + 1)
+
+/* note on DOW: 0 and 7 are both Sunday, for compatibility reasons. */
+#define	FIRST_DOW	0
+#define	LAST_DOW	7
+#define	DOW_COUNT	(LAST_DOW - FIRST_DOW + 1)
+
+			/* each user's crontab will be held as a list of
+			 * the following structure.
+			 *
+			 * These are the cron commands.
+			 */
+
+typedef	struct _entry {
+	struct _entry	*next;
+	uid_t		uid;	
+	gid_t		gid;
+	char		**envp;
+	char		*cmd;
+	bitstr_t	bit_decl(minute, MINUTE_COUNT);
+	bitstr_t	bit_decl(hour,   HOUR_COUNT);
+	bitstr_t	bit_decl(dom,    DOM_COUNT);
+	bitstr_t	bit_decl(month,  MONTH_COUNT);
+	bitstr_t	bit_decl(dow,    DOW_COUNT);
+	int		flags;
+#define	DOM_STAR	0x01
+#define	DOW_STAR	0x02
+#define	WHEN_REBOOT	0x04
+} entry;
+
+			/* the crontab database will be a list of the
+			 * following structure, one element per user
+			 * plus one for the system.
+			 *
+			 * These are the crontabs.
+			 */
+
+typedef	struct _user {
+	struct _user	*next, *prev;	/* links */
+	char		*name;
+	time_t		mtime;		/* last modtime of crontab */
+	entry		*crontab;	/* this person's crontab */
+} user;
+
+typedef	struct _cron_db {
+	user		*head, *tail;	/* links */
+	time_t		mtime;		/* last modtime on spooldir */
+} cron_db;
+
+
+void		set_cron_uid __P((void)),
+		set_cron_cwd __P((void)),
+		load_database __P((cron_db *)),
+		open_logfile __P((void)),
+		sigpipe_func __P((void)),
+		job_add __P((entry *, user *)),
+		do_command __P((entry *, user *)),
+		link_user __P((cron_db *, user *)),
+		unlink_user __P((cron_db *, user *)),
+		free_user __P((user *)),
+		env_free __P((char **)),
+		unget_char __P((int, FILE *)),
+		free_entry __P((entry *)),
+		acquire_daemonlock __P((int)),
+		skip_comments __P((FILE *)),
+		log_it __P((char *, int, char *, char *)),
+		log_close __P((void));
+
+int		job_runqueue __P((void)),
+		set_debug_flags __P((char *)),
+		get_char __P((FILE *)),
+		get_string __P((char *, int, FILE *, char *)),
+		swap_uids __P((void)),
+		load_env __P((char *, FILE *)),
+		cron_pclose __P((FILE *)),
+		strcmp_until __P((char *, char *, int)),
+		allowed __P((char *)),
+		strdtb __P((char *));
+
+char		*env_get __P((char *, char **)),
+		*arpadate __P((time_t *)),
+		*mkprints __P((unsigned char *, unsigned int)),
+		*first_word __P((char *, char *)),
+		**env_init __P((void)),
+		**env_copy __P((char **)),
+		**env_set __P((char **, char *));
+
+user		*load_user __P((int, struct passwd *, char *)),
+		*find_user __P((cron_db *, char *));
+
+entry		*load_entry __P((FILE *, void (*)(),
+				 struct passwd *, char **));
+
+FILE		*cron_popen __P((char *, char *));
+
+
+				/* in the C tradition, we only create
+				 * variables for the main program, just
+				 * extern them elsewhere.
+				 */
+
+#ifdef MAIN_PROGRAM
+# if !defined(LINT) && !defined(lint)
+char	*copyright[] = {
+		"@(#) Copyright 1988,1989,1990,1993,1994 by Paul Vixie",
+		"@(#) All rights reserved"
+	};
+# endif
+
+char	*MonthNames[] = {
+		"Jan", "Feb", "Mar", "Apr", "May", "Jun",
+		"Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
+		NULL
+	};
+
+char	*DowNames[] = {
+		"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun",
+		NULL
+	};
+
+char	*ProgramName;
+int	LineNumber;
+time_t	TargetTime;
+
+# if DEBUGGING
+int	DebugFlags;
+char	*DebugFlagNames[] = {	/* sync with #defines */
+		"ext", "sch", "proc", "pars", "load", "misc", "test", "bit",
+		NULL		/* NULL must be last element */
+	};
+# endif /* DEBUGGING */
+#else /*MAIN_PROGRAM*/
+extern	char	*copyright[],
+		*MonthNames[],
+		*DowNames[],
+		*ProgramName;
+extern	int	LineNumber;
+extern	time_t	TargetTime;
+# if DEBUGGING
+extern	int	DebugFlags;
+extern	char	*DebugFlagNames[];
+# endif /* DEBUGGING */
+#endif /*MAIN_PROGRAM*/
diff --git a/usr.sbin/cron/cron/database.c b/usr.sbin/cron/cron/database.c
new file mode 100644
index 000000000000..843401e3f76f
--- /dev/null
+++ b/usr.sbin/cron/cron/database.c
@@ -0,0 +1,261 @@
+/* Copyright 1988,1990,1993,1994 by Paul Vixie
+ * All rights reserved
+ *
+ * Distribute freely, except: don't remove my name from the source or
+ * documentation (don't take credit for my work), mark your changes (don't
+ * get me blamed for your possible bugs), don't alter or remove this
+ * notice.  May be sold if buildable source is provided to buyer.  No
+ * warrantee of any kind, express or implied, is included with this
+ * software; use at your own risk, responsibility for damages (if any) to
+ * anyone resulting from the use of this software rests entirely with the
+ * user.
+ *
+ * Send bug reports, bug fixes, enhancements, requests, flames, etc., and
+ * I'll try to keep a version up to date.  I can be reached as follows:
+ * Paul Vixie          <paul@vix.com>          uunet!decwrl!vixie!paul
+ */
+
+#if !defined(lint) && !defined(LINT)
+static char rcsid[] = "$Id: database.c,v 2.8 1994/01/15 20:43:43 vixie Exp $";
+#endif
+
+/* vix 26jan87 [RCS has the log]
+ */
+
+
+#include "cron.h"
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/file.h>
+
+
+#define TMAX(a,b) ((a)>(b)?(a):(b))
+
+
+static	void		process_crontab __P((char *, char *, char *,
+					     struct stat *,
+					     cron_db *, cron_db *));
+
+
+void
+load_database(old_db)
+	cron_db		*old_db;
+{
+	DIR		*dir;
+	struct stat	statbuf;
+	struct stat	syscron_stat;
+	DIR_T   	*dp;
+	cron_db		new_db;
+	user		*u, *nu;
+
+	Debug(DLOAD, ("[%d] load_database()\n", getpid()))
+
+	/* before we start loading any data, do a stat on SPOOL_DIR
+	 * so that if anything changes as of this moment (i.e., before we've
+	 * cached any of the database), we'll see the changes next time.
+	 */
+	if (stat(SPOOL_DIR, &statbuf) < OK) {
+		log_it("CRON", getpid(), "STAT FAILED", SPOOL_DIR);
+		(void) exit(ERROR_EXIT);
+	}
+
+	/* track system crontab file
+	 */
+	if (stat(SYSCRONTAB, &syscron_stat) < OK)
+		syscron_stat.st_mtime = 0;
+
+	/* if spooldir's mtime has not changed, we don't need to fiddle with
+	 * the database.
+	 *
+	 * Note that old_db->mtime is initialized to 0 in main(), and
+	 * so is guaranteed to be different than the stat() mtime the first
+	 * time this function is called.
+	 */
+	if (old_db->mtime == TMAX(statbuf.st_mtime, syscron_stat.st_mtime)) {
+		Debug(DLOAD, ("[%d] spool dir mtime unch, no load needed.\n",
+			      getpid()))
+		return;
+	}
+
+	/* something's different.  make a new database, moving unchanged
+	 * elements from the old database, reloading elements that have
+	 * actually changed.  Whatever is left in the old database when
+	 * we're done is chaff -- crontabs that disappeared.
+	 */
+	new_db.mtime = TMAX(statbuf.st_mtime, syscron_stat.st_mtime);
+	new_db.head = new_db.tail = NULL;
+
+	if (syscron_stat.st_mtime) {
+		process_crontab("root", "*system*",
+				SYSCRONTAB, &syscron_stat,
+				&new_db, old_db);
+	}
+
+	/* we used to keep this dir open all the time, for the sake of
+	 * efficiency.  however, we need to close it in every fork, and
+	 * we fork a lot more often than the mtime of the dir changes.
+	 */
+	if (!(dir = opendir(SPOOL_DIR))) {
+		log_it("CRON", getpid(), "OPENDIR FAILED", SPOOL_DIR);
+		(void) exit(ERROR_EXIT);
+	}
+
+	while (NULL != (dp = readdir(dir))) {
+		char	fname[MAXNAMLEN+1],
+			tabname[MAXNAMLEN+1];
+
+		/* avoid file names beginning with ".".  this is good
+		 * because we would otherwise waste two guaranteed calls
+		 * to getpwnam() for . and .., and also because user names
+		 * starting with a period are just too nasty to consider.
+		 */
+		if (dp->d_name[0] == '.')
+			continue;
+
+		(void) strcpy(fname, dp->d_name);
+		sprintf(tabname, CRON_TAB(fname));
+
+		process_crontab(fname, fname, tabname,
+				&statbuf, &new_db, old_db);
+	}
+	closedir(dir);
+
+	/* if we don't do this, then when our children eventually call
+	 * getpwnam() in do_command.c's child_process to verify MAILTO=,
+	 * they will screw us up (and v-v).
+	 */
+	endpwent();
+
+	/* whatever's left in the old database is now junk.
+	 */
+	Debug(DLOAD, ("unlinking old database:\n"))
+	for (u = old_db->head;  u != NULL;  u = nu) {
+		Debug(DLOAD, ("\t%s\n", u->name))
+		nu = u->next;
+		unlink_user(old_db, u);
+		free_user(u);
+	}
+
+	/* overwrite the database control block with the new one.
+	 */
+	*old_db = new_db;
+	Debug(DLOAD, ("load_database is done\n"))
+}
+
+
+void
+link_user(db, u)
+	cron_db	*db;
+	user	*u;
+{
+	if (db->head == NULL)
+		db->head = u;
+	if (db->tail)
+		db->tail->next = u;
+	u->prev = db->tail;
+	u->next = NULL;
+	db->tail = u;
+}
+
+
+void
+unlink_user(db, u)
+	cron_db	*db;
+	user	*u;
+{
+	if (u->prev == NULL)
+		db->head = u->next;
+	else
+		u->prev->next = u->next;
+
+	if (u->next == NULL)
+		db->tail = u->prev;
+	else
+		u->next->prev = u->prev;
+}
+
+
+user *
+find_user(db, name)
+	cron_db	*db;
+	char	*name;
+{
+	char	*env_get();
+	user	*u;
+
+	for (u = db->head;  u != NULL;  u = u->next)
+		if (!strcmp(u->name, name))
+			break;
+	return u;
+}
+
+
+static void
+process_crontab(uname, fname, tabname, statbuf, new_db, old_db)
+	char		*uname;
+	char		*fname;
+	char		*tabname;
+	struct stat	*statbuf;
+	cron_db		*new_db;
+	cron_db		*old_db;
+{
+	struct passwd	*pw = NULL;
+	int		crontab_fd = OK - 1;
+	user		*u;
+
+	if (strcmp(fname, "*system*") && !(pw = getpwnam(uname))) {
+		/* file doesn't have a user in passwd file.
+		 */
+		log_it(fname, getpid(), "ORPHAN", "no passwd entry");
+		goto next_crontab;
+	}
+
+	if ((crontab_fd = open(tabname, O_RDONLY, 0)) < OK) {
+		/* crontab not accessible?
+		 */
+		log_it(fname, getpid(), "CAN'T OPEN", tabname);
+		goto next_crontab;
+	}
+
+	if (fstat(crontab_fd, statbuf) < OK) {
+		log_it(fname, getpid(), "FSTAT FAILED", tabname);
+		goto next_crontab;
+	}
+
+	Debug(DLOAD, ("\t%s:", fname))
+	u = find_user(old_db, fname);
+	if (u != NULL) {
+		/* if crontab has not changed since we last read it
+		 * in, then we can just use our existing entry.
+		 */
+		if (u->mtime == statbuf->st_mtime) {
+			Debug(DLOAD, (" [no change, using old data]"))
+			unlink_user(old_db, u);
+			link_user(new_db, u);
+			goto next_crontab;
+		}
+
+		/* before we fall through to the code that will reload
+		 * the user, let's deallocate and unlink the user in
+		 * the old database.  This is more a point of memory
+		 * efficiency than anything else, since all leftover
+		 * users will be deleted from the old database when
+		 * we finish with the crontab...
+		 */
+		Debug(DLOAD, (" [delete old data]"))
+		unlink_user(old_db, u);
+		free_user(u);
+		log_it(fname, getpid(), "RELOAD", tabname);
+	}
+	u = load_user(crontab_fd, pw, fname);
+	if (u != NULL) {
+		u->mtime = statbuf->st_mtime;
+		link_user(new_db, u);
+	}
+
+next_crontab:
+	if (crontab_fd >= OK) {
+		Debug(DLOAD, (" [done]\n"))
+		close(crontab_fd);
+	}
+}
diff --git a/usr.sbin/cron/cron/do_command.c b/usr.sbin/cron/cron/do_command.c
new file mode 100644
index 000000000000..4083c3215c02
--- /dev/null
+++ b/usr.sbin/cron/cron/do_command.c
@@ -0,0 +1,501 @@
+/* Copyright 1988,1990,1993,1994 by Paul Vixie
+ * All rights reserved
+ *
+ * Distribute freely, except: don't remove my name from the source or
+ * documentation (don't take credit for my work), mark your changes (don't
+ * get me blamed for your possible bugs), don't alter or remove this
+ * notice.  May be sold if buildable source is provided to buyer.  No
+ * warrantee of any kind, express or implied, is included with this
+ * software; use at your own risk, responsibility for damages (if any) to
+ * anyone resulting from the use of this software rests entirely with the
+ * user.
+ *
+ * Send bug reports, bug fixes, enhancements, requests, flames, etc., and
+ * I'll try to keep a version up to date.  I can be reached as follows:
+ * Paul Vixie          <paul@vix.com>          uunet!decwrl!vixie!paul
+ */
+
+#if !defined(lint) && !defined(LINT)
+static char rcsid[] = "$Id: do_command.c,v 2.12 1994/01/15 20:43:43 vixie Exp $";
+#endif
+
+
+#include "cron.h"
+#include <sys/signal.h>
+#if defined(sequent)
+# include <sys/universe.h>
+#endif
+#if defined(SYSLOG)
+# include <syslog.h>
+#endif
+
+
+static void		child_process __P((entry *, user *)),
+			do_univ __P((user *));
+
+
+void
+do_command(e, u)
+	entry	*e;
+	user	*u;
+{
+	Debug(DPROC, ("[%d] do_command(%s, (%s,%d,%d))\n",
+		getpid(), e->cmd, u->name, e->uid, e->gid))
+
+	/* fork to become asynchronous -- parent process is done immediately,
+	 * and continues to run the normal cron code, which means return to
+	 * tick().  the child and grandchild don't leave this function, alive.
+	 *
+	 * vfork() is unsuitable, since we have much to do, and the parent
+	 * needs to be able to run off and fork other processes.
+	 */
+	switch (fork()) {
+	case -1:
+		log_it("CRON",getpid(),"error","can't fork");
+		break;
+	case 0:
+		/* child process */
+		acquire_daemonlock(1);
+		child_process(e, u);
+		Debug(DPROC, ("[%d] child process done, exiting\n", getpid()))
+		_exit(OK_EXIT);
+		break;
+	default:
+		/* parent process */
+		break;
+	}
+	Debug(DPROC, ("[%d] main process returning to work\n", getpid()))
+}
+
+
+static void
+child_process(e, u)
+	entry	*e;
+	user	*u;
+{
+	int		stdin_pipe[2], stdout_pipe[2];
+	register char	*input_data;
+	char		*usernm, *mailto;
+	int		children = 0;
+
+	Debug(DPROC, ("[%d] child_process('%s')\n", getpid(), e->cmd))
+
+	/* mark ourselves as different to PS command watchers by upshifting
+	 * our program name.  This has no effect on some kernels.
+	 */
+	/*local*/{
+		register char	*pch;
+
+		for (pch = ProgramName;  *pch;  pch++)
+			*pch = MkUpper(*pch);
+	}
+
+	/* discover some useful and important environment settings
+	 */
+	usernm = env_get("LOGNAME", e->envp);
+	mailto = env_get("MAILTO", e->envp);
+
+#ifdef USE_SIGCHLD
+	/* our parent is watching for our death by catching SIGCHLD.  we
+	 * do not care to watch for our children's deaths this way -- we
+	 * use wait() explictly.  so we have to disable the signal (which
+	 * was inherited from the parent).
+	 */
+	(void) signal(SIGCHLD, SIG_IGN);
+#else
+	/* on system-V systems, we are ignoring SIGCLD.  we have to stop
+	 * ignoring it now or the wait() in cron_pclose() won't work.
+	 * because of this, we have to wait() for our children here, as well.
+	 */
+	(void) signal(SIGCLD, SIG_DFL);
+#endif /*BSD*/
+
+	/* create some pipes to talk to our future child
+	 */
+	pipe(stdin_pipe);	/* child's stdin */
+	pipe(stdout_pipe);	/* child's stdout */
+	
+	/* since we are a forked process, we can diddle the command string
+	 * we were passed -- nobody else is going to use it again, right?
+	 *
+	 * if a % is present in the command, previous characters are the
+	 * command, and subsequent characters are the additional input to
+	 * the command.  Subsequent %'s will be transformed into newlines,
+	 * but that happens later.
+	 */
+	/*local*/{
+		register int escaped = FALSE;
+		register int ch;
+
+		for (input_data = e->cmd;  ch = *input_data;  input_data++) {
+			if (escaped) {
+				escaped = FALSE;
+				continue;
+			}
+			if (ch == '\\') {
+				escaped = TRUE;
+				continue;
+			}
+			if (ch == '%') {
+				*input_data++ = '\0';
+				break;
+			}
+		}
+	}
+
+	/* fork again, this time so we can exec the user's command.
+	 */
+	switch (vfork()) {
+	case -1:
+		log_it("CRON",getpid(),"error","can't vfork");
+		exit(ERROR_EXIT);
+		/*NOTREACHED*/
+	case 0:
+		Debug(DPROC, ("[%d] grandchild process Vfork()'ed\n",
+			      getpid()))
+
+		/* write a log message.  we've waited this long to do it
+		 * because it was not until now that we knew the PID that
+		 * the actual user command shell was going to get and the
+		 * PID is part of the log message.
+		 */
+		/*local*/{
+			char *x = mkprints((u_char *)e->cmd, strlen(e->cmd));
+
+			log_it(usernm, getpid(), "CMD", x);
+			free(x);
+		}
+
+		/* that's the last thing we'll log.  close the log files.
+		 */
+#ifdef SYSLOG
+		closelog();
+#endif
+
+		/* get new pgrp, void tty, etc.
+		 */
+		(void) setsid();
+
+		/* close the pipe ends that we won't use.  this doesn't affect
+		 * the parent, who has to read and write them; it keeps the
+		 * kernel from recording us as a potential client TWICE --
+		 * which would keep it from sending SIGPIPE in otherwise
+		 * appropriate circumstances.
+		 */
+		close(stdin_pipe[WRITE_PIPE]);
+		close(stdout_pipe[READ_PIPE]);
+
+		/* grandchild process.  make std{in,out} be the ends of
+		 * pipes opened by our daddy; make stderr go to stdout.
+		 */
+		close(STDIN);	dup2(stdin_pipe[READ_PIPE], STDIN);
+		close(STDOUT);	dup2(stdout_pipe[WRITE_PIPE], STDOUT);
+		close(STDERR);	dup2(STDOUT, STDERR);
+
+		/* close the pipes we just dup'ed.  The resources will remain.
+		 */
+		close(stdin_pipe[READ_PIPE]);
+		close(stdout_pipe[WRITE_PIPE]);
+
+		/* set our login universe.  Do this in the grandchild
+		 * so that the child can invoke /usr/lib/sendmail
+		 * without surprises.
+		 */
+		do_univ(u);
+
+		/* set our directory, uid and gid.  Set gid first, since once
+		 * we set uid, we've lost root privledges.
+		 */
+		setgid(e->gid);
+# if defined(BSD)
+		initgroups(env_get("LOGNAME", e->envp), e->gid);
+# endif
+		setuid(e->uid);		/* we aren't root after this... */
+		chdir(env_get("HOME", e->envp));
+
+		/* exec the command.
+		 */
+		{
+			char	*shell = env_get("SHELL", e->envp);
+
+# if DEBUGGING
+			if (DebugFlags & DTEST) {
+				fprintf(stderr,
+				"debug DTEST is on, not exec'ing command.\n");
+				fprintf(stderr,
+				"\tcmd='%s' shell='%s'\n", e->cmd, shell);
+				_exit(OK_EXIT);
+			}
+# endif /*DEBUGGING*/
+			execle(shell, shell, "-c", e->cmd, (char *)0, e->envp);
+			fprintf(stderr, "execl: couldn't exec `%s'\n", shell);
+			perror("execl");
+			_exit(ERROR_EXIT);
+		}
+		break;
+	default:
+		/* parent process */
+		break;
+	}
+
+	children++;
+
+	/* middle process, child of original cron, parent of process running
+	 * the user's command.
+	 */
+
+	Debug(DPROC, ("[%d] child continues, closing pipes\n", getpid()))
+
+	/* close the ends of the pipe that will only be referenced in the
+	 * grandchild process...
+	 */
+	close(stdin_pipe[READ_PIPE]);
+	close(stdout_pipe[WRITE_PIPE]);
+
+	/*
+	 * write, to the pipe connected to child's stdin, any input specified
+	 * after a % in the crontab entry.  while we copy, convert any
+	 * additional %'s to newlines.  when done, if some characters were
+	 * written and the last one wasn't a newline, write a newline.
+	 *
+	 * Note that if the input data won't fit into one pipe buffer (2K
+	 * or 4K on most BSD systems), and the child doesn't read its stdin,
+	 * we would block here.  thus we must fork again.
+	 */
+
+	if (*input_data && fork() == 0) {
+		register FILE	*out = fdopen(stdin_pipe[WRITE_PIPE], "w");
+		register int	need_newline = FALSE;
+		register int	escaped = FALSE;
+		register int	ch;
+
+		Debug(DPROC, ("[%d] child2 sending data to grandchild\n", getpid()))
+
+		/* close the pipe we don't use, since we inherited it and
+		 * are part of its reference count now.
+		 */
+		close(stdout_pipe[READ_PIPE]);
+
+		/* translation:
+		 *	\% -> %
+		 *	%  -> \n
+		 *	\x -> \x	for all x != %
+		 */
+		while (ch = *input_data++) {
+			if (escaped) {
+				if (ch != '%')
+					putc('\\', out);
+			} else {
+				if (ch == '%')
+					ch = '\n';
+			}
+
+			if (!(escaped = (ch == '\\'))) {
+				putc(ch, out);
+				need_newline = (ch != '\n');
+			}
+		}
+		if (escaped)
+			putc('\\', out);
+		if (need_newline)
+			putc('\n', out);
+
+		/* close the pipe, causing an EOF condition.  fclose causes
+		 * stdin_pipe[WRITE_PIPE] to be closed, too.
+		 */
+		fclose(out);
+
+		Debug(DPROC, ("[%d] child2 done sending to grandchild\n", getpid()))
+		exit(0);
+	}
+
+	/* close the pipe to the grandkiddie's stdin, since its wicked uncle
+	 * ernie back there has it open and will close it when he's done.
+	 */
+	close(stdin_pipe[WRITE_PIPE]);
+
+	children++;
+
+	/*
+	 * read output from the grandchild.  it's stderr has been redirected to
+	 * it's stdout, which has been redirected to our pipe.  if there is any
+	 * output, we'll be mailing it to the user whose crontab this is...
+	 * when the grandchild exits, we'll get EOF.
+	 */
+
+	Debug(DPROC, ("[%d] child reading output from grandchild\n", getpid()))
+
+	/*local*/{
+		register FILE	*in = fdopen(stdout_pipe[READ_PIPE], "r");
+		register int	ch = getc(in);
+
+		if (ch != EOF) {
+			register FILE	*mail;
+			register int	bytes = 1;
+			int		status = 0;
+
+			Debug(DPROC|DEXT,
+				("[%d] got data (%x:%c) from grandchild\n",
+					getpid(), ch, ch))
+
+			/* get name of recipient.  this is MAILTO if set to a
+			 * valid local username; USER otherwise.
+			 */
+			if (mailto) {
+				/* MAILTO was present in the environment
+				 */
+				if (!*mailto) {
+					/* ... but it's empty. set to NULL
+					 */
+					mailto = NULL;
+				}
+			} else {
+				/* MAILTO not present, set to USER.
+				 */
+				mailto = usernm;
+			}
+		
+			/* if we are supposed to be mailing, MAILTO will
+			 * be non-NULL.  only in this case should we set
+			 * up the mail command and subjects and stuff...
+			 */
+
+			if (mailto) {
+				register char	**env;
+				auto char	mailcmd[MAX_COMMAND];
+				auto char	hostname[MAXHOSTNAMELEN];
+
+				(void) gethostname(hostname, MAXHOSTNAMELEN);
+				(void) sprintf(mailcmd, MAILARGS,
+					       MAILCMD, mailto);
+				if (!(mail = cron_popen(mailcmd, "w"))) {
+					perror(MAILCMD);
+					(void) _exit(ERROR_EXIT);
+				}
+				fprintf(mail, "From: root (Cron Daemon)\n");
+				fprintf(mail, "To: %s\n", mailto);
+				fprintf(mail, "Subject: Cron <%s@%s> %s\n",
+					usernm, first_word(hostname, "."),
+					e->cmd);
+# if defined(MAIL_DATE)
+				fprintf(mail, "Date: %s\n",
+					arpadate(&TargetTime));
+# endif /* MAIL_DATE */
+				for (env = e->envp;  *env;  env++)
+					fprintf(mail, "X-Cron-Env: <%s>\n",
+						*env);
+				fprintf(mail, "\n");
+
+				/* this was the first char from the pipe
+				 */
+				putc(ch, mail);
+			}
+
+			/* we have to read the input pipe no matter whether
+			 * we mail or not, but obviously we only write to
+			 * mail pipe if we ARE mailing.
+			 */
+
+			while (EOF != (ch = getc(in))) {
+				bytes++;
+				if (mailto)
+					putc(ch, mail);
+			}
+
+			/* only close pipe if we opened it -- i.e., we're
+			 * mailing...
+			 */
+
+			if (mailto) {
+				Debug(DPROC, ("[%d] closing pipe to mail\n",
+					getpid()))
+				/* Note: the pclose will probably see
+				 * the termination of the grandchild
+				 * in addition to the mail process, since
+				 * it (the grandchild) is likely to exit
+				 * after closing its stdout.
+				 */
+				status = cron_pclose(mail);
+			}
+
+			/* if there was output and we could not mail it,
+			 * log the facts so the poor user can figure out
+			 * what's going on.
+			 */
+			if (mailto && status) {
+				char buf[MAX_TEMPSTR];
+
+				sprintf(buf,
+			"mailed %d byte%s of output but got status 0x%04x\n",
+					bytes, (bytes==1)?"":"s",
+					status);
+				log_it(usernm, getpid(), "MAIL", buf);
+			}
+
+		} /*if data from grandchild*/
+
+		Debug(DPROC, ("[%d] got EOF from grandchild\n", getpid()))
+
+		fclose(in);	/* also closes stdout_pipe[READ_PIPE] */
+	}
+
+	/* wait for children to die.
+	 */
+	for (;  children > 0;  children--)
+	{
+		WAIT_T		waiter;
+		PID_T		pid;
+
+		Debug(DPROC, ("[%d] waiting for grandchild #%d to finish\n",
+			getpid(), children))
+		pid = wait(&waiter);
+		if (pid < OK) {
+			Debug(DPROC, ("[%d] no more grandchildren--mail written?\n",
+				getpid()))
+			break;
+		}
+		Debug(DPROC, ("[%d] grandchild #%d finished, status=%04x",
+			getpid(), pid, WEXITSTATUS(waiter)))
+		if (WIFSIGNALED(waiter) && WCOREDUMP(waiter))
+			Debug(DPROC, (", dumped core"))
+		Debug(DPROC, ("\n"))
+	}
+}
+
+
+static void
+do_univ(u)
+	user	*u;
+{
+#if defined(sequent)
+/* Dynix (Sequent) hack to put the user associated with
+ * the passed user structure into the ATT universe if
+ * necessary.  We have to dig the gecos info out of
+ * the user's password entry to see if the magic
+ * "universe(att)" string is present.
+ */
+
+	struct	passwd	*p;
+	char	*s;
+	int	i;
+
+	p = getpwuid(u->uid);
+	(void) endpwent();
+
+	if (p == NULL)
+		return;
+
+	s = p->pw_gecos;
+
+	for (i = 0; i < 4; i++)
+	{
+		if ((s = strchr(s, ',')) == NULL)
+			return;
+		s++;
+	}
+	if (strcmp(s, "universe(att)"))
+		return;
+
+	(void) universe(U_ATT);
+#endif
+}
diff --git a/usr.sbin/cron/cron/externs.h b/usr.sbin/cron/cron/externs.h
new file mode 100644
index 000000000000..3efe605897ec
--- /dev/null
+++ b/usr.sbin/cron/cron/externs.h
@@ -0,0 +1,145 @@
+/* Copyright 1993,1994 by Paul Vixie
+ * All rights reserved
+ *
+ * Distribute freely, except: don't remove my name from the source or
+ * documentation (don't take credit for my work), mark your changes (don't
+ * get me blamed for your possible bugs), don't alter or remove this
+ * notice.  May be sold if buildable source is provided to buyer.  No
+ * warrantee of any kind, express or implied, is included with this
+ * software; use at your own risk, responsibility for damages (if any) to
+ * anyone resulting from the use of this software rests entirely with the
+ * user.
+ *
+ * Send bug reports, bug fixes, enhancements, requests, flames, etc., and
+ * I'll try to keep a version up to date.  I can be reached as follows:
+ * Paul Vixie          <paul@vix.com>          uunet!decwrl!vixie!paul
+ */
+
+#if defined(POSIX) || defined(ATT)
+# include <stdlib.h>
+# include <unistd.h>
+# include <string.h>
+# include <dirent.h>
+# define DIR_T	struct dirent
+# define WAIT_T	int
+# define WAIT_IS_INT 1
+extern char *tzname[2];
+# define TZONE(tm) tzname[(tm).tm_isdst]
+#endif
+
+#if defined(UNIXPC)
+# undef WAIT_T
+# undef WAIT_IS_INT
+# define WAIT_T	union wait
+#endif
+
+#if defined(POSIX)
+# define SIG_T	sig_t
+# define TIME_T	time_t
+# define PID_T pid_t
+#endif
+
+#if defined(ATT)
+# define SIG_T	void
+# define TIME_T	long
+# define PID_T int
+#endif
+
+#if !defined(POSIX) && !defined(ATT)
+/* classic BSD */
+extern	time_t		time();
+extern	unsigned	sleep();
+extern	struct tm	*localtime();
+extern	struct passwd	*getpwnam();
+extern	int		errno;
+extern	void		perror(), exit(), free();
+extern	char		*getenv(), *strcpy(), *strchr(), *strtok();
+extern	void		*malloc(), *realloc();
+# define SIG_T	void
+# define TIME_T	long
+# define PID_T int
+# define WAIT_T	union wait
+# define DIR_T	struct direct
+# include <sys/dir.h>
+# define TZONE(tm) (tm).tm_zone
+#endif
+
+/* getopt() isn't part of POSIX.  some systems define it in <stdlib.h> anyway.
+ * of those that do, some complain that our definition is different and some
+ * do not.  to add to the misery and confusion, some systems define getopt()
+ * in ways that we cannot predict or comprehend, yet do not define the adjunct
+ * external variables needed for the interface.
+ */
+#if (!defined(BSD) || (BSD < 198911)) && !defined(ATT) && !defined(UNICOS)
+int	getopt __P((int, char * const *, const char *));
+#endif
+
+#if (!defined(BSD) || (BSD < 199103))
+extern	char *optarg;
+extern	int optind, opterr, optopt;
+#endif
+
+#if WAIT_IS_INT
+# ifndef WEXITSTATUS
+#  define WEXITSTATUS(x) (((x) >> 8) & 0xff)
+# endif
+# ifndef WTERMSIG
+#  define WTERMSIG(x)	((x) & 0x7f)
+# endif
+# ifndef WCOREDUMP
+#  define WCOREDUMP(x)	((x) & 0x80)
+# endif
+#else /*WAIT_IS_INT*/
+# ifndef WEXITSTATUS
+#  define WEXITSTATUS(x) ((x).w_retcode)
+# endif
+# ifndef WTERMSIG
+#  define WTERMSIG(x)	((x).w_termsig)
+# endif
+# ifndef WCOREDUMP
+#  define WCOREDUMP(x)	((x).w_coredump)
+# endif
+#endif /*WAIT_IS_INT*/
+
+#ifndef WIFSIGNALED
+#define WIFSIGNALED(x)	(WTERMSIG(x) != 0)
+#endif
+#ifndef WIFEXITED
+#define WIFEXITED(x)	(WTERMSIG(x) == 0)
+#endif
+
+#ifdef NEED_STRCASECMP
+extern	int		strcasecmp __P((char *, char *));
+#endif
+
+#ifdef NEED_STRDUP
+extern	char		*strdup __P((char *));
+#endif
+
+#ifdef NEED_STRERROR
+extern	char		*strerror __P((int));
+#endif
+
+#ifdef NEED_FLOCK
+extern	int		flock __P((int, int));
+# define LOCK_SH 1
+# define LOCK_EX 2
+# define LOCK_NB 4
+# define LOCK_UN 8
+#endif
+
+#ifdef NEED_SETSID
+extern	int		setsid __P((void));
+#endif
+
+#ifdef NEED_GETDTABLESIZE
+extern	int		getdtablesize __P((void));
+#endif
+
+#ifdef NEED_SETENV
+extern	int		setenv __P((char *, char *, int));
+#endif
+
+#ifdef NEED_VFORK
+extern	PID_T		vfork __P((void));
+#endif
diff --git a/usr.sbin/cron/cron/job.c b/usr.sbin/cron/cron/job.c
new file mode 100644
index 000000000000..adaa072fd48a
--- /dev/null
+++ b/usr.sbin/cron/cron/job.c
@@ -0,0 +1,74 @@
+/* Copyright 1988,1990,1993,1994 by Paul Vixie
+ * All rights reserved
+ *
+ * Distribute freely, except: don't remove my name from the source or
+ * documentation (don't take credit for my work), mark your changes (don't
+ * get me blamed for your possible bugs), don't alter or remove this
+ * notice.  May be sold if buildable source is provided to buyer.  No
+ * warrantee of any kind, express or implied, is included with this
+ * software; use at your own risk, responsibility for damages (if any) to
+ * anyone resulting from the use of this software rests entirely with the
+ * user.
+ *
+ * Send bug reports, bug fixes, enhancements, requests, flames, etc., and
+ * I'll try to keep a version up to date.  I can be reached as follows:
+ * Paul Vixie          <paul@vix.com>          uunet!decwrl!vixie!paul
+ */
+
+#if !defined(lint) && !defined(LINT)
+static char rcsid[] = "$Id: job.c,v 1.6 1994/01/15 20:43:43 vixie Exp $";
+#endif
+
+
+#include "cron.h"
+
+
+typedef	struct _job {
+	struct _job	*next;
+	entry		*e;
+	user		*u;
+} job;
+
+
+static job	*jhead = NULL, *jtail = NULL;
+
+
+void
+job_add(e, u)
+	register entry *e;
+	register user *u;
+{
+	register job *j;
+
+	/* if already on queue, keep going */
+	for (j=jhead; j; j=j->next)
+		if (j->e == e && j->u == u) { return; }
+
+	/* build a job queue element */
+	j = (job*)malloc(sizeof(job));
+	j->next = (job*) NULL;
+	j->e = e;
+	j->u = u;
+
+	/* add it to the tail */
+	if (!jhead) { jhead=j; }
+	else { jtail->next=j; }
+	jtail = j;
+}
+
+
+int
+job_runqueue()
+{
+	register job	*j, *jn;
+	register int	run = 0;
+
+	for (j=jhead; j; j=jn) {
+		do_command(j->e, j->u);
+		jn = j->next;
+		free(j);
+		run++;
+	}
+	jhead = jtail = NULL;
+	return run;
+}
diff --git a/usr.sbin/cron/cron/pathnames.h b/usr.sbin/cron/cron/pathnames.h
new file mode 100644
index 000000000000..df6bf1e85263
--- /dev/null
+++ b/usr.sbin/cron/cron/pathnames.h
@@ -0,0 +1,81 @@
+/* Copyright 1993,1994 by Paul Vixie
+ * All rights reserved
+ *
+ * Distribute freely, except: don't remove my name from the source or
+ * documentation (don't take credit for my work), mark your changes (don't
+ * get me blamed for your possible bugs), don't alter or remove this
+ * notice.  May be sold if buildable source is provided to buyer.  No
+ * warrantee of any kind, express or implied, is included with this
+ * software; use at your own risk, responsibility for damages (if any) to
+ * anyone resulting from the use of this software rests entirely with the
+ * user.
+ *
+ * Send bug reports, bug fixes, enhancements, requests, flames, etc., and
+ * I'll try to keep a version up to date.  I can be reached as follows:
+ * Paul Vixie          <paul@vix.com>          uunet!decwrl!vixie!paul
+ */
+
+/*
+ * $Id: pathnames.h,v 1.3 1994/01/15 20:43:43 vixie Exp $
+ */
+
+#if (defined(BSD)) && (BSD >= 199103) || defined(__linux) || defined(AIX)
+# include <paths.h>
+#endif /*BSD*/
+
+#ifndef CRONDIR
+			/* CRONDIR is where crond(8) and crontab(1) both chdir
+			 * to; SPOOL_DIR, ALLOW_FILE, DENY_FILE, and LOG_FILE
+			 * are all relative to this directory.
+			 */
+#define CRONDIR		"/var/cron"
+#endif
+
+			/* SPOOLDIR is where the crontabs live.
+			 * This directory will have its modtime updated
+			 * whenever crontab(1) changes a crontab; this is
+			 * the signal for crond(8) to look at each individual
+			 * crontab file and reload those whose modtimes are
+			 * newer than they were last time around (or which
+			 * didn't exist last time around...)
+			 */
+#define SPOOL_DIR	"tabs"
+
+			/* undefining these turns off their features.  note
+			 * that ALLOW_FILE and DENY_FILE must both be defined
+			 * in order to enable the allow/deny code.  If neither
+			 * LOG_FILE or SYSLOG is defined, we don't log.  If
+			 * both are defined, we log both ways.
+			 */
+#define	ALLOW_FILE	"allow"		/*-*/
+#define DENY_FILE	"deny"		/*-*/
+#define LOG_FILE	"log"		/*-*/
+
+			/* where should the daemon stick its PID?
+			 */
+#ifdef _PATH_VARRUN
+# define PIDDIR	_PATH_VARRUN
+#else
+# define PIDDIR "/etc/"
+#endif
+#define PIDFILE		"%scron.pid"
+
+			/* 4.3BSD-style crontab */
+#define SYSCRONTAB	"/etc/crontab"
+
+			/* what editor to use if no EDITOR or VISUAL
+			 * environment variable specified.
+			 */
+#if defined(_PATH_VI)
+# define EDITOR _PATH_VI
+#else
+# define EDITOR "/usr/ucb/vi"
+#endif
+
+#ifndef _PATH_BSHELL
+# define _PATH_BSHELL "/bin/sh"
+#endif
+
+#ifndef _PATH_DEFPATH
+# define _PATH_DEFPATH "/usr/bin:/bin"
+#endif
diff --git a/usr.sbin/cron/cron/popen.c b/usr.sbin/cron/cron/popen.c
new file mode 100644
index 000000000000..55708bb2400e
--- /dev/null
+++ b/usr.sbin/cron/cron/popen.c
@@ -0,0 +1,166 @@
+/*
+ * Copyright (c) 1988 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * This code is derived from software written by Ken Arnold and
+ * published in UNIX Review, Vol. 6, No. 8.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ */
+
+/* this came out of the ftpd sources; it's been modified to avoid the
+ * globbing stuff since we don't need it.  also execvp instead of execv.
+ */
+
+#ifndef lint
+static char rcsid[] = "$Id: popen.c,v 1.5 1994/01/15 20:43:43 vixie Exp $";
+static char sccsid[] = "@(#)popen.c	5.7 (Berkeley) 2/14/89";
+#endif /* not lint */
+
+#include "cron.h"
+#include <sys/signal.h>
+
+
+#define WANT_GLOBBING 0
+
+/*
+ * Special version of popen which avoids call to shell.  This insures noone
+ * may create a pipe to a hidden program as a side effect of a list or dir
+ * command.
+ */
+static PID_T *pids;
+static int fds;
+
+FILE *
+cron_popen(program, type)
+	char *program, *type;
+{
+	register char *cp;
+	FILE *iop;
+	int argc, pdes[2];
+	PID_T pid;
+	char *argv[100];
+#if WANT_GLOBBING
+	char **pop, *vv[2];
+	int gargc;
+	char *gargv[1000];
+	extern char **glob(), **copyblk();
+#endif
+
+	if (*type != 'r' && *type != 'w' || type[1])
+		return(NULL);
+
+	if (!pids) {
+		if ((fds = getdtablesize()) <= 0)
+			return(NULL);
+		if (!(pids = (PID_T *)malloc((u_int)(fds * sizeof(PID_T)))))
+			return(NULL);
+		bzero((char *)pids, fds * sizeof(PID_T));
+	}
+	if (pipe(pdes) < 0)
+		return(NULL);
+
+	/* break up string into pieces */
+	for (argc = 0, cp = program;; cp = NULL)
+		if (!(argv[argc++] = strtok(cp, " \t\n")))
+			break;
+
+#if WANT_GLOBBING
+	/* glob each piece */
+	gargv[0] = argv[0];
+	for (gargc = argc = 1; argv[argc]; argc++) {
+		if (!(pop = glob(argv[argc]))) {	/* globbing failed */
+			vv[0] = argv[argc];
+			vv[1] = NULL;
+			pop = copyblk(vv);
+		}
+		argv[argc] = (char *)pop;		/* save to free later */
+		while (*pop && gargc < 1000)
+			gargv[gargc++] = *pop++;
+	}
+	gargv[gargc] = NULL;
+#endif
+
+	iop = NULL;
+	switch(pid = vfork()) {
+	case -1:			/* error */
+		(void)close(pdes[0]);
+		(void)close(pdes[1]);
+		goto pfree;
+		/* NOTREACHED */
+	case 0:				/* child */
+		if (*type == 'r') {
+			if (pdes[1] != 1) {
+				dup2(pdes[1], 1);
+				dup2(pdes[1], 2);	/* stderr, too! */
+				(void)close(pdes[1]);
+			}
+			(void)close(pdes[0]);
+		} else {
+			if (pdes[0] != 0) {
+				dup2(pdes[0], 0);
+				(void)close(pdes[0]);
+			}
+			(void)close(pdes[1]);
+		}
+#if WANT_GLOBBING
+		execvp(gargv[0], gargv);
+#else
+		execvp(argv[0], argv);
+#endif
+		_exit(1);
+	}
+	/* parent; assume fdopen can't fail...  */
+	if (*type == 'r') {
+		iop = fdopen(pdes[0], type);
+		(void)close(pdes[1]);
+	} else {
+		iop = fdopen(pdes[1], type);
+		(void)close(pdes[0]);
+	}
+	pids[fileno(iop)] = pid;
+
+pfree:
+#if WANT_GLOBBING
+	for (argc = 1; argv[argc] != NULL; argc++) {
+/*		blkfree((char **)argv[argc]);	*/
+		free((char *)argv[argc]);
+	}
+#endif
+	return(iop);
+}
+
+int
+cron_pclose(iop)
+	FILE *iop;
+{
+	register int fdes;
+	int omask;
+	WAIT_T stat_loc;
+	PID_T pid;
+
+	/*
+	 * pclose returns -1 if stream is not associated with a
+	 * `popened' command, or, if already `pclosed'.
+	 */
+	if (pids == 0 || pids[fdes = fileno(iop)] == 0)
+		return(-1);
+	(void)fclose(iop);
+	omask = sigblock(sigmask(SIGINT)|sigmask(SIGQUIT)|sigmask(SIGHUP));
+	while ((pid = wait(&stat_loc)) != pids[fdes] && pid != -1)
+		;
+	(void)sigsetmask(omask);
+	pids[fdes] = 0;
+	return (pid == -1 ? -1 : WEXITSTATUS(stat_loc));
+}
diff --git a/usr.sbin/cron/cron/putman.sh b/usr.sbin/cron/cron/putman.sh
new file mode 100644
index 000000000000..4aef625c6174
--- /dev/null
+++ b/usr.sbin/cron/cron/putman.sh
@@ -0,0 +1,23 @@
+#!/bin/sh
+
+# putman.sh - install a man page according to local custom
+# vixie 27dec93 [original]
+#
+# $Id:$
+
+PAGE=$1
+DIR=$2
+
+SECT=`expr $PAGE : '[a-z]*.\([0-9]\)'`
+
+[ -d $DIR/man$SECT ] && {
+	set -x
+	cp $PAGE $DIR/man$SECT/$PAGE
+	set +x
+} || {
+	set -x
+	nroff -man $PAGE >$DIR/cat$SECT/`basename $PAGE .$SECT`.0
+	set +x
+}
+
+exit 0
diff --git a/usr.sbin/cron/cron/user.c b/usr.sbin/cron/cron/user.c
new file mode 100644
index 000000000000..9672dd5d7817
--- /dev/null
+++ b/usr.sbin/cron/cron/user.c
@@ -0,0 +1,102 @@
+/* Copyright 1988,1990,1993,1994 by Paul Vixie
+ * All rights reserved
+ *
+ * Distribute freely, except: don't remove my name from the source or
+ * documentation (don't take credit for my work), mark your changes (don't
+ * get me blamed for your possible bugs), don't alter or remove this
+ * notice.  May be sold if buildable source is provided to buyer.  No
+ * warrantee of any kind, express or implied, is included with this
+ * software; use at your own risk, responsibility for damages (if any) to
+ * anyone resulting from the use of this software rests entirely with the
+ * user.
+ *
+ * Send bug reports, bug fixes, enhancements, requests, flames, etc., and
+ * I'll try to keep a version up to date.  I can be reached as follows:
+ * Paul Vixie          <paul@vix.com>          uunet!decwrl!vixie!paul
+ */
+
+#if !defined(lint) && !defined(LINT)
+static char rcsid[] = "$Id: user.c,v 2.8 1994/01/15 20:43:43 vixie Exp $";
+#endif
+
+/* vix 26jan87 [log is in RCS file]
+ */
+
+
+#include "cron.h"
+
+
+void
+free_user(u)
+	user	*u;
+{
+	entry	*e, *ne;
+
+	free(u->name);
+	for (e = u->crontab;  e != NULL;  e = ne) {
+		ne = e->next;
+		free_entry(e);
+	}
+	free(u);
+}
+
+
+user *
+load_user(crontab_fd, pw, name)
+	int		crontab_fd;
+	struct passwd	*pw;		/* NULL implies syscrontab */
+	char		*name;
+{
+	char	envstr[MAX_ENVSTR];
+	FILE	*file;
+	user	*u;
+	entry	*e;
+	int	status;
+	char	**envp;
+
+	if (!(file = fdopen(crontab_fd, "r"))) {
+		perror("fdopen on crontab_fd in load_user");
+		return NULL;
+	}
+
+	Debug(DPARS, ("load_user()\n"))
+
+	/* file is open.  build user entry, then read the crontab file.
+	 */
+	u = (user *) malloc(sizeof(user));
+	u->name = strdup(name);
+	u->crontab = NULL;
+
+	/* 
+	 * init environment.  this will be copied/augmented for each entry.
+	 */
+	envp = env_init();
+
+	/*
+	 * load the crontab
+	 */
+	while ((status = load_env(envstr, file)) >= OK) {
+		switch (status) {
+		case ERR:
+			free_user(u);
+			u = NULL;
+			goto done;
+		case FALSE:
+			e = load_entry(file, NULL, pw, envp);
+			if (e) {
+				e->next = u->crontab;
+				u->crontab = e;
+			}
+			break;
+		case TRUE:
+			envp = env_set(envp, envstr);
+			break;
+		}
+	}
+
+ done:
+	env_free(envp);
+	fclose(file);
+	Debug(DPARS, ("...load_user() done\n"))
+	return u;
+}
diff --git a/usr.sbin/cron/crontab/Makefile b/usr.sbin/cron/crontab/Makefile
new file mode 100644
index 000000000000..33889690f4ed
--- /dev/null
+++ b/usr.sbin/cron/crontab/Makefile
@@ -0,0 +1,10 @@
+BINDIR?=	/usr/bin
+
+PROG=	crontab
+SRCS=	crontab.c 
+CFLAGS+= -I${.CURDIR}/../cron
+LDADD+=	-L${.CURDIR}/../lib -lcron
+MAN1=	crontab.1
+MAN5=	crontab.5
+
+.include <bsd.prog.mk>
diff --git a/usr.sbin/cron/crontab/crontab.1 b/usr.sbin/cron/crontab/crontab.1
new file mode 100644
index 000000000000..c3c39431f7ae
--- /dev/null
+++ b/usr.sbin/cron/crontab/crontab.1
@@ -0,0 +1,100 @@
+.\"/* Copyright 1988,1990,1993 by Paul Vixie
+.\" * All rights reserved
+.\" *
+.\" * Distribute freely, except: don't remove my name from the source or
+.\" * documentation (don't take credit for my work), mark your changes (don't
+.\" * get me blamed for your possible bugs), don't alter or remove this
+.\" * notice.  May be sold if buildable source is provided to buyer.  No
+.\" * warrantee of any kind, express or implied, is included with this
+.\" * software; use at your own risk, responsibility for damages (if any) to
+.\" * anyone resulting from the use of this software rests entirely with the
+.\" * user.
+.\" *
+.\" * Send bug reports, bug fixes, enhancements, requests, flames, etc., and
+.\" * I'll try to keep a version up to date.  I can be reached as follows:
+.\" * Paul Vixie          <paul@vix.com>          uunet!decwrl!vixie!paul
+.\" */
+.\"
+.\" $Id: crontab.1,v 2.4 1993/12/31 10:47:33 vixie Exp $
+.\"
+.TH CRONTAB 1 "29 December 1993"
+.UC 4
+.SH NAME
+crontab \- maintain crontab files for individual users (V3)
+.SH SYNOPSIS
+crontab [ -u user ] file
+.br
+crontab [ -u user ] { -l | -r | -e }
+.SH DESCRIPTION
+.I Crontab
+is the program used to install, deinstall or list the tables
+used to drive the
+.IR cron (8)
+daemon in Vixie Cron.  Each user can have their own crontab, and though
+these are files in /var, they are not intended to be edited directly.
+.PP
+If the
+.I allow
+file exists, then you must be listed therein in order to be allowed to use
+this command.  If the
+.I allow
+file does not exist but the
+.I deny
+file does exist, then you must \fBnot\fR be listed in the
+.I deny
+file in order to use this command.  If neither of these files exists, then
+depending on site-dependent configuration parameters, only the super user
+will be allowed to use this command, or all users will be able to use this
+command.
+.PP
+If the
+.I -u
+option is given, it specifies the name of the user whose crontab is to be
+tweaked.  If this option is not given,
+.I crontab
+examines "your" crontab, i.e., the crontab of the person executing the
+command.  Note that
+.IR su (8)
+can confuse
+.I crontab
+and that if you are running inside of
+.IR su (8)
+you should always use the
+.I -u
+option for safety's sake.
+.PP
+The first form of this command is used to install a new crontab from some
+named file or standard input if the pseudo-filename ``-'' is given.
+.PP
+The
+.I -l
+option causes the current crontab to be displayed on standard output.
+.PP
+The
+.I -r
+option causes the current crontab to be removed.
+.PP
+The
+.I -e
+option is used to edit the current crontab using the editor specified by
+the \s-1VISUAL\s+1 or \s-1EDITOR\s+1 environment variables.  After you exit
+from the editor, the modified crontab will be installed automatically.
+.SH "SEE ALSO"
+crontab(5), cron(8)
+.SH FILES
+.nf
+/var/cron/allow
+/var/cron/deny
+.fi
+.SH STANDARDS
+The
+.I crontab
+command conforms to IEEE Std1003.2-1992 (``POSIX'').  This new command syntax
+differs from previous versions of Vixie Cron, as well as from the classic
+SVR3 syntax.
+.SH DIAGNOSTICS
+A fairly informative usage message appears if you run it with a bad command
+line.
+.SH AUTHOR
+.nf
+Paul Vixie <paul@vix.com>
diff --git a/usr.sbin/cron/crontab/crontab.5 b/usr.sbin/cron/crontab/crontab.5
new file mode 100644
index 000000000000..01b52f03fb31
--- /dev/null
+++ b/usr.sbin/cron/crontab/crontab.5
@@ -0,0 +1,188 @@
+.\"/* Copyright 1988,1990,1993,1994 by Paul Vixie
+.\" * All rights reserved
+.\" *
+.\" * Distribute freely, except: don't remove my name from the source or
+.\" * documentation (don't take credit for my work), mark your changes (don't
+.\" * get me blamed for your possible bugs), don't alter or remove this
+.\" * notice.  May be sold if buildable source is provided to buyer.  No
+.\" * warrantee of any kind, express or implied, is included with this
+.\" * software; use at your own risk, responsibility for damages (if any) to
+.\" * anyone resulting from the use of this software rests entirely with the
+.\" * user.
+.\" *
+.\" * Send bug reports, bug fixes, enhancements, requests, flames, etc., and
+.\" * I'll try to keep a version up to date.  I can be reached as follows:
+.\" * Paul Vixie          <paul@vix.com>          uunet!decwrl!vixie!paul
+.\" */
+.\"
+.\" $Id: crontab.5,v 2.4 1994/01/15 20:43:43 vixie Exp $
+.\" 
+.TH CRONTAB 5 "24 January 1994"
+.UC 4
+.SH NAME
+crontab \- tables for driving cron
+.SH DESCRIPTION
+A
+.I crontab
+file contains instructions to the
+.IR cron (8)
+daemon of the general form: ``run this command at this time on this date''.
+Each user has their own crontab, and commands in any given crontab will be
+executed as the user who owns the crontab.  Uucp and News will usually have
+their own crontabs, eliminating the need for explicitly running
+.IR su (1)
+as part of a cron command.
+.PP
+Blank lines and leading spaces and tabs are ignored.  Lines whose first
+non-space character is a pound-sign (#) are comments, and are ignored.
+Note that comments are not allowed on the same line as cron commands, since
+they will be taken to be part of the command.  Similarly, comments are not
+allowed on the same line as environment variable settings.
+.PP
+An active line in a crontab will be either an environment setting or a cron
+command.  An environment setting is of the form,
+.PP
+    name = value
+.PP
+where the spaces around the equal-sign (=) are optional, and any subsequent
+non-leading spaces in
+.I value
+will be part of the value assigned to
+.IR name .
+The
+.I value
+string may be placed in quotes (single or double, but matching) to preserve
+leading or trailing blanks.
+.PP
+Several environment variables are set up
+automatically by the
+.IR cron (8)
+daemon.
+SHELL is set to /bin/sh, and LOGNAME and HOME are set from the /etc/passwd 
+line of the crontab's owner.
+HOME and SHELL may be overridden by settings in the crontab; LOGNAME may not.
+.PP
+(Another note: the LOGNAME variable is sometimes called USER on BSD systems...
+on these systems, USER will be set also.)
+.PP
+In addition to LOGNAME, HOME, and SHELL,
+.IR cron (8)
+will look at MAILTO if it has any reason to send mail as a result of running
+commands in ``this'' crontab.  If MAILTO is defined (and non-empty), mail is
+sent to the user so named.  If MAILTO is defined but empty (MAILTO=""), no
+mail will be sent.  Otherwise mail is sent to the owner of the crontab.  This
+option is useful if you decide on /bin/mail instead of /usr/lib/sendmail as
+your mailer when you install cron -- /bin/mail doesn't do aliasing, and UUCP
+usually doesn't read its mail.
+.PP
+The format of a cron command is very much the V7 standard, with a number of
+upward-compatible extensions.  Each line has five time and date fields,
+followed by a user name if this is the system crontab file,
+followed by a command.  Commands are executed by
+.IR cron (8)
+when the minute, hour, and month of year fields match the current time,
+.I and
+when at least one of the two day fields (day of month, or day of week)
+match the current time (see ``Note'' below).
+.IR cron (8)
+examines cron entries once every minute.
+The time and date fields are:
+.IP
+.ta 1.5i
+field	allowed values
+.br
+-----	--------------
+.br
+minute	0-59
+.br
+hour	0-23
+.br
+day of month	0-31
+.br
+month	0-12 (or names, see below)
+.br
+day of week	0-7 (0 or 7 is Sun, or use names)
+.br
+.PP
+A field may be an asterisk (*), which always stands for ``first\-last''.
+.PP
+Ranges of numbers are allowed.  Ranges are two numbers separated
+with a hyphen.  The specified range is inclusive.  For example,
+8-11 for an ``hours'' entry specifies execution at hours 8, 9, 10
+and 11.
+.PP
+Lists are allowed.  A list is a set of numbers (or ranges)
+separated by commas.  Examples: ``1,2,5,9'', ``0-4,8-12''.
+.PP
+Step values can be used in conjunction with ranges.  Following
+a range with ``/<number>'' specifies skips of the number's value
+through the range.  For example, ``0-23/2'' can be used in the hours
+field to specify command execution every other hour (the alternative
+in the V7 standard is ``0,2,4,6,8,10,12,14,16,18,20,22'').  Steps are
+also permitted after an asterisk, so if you want to say ``every two
+hours'', just use ``*/2''.
+.PP
+Names can also be used for the ``month'' and ``day of week''
+fields.  Use the first three letters of the particular
+day or month (case doesn't matter).  Ranges or
+lists of names are not allowed.
+.PP
+The ``sixth'' field (the rest of the line) specifies the command to be
+run.
+The entire command portion of the line, up to a newline or %
+character, will be executed by /bin/sh or by the shell
+specified in the SHELL variable of the cronfile.
+Percent-signs (%) in the command, unless escaped with backslash
+(\\), will be changed into newline characters, and all data
+after the first % will be sent to the command as standard
+input.
+.PP
+Note: The day of a command's execution can be specified by two
+fields \(em day of month, and day of week.  If both fields are
+restricted (ie, aren't *), the command will be run when
+.I either
+field matches the current time.  For example,
+.br
+``30 4 1,15 * 5''
+would cause a command to be run at 4:30 am on the 1st and 15th of each
+month, plus every Friday.
+.SH EXAMPLE CRON FILE
+.nf
+
+# use /bin/sh to run commands, no matter what /etc/passwd says
+SHELL=/bin/sh
+# mail any output to `paul', no matter whose crontab this is
+MAILTO=paul
+#
+# run five minutes after midnight, every day
+5 0 * * *       $HOME/bin/daily.job >> $HOME/tmp/out 2>&1
+# run at 2:15pm on the first of every month -- output mailed to paul
+15 14 1 * *     $HOME/bin/monthly
+# run at 10 pm on weekdays, annoy Joe
+0 22 * * 1-5	mail -s "It's 10pm" joe%Joe,%%Where are your kids?%
+23 0-23/2 * * * echo "run 23 minutes after midn, 2am, 4am ..., everyday"
+5 4 * * sun     echo "run at 5 after 4 every sunday"
+.fi
+.SH SEE ALSO
+cron(8), crontab(1)
+.SH EXTENSIONS
+When specifying day of week, both day 0 and day 7 will be considered Sunday.
+BSD and ATT seem to disagree about this.
+.PP
+Lists and ranges are allowed to co-exist in the same field.  "1-3,7-9" would
+be rejected by ATT or BSD cron -- they want to see "1-3" or "7,8,9" ONLY.
+.PP
+Ranges can include "steps", so "1-9/2" is the same as "1,3,5,7,9".
+.PP
+Names of months or days of the week can be specified by name.
+.PP
+Environment variables can be set in the crontab.  In BSD or ATT, the
+environment handed to child processes is basically the one from /etc/rc.
+.PP
+Command output is mailed to the crontab owner (BSD can't do this), can be
+mailed to a person other than the crontab owner (SysV can't do this), or the
+feature can be turned off and no mail will be sent at all (SysV can't do this
+either).
+.SH AUTHOR
+.nf
+Paul Vixie <paul@vix.com>
diff --git a/usr.sbin/cron/crontab/crontab.c b/usr.sbin/cron/crontab/crontab.c
new file mode 100644
index 000000000000..657af71d8d62
--- /dev/null
+++ b/usr.sbin/cron/crontab/crontab.c
@@ -0,0 +1,624 @@
+/* Copyright 1988,1990,1993,1994 by Paul Vixie
+ * All rights reserved
+ *
+ * Distribute freely, except: don't remove my name from the source or
+ * documentation (don't take credit for my work), mark your changes (don't
+ * get me blamed for your possible bugs), don't alter or remove this
+ * notice.  May be sold if buildable source is provided to buyer.  No
+ * warrantee of any kind, express or implied, is included with this
+ * software; use at your own risk, responsibility for damages (if any) to
+ * anyone resulting from the use of this software rests entirely with the
+ * user.
+ *
+ * Send bug reports, bug fixes, enhancements, requests, flames, etc., and
+ * I'll try to keep a version up to date.  I can be reached as follows:
+ * Paul Vixie          <paul@vix.com>          uunet!decwrl!vixie!paul
+ */
+
+#if !defined(lint) && !defined(LINT)
+static char rcsid[] = "$Id: crontab.c,v 2.13 1994/01/17 03:20:37 vixie Exp $";
+#endif
+
+/* crontab - install and manage per-user crontab files
+ * vix 02may87 [RCS has the rest of the log]
+ * vix 26jan87 [original]
+ */
+
+
+#define	MAIN_PROGRAM
+
+
+#include "cron.h"
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/file.h>
+#include <sys/stat.h>
+#ifdef USE_UTIMES
+# include <sys/time.h>
+#else
+# include <time.h>
+# include <utime.h>
+#endif
+#if defined(POSIX)
+# include <locale.h>
+#endif
+
+
+#define NHEADER_LINES 3
+
+
+enum opt_t	{ opt_unknown, opt_list, opt_delete, opt_edit, opt_replace };
+
+#if DEBUGGING
+static char	*Options[] = { "???", "list", "delete", "edit", "replace" };
+#endif
+
+
+static	PID_T		Pid;
+static	char		User[MAX_UNAME], RealUser[MAX_UNAME];
+static	char		Filename[MAX_FNAME];
+static	FILE		*NewCrontab;
+static	int		CheckErrorCount;
+static	enum opt_t	Option;
+static	struct passwd	*pw;
+static	void		list_cmd __P((void)),
+			delete_cmd __P((void)),
+			edit_cmd __P((void)),
+			poke_daemon __P((void)),
+			check_error __P((char *)),
+			parse_args __P((int c, char *v[]));
+static	int		replace_cmd __P((void));
+
+
+static void
+usage(msg)
+	char *msg;
+{
+	fprintf(stderr, "%s: usage error: %s\n", ProgramName, msg);
+	fprintf(stderr, "usage:\t%s [-u user] file\n", ProgramName);
+	fprintf(stderr, "\t%s [-u user] { -e | -l | -r }\n", ProgramName);
+	fprintf(stderr, "\t\t(default operation is replace, per 1003.2)\n");
+	fprintf(stderr, "\t-e\t(edit user's crontab)\n");
+	fprintf(stderr, "\t-l\t(list user's crontab)\n");
+	fprintf(stderr, "\t-r\t(delete user's crontab)\n");
+	exit(ERROR_EXIT);
+}
+
+
+int
+main(argc, argv)
+	int	argc;
+	char	*argv[];
+{
+	int	exitstatus;
+
+	Pid = getpid();
+	ProgramName = argv[0];
+
+#if defined(POSIX)
+	setlocale(LC_ALL, "");
+#endif
+
+#if defined(BSD)
+	setlinebuf(stderr);
+#endif
+	parse_args(argc, argv);		/* sets many globals, opens a file */
+	set_cron_uid();
+	set_cron_cwd();
+	if (!allowed(User)) {
+		fprintf(stderr,
+			"You (%s) are not allowed to use this program (%s)\n",
+			User, ProgramName);
+		fprintf(stderr, "See crontab(1) for more information\n");
+		log_it(RealUser, Pid, "AUTH", "crontab command not allowed");
+		exit(ERROR_EXIT);
+	}
+	exitstatus = OK_EXIT;
+	switch (Option) {
+	case opt_list:		list_cmd();
+				break;
+	case opt_delete:	delete_cmd();
+				break;
+	case opt_edit:		edit_cmd();
+				break;
+	case opt_replace:	if (replace_cmd() < 0)
+					exitstatus = ERROR_EXIT;
+				break;
+	}
+	exit(0);
+	/*NOTREACHED*/
+}
+	
+
+static void
+parse_args(argc, argv)
+	int	argc;
+	char	*argv[];
+{
+	int		argch;
+
+	if (!(pw = getpwuid(getuid()))) {
+		fprintf(stderr, "%s: your UID isn't in the passwd file.\n",
+			ProgramName);
+		fprintf(stderr, "bailing out.\n");
+		exit(ERROR_EXIT);
+	}
+	strcpy(User, pw->pw_name);
+	strcpy(RealUser, User);
+	Filename[0] = '\0';
+	Option = opt_unknown;
+	while (EOF != (argch = getopt(argc, argv, "u:lerx:"))) {
+		switch (argch) {
+		case 'x':
+			if (!set_debug_flags(optarg))
+				usage("bad debug option");
+			break;
+		case 'u':
+			if (getuid() != ROOT_UID)
+			{
+				fprintf(stderr,
+					"must be privileged to use -u\n");
+				exit(ERROR_EXIT);
+			}
+			if (!(pw = getpwnam(optarg)))
+			{
+				fprintf(stderr, "%s:  user `%s' unknown\n",
+					ProgramName, optarg);
+				exit(ERROR_EXIT);
+			}
+			(void) strcpy(User, optarg);
+			break;
+		case 'l':
+			if (Option != opt_unknown)
+				usage("only one operation permitted");
+			Option = opt_list;
+			break;
+		case 'r':
+			if (Option != opt_unknown)
+				usage("only one operation permitted");
+			Option = opt_delete;
+			break;
+		case 'e':
+			if (Option != opt_unknown)
+				usage("only one operation permitted");
+			Option = opt_edit;
+			break;
+		default:
+			usage("unrecognized option");
+		}
+	}
+
+	endpwent();
+
+	if (Option != opt_unknown) {
+		if (argv[optind] != NULL) {
+			usage("no arguments permitted after this option");
+		}
+	} else {
+		if (argv[optind] != NULL) {
+			Option = opt_replace;
+			(void) strcpy (Filename, argv[optind]);
+		} else {
+			usage("file name must be specified for replace");
+		}
+	}
+
+	if (Option == opt_replace) {
+		/* we have to open the file here because we're going to
+		 * chdir(2) into /var/cron before we get around to
+		 * reading the file.
+		 */
+		if (!strcmp(Filename, "-")) {
+			NewCrontab = stdin;
+		} else {
+			/* relinquish the setuid status of the binary during
+			 * the open, lest nonroot users read files they should
+			 * not be able to read.  we can't use access() here
+			 * since there's a race condition.  thanks go out to
+			 * Arnt Gulbrandsen <agulbra@pvv.unit.no> for spotting
+			 * the race.
+			 */
+
+			if (swap_uids() < OK) {
+				perror("swapping uids");
+				exit(ERROR_EXIT);
+			}
+			if (!(NewCrontab = fopen(Filename, "r"))) {
+				perror(Filename);
+				exit(ERROR_EXIT);
+			}
+			if (swap_uids() < OK) {
+				perror("swapping uids back");
+				exit(ERROR_EXIT);
+			}
+		}
+	}
+
+	Debug(DMISC, ("user=%s, file=%s, option=%s\n",
+		      User, Filename, Options[(int)Option]))
+}
+
+
+static void
+list_cmd() {
+	char	n[MAX_FNAME];
+	FILE	*f;
+	int	ch;
+
+	log_it(RealUser, Pid, "LIST", User);
+	(void) sprintf(n, CRON_TAB(User));
+	if (!(f = fopen(n, "r"))) {
+		if (errno == ENOENT)
+			fprintf(stderr, "no crontab for %s\n", User);
+		else
+			perror(n);
+		exit(ERROR_EXIT);
+	}
+
+	/* file is open. copy to stdout, close.
+	 */
+	Set_LineNum(1)
+	while (EOF != (ch = get_char(f)))
+		putchar(ch);
+	fclose(f);
+}
+
+
+static void
+delete_cmd() {
+	char	n[MAX_FNAME];
+
+	log_it(RealUser, Pid, "DELETE", User);
+	(void) sprintf(n, CRON_TAB(User));
+	if (unlink(n)) {
+		if (errno == ENOENT)
+			fprintf(stderr, "no crontab for %s\n", User);
+		else
+			perror(n);
+		exit(ERROR_EXIT);
+	}
+	poke_daemon();
+}
+
+
+static void
+check_error(msg)
+	char	*msg;
+{
+	CheckErrorCount++;
+	fprintf(stderr, "\"%s\":%d: %s\n", Filename, LineNumber-1, msg);
+}
+
+
+static void
+edit_cmd() {
+	char		n[MAX_FNAME], q[MAX_TEMPSTR], *editor;
+	FILE		*f;
+	int		ch, t, x;
+	struct stat	statbuf;
+	time_t		mtime;
+	WAIT_T		waiter;
+	PID_T		pid, xpid;
+
+	log_it(RealUser, Pid, "BEGIN EDIT", User);
+	(void) sprintf(n, CRON_TAB(User));
+	if (!(f = fopen(n, "r"))) {
+		if (errno != ENOENT) {
+			perror(n);
+			exit(ERROR_EXIT);
+		}
+		fprintf(stderr, "no crontab for %s - using an empty one\n",
+			User);
+		if (!(f = fopen("/dev/null", "r"))) {
+			perror("/dev/null");
+			exit(ERROR_EXIT);
+		}
+	}
+
+	(void) sprintf(Filename, "/tmp/crontab.%d", Pid);
+	if (-1 == (t = open(Filename, O_CREAT|O_EXCL|O_RDWR, 0600))) {
+		perror(Filename);
+		goto fatal;
+	}
+#ifdef HAS_FCHOWN
+	if (fchown(t, getuid(), getgid()) < 0) {
+#else
+	if (chown(Filename, getuid(), getgid()) < 0) {
+#endif
+		perror("fchown");
+		goto fatal;
+	}
+	if (!(NewCrontab = fdopen(t, "r+"))) {
+		perror("fdopen");
+		goto fatal;
+	}
+
+	Set_LineNum(1)
+
+	/* ignore the top few comments since we probably put them there.
+	 */
+	for (x = 0;  x < NHEADER_LINES;  x++) {
+		ch = get_char(f);
+		if (EOF == ch)
+			break;
+		if ('#' != ch) {
+			putc(ch, NewCrontab);
+			break;
+		}
+		while (EOF != (ch = get_char(f)))
+			if (ch == '\n')
+				break;
+		if (EOF == ch)
+			break;
+	}
+
+	/* copy the rest of the crontab (if any) to the temp file.
+	 */
+	if (EOF != ch)
+		while (EOF != (ch = get_char(f)))
+			putc(ch, NewCrontab);
+	fclose(f);
+	if (fflush(NewCrontab) < OK) {
+		perror(Filename);
+		exit(ERROR_EXIT);
+	}
+ again:
+	rewind(NewCrontab);
+	if (ferror(NewCrontab)) {
+		fprintf(stderr, "%s: error while writing new crontab to %s\n",
+			ProgramName, Filename);
+ fatal:		unlink(Filename);
+		exit(ERROR_EXIT);
+	}
+	if (fstat(t, &statbuf) < 0) {
+		perror("fstat");
+		goto fatal;
+	}
+	mtime = statbuf.st_mtime;
+
+	if ((!(editor = getenv("VISUAL")))
+	 && (!(editor = getenv("EDITOR")))
+	    ) {
+		editor = EDITOR;
+	}
+
+	/* we still have the file open.  editors will generally rewrite the
+	 * original file rather than renaming/unlinking it and starting a
+	 * new one; even backup files are supposed to be made by copying
+	 * rather than by renaming.  if some editor does not support this,
+	 * then don't use it.  the security problems are more severe if we
+	 * close and reopen the file around the edit.
+	 */
+
+	switch (pid = fork()) {
+	case -1:
+		perror("fork");
+		goto fatal;
+	case 0:
+		/* child */
+		if (setuid(getuid()) < 0) {
+			perror("setuid(getuid())");
+			exit(ERROR_EXIT);
+		}
+		if (chdir("/tmp") < 0) {
+			perror("chdir(/tmp)");
+			exit(ERROR_EXIT);
+		}
+		if (strlen(editor) + strlen(Filename) + 2 >= MAX_TEMPSTR) {
+			fprintf(stderr, "%s: editor or filename too long\n",
+				ProgramName);
+			exit(ERROR_EXIT);
+		}
+		sprintf(q, "%s %s", editor, Filename);
+		execlp(_PATH_BSHELL, _PATH_BSHELL, "-c", q, NULL);
+		perror(editor);
+		exit(ERROR_EXIT);
+		/*NOTREACHED*/
+	default:
+		/* parent */
+		break;
+	}
+
+	/* parent */
+	xpid = wait(&waiter);
+	if (xpid != pid) {
+		fprintf(stderr, "%s: wrong PID (%d != %d) from \"%s\"\n",
+			ProgramName, xpid, pid, editor);
+		goto fatal;
+	}
+	if (WIFEXITED(waiter) && WEXITSTATUS(waiter)) {
+		fprintf(stderr, "%s: \"%s\" exited with status %d\n",
+			ProgramName, editor, WEXITSTATUS(waiter));
+		goto fatal;
+	}
+	if (WIFSIGNALED(waiter)) {
+		fprintf(stderr,
+			"%s: \"%s\" killed; signal %d (%score dumped)\n",
+			ProgramName, editor, WTERMSIG(waiter),
+			WCOREDUMP(waiter) ?"" :"no ");
+		goto fatal;
+	}
+	if (fstat(t, &statbuf) < 0) {
+		perror("fstat");
+		goto fatal;
+	}
+	if (mtime == statbuf.st_mtime) {
+		fprintf(stderr, "%s: no changes made to crontab\n",
+			ProgramName);
+		goto remove;
+	}
+	fprintf(stderr, "%s: installing new crontab\n", ProgramName);
+	switch (replace_cmd()) {
+	case 0:
+		break;
+	case -1:
+		for (;;) {
+			printf("Do you want to retry the same edit? ");
+			fflush(stdout);
+			q[0] = '\0';
+			(void) fgets(q, sizeof q, stdin);
+			switch (islower(q[0]) ? q[0] : tolower(q[0])) {
+			case 'y':
+				goto again;
+			case 'n':
+				goto abandon;
+			default:
+				fprintf(stderr, "Enter Y or N\n");
+			}
+		}
+		/*NOTREACHED*/
+	case -2:
+	abandon:
+		fprintf(stderr, "%s: edits left in %s\n",
+			ProgramName, Filename);
+		goto done;
+	default:
+		fprintf(stderr, "%s: panic: bad switch() in replace_cmd()\n");
+		goto fatal;
+	}
+ remove:
+	unlink(Filename);
+ done:
+	log_it(RealUser, Pid, "END EDIT", User);
+}
+	
+
+/* returns	0	on success
+ *		-1	on syntax error
+ *		-2	on install error
+ */
+static int
+replace_cmd() {
+	char	n[MAX_FNAME], envstr[MAX_ENVSTR], tn[MAX_FNAME];
+	FILE	*tmp;
+	int	ch, eof;
+	entry	*e;
+	time_t	now = time(NULL);
+	char	**envp = env_init();
+
+	(void) sprintf(n, "tmp.%d", Pid);
+	(void) sprintf(tn, CRON_TAB(n));
+	if (!(tmp = fopen(tn, "w+"))) {
+		perror(tn);
+		return (-2);
+	}
+
+	/* write a signature at the top of the file.
+	 *
+	 * VERY IMPORTANT: make sure NHEADER_LINES agrees with this code.
+	 */
+	fprintf(tmp, "# DO NOT EDIT THIS FILE - edit the master and reinstall.\n");
+	fprintf(tmp, "# (%s installed on %-24.24s)\n", Filename, ctime(&now));
+	fprintf(tmp, "# (Cron version -- %s)\n", rcsid);
+
+	/* copy the crontab to the tmp
+	 */
+	rewind(NewCrontab);
+	Set_LineNum(1)
+	while (EOF != (ch = get_char(NewCrontab)))
+		putc(ch, tmp);
+	ftruncate(fileno(tmp), ftell(tmp));
+	fflush(tmp);  rewind(tmp);
+
+	if (ferror(tmp)) {
+		fprintf(stderr, "%s: error while writing new crontab to %s\n",
+			ProgramName, tn);
+		fclose(tmp);  unlink(tn);
+		return (-2);
+	}
+
+	/* check the syntax of the file being installed.
+	 */
+
+	/* BUG: was reporting errors after the EOF if there were any errors
+	 * in the file proper -- kludged it by stopping after first error.
+	 *		vix 31mar87
+	 */
+	Set_LineNum(1 - NHEADER_LINES)
+	CheckErrorCount = 0;  eof = FALSE;
+	while (!CheckErrorCount && !eof) {
+		switch (load_env(envstr, tmp)) {
+		case ERR:
+			eof = TRUE;
+			break;
+		case FALSE:
+			e = load_entry(tmp, check_error, pw, envp);
+			if (e)
+				free(e);
+			break;
+		case TRUE:
+			break;
+		}
+	}
+
+	if (CheckErrorCount != 0) {
+		fprintf(stderr, "errors in crontab file, can't install.\n");
+		fclose(tmp);  unlink(tn);
+		return (-1);
+	}
+
+#ifdef HAS_FCHOWN
+	if (fchown(fileno(tmp), ROOT_UID, -1) < OK)
+#else
+	if (chown(tn, ROOT_UID, -1) < OK)
+#endif
+	{
+		perror("chown");
+		fclose(tmp);  unlink(tn);
+		return (-2);
+	}
+
+#ifdef HAS_FCHMOD
+	if (fchmod(fileno(tmp), 0600) < OK)
+#else
+	if (chmod(tn, 0600) < OK)
+#endif
+	{
+		perror("chown");
+		fclose(tmp);  unlink(tn);
+		return (-2);
+	}
+
+	if (fclose(tmp) == EOF) {
+		perror("fclose");
+		unlink(tn);
+		return (-2);
+	}
+
+	(void) sprintf(n, CRON_TAB(User));
+	if (rename(tn, n)) {
+		fprintf(stderr, "%s: error renaming %s to %s\n",
+			ProgramName, tn, n);
+		perror("rename");
+		unlink(tn);
+		return (-2);
+	}
+	log_it(RealUser, Pid, "REPLACE", User);
+
+	poke_daemon();
+
+	return (0);
+}
+
+
+static void
+poke_daemon() {
+#ifdef USE_UTIMES
+	struct timeval tvs[2];
+	struct timezone tz;
+
+	(void) gettimeofday(&tvs[0], &tz);
+	tvs[1] = tvs[0];
+	if (utimes(SPOOL_DIR, tvs) < OK) {
+		fprintf(stderr, "crontab: can't update mtime on spooldir\n");
+		perror(SPOOL_DIR);
+		return;
+	}
+#else
+	if (utime(SPOOL_DIR, NULL) < OK) {
+		fprintf(stderr, "crontab: can't update mtime on spooldir\n");
+		perror(SPOOL_DIR);
+		return;
+	}
+#endif /*USE_UTIMES*/
+}
diff --git a/usr.sbin/cron/doc/CHANGES b/usr.sbin/cron/doc/CHANGES
new file mode 100644
index 000000000000..59f6803dbc01
--- /dev/null
+++ b/usr.sbin/cron/doc/CHANGES
@@ -0,0 +1,155 @@
+Vixie Cron		Changes from V2 to V3
+Paul Vixie
+29-Dec-1993
+
+The crontab command now conforms to POSIX 1003.2.  This means that when you
+install it, if you have any "crontab" command lines floating around in shell
+scripts (such as /etc/rc or /etc/rc.local), you will need to change them.
+
+I have integrated several changes made by BSDi for their BSD/386 operating
+system; these were offerred to me before I started consulting for them, so
+it is safe to say that they were intended for publication.  Most notably,
+the name of the cron daemon has changed from "crond" to "cron".  This was
+done for compatibility with 4.3BSD.  Another change made for the same reason
+is the ability to read in an /etc/crontab file which has an extra field in
+each entry, between the time fields and the command.  This field is a user
+name, and it permits the /etc/crontab command to contain commands which are
+to be run by any user on the system.  /etc/crontab is not "installed" via
+the crontab(1) command; it is automatically read at startup time and it will
+be reread whenever it changes.
+
+I also added a "-e" option to crontab(1).  Nine people also sent me diffs
+to add this option, but I had already implemented it on my own.  I actually
+released an interrim version (V2.2, I think) for limited testing, and got a
+chance to fix a bad security bug in the "-e" option thanks to XXX.
+
+The daemon used to be extraordinarily sloppy in its use of file descriptors.
+A heck of a lot of them were left open in spawned jobs, which caused problems
+for the daemon and also caused problems with the spawned jobs if they were 
+shell scripts since "sh" and "csh" have traditionally used hidden file
+descriptors to pass information to subshells, and cron was causing them to
+think they were subshells.  If you had trouble with "sh" or "csh" scripts in
+V2, chances are good that V3 will fix your problems.
+
+About a dozen people have reminded me that I forgot to initialize
+"crontab_fd" in database.c.  Keith Cantrell was the first, so he gets the
+point.
+
+Steve Simmons reminded me that once an account has been deleted from the
+system, "crontab -u USER -d" will not work.  My solution is to suggest to
+all of you that before you delete a user's account, you first delete that
+user's crontab file if any.  From cron's point of view, usernames can never
+be treated as arbitrary strings.  Either they are valid user names, or they
+are not.  I will not make an exception for the "-d" case, for security
+reasons that I consider reasonable.  It is trivial for a root user to delete
+the entry by hand if necessary.
+
+Dan O'Neil reminded me that I forgot to reset "log_fd" in misc.c.  A lot of
+others also reminded me of this, but Dan gets the point.  I didn't fix it
+there, since the real bug was that it should have been open in the parent.
+
+Peter Kabal reminded me that I forgot to "#ifdef DEBUGGING" some code in
+misc.c.  Hans Trompert actually told me first, but Peter sent the patch so
+he gets the point.
+
+Russell Nelson told me that I'd forgotten to "#include <syslog.h>" in misc.c,
+which explains why a lot of other people complained that it wasn't using
+syslog even when they configured it that way :-).  Steve Simmons told me
+first, though, so he gets the point.
+
+An interrim version of the daemon tried to "stat" every file before
+executing it; this turned out to be a horribly bad idea since finding the
+name of a file from a shell command is a hard job (that's why we have
+shells, right?)  I removed this bogus code.  Dave Burgess gets the point.
+
+Dennis R. Conley sent a suggestion for MMDF systems, which I've added to the
+comments in cron.h.
+
+Mike Heisler noted that I use comments in the CONVERSION file which are
+documented as illegal in the man pages.  Thanks, Mike.
+
+Irving Wolfe sent me some very cheerful changes for a NeXT system, but I
+consider the system itself broken and I can't bring myself to #ifdef for
+something as screwed up as this system seems to be.  However, various others
+did send me smaller patches which appear to have cause cron to build and run
+correctly on (the latest) NeXT machines, with or without the "-posix" CFLAG.
+Irving also asked for a per-job MAILTO, and this was finally added later when
+I integrated the BSD/386 changes contributed by BSDi, and generalized some of
+the parsing.
+
+Lots of folks complained that the autogenerated "Date:" header wasn't in
+ARPA format.  I didn't understand this -- either folks will use Sendmail and
+not generate a Date:  at all (since Sendmail will do it), or folks will use
+something other than Sendmail which won't care about Date: formats.  But
+I've "fixed" it anyway...
+
+Several people suggested that "*" should be able to take a "/step".  One person
+suggested that "N/step" ought to mean "N-last/step", but that's stretching things
+a bit far.  "*/step" seems quite intuitive to me, so I've added it.  Colin Plumb
+sent in the first and most polite request for this feature.
+
+As with every release of Cron, BIND, and seemingly everything else I do, one
+user stands out with the most critical but also the most useful analysis.
+Cron V3's high score belongs to Peter Holzer, who sent in the nicest looking
+patch for the "%" interpretation problem and also helped me understand a
+tricky bit of badness in the "log_fd" problem.
+
+agulbra@flode.nvg.unit.no wins the honors for being the first to point out the
+nasty security hole in "crontab -r".  'Nuff said.
+
+Several folks pointed out that log_it() needed to exist even if logging was
+disabled.  Some day I will create a tool that will compile a subsystem with
+every possible combination and permutation of #ifdef options, but meanwhile
+thanks to everybody.
+
+job_runqueue() was using storage after freeing it, since Jordan told me back
+in 1983 that C let you do that, and I believed him in 1986 when I wrote all
+this junk.  Linux was the first to die from this error, and the Linux people
+sent me the most amazing, um, collection of patches for this problem.  Thanks
+for all the fish.
+
+Jeremy Bettis reminded me that popen() isn't safe.  I grabbed Ken Arnold's 
+version of popen/pclose from the ftpd and hacked it to taste.  We're safe now,
+from this at least.
+
+Branko Lankester sent me a very timely and helpful fix for a looming security
+problem in my "crontab -e" implementation.
+
+--------
+
+Vixie Cron		Changes from V1 to V2
+Paul Vixie
+8-Feb-1988
+
+Many changes were made in a rash of activity about six months ago, the exact
+list of which is no longer clear in my memory.  I know that V1 used a file
+called POKECRON in /usr/spool/cron to tell it that it was time to re-read
+all the crontab files; V2 uses the modtime the crontab directory as a flag to
+check out the crontab files; those whose modtime has changed will be re-read,
+and the others left alone.  Note that the crontab(1) command will do a utimes
+call to make sure the mtime of the dir changes, since the filename/inode will
+often remain the same after a replacement and the mtime wouldn't change in
+that case.
+
+8-Feb-88: made it possible to use much larger environment variable strings.
+	V1 allowed 100 characters; V2 allows 1000.  This was needed for PATH
+	variables on some systems.  Thanks to Toerless Eckert for this idea.
+	E-mail: UUCP: ...pyramid!fauern!faui10!eckert
+
+16-Feb-88: added allow/deny, moved /usr/spool/cron/crontabs to
+	/usr/lib/cron/tabs.  allow and deny are /usr/lib/cron/{allow,deny},
+	since the sysv naming for this depends on 'at' using the same
+	dir, which would be stupid (hint: use /usr/{lib,spool}/at).
+
+22-Feb-88: made it read the spool directory for crontabs and look each one
+	up using getpwnam() rather than reading all passwds with getpwent()
+	and trying to open each crontab.
+
+9-Dec-88: made it sync to :00 after the minute, makes cron predictable.
+	added logging to /var/cron/log.
+
+14-Apr-90: (actually, changes since December 1989)
+	fixed a number of bugs reported from the net and from John Gilmore.
+	added syslog per Keith Bostic.  security features including not
+	being willing to run a command owned or writable by other than
+	the owner of the crontab 9not working well yet)
diff --git a/usr.sbin/cron/doc/CONVERSION b/usr.sbin/cron/doc/CONVERSION
new file mode 100644
index 000000000000..b86427d72cc8
--- /dev/null
+++ b/usr.sbin/cron/doc/CONVERSION
@@ -0,0 +1,85 @@
+$Id: CONVERSION,v 2.2 1993/12/28 08:34:43 vixie Exp $
+
+Conversion of BSD 4.[23] crontab files:
+
+Edit your current crontab (/usr/lib/crontab) into little pieces, with each
+users' commands in a different file.  This is different on 4.2 and 4.3,
+but I'll get to that below.  The biggest feature of this cron is that you
+can move 'news' and 'uucp' cron commands into files owned and maintainable
+by those two users.  You also get to rip all the fancy 'su' footwork out
+of the cron commands.  On 4.3, there's no need for the 'su' stuff since the
+user name appears on each command -- but I'd still rather have separate
+crontabs with seperate environments and so on.
+
+Leave the original /usr/lib/crontab!  This cron doesn't use it, so you may
+as well keep it around for a while in case something goes wakko with this
+fancy version.
+
+Most commands in most crontabs are run by root, have to run by root, and
+should continue to be run by root.  They still have to be in their own file;
+I recommend /etc/crontab.src or /usr/adm/crontab.src.
+
+'uucp's commands need their own file; how about /usr/lib/uucp/crontab.src?
+'news' also, perhaps in /usr/lib/news/crontab.src...
+
+I say `how about' and `perhaps' because it really doesn't matter to anyone
+(except you) where you put the crontab source files.  The `crontab' command
+COPIES them into a protected directory (CRONDIR/SPOOL_DIR in cron.h), named
+after the user whose crontab it is.  If you want to examine, replace, or
+delete a crontab, the `crontab' command does all of those things.  The
+various `crontab.src' (my suggested name for them) files are just source
+files---they have to be copied to SPOOLDIR using `crontab' before they'll be
+executed.
+
+On 4.2, your crontab might have a few lines like this:
+
+	5 * * * *   su uucp < /usr/lib/uucp/uudemon.hr
+	10 4 * * *  su uucp < /usr/lib/uucp/uudemon.day
+	15 5 * * 0  su uucp < /usr/lib/uucp/uudemon.wk
+
+...or like this:
+
+	5 * * * *   echo /usr/lib/uucp/uudemon.hr | su uucp
+	10 4 * * *  echo /usr/lib/uucp/uudemon.day | su uucp
+	15 5 * * 0  echo /usr/lib/uucp/uudemon.wk | su uucp
+
+On 4.3, they'd look a little bit better, but not much:
+
+	5 * * * *   uucp  /usr/lib/uucp/uudemon.hr
+	10 4 * * *  uucp  /usr/lib/uucp/uudemon.day
+	15 5 * * 0  uucp  /usr/lib/uucp/uudemon.wk
+
+For this cron, you'd create /usr/lib/uucp/crontab.src (or wherever you want
+to keep uucp's commands) which would look like this:
+
+	# /usr/lib/uucp/crontab.src - uucp's crontab
+	#
+	PATH=/usr/lib/uucp:/bin:/usr/bin
+	SHELL=/bin/sh
+	HOME=/usr/lib/uucp
+	#
+	5 * * * *   uudemon.hr
+	10 4 * * *  uudemon.day
+	15 5 * * 0  uudemon.wk
+
+The application to the `news' cron commands (if any) is left for you to
+figure out.  Likewise if there are any other cruddy-looking 'su' commands in
+your crontab commands, you don't need them anymore: just find a good place
+to put the `crontab.src' (or whatever you want to call it) file for that
+user, put the cron commands into it, and install it using the `crontab'
+command (probably with "-u USERNAME", but see the man page).
+
+If you run a 4.2-derived cron, you could of course just install your current
+crontab in toto as root's crontab.  It would work exactly the way your
+current one does, barring the extra steps in installing or changing it.
+There would still be advantages to this cron, mostly that you get mail if
+there is any output from your cron commands.
+
+One note about getting mail from cron: you will probably find, after you
+install this version of cron, that your cron commands are generating a lot
+of irritating output.  The work-around for this is to redirect all EXPECTED
+output to a per-execution log file, which you can examine if you want to
+see the output from the "last time" a command was executed; if you get any
+UNEXPECTED output, it will be mailed to you.  This takes a while to get
+right, but it's amazingly convenient.  Trust me.
+
diff --git a/usr.sbin/cron/doc/FEATURES b/usr.sbin/cron/doc/FEATURES
new file mode 100644
index 000000000000..209b1e99a96c
--- /dev/null
+++ b/usr.sbin/cron/doc/FEATURES
@@ -0,0 +1,84 @@
+$Id: FEATURES,v 2.1 1993/12/28 08:34:43 vixie Exp $
+
+Features of Vixie's cron relative to BSD 4.[23] and SysV crons:
+
+--	Environment variables can be set in each crontab.  SHELL, USER,
+	LOGNAME, and HOME are set from the user's passwd entry; all except
+	USER can be changed in the crontab.  PATH is especially useful to
+	set there.  TZ can be set, but cron ignores it other than passing
+	it on through to the commands it runs.  Format is
+
+		variable=value
+
+	Blanks surrounding the '=' will be eaten; other blanks in value are
+	okay.  Leading or trailing blanks can be preserved by quoting, single
+	or double quotes are okay, just so they match.
+
+		PATH=.:/bin:/usr/bin
+		SHELL=/bin/sh
+		FOOBAR = this is a long blanky example
+
+	Above, FOOBAR would get "this is a long blanky example" as its value.
+
+	SHELL and HOME will be used when it's time to run a command; if
+	you don't set them, HOME defaults to your /etc/passwd entry
+	and SHELL defaults to /bin/sh.
+
+	MAILTO, if set to the login name of a user on your system, will be the
+	person that cron mails the output of commands in that crontab.  This is
+	useful if you decide on BINMAIL when configuring cron.h, since binmail
+	doesn't know anything about aliasing.
+
+--	Weekdays can be specified by name.  Case is not significant, but only
+	the first three letters should be specified.
+
+--	Months can likewise be specified by name.  Three letters only.
+
+--	Ranges and lists can be mixed.  Standard crons won't allow '1,3-5'.
+
+--	Ranges can specify 'step' values.  '10-16/2' is like '10,12,14,16'.
+
+--	Sunday is both day 0 and day 7 -- apparently BSD and ATT disagree
+	about this.
+
+--	Each user gets their own crontab file.  This is a win over BSD 4.2,
+	where only root has one, and over BSD 4.3, where they made the crontab
+	format incompatible and although the commands can be run by non-root
+	uid's, root is still the only one who can edit the crontab file.  This
+	feature mimics the SysV cron.
+
+--	The 'crontab' command is loosely compatible with SysV, but has more
+	options which just generally make more sense.  Running crontab with
+	no arguments will print a cute little summary of the command syntax.
+
+--	Comments and blank lines are allowed in the crontab file.  Comments
+	must be on a line by themselves; leading whitespace is ignored, and
+	a '#' introduces the comment.
+
+--	(big win) If the `crontab' command changes anything in any crontab,
+	the 'cron' daemon will reload all the tables before running the
+	next iteration.  In some crons, you have to kill and restart the
+	daemon whenever you change a crontab.  In other crons, the crontab
+	file is reread and reparsed every minute even if it didn't change.
+
+--	In order to support the automatic reload, the crontab files are not
+	readable or writable except by 'crontab' or 'cron'.  This is not a
+	problem, since 'crontab' will let you do pretty much whatever you
+	want to your own crontab, or if you are root, to anybody's crontab.
+
+--	If any output is generated by a command (on stdout OR stderr), it will
+	be mailed to the owner of the crontab that contained the command (or
+	MAILTO, see discussion of environment variables, above).  The headers
+	of the mail message will include the command that was run, and a
+	complete list of the environment that was passed to it, which will
+	contain (at least) the USER (LOGNAME on SysV), HOME, and SHELL.
+
+--	the dom/dow situation is odd.  '* * 1,15 * Sun' will run on the
+	first and fifteenth AND every Sunday;  '* * * * Sun' will run *only*
+	on Sundays;  '* * 1,15 * *' will run *only* the 1st and 15th.  this
+	is why we keep 'e->dow_star' and 'e->dom_star'.  I didn't think up
+	this behaviour; it's how cron has always worked but the documentation
+	hasn't been very clear.  I have been told that some AT&T crons do not
+	act this way and do the more reasonable thing, which is (IMHO) to "or"
+	the various field-matches together.  In that sense this cron may not
+	be completely similar to some AT&T crons.
diff --git a/usr.sbin/cron/doc/INSTALL b/usr.sbin/cron/doc/INSTALL
new file mode 100644
index 000000000000..cc660ffdaa69
--- /dev/null
+++ b/usr.sbin/cron/doc/INSTALL
@@ -0,0 +1,87 @@
+/* Copyright 1993,1994 by Paul Vixie
+ * All rights reserved
+ *
+ * Distribute freely, except: don't remove my name from the source or
+ * documentation (don't take credit for my work), mark your changes (don't
+ * get me blamed for your possible bugs), don't alter or remove this
+ * notice.  May be sold if buildable source is provided to buyer.  No
+ * warrantee of any kind, express or implied, is included with this
+ * software; use at your own risk, responsibility for damages (if any) to
+ * anyone resulting from the use of this software rests entirely with the
+ * user.
+ *
+ * Send bug reports, bug fixes, enhancements, requests, flames, etc., and
+ * I'll try to keep a version up to date.  I can be reached as follows:
+ * Paul Vixie          <paul@vix.com>          uunet!decwrl!vixie!paul
+ */
+
+$Id: INSTALL,v 2.5 1994/01/15 20:43:43 vixie Exp $
+
+Read the comments at the top of the Makefile, then edit the area marked
+'configurable stuff'.
+
+Edit config.h.  The stuff I expect you to change is down a bit from the
+top of the file, but it's clearly marked.  Also look at pathnames.h.
+
+You don't have to create the /var/cron or /var/cron/tabs directories, since
+both the daemon and the `crontab' program will do this the first time they
+run if they don't exist.  You do need to have a /var, though -- just "mkdir
+/var" if you don't have one, or you can "mkdir /usr/var; ln -s /usr/var /var"
+if you expect your /var to have a lot of stuff in it.
+
+You will also need /usr/local/etc and /usr/local/bin directories unless you
+change the Makefile.  These will have to be created by hand, but if you are
+a long-time Usenet user you probably have them already.  /usr/local/man is
+where I keep my man pages, but I have the source for `man' and you probably
+do not.  Therefore you may have to put the man pages into /usr/man/manl,
+which will be hard since there will be name collisions.  (Note that the man
+command was originally written by Bill Joy before he left Berkeley, and it
+contains no AT&T code, so it is in UUNET's archive of freely-distributable
+BSD code.)
+
+LINUX note: /usr/include/paths.h on some linux systems shows _PATH_SENDMAIL
+	to be /usr/bin/sendmail even though sendmail is installed in /usr/lib.
+	you should check this out.
+
+say:
+	make all
+
+su and say:
+	make install
+
+Note that if I can get you to "su and say" something just by asking, you have
+a very serious security problem on your system and you should look into it.
+
+Edit your /usr/lib/crontab file into little pieces -- see the CONVERSION file
+for help on this.
+
+Use the `crontab' command to install all the little pieces you just created.
+Some examples (see below before trying any of these!)
+
+	crontab -u uucp -r /usr/lib/uucp/crontab.src
+	crontab -u news -r /usr/lib/news/crontab.src
+	crontab -u root -r /usr/adm/crontab.src
+
+Notes on above examples: (1) the .src files are copied at the time the
+command is issued; changing the source files later will have no effect until
+they are reinstalled with another `crontab -r' command.  (2) The crontab
+command will affect the crontab of the person using the command unless `-u
+USER' is given; `-u' only works for root.  When using most `su' commands
+under most BSD's, `crontab' will still think of you as yourself even though
+you may think of yourself as root -- so use `-u' liberally.  (3) the `-r'
+option stands for `replace'; check the man page for crontab(1) for other
+possibilities.
+
+Kill your existing cron daemon -- do `ps aux' and look for /etc/cron.
+
+Edit your /etc/rc or /etc/rc.local, looking for the line that starts up
+/etc/cron.  Comment it out and add a line to start the new cron daemon
+-- usually /usr/local/etc/cron, unless you changed it in the Makefile.
+
+Start up this cron daemon yourself as root.  Just type /usr/local/etc/cron
+(or whatever); no '&' is needed since the daemon forks itself and the
+process you executed returns immediately.
+
+ATT notes: for those people unfortunate enough to be stuck on a AT&T UNIX,
+you will need the public-domain "libndir", found in the B News source and in
+any comp.sources.unix archive.  You will also need to hack the code some.
diff --git a/usr.sbin/cron/doc/MAIL b/usr.sbin/cron/doc/MAIL
new file mode 100644
index 000000000000..b066e7e8e39d
--- /dev/null
+++ b/usr.sbin/cron/doc/MAIL
@@ -0,0 +1,475 @@
+[ this is really old mail that came to me in response to my 1986 posting
+  to usenet asking for feature suggestions before releasing the first 
+  version of cron.  it is presented here for its entertainment value.
+  --vix ]
+
+$Id: MAIL,v 1.1 1993/12/28 08:30:36 vixie Exp $
+
+From ptsfa!lll-crg!ames!acornrc!bob Wed Dec 31 10:07:08 1986
+Date: Wed, 31 Dec 86 08:59:31 pst
+From: lll-crg!ames!acornrc!bob (Bob Weissman)
+To: ptsfa!vixie!paul
+Status: RO
+
+Sure, here's a suggestion: I'd like to be able to run a program, say,
+every two hours.  Current cron requires me to write
+0,2,4,6,8,10,12,14,16,18,20,22 in the hours field.  How about a notation
+to handle this more elegantly?
+
+<<	Okay, I've allowed 0-22/2 as a means of handling this.
+	The time specification for my cron is as follows:
+		specification = range {"," range}
+		range = (start "-" finish ["/" step]) | single-unit
+	This allows "1,3,5-7", which the current cron doesn't (it won't
+	do a range inside a list), and handles your specific need.	>>
+
+From drw@mit-eddie Wed Dec 31 18:25:27 1986
+Date: Wed, 31 Dec 86 14:28:19 est
+From: drw@mit-eddie (Dale Worley)
+To: mit-eddie!vixie!paul
+Status: RO
+
+We have a lot of lines in our crontab of the form
+
+	00 12 * * * su user < /usr/users/user/script.file
+
+This barfs (silently!) on our system (Dec Ultrix 1.2 == 4.2bsd) if
+user's shell is csh.  This, I am told, is because csh requires that
+the environment be set up in certain ways, which cron doesn't do.
+(Actually, I believe, it is because /etc/rc, which runs cron, doesn't
+set up the environment enough for csh to run, and cron just inherits
+the situation.)  Anyway, the point is that if you find out what csh
+really needs in its environment, you might want to set up cron to
+provide some reasonable defaults (if it isn't supplied by cron's
+parent).  Also, could you tell me what csh needs, if you find out, so
+we can hack our /etc/rc?
+
+<<	well, the environment IS a problem. processes that cron forks
+	will inherit the environment of the person who ran the cron
+	daemon... I plan to edit out such useless things as TERMCAP,
+	TERM, and the like; supply correct values for HOME, USER, CWD,
+	and whatever else comes to mind.  I'll make sure csh works...	>>
+From ptsfa!ames!seismo!dgis!generous Thu Jan  1 07:33:17 1987
+Date: Thu Jan 1 10:29:20 1987
+From: ames!seismo!dgis!generous (Curtis Generous)
+To: nike!ptsfa!vixie!paul
+Status: RO
+
+Paul:
+
+One of the limitations of the present versions of cron is the lack
+of the capability of specifying a way to execute a command every
+n units of time.
+
+Here is a good example:
+
+# Present method to start up uucico
+02,12,22,32,42,52 * * * * 	exec /usr/lib/uucp/uucico -r1
+
+# New method ?? (the ':' here is just one possibility for syntax)
+02:10 * * * *			exec /usr/lib/uucp/uucico -r1
+
+This method would prove very helpful for those programs that get started
+every few minutes, making the entry long and not easily readable.  The first
+number would specify the base time, and the second number the repetition
+interval.
+
+<<	Good idea, but bob@acornrc beat you to it.  I used '/' instead of
+	':'.  This is my personal preference, and seems intuitive when you
+	think of the divide operator in C... Does anyone have a preference? >>
+
+From ptsfa!lll-lcc!seismo!decuac!c3pe!c3engr!charles Thu Jan  1 17:04:24 1987
+From: lll-lcc!seismo!c3pe!c3engr!charles (Charles Green)
+To: c3pe!decuac!dolqci!vrdxhq!seismo!lll-lcc!ptsfa!vixie!paul
+Date: Thu Jan  1 19:22:47 1987
+Status: RO
+
+Well, this isn't a compatible extension, but I have in times past wondered
+about a facility to let you start a process at intervals of, say, 17 minutes,
+instead of particular minutes out of each hour.
+
+<<	This was a popular request!	>>
+
+From seismo!uwvax!astroatc!nicmad!norvax!mann Sun Jan  4 13:04:01 1987
+Date: Fri, 2 Jan 87 09:23:53 cst
+From: lll-lcc!seismo!uwvax!astroatc!nicmad!norvax!mann (Tom Mann)
+To: ptsfa!vixie!paul
+Status: RO
+
+I'm not sure if it is in cron (either SysV or BSD ... if it is, I haven't
+figured it out ) but a comment feature would SURE BE NICE!.
+There are times when I want to comment out an entry
+for a period of time; it might also make it a lot more legible.
+
+<<	My cron allows blank lines and standard #-type comments.  I know
+	that one BSD4.2 cron I've used had it.  I don't know about SysV.  >>
+
+From ptsfa!hoptoad!hugh Mon Jan  5 10:26:46 1987
+Date: Mon, 5 Jan 87 01:22:17 PST
+From: hoptoad!hugh (Hugh Daniel)
+To: ptsfa!vixie!paul
+Status: RO
+
+  Hi, I do have a BIG one that I would like.  I want to log ALL output
+from command lines into a file for each line.  Thus I might have a chance
+of finding out why my crontab entry did not work.
+  This would seem to work best if done by cron, as it is now I have a google
+of shell scripts laying about just to put the error output where I can see
+it.
+
+<<	My cron (and the SysV cron) will send mail to the owner of the
+	particular crontab file if a command generates any output on stdout
+	or stderr.  This can be irritating, but if you write a script such
+	that any output means a problem occurred, you can avoid most logfile
+	needs, and not generate mail except in unforeseen circumstances.   >>
+
+From ptsfa!dual!ucbvax!ihnp4!anvil!es!Robert_Toxen Mon Jan  5 13:08:46 1987
+From: dual!ucbvax!ihnp4!anvil!es!Robert_Toxen
+Date: Fri,  2 Jan 87 14:25:29 EST
+To: anvil!ihnp4!ucbvax!dual!ptsfa!vixie!paul
+Status: RO
+
+Here are some suggestions:
+1. Run it through the C preprocessor via "/lib/<whatever>".
+
+<<	hmmm. this seems of limited utility, and if you really wanted
+	to do it that way, you could do it yourself (since users can
+	write to their own crontab files).  I'll add '-' (read stdin)
+	to the crontab installer program to facilitate this.		>>
+
+2. Allow specifying every Nth day of week, i.e., every second Wednesday.
+   I did this to calendar by separating the day of week (Wed=4, which one
+   to start on and N with slashes).  I took modulo the day of year as a
+   starting point so that someone with a desk calendar documenting such
+   things can easily determine the offset (second number).  I did this
+   while at SGI; alas I don't have a copy of the code.
+
+<<	I can see how this could be useful, but I'm not sure how I'd
+	implement it.  Cron currently doesn't keep track of the last time
+	a given command was run; whether the current Wednesday is the first
+	or second since the command was last run would be pretty hard to
+	figure out.  I'd have to keep a database of commands and their
+	execution around, and purge it when the crontab was overwritten.
+	This is too much work for me, but if someone adds it, let me know.  >>
+
+From ptsfa!ames!seismo!cbmvax!devon!paul Tue Jan  6 05:50:17 1987
+From: ames!seismo!cbmvax!devon!paul
+To: cbmvax!seismo!nike!ptsfa!vixie!paul
+Date: Mon Jan  5 09:29:57 1987
+Status: RO
+
+One problem that has always plagued me with cron is the assumed ORing.
+I'd like to see some type of ANDing implemented.  I guess I can best
+describe this by example.  Say I have the following line in my crontab
+file:
+
+*  *  4-31  *  1-6	/usr/bin/command
+
+What this does is run 'command' on the 4th thru 31st days of the
+month, AND on Monday thru Saturday; which probably means running it
+every day of the month (unless Sunday falls on days 1-3).  This
+happens because cron runs the command if the day-of-month OR the
+day-of-week is true.
+
+What I'd like to happen with the above line is to run the command ONLY
+on Monday thru Saturday any time after the 3rd of the month, e.g. if
+the day-of-month AND the day-of-week are true.
+
+My proposal to you is to implement some special chars for the first
+five fields.  Examples:
+
+*  *  !1-3  *  1-6	/usr/bin/command
+
+(run command Mon-Sat, but NOT [!] on the first 3 days of the month)
+
+*  *  &4-31 *  &1-6	/usr/bin/command
+
+(run command if day-of-month AND day-of-week are true)
+
+Get the picture?  This would be compatable with existing versions of
+cron (which wouldn't currently be using any special characters, so
+that old crontabs would be handled correctly).
+
+<<	This message made me aware of the actual boolean expression involved
+	in a crontab entry.  I'd assumed that it was
+		(minute && hour && DoM && month && DoW)
+	But it's really
+		(minute && hour && month && (DoM || DoW))
+
+	I can see some value in changing this, but with a fixed order of
+	fields, operators get to be kindof unary, which && and || really
+	aren't.  If someone has an idea on a syntax that allows useful
+	variations to the standard (&& && && (||)) default, please suggest. >>
+
+From bobkat!pedz Tue Jan  6 20:02:10 1987
+From: pedz@bobkat.UUCP (Pedz Thing)
+Date: 2 Jan 87 17:34:44 GMT
+Status: RO
+
+Log files!  It would be nice to be able to specify a log for cron
+itself and also a log for each program's stdout and stderr to go to.
+The latter can of course be done with > and 2> but it would be nice if
+there could be a single line with some sort of pattern like
+`> /usr/spool/log/%' and the command would be substituted for the %.
+Another thing which would be nice is to be able to specify which shell
+to call to give the command to.
+
+<<	Log files are done with mail.  The '%' idea could be useful if
+	a different character were used (% is special to cron, see man
+	page); a different directory would have to be chosen, since each
+	user has their own crontab file; and something intelligent would
+	have to be done in the file naming, since the first word of the
+	command might be ambiguous (with other commands).  In short, it's
+	too much work.  Sorry.						  >>
+
+From guy%gorodish@sun Tue Jan  6 20:03:13 1987
+From: guy%gorodish@sun (Guy Harris)
+Message-ID: <10944@sun.uucp>
+Date: 5 Jan 87 12:09:09 GMT
+References: <429@vixie.UUCP> <359@bobkat.UUCP>
+Sender: news@sun.uucp
+Status: RO
+
+> Another thing which would be nice is to be able to specify which shell
+> to call to give the command to.
+
+Well, the obvious choice would be the user's shell, but this wouldn't work
+for accounts like "uucico".
+
+<<	I use the owning user's shell, and to handle "uucico" I check a
+	list of "acceptable shells" (currently compiled in, does anybody
+	mind?), substituting a default (compiled in) shell if the user's
+	shell isn't on the list.
+
+	BTW, "compiled in" means that it's in a .h file, easily changed
+	during installation, but requiring recompilation to modify.  You
+	don't have to go digging through the code to find it...		  >>
+
+From qantel!hplabs!ucbvax!mwm@violet.berkeley.edu Tue Jan  6 21:24:48 1987
+To: hplabs!qantel!vixie!paul (Paul Vixie Esq)
+Date: 04 Jan 87 00:42:35 PST (Sun)
+From: Mike Meyer <mwm@violet.berkeley.edu>
+Status: RO
+
+<<[Discussion of RMS/FSF, and mwm's GNU Cron deleted]>>
+
+Oh, yeah - here are the extensions on my cron:
+
+1) Sunday is both day 0 and day 7, so it complies with both SysV and
+BSD cron.
+
+<<	Good idea. I did it too, thanks for informing me.	>>
+
+2) At is integrated into the cron. Instead of atrun to scan the
+/usr/spool/at directory, at files are put into the /usr/lib/cron
+directory along with users cron files, and cron fabricates a line from
+a crontab file to run them. This is considered a major win by all who
+use it.
+
+<<	I don't use 'at', and my cron doesn't do anything with it.  To run
+	'at', I use 'atrun' the same way the current BSD cron does.  My
+	crontab files are in /usr/spool/cron/crontabs, in the SysV
+	tradition -- not in /usr/lib/cron.  This is a configuration
+	parameter, of course.						>>
+
+There are two known restrictions:
+
+1) I don't support any of the SysV security hooks. I don't have a use
+for them, and RMS didn't like the idea at all :-).
+
+<<	This means cron.allow and cron.deny.  I plan to support them, as
+	they've been quite helpful at various HPUX sites I've administered. >>
+
+2) Cron expects to be able to create files with names longer than 14
+characters, which makes it hard to run on SysV. At least one person
+was working on a port, but I don't know how it's going. That might
+make for a good reason for releasing yours, right there.
+
+<<	If someone has SysV (with the 14-character limit), they probably
+	won't want my cron, since it doesn't add much to the standard
+	version (which they may have support for).  My cron is not currently
+	portable to non-BSD systems, since it relies on interval timers (I
+	needed to sleep for intervals more granular than seconds alone would
+	allow).  The port would be trivial, and I will do it if a lot of
+	people ask for it...						>>
+
+Oh, yeah - I'm going to see about getting this cron integrated into
+the next 4BSD release.
+
+<<	How does one go about this?  I have a few nifty gadgets I'd like
+	to contribute, this cron being one of them...			>>
+
+<<[more FSF/GNU discussion deleted]>>
+
+From qantel!hplabs!ames!ut-sally!ut-ngp!melpad!bigtex!james Tue Jan  6 21:24:57 1987
+Posted-Date: Fri, 2 Jan 87 19:26:16 est
+Date: Fri, 2 Jan 87 19:26:16 est
+From: hplabs!ames!ut-sally!ut-ngp!bigtex!james
+To: vixie!paul
+Status: RO
+
+Yes!!!  There are several critical failures in System V cron...
+
+1. Pass all variables in cron's environment into the environment of things
+   cron starts up, or at least into the crontab entries started up (at jobs
+   will inherit the environment of the user).  If nothing else it is critically
+   important that the TZ variable be passed on.  PATH should be passed on too.
+   Basically, passing environment values allows one to design a standard
+   environment with TZ and PATH and have that run by everything.  If anyone
+   tells you this is no big deal, consider what happens when uucico is
+   started by cron in CA to make a long distance phone link...  Unless the
+   administrator is really on his/her toes, calls scheduled at 5pm will really
+   go at two in the afternoon, needlessly incurring huge phone bills, all
+   because System V refuses to pass the TZ from its environment down.  There
+   are work arounds, but only putting it in cron will really work.  This is
+   not a security hole.
+
+<<	delete TERM and TERMCAP; modify HOME, USER, and CWD; pass TZ and
+	PATH through undisturbed.  any other requests out there?
+
+	BSD doesn't have this problem -- TZ is passed right on through if
+	you define it in the shell before starting my cron daemon.  However,
+	the BSD I'm running this on doesn't need TZ to be defined anyway...
+	The default in the kernel has been just fine so far...  But just the
+	same, if/when I port to SysV (I guess I really should), I'll make
+	sure this works right.
+
+	I guess I've been spoiled.  HPUX is SysV-based, and I never had a
+	problem with cron and TZ when I used it.			  >>
+
+2. A way to avoid logging stuff in /usr/lib/cron/log.  I have a cron entry
+   run uudemon.hr every 10 minutes.  This is 144 times/day.  Each run generates
+   three lines of text, for a total of 432 lines of text I don't want to see.
+   Obviously this should be optional, but it would be nice if there were a
+   way to flag an entry so that it wasn't logged at all unless there was an
+   error.
+
+<<	I don't know nothin' 'bout no /usr/lib/cron/log.  What is this file?
+	I don't see any reason to create log entries, given the mail-the-
+	output behaviour.  Opinions, anyone?				>>
+
+I will come up with other ideas no doubt, but I can always implement them
+myself.
+
+<<	That's what I like about PD software.  Please send me the diffs!  >>
+
+The other problem you have is making sure you can run standard
+crontabs.  I would suggest something like this: if the command part of the
+entry starts with an unescaped -, then flags and options follow immediately
+thereafter.  As in:
+
+2,12,22,32,42,52 * * * * -q /usr/lib/uucp/uudemon.hr
+
+This could mean do not log the uudemon.hr run unless there is a problem of
+some kind.  This is probably safe as not many filenames start with "-", and
+those that do are already a problem for people.
+
+<<	Since I don't plan on supporting /usr/lib/cron/log in ANY form unless
+	many people request it, I won't be needing -q as you've defined it.
+	I could use something like this to avoid sending mail on errors, for
+	the occasional script that you don't want to bullet-proof.
+
+	The compatibility issue is CRITICAL.  The 4.3BSD crontab format is
+	a crime against the whole philosophy of Unix(TM), in my opinion.   >>
+
+One other minor thing to consider is the ulimit: can different users get
+different ulimits for their crontab entries?
+
+<<	Boy I'm ignorant today.  What's a ulimit, and what should I do with
+	it in a crontab?  Suggestions, enlightenment, etc ??		   >>
+
+From qantel!lll-crg!ames!uw-beaver!uw-nsr!john Tue Jan  6 23:32:44 1987
+Date: Thu, 1 Jan 87 10:53:05 pst
+From: lll-crg!ames!uw-beaver!uw-nsr!john (John Sambrook 5-7433)
+To: vixie!paul
+Status: RO
+
+How about not hardwiring the default environment that cron builds for its
+children in the cron program itself?  Our cron does this and it's the pits
+because we are TZ=PST8PDT not TZ=EST5EDT !
+
+<<	yeachk.  I assure you, I will not hardwire the TZ!		>>
+From ptsfa!well!dv Fri Jan  9 04:01:50 1987
+Date: Thu, 8 Jan 87 23:50:40 pst
+From: well!dv (David W. Vezie)
+To: ptsfa!vixie!paul
+Status: RO
+
+6, have a special notation called 'H' which would expand to weekends
+   and holidays (you'd have to keep a database somewhere of real
+   holidays), and also 'W' for workdays (neither weekend or holiday).
+
+<<	Too much work.  There should be a standard way to define and
+	detect holidays under Unix(TM); if there were, I'd use it.  As
+	it is, I'll leave this for someone else to add.
+
+	I can see the usefulness; it just doesn't quite seem worth it.    >>
+From qantel!gatech!akgua!blnt1!jat Wed Jan 14 20:00:40 1987
+Date: Tue, 13 Jan 87 16:39:38 EST
+From: gatech!akgua!blnt1!jat
+Status: RO
+
+1) Add some way to tell cron to reread the files, say kill -1 <pid>
+
+<<	whenever the 'crontab' program is run and updates a crontab file,
+	a file /usr/spool/cron/POKECRON is created; next time the cron
+	daemon wakes up, it sees it, and re-reads the crontab files.
+
+	I thought of handling the signal; even implemented it.  Then this
+	clever idea hit me and I ripped it all out and added a single
+	IF-statement to handle the POKECRON file.			>>
+
+2) Have some kind of retry time so that if a command fails, cron will try to
+   execute it again after a certain period.  This is useful if you have some
+   type of cleanup program that can run at the scheduled time for some reason
+   (such as locked device, unmounted filesystem, etc).
+
+<<	Hmmm, sounds useful.  I could do this by submitting an 'at' job...
+	I'll think about it.						>>
+From ptsfa!dual!ucbvax!ihnp4!mtuxo!ender Sat Jan  3 16:54:00 1987
+From: dual!ucbvax!ihnp4!mtuxo!ender
+Date: Sat, 3 Jan 87 14:05:13 PST
+To: ucbvax!dual!ptsfa!vixie!paul
+Status: RO
+
+It would be nice if nonprivileged users can setup personal crontab files
+(~/.cronrc, say) and be able to run personal jobs at regular intervals.
+	
+<<	this is done, but in the SysV style: the 'crontab' program installs
+	a new crontab file for the executing user (can be overridden by root
+	for setup of uucp and news).  the advantage of this is that (1) when
+	a crontab is changed, the daemon can be informed automatically; and
+	(2) the file can be syntax-checked before installation.		>>
+From ptsfa!ames!seismo!ihnp4!lcc!richard Fri Jan 16 04:47:33 1987
+Date: Fri, 16 Jan 87 07:44:57 EST
+To: nike!ptsfa!vixie!paul
+Status: RO
+
+The System V cron is nice, but it has a few annoying features.  One is that
+its mail files will say that the previous message is the output of "one of your
+cron commands."  I wish it would say WHICH cron commmand.
+
+<<	Done.  Also which shell, which user (useful when the mail gets
+	forwarded), which home directory, and other useful crud.	>>
+
+Another problem is with timezones.  It is necessary to specify TZ=PST8PDT (or
+whatever) when you invoke cron (from inittab, or /etc/rc) and it is also
+necessary to add TZ=PST8PDT to each crontab line which might need it.  Cron
+should automatically export its idea of the "TZ" to each invoked command, and
+it should be possible to put a line in the crontab file which overrides that
+for every command in the file (e.g., most users are on EST, so cron is run
+with TZ=EST5EDT; but one user is usually on PST and wants all of his cron
+commands to run with TZ=PST8PDT).  This might be extended to allow any
+environment variable to be specified once for the whole crontab file (e.g.,
+PATH).
+
+<<	Well, since I run the user's shell, you could put this into .cshrc.
+	generic environment-variable setting could be useful, though.  Since
+	I have to modify the environment anyway, I'll consider this.	  >>
+
+A log file might be a nice idea, but the System V cron log is too verbose.
+I seem to remember that cron keeps it open, too; so you can't even have
+something go and periodically clean it out.
+
+<<	I don't do /usr/lib/cron/log.  I wasn't aware of this file until I
+	got all these suggestions.  Do people want this file?  Tell me!    >>
diff --git a/usr.sbin/cron/doc/Makefile.vixie b/usr.sbin/cron/doc/Makefile.vixie
new file mode 100644
index 000000000000..3dab5ad16372
--- /dev/null
+++ b/usr.sbin/cron/doc/Makefile.vixie
@@ -0,0 +1,128 @@
+#/* Copyright 1988,1990,1993,1994 by Paul Vixie
+# * All rights reserved
+# *
+# * Distribute freely, except: don't remove my name from the source or
+# * documentation (don't take credit for my work), mark your changes (don't
+# * get me blamed for your possible bugs), don't alter or remove this
+# * notice.  May be sold if buildable source is provided to buyer.  No
+# * warrantee of any kind, express or implied, is included with this
+# * software; use at your own risk, responsibility for damages (if any) to
+# * anyone resulting from the use of this software rests entirely with the
+# * user.
+# *
+# * Send bug reports, bug fixes, enhancements, requests, flames, etc., and
+# * I'll try to keep a version up to date.  I can be reached as follows:
+# * Paul Vixie          <paul@vix.com>          uunet!decwrl!vixie!paul
+# */
+
+# Makefile for vixie's cron
+#
+# $Id: Makefile,v 2.9 1994/01/15 20:43:43 vixie Exp $
+#
+# vix 03mar88 [moved to RCS, rest of log is in there]
+# vix 30mar87 [goodbye, time.c; hello, getopt]
+# vix 12feb87 [cleanup for distribution]
+# vix 30dec86 [written]
+
+# NOTES:
+#	'make' can be done by anyone
+#	'make install' must be done by root
+#
+#	this package needs getopt(3), bitstring(3), and BSD install(8).
+#
+#	the configurable stuff in this makefile consists of compilation
+#	options (use -O, cron runs forever) and destination directories.
+#	SHELL is for the 'augumented make' systems where 'make' imports
+#	SHELL from the environment and then uses it to run its commands.
+#	if your environment SHELL variable is /bin/csh, make goes real
+#	slow and sometimes does the wrong thing.  
+#
+#	this package needs the 'bitstring macros' library, which is
+#	available from me or from the comp.sources.unix archive.  if you
+#	put 'bitstring.h' in a non-standard place (i.e., not intuited by
+#	cc(1)), you will have to define INCLUDE to set the include
+#	directory for cc.  INCLUDE should be `-Isomethingorother'.
+#
+#	there's more configuration info in config.h; edit that first!
+
+#################################### begin configurable stuff
+#<<DESTROOT is assumed to have ./etc, ./bin, and ./man subdirectories>>
+DESTROOT	=	$(DESTDIR)/usr
+DESTSBIN	=	$(DESTROOT)/sbin
+DESTBIN		=	$(DESTROOT)/bin
+DESTMAN		=	$(DESTROOT)/share/man
+#<<need bitstring.h>>
+INCLUDE		=	-I.
+#INCLUDE	=
+#<<need getopt()>>
+LIBS		=
+#<<optimize or debug?>>
+#OPTIM		=	-O
+OPTIM		=	-g
+#<<ATT or BSD or POSIX?>>
+# (ATT untested)
+#COMPAT		=	-DATT
+#(BSD is only needed if <sys/params.h> does not define it, as on ULTRIX)
+#COMPAT		=	-DBSD
+# (POSIX)
+#COMPAT		=	-DPOSIX
+#<<lint flags of choice?>>
+LINTFLAGS	=	-hbxa $(INCLUDE) $(COMPAT) $(DEBUGGING)
+#<<want to use a nonstandard CC?>>
+#CC		=	vcc
+#<<manifest defines>>
+DEFS		=
+#(SGI IRIX systems need this)
+#DEFS		=	-D_BSD_SIGNALS -Dconst=
+#<<the name of the BSD-like install program>>
+#INSTALL = installbsd
+INSTALL = install
+#<<any special load flags>>
+LDFLAGS		=
+#################################### end configurable stuff
+
+SHELL		=	/bin/sh
+CFLAGS		=	$(OPTIM) $(INCLUDE) $(COMPAT) $(DEFS)
+
+INFOS		=	README CHANGES FEATURES INSTALL CONVERSION THANKS MAIL
+MANPAGES	=	bitstring.3 crontab.5 crontab.1 cron.8 putman.sh
+HEADERS		=	bitstring.h cron.h config.h pathnames.h \
+			externs.h compat.h
+SOURCES		=	cron.c crontab.c database.c do_command.c entry.c \
+			env.c job.c user.c popen.c misc.c compat.c
+SHAR_SOURCE	=	$(INFOS) $(MANPAGES) Makefile $(HEADERS) $(SOURCES)
+LINT_CRON	=	cron.c database.c user.c entry.c compat.c \
+			misc.c job.c do_command.c env.c popen.c
+LINT_CRONTAB	=	crontab.c misc.c entry.c env.c compat.c
+CRON_OBJ	=	cron.o database.o user.o entry.o job.o do_command.o \
+			misc.o env.o popen.o compat.o
+CRONTAB_OBJ	=	crontab.o misc.o entry.o env.o compat.o
+
+all		:	cron crontab
+
+lint		:
+			lint $(LINTFLAGS) $(LINT_CRON) $(LIBS) \
+			|grep -v "constant argument to NOT" 2>&1
+			lint $(LINTFLAGS) $(LINT_CRONTAB) $(LIBS) \
+			|grep -v "constant argument to NOT" 2>&1
+
+cron		:	$(CRON_OBJ)
+			$(CC) $(LDFLAGS) -o cron $(CRON_OBJ) $(LIBS)
+
+crontab		:	$(CRONTAB_OBJ)
+			$(CC) $(LDFLAGS) -o crontab $(CRONTAB_OBJ) $(LIBS)
+
+install		:	all
+			$(INSTALL) -c -m  111 -o root -s cron    $(DESTSBIN)/
+			$(INSTALL) -c -m 4111 -o root -s crontab $(DESTBIN)/
+			sh putman.sh crontab.1 $(DESTMAN)
+			sh putman.sh cron.8    $(DESTMAN)
+			sh putman.sh crontab.5 $(DESTMAN)
+
+clean		:;	rm -f *.o cron crontab a.out core tags *~ #*
+
+kit		:	$(SHAR_SOURCE)
+			makekit -m -s99k $(SHAR_SOURCE)
+
+$(CRON_OBJ)	:	cron.h compat.h config.h externs.h pathnames.h Makefile
+$(CRONTAB_OBJ)	:	cron.h compat.h config.h externs.h pathnames.h Makefile
diff --git a/usr.sbin/cron/doc/README b/usr.sbin/cron/doc/README
new file mode 100644
index 000000000000..751f04f646fc
--- /dev/null
+++ b/usr.sbin/cron/doc/README
@@ -0,0 +1,72 @@
+#/* Copyright 1988,1990,1993 by Paul Vixie
+# * All rights reserved
+# *
+# * Distribute freely, except: don't remove my name from the source or
+# * documentation (don't take credit for my work), mark your changes (don't
+# * get me blamed for your possible bugs), don't alter or remove this
+# * notice.  May be sold if buildable source is provided to buyer.  No
+# * warrantee of any kind, express or implied, is included with this
+# * software; use at your own risk, responsibility for damages (if any) to
+# * anyone resulting from the use of this software rests entirely with the
+# * user.
+# *
+# * Send bug reports, bug fixes, enhancements, requests, flames, etc., and
+# * I'll try to keep a version up to date.  I can be reached as follows:
+# * Paul Vixie          <paul@vix.com>          uunet!decwrl!vixie!paul
+# */
+
+Vixie Cron V3.0
+December 27, 1993
+[V2.2 was some time in 1992]
+[V2.1 was May 29, 1991]
+[V2.0 was July 5, 1990]
+[V2.0-beta was December 9, 1988]
+[V1.0 was May 6, 1987]
+Paul Vixie
+
+This is a version of 'cron' that is known to run on BSD 4.[23] systems.  It
+is functionally based on the SysV cron, which means that each user can have
+their own crontab file (all crontab files are stored in a read-protected
+directory, usually /var/cron/tabs).  No direct support is provided for
+'at'; you can continue to run 'atrun' from the crontab as you have been
+doing.  If you don't have atrun (i.e., System V) you are in trouble.
+
+A messages is logged each time a command is executed; also, the files
+"allow" and "deny" in /var/cron can be used to control access to the
+"crontab" command (which installs crontabs).  It hasn't been tested on
+SysV, although some effort has gone into making the port an easy one.
+
+This is more or less the copyright that USENET contributed software usually
+has.  Since ATT couldn't use this version if they had to freely distribute
+source, and since I'd love to see them use it, I'll offer some rediculously
+low license fee just to have them take it.  In the unlikely event that they
+do this, I will continue to support and distribute the pseudo-PD version, so
+please, don't flame me for wanting my work to see a wider distribution.
+
+To use this: Sorry, folks, there is no cutesy 'Configure' script.  You'll
+have to go edit a couple of files... So, here's the checklist:
+
+	Read all the FEATURES, INSTALL, and CONVERSION files
+	Edit config.h
+	Edit Makefile
+		(both of these files have instructions inside; note that
+		 some things in config.h are definable in Makefile and are
+		 therefore surrounded by #ifndef...#endif)
+	'make'
+	'su' and 'make install'
+		(you may have to install the man pages by hand)
+	kill your existing cron process
+		(actually you can run your existing cron if you want, but why?)
+	build new crontabs using /usr/lib/{crontab,crontab.local}
+		(either put them all in "root"'s crontab, or divide it up
+		 and rip out all the 'su' commands, collapse the lengthy
+		 lists into ranges with steps -- basically, this step is
+		 as much work as you want to make it)
+	start up the new cron
+		(must be done as root)
+	watch it. test it with 'crontab -r' and watch the daemon track your
+		changes.
+	if you like it, change your /etc/{rc,rc.local} to use it instead of
+		the old one.
+
+$Id: README,v 2.3 1993/12/28 08:34:43 vixie Exp $
diff --git a/usr.sbin/cron/doc/README.1ST b/usr.sbin/cron/doc/README.1ST
new file mode 100644
index 000000000000..66cd0b237bd2
--- /dev/null
+++ b/usr.sbin/cron/doc/README.1ST
@@ -0,0 +1,4 @@
+Sources substantially rearranged 26 Aug 94, Jordan Hubbard.  Content
+remains faithful to the original 3.0 cron source from Paul Vixie, but
+any bugs introduced by this reorganization or the port to FreeBSD remain
+purely my own.  - Jordan
diff --git a/usr.sbin/cron/doc/THANKS b/usr.sbin/cron/doc/THANKS
new file mode 100644
index 000000000000..3787c2943d7a
--- /dev/null
+++ b/usr.sbin/cron/doc/THANKS
@@ -0,0 +1,29 @@
+15 January 1990
+Paul Vixie
+
+Many people have contributed to cron.  Many more than I can remember, in fact.
+Rich Salz and Carl Gutekunst were each of enormous help to me in V1; Carl for
+helping me understand UNIX well enough to write it, and Rich for helping me
+get the features right.
+
+John Gilmore wrote me a wonderful review of V2, which took me a whole year to
+answer even though it made me clean up some really awful things in the code.
+(According to John the most awful things are still in here, of course.)
+
+Paul Close made a suggestion which led to /etc/crond.pid and the mutex locking
+on it.  Kevin Braunsdorf of Purdue made a suggestion that led to @reboot and
+its brothers and sisters; he also sent some diffs that lead cron toward compil-
+ability with System V, though without at(1) capabilities, this cron isn't going
+to be that useful on System V.  Bob Alverson fixed a silly bug in the line
+number counting.  Brian Reid made suggestions which led to the run queue and
+the source-file labelling in installed crontabs.
+
+Scott Narveson ported V2 to a Sequent, and sent in the most useful single batch
+of diffs I got from anybody.  Changes attributable to Scott are:
+	-> sendmail won't time out if the command is slow to generate output
+	-> day-of-week names aren't off by one anymore
+	-> crontab says the right thing if you do something you shouldn't do
+	-> crontab(5) man page is longer and more informative
+	-> misc changes related to the side effects of fclose()
+	-> Sequent "universe" support added (may also help on Pyramids)
+	-> null pw_shell is dealt with now; default is /bin/sh
diff --git a/usr.sbin/cron/lib/Makefile b/usr.sbin/cron/lib/Makefile
new file mode 100644
index 000000000000..f3c7632bc66a
--- /dev/null
+++ b/usr.sbin/cron/lib/Makefile
@@ -0,0 +1,8 @@
+LIB=	cron
+
+SRCS=	entry.c env.c misc.c
+CFLAGS+= -I${.CURDIR}/../cron
+NOSHARED=	yes
+NOPROFILE=	yes
+
+.include <bsd.lib.mk>
diff --git a/usr.sbin/cron/lib/compat.c b/usr.sbin/cron/lib/compat.c
new file mode 100644
index 000000000000..205c73163d8d
--- /dev/null
+++ b/usr.sbin/cron/lib/compat.c
@@ -0,0 +1,233 @@
+/* Copyright 1988,1990,1993,1994 by Paul Vixie
+ * All rights reserved
+ *
+ * Distribute freely, except: don't remove my name from the source or
+ * documentation (don't take credit for my work), mark your changes (don't
+ * get me blamed for your possible bugs), don't alter or remove this
+ * notice.  May be sold if buildable source is provided to buyer.  No
+ * warrantee of any kind, express or implied, is included with this
+ * software; use at your own risk, responsibility for damages (if any) to
+ * anyone resulting from the use of this software rests entirely with the
+ * user.
+ *
+ * Send bug reports, bug fixes, enhancements, requests, flames, etc., and
+ * I'll try to keep a version up to date.  I can be reached as follows:
+ * Paul Vixie          <paul@vix.com>          uunet!decwrl!vixie!paul
+ */
+
+#if !defined(lint) && !defined(LINT)
+static char rcsid[] = "$Id: compat.c,v 1.6 1994/01/15 20:43:43 vixie Exp $";
+#endif
+
+/* vix 30dec93 [broke this out of misc.c - see RCS log for history]
+ * vix 15jan87 [added TIOCNOTTY, thanks csg@pyramid]
+ */
+
+
+#include "cron.h"
+#ifdef NEED_GETDTABLESIZE
+# include <limits.h>
+#endif
+#if defined(NEED_SETSID) && defined(BSD)
+# include <sys/ioctl.h>
+#endif
+#include <errno.h>
+
+
+/* the code does not depend on any of vfork's
+ * side-effects; it just uses it as a quick
+ * fork-and-exec.
+ */
+#ifdef NEED_VFORK
+PID_T
+vfork() {
+	return (fork());
+}
+#endif
+
+
+#ifdef NEED_STRDUP
+char *
+strdup(str)
+	char	*str;
+{
+	char	*temp;
+
+	temp = malloc(strlen(str) + 1);
+	(void) strcpy(temp, str);
+	return temp;
+}
+#endif
+
+
+#ifdef NEED_STRERROR
+char *
+strerror(error)
+	int error;
+{
+	extern char *sys_errlist[];
+	extern int sys_nerr;
+	static char buf[32];
+
+	if ((error <= sys_nerr) && (error > 0)) {
+		return sys_errlist[error];
+	}
+
+	sprintf(buf, "Unknown error: %d", error);
+	return buf;
+}
+#endif
+
+
+#ifdef NEED_STRCASECMP
+int
+strcasecmp(left, right)
+	char	*left;
+	char	*right;
+{
+	while (*left && (MkLower(*left) == MkLower(*right))) {
+		left++;
+		right++;
+	}
+	return MkLower(*left) - MkLower(*right);
+}
+#endif
+
+
+#ifdef NEED_SETSID
+int
+setsid()
+{
+	int	newpgrp;
+# if defined(BSD)
+	int	fd;
+#  if defined(POSIX)
+	newpgrp = setpgid((pid_t)0, getpid());
+#  else
+	newpgrp = setpgrp(0, getpid());
+#  endif
+	if ((fd = open("/dev/tty", 2)) >= 0)
+	{
+		(void) ioctl(fd, TIOCNOTTY, (char*)0);
+		(void) close(fd);
+	}
+# else /*BSD*/
+	newpgrp = setpgrp();
+
+	(void) close(STDIN);	(void) open("/dev/null", 0);
+	(void) close(STDOUT);	(void) open("/dev/null", 1);
+	(void) close(STDERR);	(void) open("/dev/null", 2);
+# endif /*BSD*/
+	return newpgrp;
+}
+#endif /*NEED_SETSID*/
+
+
+#ifdef NEED_GETDTABLESIZE
+int
+getdtablesize() {
+#ifdef _SC_OPEN_MAX
+	return sysconf(_SC_OPEN_MAX);
+#else
+	return _POSIX_OPEN_MAX;
+#endif
+}
+#endif
+
+
+#ifdef NEED_FLOCK
+/* The following flock() emulation snarfed intact *) from the HP-UX
+ * "BSD to HP-UX porting tricks" maintained by
+ * system@alchemy.chem.utoronto.ca (System Admin (Mike Peterson))
+ * from the version "last updated: 11-Jan-1993"
+ * Snarfage done by Jarkko Hietaniemi <Jarkko.Hietaniemi@hut.fi>
+ * *) well, almost, had to K&R the function entry, HPUX "cc"
+ * does not grok ANSI function prototypes */
+ 
+/*
+ * flock (fd, operation)
+ *
+ * This routine performs some file locking like the BSD 'flock'
+ * on the object described by the int file descriptor 'fd',
+ * which must already be open.
+ *
+ * The operations that are available are:
+ *
+ * LOCK_SH  -  get a shared lock.
+ * LOCK_EX  -  get an exclusive lock.
+ * LOCK_NB  -  don't block (must be ORed with LOCK_SH or LOCK_EX).
+ * LOCK_UN  -  release a lock.
+ *
+ * Return value: 0 if lock successful, -1 if failed.
+ *
+ * Note that whether the locks are enforced or advisory is
+ * controlled by the presence or absence of the SETGID bit on
+ * the executable.
+ *
+ * Note that there is no difference between shared and exclusive
+ * locks, since the 'lockf' system call in SYSV doesn't make any
+ * distinction.
+ *
+ * The file "<sys/file.h>" should be modified to contain the definitions
+ * of the available operations, which must be added manually (see below
+ * for the values).
+ */
+
+/* this code has been reformatted by vixie */
+
+int
+flock(fd, operation)
+	int fd;
+	int operation;
+{
+	int i;
+
+	switch (operation) {
+	case LOCK_SH:		/* get a shared lock */
+	case LOCK_EX:		/* get an exclusive lock */
+		i = lockf (fd, F_LOCK, 0);
+		break;
+
+	case LOCK_SH|LOCK_NB:	/* get a non-blocking shared lock */
+	case LOCK_EX|LOCK_NB:	/* get a non-blocking exclusive lock */
+		i = lockf (fd, F_TLOCK, 0);
+		if (i == -1)
+			if ((errno == EAGAIN) || (errno == EACCES))
+				errno = EWOULDBLOCK;
+		break;
+
+	case LOCK_UN:		/* unlock */
+		i = lockf (fd, F_ULOCK, 0);
+		break;
+ 
+	default:		/* can't decipher operation */
+		i = -1;
+		errno = EINVAL;
+		break;
+	}
+ 
+	return (i);
+}
+#endif /*NEED_FLOCK*/
+
+
+#ifdef NEED_SETENV
+int
+setenv(name, value, overwrite)
+	char *name, *value;
+	int overwrite;
+{
+	char *tmp;
+
+	if (overwrite && getenv(name))
+		return -1;
+
+	if (!(tmp = malloc(strlen(name) + strlen(value) + 2))) {
+		errno = ENOMEM;
+		return -1;
+	}
+
+	sprintf("%s=%s", name, value);
+	return putenv(tmp);	/* intentionally orphan 'tmp' storage */
+}
+#endif
diff --git a/usr.sbin/cron/lib/entry.c b/usr.sbin/cron/lib/entry.c
new file mode 100644
index 000000000000..03273a38ddb2
--- /dev/null
+++ b/usr.sbin/cron/lib/entry.c
@@ -0,0 +1,507 @@
+/* Copyright 1988,1990,1993,1994 by Paul Vixie
+ * All rights reserved
+ *
+ * Distribute freely, except: don't remove my name from the source or
+ * documentation (don't take credit for my work), mark your changes (don't
+ * get me blamed for your possible bugs), don't alter or remove this
+ * notice.  May be sold if buildable source is provided to buyer.  No
+ * warrantee of any kind, express or implied, is included with this
+ * software; use at your own risk, responsibility for damages (if any) to
+ * anyone resulting from the use of this software rests entirely with the
+ * user.
+ *
+ * Send bug reports, bug fixes, enhancements, requests, flames, etc., and
+ * I'll try to keep a version up to date.  I can be reached as follows:
+ * Paul Vixie          <paul@vix.com>          uunet!decwrl!vixie!paul
+ */
+
+#if !defined(lint) && !defined(LINT)
+static char rcsid[] = "$Id: entry.c,v 2.12 1994/01/17 03:20:37 vixie Exp $";
+#endif
+
+/* vix 26jan87 [RCS'd; rest of log is in RCS file]
+ * vix 01jan87 [added line-level error recovery]
+ * vix 31dec86 [added /step to the from-to range, per bob@acornrc]
+ * vix 30dec86 [written]
+ */
+
+
+#include "cron.h"
+
+
+typedef	enum ecode {
+	e_none, e_minute, e_hour, e_dom, e_month, e_dow,
+	e_cmd, e_timespec, e_username
+} ecode_e;
+
+static char	get_list __P((bitstr_t *, int, int, char *[], int, FILE *)),
+		get_range __P((bitstr_t *, int, int, char *[], int, FILE *)),
+		get_number __P((int *, int, char *[], int, FILE *));
+static int	set_element __P((bitstr_t *, int, int, int));
+
+static char *ecodes[] =
+	{
+		"no error",
+		"bad minute",
+		"bad hour",
+		"bad day-of-month",
+		"bad month",
+		"bad day-of-week",
+		"bad command",
+		"bad time specifier",
+		"bad username",
+	};
+
+
+void
+free_entry(e)
+	entry	*e;
+{
+	free(e->cmd);
+	env_free(e->envp);
+	free(e);
+}
+
+
+/* return NULL if eof or syntax error occurs;
+ * otherwise return a pointer to a new entry.
+ */
+entry *
+load_entry(file, error_func, pw, envp)
+	FILE		*file;
+	void		(*error_func)();
+	struct passwd	*pw;
+	char		**envp;
+{
+	/* this function reads one crontab entry -- the next -- from a file.
+	 * it skips any leading blank lines, ignores comments, and returns
+	 * EOF if for any reason the entry can't be read and parsed.
+	 *
+	 * the entry is also parsed here.
+	 *
+	 * syntax:
+	 *   user crontab:
+	 *	minutes hours doms months dows cmd\n
+	 *   system crontab (/etc/crontab):
+	 *	minutes hours doms months dows USERNAME cmd\n
+	 */
+
+	ecode_e	ecode = e_none;
+	entry	*e;
+	int	ch;
+	char	cmd[MAX_COMMAND];
+	char	envstr[MAX_ENVSTR];
+
+	Debug(DPARS, ("load_entry()...about to eat comments\n"))
+
+	skip_comments(file);
+
+	ch = get_char(file);
+	if (ch == EOF)
+		return NULL;
+
+	/* ch is now the first useful character of a useful line.
+	 * it may be an @special or it may be the first character
+	 * of a list of minutes.
+	 */
+
+	e = (entry *) calloc(sizeof(entry), sizeof(char));
+
+	if (ch == '@') {
+		/* all of these should be flagged and load-limited; i.e.,
+		 * instead of @hourly meaning "0 * * * *" it should mean
+		 * "close to the front of every hour but not 'til the
+		 * system load is low".  Problems are: how do you know
+		 * what "low" means? (save me from /etc/cron.conf!) and:
+		 * how to guarantee low variance (how low is low?), which
+		 * means how to we run roughly every hour -- seems like
+		 * we need to keep a history or let the first hour set
+		 * the schedule, which means we aren't load-limited
+		 * anymore.  too much for my overloaded brain. (vix, jan90)
+		 * HINT
+		 */
+		ch = get_string(cmd, MAX_COMMAND, file, " \t\n");
+		if (!strcmp("reboot", cmd)) {
+			e->flags |= WHEN_REBOOT;
+		} else if (!strcmp("yearly", cmd) || !strcmp("annually", cmd)){
+			bit_set(e->minute, 0);
+			bit_set(e->hour, 0);
+			bit_set(e->dom, 0);
+			bit_set(e->month, 0);
+			bit_nset(e->dow, 0, (LAST_DOW-FIRST_DOW+1));
+		} else if (!strcmp("monthly", cmd)) {
+			bit_set(e->minute, 0);
+			bit_set(e->hour, 0);
+			bit_set(e->dom, 0);
+			bit_nset(e->month, 0, (LAST_MONTH-FIRST_MONTH+1));
+			bit_nset(e->dow, 0, (LAST_DOW-FIRST_DOW+1));
+		} else if (!strcmp("weekly", cmd)) {
+			bit_set(e->minute, 0);
+			bit_set(e->hour, 0);
+			bit_nset(e->dom, 0, (LAST_DOM-FIRST_DOM+1));
+			bit_nset(e->month, 0, (LAST_MONTH-FIRST_MONTH+1));
+			bit_set(e->dow, 0);
+		} else if (!strcmp("daily", cmd) || !strcmp("midnight", cmd)) {
+			bit_set(e->minute, 0);
+			bit_set(e->hour, 0);
+			bit_nset(e->dom, 0, (LAST_DOM-FIRST_DOM+1));
+			bit_nset(e->month, 0, (LAST_MONTH-FIRST_MONTH+1));
+			bit_nset(e->dow, 0, (LAST_DOW-FIRST_DOW+1));
+		} else if (!strcmp("hourly", cmd)) {
+			bit_set(e->minute, 0);
+			bit_set(e->hour, (LAST_HOUR-FIRST_HOUR+1));
+			bit_nset(e->dom, 0, (LAST_DOM-FIRST_DOM+1));
+			bit_nset(e->month, 0, (LAST_MONTH-FIRST_MONTH+1));
+			bit_nset(e->dow, 0, (LAST_DOW-FIRST_DOW+1));
+		} else {
+			ecode = e_timespec;
+			goto eof;
+		}
+	} else {
+		Debug(DPARS, ("load_entry()...about to parse numerics\n"))
+
+		ch = get_list(e->minute, FIRST_MINUTE, LAST_MINUTE,
+			      PPC_NULL, ch, file);
+		if (ch == EOF) {
+			ecode = e_minute;
+			goto eof;
+		}
+
+		/* hours
+		 */
+
+		ch = get_list(e->hour, FIRST_HOUR, LAST_HOUR,
+			      PPC_NULL, ch, file);
+		if (ch == EOF) {
+			ecode = e_hour;
+			goto eof;
+		}
+
+		/* DOM (days of month)
+		 */
+
+		if (ch == '*')
+			e->flags |= DOM_STAR;
+		ch = get_list(e->dom, FIRST_DOM, LAST_DOM,
+			      PPC_NULL, ch, file);
+		if (ch == EOF) {
+			ecode = e_dom;
+			goto eof;
+		}
+
+		/* month
+		 */
+
+		ch = get_list(e->month, FIRST_MONTH, LAST_MONTH,
+			      MonthNames, ch, file);
+		if (ch == EOF) {
+			ecode = e_month;
+			goto eof;
+		}
+
+		/* DOW (days of week)
+		 */
+
+		if (ch == '*')
+			e->flags |= DOW_STAR;
+		ch = get_list(e->dow, FIRST_DOW, LAST_DOW,
+			      DowNames, ch, file);
+		if (ch == EOF) {
+			ecode = e_dow;
+			goto eof;
+		}
+	}
+
+	/* make sundays equivilent */
+	if (bit_test(e->dow, 0) || bit_test(e->dow, 7)) {
+		bit_set(e->dow, 0);
+		bit_set(e->dow, 7);
+	}
+
+	/* ch is the first character of a command, or a username */
+	unget_char(ch, file);
+
+	if (!pw) {
+		char		*username = cmd;	/* temp buffer */
+
+		Debug(DPARS, ("load_entry()...about to parse username\n"))
+		ch = get_string(username, MAX_COMMAND, file, " \t");
+
+		Debug(DPARS, ("load_entry()...got %s\n",username))
+		if (ch == EOF) {
+			ecode = e_cmd;
+			goto eof;
+		}
+
+		pw = getpwnam(username);
+		if (pw == NULL) {
+			ecode = e_username;
+			goto eof;
+		}
+		Debug(DPARS, ("load_entry()...uid %d, gid %d\n",e->uid,e->gid))
+	}
+
+	e->uid = pw->pw_uid;
+	e->gid = pw->pw_gid;
+
+	/* copy and fix up environment.  some variables are just defaults and
+	 * others are overrides.
+	 */
+	e->envp = env_copy(envp);
+	if (!env_get("SHELL", e->envp)) {
+		sprintf(envstr, "SHELL=%s", _PATH_BSHELL);
+		e->envp = env_set(e->envp, envstr);
+	}
+	if (!env_get("HOME", e->envp)) {
+		sprintf(envstr, "HOME=%s", pw->pw_dir);
+		e->envp = env_set(e->envp, envstr);
+	}
+	if (!env_get("PATH", e->envp)) {
+		sprintf(envstr, "PATH=%s", _PATH_DEFPATH);
+		e->envp = env_set(e->envp, envstr);
+	}
+	sprintf(envstr, "%s=%s", "LOGNAME", pw->pw_name);
+	e->envp = env_set(e->envp, envstr);
+#if defined(BSD)
+	sprintf(envstr, "%s=%s", "USER", pw->pw_name);
+	e->envp = env_set(e->envp, envstr);
+#endif
+
+	Debug(DPARS, ("load_entry()...about to parse command\n"))
+
+	/* Everything up to the next \n or EOF is part of the command...
+	 * too bad we don't know in advance how long it will be, since we
+	 * need to malloc a string for it... so, we limit it to MAX_COMMAND.
+	 * XXX - should use realloc().
+	 */ 
+	ch = get_string(cmd, MAX_COMMAND, file, "\n");
+
+	/* a file without a \n before the EOF is rude, so we'll complain...
+	 */
+	if (ch == EOF) {
+		ecode = e_cmd;
+		goto eof;
+	}
+
+	/* got the command in the 'cmd' string; save it in *e.
+	 */
+	e->cmd = strdup(cmd);
+
+	Debug(DPARS, ("load_entry()...returning successfully\n"))
+
+	/* success, fini, return pointer to the entry we just created...
+	 */
+	return e;
+
+ eof:
+	free(e);
+	if (ecode != e_none && error_func)
+		(*error_func)(ecodes[(int)ecode]);
+	while (ch != EOF && ch != '\n')
+		ch = get_char(file);
+	return NULL;
+}
+
+
+static char
+get_list(bits, low, high, names, ch, file)
+	bitstr_t	*bits;		/* one bit per flag, default=FALSE */
+	int		low, high;	/* bounds, impl. offset for bitstr */
+	char		*names[];	/* NULL or *[] of names for these elements */
+	int		ch;		/* current character being processed */
+	FILE		*file;		/* file being read */
+{
+	register int	done;
+
+	/* we know that we point to a non-blank character here;
+	 * must do a Skip_Blanks before we exit, so that the
+	 * next call (or the code that picks up the cmd) can
+	 * assume the same thing.
+	 */
+
+	Debug(DPARS|DEXT, ("get_list()...entered\n"))
+
+	/* list = range {"," range}
+	 */
+	
+	/* clear the bit string, since the default is 'off'.
+	 */
+	bit_nclear(bits, 0, (high-low+1));
+
+	/* process all ranges
+	 */
+	done = FALSE;
+	while (!done) {
+		ch = get_range(bits, low, high, names, ch, file);
+		if (ch == ',')
+			ch = get_char(file);
+		else
+			done = TRUE;
+	}
+
+	/* exiting.  skip to some blanks, then skip over the blanks.
+	 */
+	Skip_Nonblanks(ch, file)
+	Skip_Blanks(ch, file)
+
+	Debug(DPARS|DEXT, ("get_list()...exiting w/ %02x\n", ch))
+
+	return ch;
+}
+
+
+static char
+get_range(bits, low, high, names, ch, file)
+	bitstr_t	*bits;		/* one bit per flag, default=FALSE */
+	int		low, high;	/* bounds, impl. offset for bitstr */
+	char		*names[];	/* NULL or names of elements */
+	int		ch;		/* current character being processed */
+	FILE		*file;		/* file being read */
+{
+	/* range = number | number "-" number [ "/" number ]
+	 */
+
+	register int	i;
+	auto int	num1, num2, num3;
+
+	Debug(DPARS|DEXT, ("get_range()...entering, exit won't show\n"))
+
+	if (ch == '*') {
+		/* '*' means "first-last" but can still be modified by /step
+		 */
+		num1 = low;
+		num2 = high;
+		ch = get_char(file);
+		if (ch == EOF)
+			return EOF;
+	} else {
+		if (EOF == (ch = get_number(&num1, low, names, ch, file)))
+			return EOF;
+
+		if (ch != '-') {
+			/* not a range, it's a single number.
+			 */
+			if (EOF == set_element(bits, low, high, num1))
+				return EOF;
+			return ch;
+		} else {
+			/* eat the dash
+			 */
+			ch = get_char(file);
+			if (ch == EOF)
+				return EOF;
+
+			/* get the number following the dash
+			 */
+			ch = get_number(&num2, low, names, ch, file);
+			if (ch == EOF)
+				return EOF;
+		}
+	}
+
+	/* check for step size
+	 */
+	if (ch == '/') {
+		/* eat the slash
+		 */
+		ch = get_char(file);
+		if (ch == EOF)
+			return EOF;
+
+		/* get the step size -- note: we don't pass the
+		 * names here, because the number is not an
+		 * element id, it's a step size.  'low' is
+		 * sent as a 0 since there is no offset either.
+		 */
+		ch = get_number(&num3, 0, PPC_NULL, ch, file);
+		if (ch == EOF)
+			return EOF;
+	} else {
+		/* no step.  default==1.
+		 */
+		num3 = 1;
+	}
+
+	/* range. set all elements from num1 to num2, stepping
+	 * by num3.  (the step is a downward-compatible extension
+	 * proposed conceptually by bob@acornrc, syntactically
+	 * designed then implmented by paul vixie).
+	 */
+	for (i = num1;  i <= num2;  i += num3)
+		if (EOF == set_element(bits, low, high, i))
+			return EOF;
+
+	return ch;
+}
+
+
+static char
+get_number(numptr, low, names, ch, file)
+	int	*numptr;	/* where does the result go? */
+	int	low;		/* offset applied to result if symbolic enum used */
+	char	*names[];	/* symbolic names, if any, for enums */
+	int	ch;		/* current character */
+	FILE	*file;		/* source */
+{
+	char	temp[MAX_TEMPSTR], *pc;
+	int	len, i, all_digits;
+
+	/* collect alphanumerics into our fixed-size temp array
+	 */
+	pc = temp;
+	len = 0;
+	all_digits = TRUE;
+	while (isalnum(ch)) {
+		if (++len >= MAX_TEMPSTR)
+			return EOF;
+
+		*pc++ = ch;
+
+		if (!isdigit(ch))
+			all_digits = FALSE;
+
+		ch = get_char(file);
+	}
+	*pc = '\0';
+
+	/* try to find the name in the name list
+	 */
+	if (names) {
+		for (i = 0;  names[i] != NULL;  i++) {
+			Debug(DPARS|DEXT,
+				("get_num, compare(%s,%s)\n", names[i], temp))
+			if (!strcasecmp(names[i], temp)) {
+				*numptr = i+low;
+				return ch;
+			}
+		}
+	}
+
+	/* no name list specified, or there is one and our string isn't
+	 * in it.  either way: if it's all digits, use its magnitude.
+	 * otherwise, it's an error.
+	 */
+	if (all_digits) {
+		*numptr = atoi(temp);
+		return ch;
+	}
+
+	return EOF;
+}
+
+
+static int
+set_element(bits, low, high, number)
+	bitstr_t	*bits; 		/* one bit per flag, default=FALSE */
+	int		low;
+	int		high;
+	int		number;
+{
+	Debug(DPARS|DEXT, ("set_element(?,%d,%d,%d)\n", low, high, number))
+
+	if (number < low || number > high)
+		return EOF;
+
+	bit_set(bits, (number-low));
+	return OK;
+}
diff --git a/usr.sbin/cron/lib/env.c b/usr.sbin/cron/lib/env.c
new file mode 100644
index 000000000000..535cb3729b66
--- /dev/null
+++ b/usr.sbin/cron/lib/env.c
@@ -0,0 +1,178 @@
+/* Copyright 1988,1990,1993,1994 by Paul Vixie
+ * All rights reserved
+ *
+ * Distribute freely, except: don't remove my name from the source or
+ * documentation (don't take credit for my work), mark your changes (don't
+ * get me blamed for your possible bugs), don't alter or remove this
+ * notice.  May be sold if buildable source is provided to buyer.  No
+ * warrantee of any kind, express or implied, is included with this
+ * software; use at your own risk, responsibility for damages (if any) to
+ * anyone resulting from the use of this software rests entirely with the
+ * user.
+ *
+ * Send bug reports, bug fixes, enhancements, requests, flames, etc., and
+ * I'll try to keep a version up to date.  I can be reached as follows:
+ * Paul Vixie          <paul@vix.com>          uunet!decwrl!vixie!paul
+ */
+
+#if !defined(lint) && !defined(LINT)
+static char rcsid[] = "$Id: env.c,v 2.6 1994/01/15 20:43:43 vixie Exp $";
+#endif
+
+
+#include "cron.h"
+
+
+char **
+env_init()
+{
+	register char	**p = (char **) malloc(sizeof(char **));
+
+	p[0] = NULL;
+	return (p);
+}
+
+
+void
+env_free(envp)
+	char	**envp;
+{
+	char	**p;
+
+	for (p = envp;  *p;  p++)
+		free(*p);
+	free(envp);
+}
+
+
+char **
+env_copy(envp)
+	register char	**envp;
+{
+	register int	count, i;
+	register char	**p;
+
+	for (count = 0;  envp[count] != NULL;  count++)
+		;
+	p = (char **) malloc((count+1) * sizeof(char *));  /* 1 for the NULL */
+	for (i = 0;  i < count;  i++)
+		p[i] = strdup(envp[i]);
+	p[count] = NULL;
+	return (p);
+}
+
+
+char **
+env_set(envp, envstr)
+	char	**envp;
+	char	*envstr;
+{
+	register int	count, found;
+	register char	**p;
+
+	/*
+	 * count the number of elements, including the null pointer;
+	 * also set 'found' to -1 or index of entry if already in here.
+	 */
+	found = -1;
+	for (count = 0;  envp[count] != NULL;  count++) {
+		if (!strcmp_until(envp[count], envstr, '='))
+			found = count;
+	}
+	count++;	/* for the NULL */
+
+	if (found != -1) {
+		/*
+		 * it exists already, so just free the existing setting,
+		 * save our new one there, and return the existing array.
+		 */
+		free(envp[found]);
+		envp[found] = strdup(envstr);
+		return (envp);
+	}
+
+	/*
+	 * it doesn't exist yet, so resize the array, move null pointer over
+	 * one, save our string over the old null pointer, and return resized
+	 * array.
+	 */
+	p = (char **) realloc((void *) envp,
+			      (unsigned) ((count+1) * sizeof(char **)));
+	p[count] = p[count-1];
+	p[count-1] = strdup(envstr);
+	return (p);
+}
+
+
+/* return	ERR = end of file
+ *		FALSE = not an env setting (file was repositioned)
+ *		TRUE = was an env setting
+ */
+int
+load_env(envstr, f)
+	char	*envstr;
+	FILE	*f;
+{
+	long	filepos;
+	int	fileline;
+	char	name[MAX_TEMPSTR], val[MAX_ENVSTR];
+	int	fields;
+
+	filepos = ftell(f);
+	fileline = LineNumber;
+	skip_comments(f);
+	if (EOF == get_string(envstr, MAX_ENVSTR, f, "\n"))
+		return (ERR);
+
+	Debug(DPARS, ("load_env, read <%s>\n", envstr))
+
+	name[0] = val[0] = '\0';
+	fields = sscanf(envstr, "%[^ =] = %[^\n#]", name, val);
+	if (fields != 2) {
+		Debug(DPARS, ("load_env, not 2 fields (%d)\n", fields))
+		fseek(f, filepos, 0);
+		Set_LineNum(fileline);
+		return (FALSE);
+	}
+
+	/* 2 fields from scanf; looks like an env setting
+	 */
+
+	/*
+	 * process value string
+	 */
+	/*local*/{
+		int	len = strdtb(val);
+
+		if (len >= 2) {
+			if (val[0] == '\'' || val[0] == '"') {
+				if (val[len-1] == val[0]) {
+					val[len-1] = '\0';
+					(void) strcpy(val, val+1);
+				}
+			}
+		}
+	}
+
+	(void) sprintf(envstr, "%s=%s", name, val);
+	Debug(DPARS, ("load_env, <%s> <%s> -> <%s>\n", name, val, envstr))
+	return (TRUE);
+}
+
+
+char *
+env_get(name, envp)
+	register char	*name;
+	register char	**envp;
+{
+	register int	len = strlen(name);
+	register char	*p, *q;
+
+	while (p = *envp++) {
+		if (!(q = strchr(p, '=')))
+			continue;
+		if ((q - p) == len && !strncmp(p, name, len))
+			return (q+1);
+	}
+	return (NULL);
+}
diff --git a/usr.sbin/cron/lib/misc.c b/usr.sbin/cron/lib/misc.c
new file mode 100644
index 000000000000..c912ffb3acca
--- /dev/null
+++ b/usr.sbin/cron/lib/misc.c
@@ -0,0 +1,664 @@
+/* Copyright 1988,1990,1993,1994 by Paul Vixie
+ * All rights reserved
+ *
+ * Distribute freely, except: don't remove my name from the source or
+ * documentation (don't take credit for my work), mark your changes (don't
+ * get me blamed for your possible bugs), don't alter or remove this
+ * notice.  May be sold if buildable source is provided to buyer.  No
+ * warrantee of any kind, express or implied, is included with this
+ * software; use at your own risk, responsibility for damages (if any) to
+ * anyone resulting from the use of this software rests entirely with the
+ * user.
+ *
+ * Send bug reports, bug fixes, enhancements, requests, flames, etc., and
+ * I'll try to keep a version up to date.  I can be reached as follows:
+ * Paul Vixie          <paul@vix.com>          uunet!decwrl!vixie!paul
+ */
+
+#if !defined(lint) && !defined(LINT)
+static char rcsid[] = "$Id: misc.c,v 2.9 1994/01/15 20:43:43 vixie Exp $";
+#endif
+
+/* vix 26jan87 [RCS has the rest of the log]
+ * vix 30dec86 [written]
+ */
+
+
+#include "cron.h"
+#if SYS_TIME_H
+# include <sys/time.h>
+#else
+# include <time.h>
+#endif
+#include <sys/file.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <string.h>
+#include <fcntl.h>
+#if defined(SYSLOG)
+# include <syslog.h>
+#endif
+
+
+#if defined(LOG_DAEMON) && !defined(LOG_CRON)
+#define LOG_CRON LOG_DAEMON
+#endif
+
+
+static int		LogFD = ERR;
+
+
+int
+strcmp_until(left, right, until)
+	char	*left;
+	char	*right;
+	int	until;
+{
+	register int	diff;
+
+	while (*left && *left != until && *left == *right) {
+		left++;
+		right++;
+	}
+
+	if ((*left=='\0' || *left == until) &&
+	    (*right=='\0' || *right == until)) {
+		diff = 0;
+	} else {
+		diff = *left - *right;
+	}
+
+	return diff;
+}
+
+
+/* strdtb(s) - delete trailing blanks in string 's' and return new length
+ */
+int
+strdtb(s)
+	char	*s;
+{
+	char	*x = s;
+
+	/* scan forward to the null
+	 */
+	while (*x)
+		x++;
+
+	/* scan backward to either the first character before the string,
+	 * or the last non-blank in the string, whichever comes first.
+	 */
+	do	{x--;}
+	while (x >= s && isspace(*x));
+
+	/* one character beyond where we stopped above is where the null
+	 * goes.
+	 */
+	*++x = '\0';
+
+	/* the difference between the position of the null character and
+	 * the position of the first character of the string is the length.
+	 */
+	return x - s;
+}
+
+
+int
+set_debug_flags(flags)
+	char	*flags;
+{
+	/* debug flags are of the form    flag[,flag ...]
+	 *
+	 * if an error occurs, print a message to stdout and return FALSE.
+	 * otherwise return TRUE after setting ERROR_FLAGS.
+	 */
+
+#if !DEBUGGING
+
+	printf("this program was compiled without debugging enabled\n");
+	return FALSE;
+
+#else /* DEBUGGING */
+
+	char	*pc = flags;
+
+	DebugFlags = 0;
+
+	while (*pc) {
+		char	**test;
+		int	mask;
+
+		/* try to find debug flag name in our list.
+		 */
+		for (	test = DebugFlagNames, mask = 1;
+			*test && strcmp_until(*test, pc, ',');
+			test++, mask <<= 1
+		    )
+			;
+
+		if (!*test) {
+			fprintf(stderr,
+				"unrecognized debug flag <%s> <%s>\n",
+				flags, pc);
+			return FALSE;
+		}
+
+		DebugFlags |= mask;
+
+		/* skip to the next flag
+		 */
+		while (*pc && *pc != ',')
+			pc++;
+		if (*pc == ',')
+			pc++;
+	}
+
+	if (DebugFlags) {
+		int	flag;
+
+		fprintf(stderr, "debug flags enabled:");
+
+		for (flag = 0;  DebugFlagNames[flag];  flag++)
+			if (DebugFlags & (1 << flag))
+				fprintf(stderr, " %s", DebugFlagNames[flag]);
+		fprintf(stderr, "\n");
+	}
+
+	return TRUE;
+
+#endif /* DEBUGGING */
+}
+
+
+void
+set_cron_uid()
+{
+#if defined(BSD) || defined(POSIX)
+	if (seteuid(ROOT_UID) < OK) {
+		perror("seteuid");
+		exit(ERROR_EXIT);
+	}
+#else
+	if (setuid(ROOT_UID) < OK) {
+		perror("setuid");
+		exit(ERROR_EXIT);
+	}
+#endif
+}
+
+
+void
+set_cron_cwd()
+{
+	struct stat	sb;
+
+	/* first check for CRONDIR ("/var/cron" or some such)
+	 */
+	if (stat(CRONDIR, &sb) < OK && errno == ENOENT) {
+		perror(CRONDIR);
+		if (OK == mkdir(CRONDIR, 0700)) {
+			fprintf(stderr, "%s: created\n", CRONDIR);
+			stat(CRONDIR, &sb);
+		} else {
+			fprintf(stderr, "%s: ", CRONDIR);
+			perror("mkdir");
+			exit(ERROR_EXIT);
+		}
+	}
+	if (!(sb.st_mode & S_IFDIR)) {
+		fprintf(stderr, "'%s' is not a directory, bailing out.\n",
+			CRONDIR);
+		exit(ERROR_EXIT);
+	}
+	if (chdir(CRONDIR) < OK) {
+		fprintf(stderr, "cannot chdir(%s), bailing out.\n", CRONDIR);
+		perror(CRONDIR);
+		exit(ERROR_EXIT);
+	}
+
+	/* CRONDIR okay (now==CWD), now look at SPOOL_DIR ("tabs" or some such)
+	 */
+	if (stat(SPOOL_DIR, &sb) < OK && errno == ENOENT) {
+		perror(SPOOL_DIR);
+		if (OK == mkdir(SPOOL_DIR, 0700)) {
+			fprintf(stderr, "%s: created\n", SPOOL_DIR);
+			stat(SPOOL_DIR, &sb);
+		} else {
+			fprintf(stderr, "%s: ", SPOOL_DIR);
+			perror("mkdir");
+			exit(ERROR_EXIT);
+		}
+	}
+	if (!(sb.st_mode & S_IFDIR)) {
+		fprintf(stderr, "'%s' is not a directory, bailing out.\n",
+			SPOOL_DIR);
+		exit(ERROR_EXIT);
+	}
+}
+
+
+/* acquire_daemonlock() - write our PID into /etc/cron.pid, unless
+ *	another daemon is already running, which we detect here.
+ *
+ * note: main() calls us twice; once before forking, once after.
+ *	we maintain static storage of the file pointer so that we
+ *	can rewrite our PID into the PIDFILE after the fork.
+ *
+ * it would be great if fflush() disassociated the file buffer.
+ */
+void
+acquire_daemonlock(closeflag)
+	int closeflag;
+{
+	static	FILE	*fp = NULL;
+
+	if (closeflag && fp) {
+		fclose(fp);
+		fp = NULL;
+		return;
+	}
+
+	if (!fp) {
+		char	pidfile[MAX_FNAME];
+		char	buf[MAX_TEMPSTR];
+		int	fd, otherpid;
+
+		(void) sprintf(pidfile, PIDFILE, PIDDIR);
+		if ((-1 == (fd = open(pidfile, O_RDWR|O_CREAT, 0644)))
+		    || (NULL == (fp = fdopen(fd, "r+")))
+		    ) {
+			sprintf(buf, "can't open or create %s: %s",
+				pidfile, strerror(errno));
+			fprintf(stderr, "%s: %s\n", ProgramName, buf);
+			log_it("CRON", getpid(), "DEATH", buf);
+			exit(ERROR_EXIT);
+		}
+
+		if (flock(fd, LOCK_EX|LOCK_NB) < OK) {
+			int save_errno = errno;
+
+			fscanf(fp, "%d", &otherpid);
+			sprintf(buf, "can't lock %s, otherpid may be %d: %s",
+				pidfile, otherpid, strerror(save_errno));
+			fprintf(stderr, "%s: %s\n", ProgramName, buf);
+			log_it("CRON", getpid(), "DEATH", buf);
+			exit(ERROR_EXIT);
+		}
+
+		(void) fcntl(fd, F_SETFD, 1);
+	}
+
+	rewind(fp);
+	fprintf(fp, "%d\n", getpid());
+	fflush(fp);
+	(void) ftruncate(fileno(fp), ftell(fp));
+
+	/* abandon fd and fp even though the file is open. we need to
+	 * keep it open and locked, but we don't need the handles elsewhere.
+	 */
+}
+
+/* get_char(file) : like getc() but increment LineNumber on newlines
+ */
+int
+get_char(file)
+	FILE	*file;
+{
+	int	ch;
+
+	ch = getc(file);
+	if (ch == '\n')
+		Set_LineNum(LineNumber + 1)
+	return ch;
+}
+
+
+/* unget_char(ch, file) : like ungetc but do LineNumber processing
+ */
+void
+unget_char(ch, file)
+	int	ch;
+	FILE	*file;
+{
+	ungetc(ch, file);
+	if (ch == '\n')
+		Set_LineNum(LineNumber - 1)
+}
+
+
+/* get_string(str, max, file, termstr) : like fgets() but
+ *		(1) has terminator string which should include \n
+ *		(2) will always leave room for the null
+ *		(3) uses get_char() so LineNumber will be accurate
+ *		(4) returns EOF or terminating character, whichever
+ */
+int
+get_string(string, size, file, terms)
+	char	*string;
+	int	size;
+	FILE	*file;
+	char	*terms;
+{
+	int	ch;
+
+	while (EOF != (ch = get_char(file)) && !strchr(terms, ch)) {
+		if (size > 1) {
+			*string++ = (char) ch;
+			size--;
+		}
+	}
+
+	if (size > 0)
+		*string = '\0';
+
+	return ch;
+}
+
+
+/* skip_comments(file) : read past comment (if any)
+ */
+void
+skip_comments(file)
+	FILE	*file;
+{
+	int	ch;
+
+	while (EOF != (ch = get_char(file))) {
+		/* ch is now the first character of a line.
+		 */
+
+		while (ch == ' ' || ch == '\t')
+			ch = get_char(file);
+
+		if (ch == EOF)
+			break;
+
+		/* ch is now the first non-blank character of a line.
+		 */
+
+		if (ch != '\n' && ch != '#')
+			break;
+
+		/* ch must be a newline or comment as first non-blank
+		 * character on a line.
+		 */
+
+		while (ch != '\n' && ch != EOF)
+			ch = get_char(file);
+
+		/* ch is now the newline of a line which we're going to
+		 * ignore.
+		 */
+	}
+	if (ch != EOF)
+		unget_char(ch, file);
+}
+
+
+/* int in_file(char *string, FILE *file)
+ *	return TRUE if one of the lines in file matches string exactly,
+ *	FALSE otherwise.
+ */
+static int
+in_file(string, file)
+	char *string;
+	FILE *file;
+{
+	char line[MAX_TEMPSTR];
+
+	rewind(file);
+	while (fgets(line, MAX_TEMPSTR, file)) {
+		if (line[0] != '\0')
+			line[strlen(line)-1] = '\0';
+		if (0 == strcmp(line, string))
+			return TRUE;
+	}
+	return FALSE;
+}
+
+
+/* int allowed(char *username)
+ *	returns TRUE if (ALLOW_FILE exists and user is listed)
+ *	or (DENY_FILE exists and user is NOT listed)
+ *	or (neither file exists but user=="root" so it's okay)
+ */
+int
+allowed(username)
+	char *username;
+{
+	static int	init = FALSE;
+	static FILE	*allow, *deny;
+
+	if (!init) {
+		init = TRUE;
+#if defined(ALLOW_FILE) && defined(DENY_FILE)
+		allow = fopen(ALLOW_FILE, "r");
+		deny = fopen(DENY_FILE, "r");
+		Debug(DMISC, ("allow/deny enabled, %d/%d\n", !!allow, !!deny))
+#else
+		allow = NULL;
+		deny = NULL;
+#endif
+	}
+
+	if (allow)
+		return (in_file(username, allow));
+	if (deny)
+		return (!in_file(username, deny));
+
+#if defined(ALLOW_ONLY_ROOT)
+	return (strcmp(username, ROOT_USER) == 0);
+#else
+	return TRUE;
+#endif
+}
+
+
+void
+log_it(username, xpid, event, detail)
+	char	*username;
+	int	xpid;
+	char	*event;
+	char	*detail;
+{
+	PID_T			pid = xpid;
+#if defined(LOG_FILE)
+	char			*msg;
+	TIME_T			now = time((TIME_T) 0);
+	register struct tm	*t = localtime(&now);
+#endif /*LOG_FILE*/
+
+#if defined(SYSLOG)
+	static int		syslog_open = 0;
+#endif
+
+#if defined(LOG_FILE)
+	/* we assume that MAX_TEMPSTR will hold the date, time, &punctuation.
+	 */
+	msg = malloc(strlen(username)
+		     + strlen(event)
+		     + strlen(detail)
+		     + MAX_TEMPSTR);
+
+	if (LogFD < OK) {
+		LogFD = open(LOG_FILE, O_WRONLY|O_APPEND|O_CREAT, 0600);
+		if (LogFD < OK) {
+			fprintf(stderr, "%s: can't open log file\n",
+				ProgramName);
+			perror(LOG_FILE);
+		} else {
+			(void) fcntl(LogFD, F_SETFD, 1);
+		}
+	}
+
+	/* we have to sprintf() it because fprintf() doesn't always write
+	 * everything out in one chunk and this has to be atomically appended
+	 * to the log file.
+	 */
+	sprintf(msg, "%s (%02d/%02d-%02d:%02d:%02d-%d) %s (%s)\n",
+		username,
+		t->tm_mon+1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec, pid,
+		event, detail);
+
+	/* we have to run strlen() because sprintf() returns (char*) on old BSD
+	 */
+	if (LogFD < OK || write(LogFD, msg, strlen(msg)) < OK) {
+		if (LogFD >= OK)
+			perror(LOG_FILE);
+		fprintf(stderr, "%s: can't write to log file\n", ProgramName);
+		write(STDERR, msg, strlen(msg));
+	}
+
+	free(msg);
+#endif /*LOG_FILE*/
+
+#if defined(SYSLOG)
+	if (!syslog_open) {
+		/* we don't use LOG_PID since the pid passed to us by
+		 * our client may not be our own.  therefore we want to
+		 * print the pid ourselves.
+		 */
+# ifdef LOG_DAEMON
+		openlog(ProgramName, LOG_PID, LOG_CRON);
+# else
+		openlog(ProgramName, LOG_PID);
+# endif
+		syslog_open = TRUE;		/* assume openlog success */
+	}
+
+	syslog(LOG_INFO, "(%s) %s (%s)\n", username, event, detail);
+
+#endif /*SYSLOG*/
+
+#if DEBUGGING
+	if (DebugFlags) {
+		fprintf(stderr, "log_it: (%s %d) %s (%s)\n",
+			username, pid, event, detail);
+	}
+#endif
+}
+
+
+void
+log_close() {
+	if (LogFD != ERR) {
+		close(LogFD);
+		LogFD = ERR;
+	}
+}
+
+
+/* two warnings:
+ *	(1) this routine is fairly slow
+ *	(2) it returns a pointer to static storage
+ */
+char *
+first_word(s, t)
+	register char *s;	/* string we want the first word of */
+	register char *t;	/* terminators, implicitly including \0 */
+{
+	static char retbuf[2][MAX_TEMPSTR + 1];	/* sure wish C had GC */
+	static int retsel = 0;
+	register char *rb, *rp;
+
+	/* select a return buffer */
+	retsel = 1-retsel;
+	rb = &retbuf[retsel][0];
+	rp = rb;
+
+	/* skip any leading terminators */
+	while (*s && (NULL != strchr(t, *s))) {
+		s++;
+	}
+
+	/* copy until next terminator or full buffer */
+	while (*s && (NULL == strchr(t, *s)) && (rp < &rb[MAX_TEMPSTR])) {
+		*rp++ = *s++;
+	}
+
+	/* finish the return-string and return it */
+	*rp = '\0';
+	return rb;
+}
+
+
+/* warning:
+ *	heavily ascii-dependent.
+ */
+void
+mkprint(dst, src, len)
+	register char *dst;
+	register unsigned char *src;
+	register int len;
+{
+	while (len-- > 0)
+	{
+		register unsigned char ch = *src++;
+
+		if (ch < ' ') {			/* control character */
+			*dst++ = '^';
+			*dst++ = ch + '@';
+		} else if (ch < 0177) {		/* printable */
+			*dst++ = ch;
+		} else if (ch == 0177) {	/* delete/rubout */
+			*dst++ = '^';
+			*dst++ = '?';
+		} else {			/* parity character */
+			sprintf(dst, "\\%03o", ch);
+			dst += 4;
+		}
+	}
+	*dst = '\0';
+}
+
+
+/* warning:
+ *	returns a pointer to malloc'd storage, you must call free yourself.
+ */
+char *
+mkprints(src, len)
+	register unsigned char *src;
+	register unsigned int len;
+{
+	register char *dst = malloc(len*4 + 1);
+
+	mkprint(dst, src, len);
+
+	return dst;
+}
+
+
+#ifdef MAIL_DATE
+/* Sat, 27 Feb 93 11:44:51 CST
+ * 123456789012345678901234567
+ */
+char *
+arpadate(clock)
+	time_t *clock;
+{
+	time_t t = clock ?*clock :time(0L);
+	struct tm *tm = localtime(&t);
+	static char ret[30];	/* zone name might be >3 chars */
+	
+	(void) sprintf(ret, "%s, %2d %s %2d %02d:%02d:%02d %s",
+		       DowNames[tm->tm_wday],
+		       tm->tm_mday,
+		       MonthNames[tm->tm_mon],
+		       tm->tm_year,
+		       tm->tm_hour,
+		       tm->tm_min,
+		       tm->tm_sec,
+		       TZONE(*tm));
+	return ret;
+}
+#endif /*MAIL_DATE*/
+
+
+#ifdef HAVE_SAVED_SUIDS
+static int save_euid;
+int swap_uids() { save_euid = geteuid(); return seteuid(getuid()); }
+int swap_uids_back() { return seteuid(save_euid); }
+#else /*HAVE_SAVED_UIDS*/
+int swap_uids() { return setreuid(geteuid(), getuid()); }
+int swap_uids_back() { return swap_uids(); }
+#endif /*HAVE_SAVED_UIDS*/