xntpd 3.3b from UDel

64 files changed, 6024 insertions, 0 deletions

diff --git a/usr.sbin/xntpd/lib/Makefile.tmpl b/usr.sbin/xntpd/lib/Makefile.tmpl
new file mode 100644
index 0000000..697edcf
--- /dev/null
+++ b/usr.sbin/xntpd/lib/Makefile.tmpl
@@ -0,0 +1,75 @@
+#
+# Makefile.tmpl,v 3.1 1993/07/06 01:07:38 jbj Exp
+#
+LIBNAME=	libntp
+#
+# xntp routines which are used a lot of places
+#
+COMPILER= cc
+COPTS= -O
+AUTHDEFS=-DDES
+LIBDEFS= -DBIG_ENDIAN
+RANLIB=		ranlib
+INSTALL= install
+CLOCKDEFS=
+DEFS=
+DEFS_OPT=
+DEFS_LOCAL=
+#
+INCL=-I../include
+CFLAGS=	$(COPTS) $(AUTHDEFS) $(LIBDEFS) $(DEFS) $(DEFS_LOCAL) $(INCL)
+CC=		$(COMPILER)
+#
+SOURCE=	atoint.c atolfp.c atouint.c auth12crypt.c authdecrypt.c authdes.c \
+	authencrypt.c authkeys.c authparity.c authreadkeys.c authusekey.c \
+	buftvtots.c caljulian.c calleapwhen.c caltontp.c calyearstart.c \
+	clocktime.c dofptoa.c dolfptoa.c emalloc.c fptoa.c fptoms.c getopt.c \
+	gettstamp.c hextoint.c hextolfp.c humandate.c inttoa.c \
+	lib_strbuf.c mfptoa.c mfptoms.c modetoa.c mstolfp.c \
+	msutotsf.c numtoa.c refnumtoa.c numtohost.c octtoint.c \
+	prettydate.c ranny.c tsftomsu.c tstotv.c tvtoa.c tvtots.c \
+	uglydate.c uinttoa.c utvtoa.c machines.c clocktypes.c \
+	md5.c a_md5encrypt.c a_md5decrypt.c \
+	a_md512crypt.c decodenetnum.c systime.c msyslog.c syssignal.c \
+	findconfig.c
+
+OBJS=	atoint.o atolfp.o atouint.o auth12crypt.o authdecrypt.o authdes.o \
+	authencrypt.o authkeys.o authparity.o authreadkeys.o authusekey.o \
+	buftvtots.o caljulian.o calleapwhen.o caltontp.o calyearstart.o \
+	clocktime.o dofptoa.o dolfptoa.o emalloc.o fptoa.o fptoms.o getopt.o \
+	gettstamp.o hextoint.o hextolfp.o humandate.o inttoa.o \
+	lib_strbuf.o mfptoa.o mfptoms.o modetoa.o mstolfp.o \
+	msutotsf.o numtoa.o refnumtoa.o numtohost.o octtoint.o \
+	prettydate.o ranny.o tsftomsu.o tstotv.o tvtoa.o tvtots.o \
+	uglydate.o uinttoa.o utvtoa.o machines.o clocktypes.o \
+	md5.o a_md5encrypt.o a_md5decrypt.o \
+	a_md512crypt.o decodenetnum.o systime.o msyslog.o syssignal.o \
+	findconfig.o
+
+$(LIBNAME).a:	$(OBJS)
+	ar rv $@ $?
+	-rm -f $?
+	@if ( hp-pa || hp-mc680x0 ) > /dev/null 2>&1; then \
+		( cd ../adjtime && $(MAKE) $(MFLAGS) MFLAGS="$(MFLAGS)" MAKE="$(MAKE)" ) && ar rv $@ ../adjtime/adjtime.o; \
+	 else \
+		:; \
+	 fi
+	$(RANLIB) $@
+
+lintlib:	llib-l$(LIBNAME).ln
+
+llib-l$(LIBNAME).ln:	$(SOURCE)
+	lint -C$(LIBNAME) $(INCL) $(CLOCKDEFS) $(AUTHDEFS) $(LIBDEFS) $(SOURCE) >lintlib.errs
+
+lint:
+	lint -u $(DEFS) $(INCL) $(CLOCKDEFS) $(AUTHDEFS) $(LIBDEFS) $(SOURCE) >lint.errs
+
+depend:
+	mkdep $(CFLAGS) $(SOURCE)
+
+clean:
+	-@rm -f $(LIBNAME).a *.o *.out *.ln make.log Makefile.bak \
+		lintlib.errs lint.errs
+
+distclean:	clean
+	-@rm -f *.orig *.rej .version Makefile
diff --git a/usr.sbin/xntpd/lib/README b/usr.sbin/xntpd/lib/README
new file mode 100644
index 0000000..c2b65d9
--- /dev/null
+++ b/usr.sbin/xntpd/lib/README
@@ -0,0 +1,5 @@
+README file for directory ./lib of the NTP Version 3 distribution
+
+This directory contains the sources for the NTP library used by most
+programs in this distribution. See the README and RELNOTES files in the
+parent directory for directions on how to make this library.
diff --git a/usr.sbin/xntpd/lib/a_md512crypt.c b/usr.sbin/xntpd/lib/a_md512crypt.c
new file mode 100644
index 0000000..a3714a2
--- /dev/null
+++ b/usr.sbin/xntpd/lib/a_md512crypt.c
@@ -0,0 +1,86 @@
+/* authmd512crypt.c,v 3.1 1993/07/06 01:07:52 jbj Exp
+ *  md5crypt - MD5 based authentication routines
+ */
+
+#include "ntp_types.h"
+#include "ntp_string.h"
+#include "md5.h"
+#include "ntp_stdlib.h"
+
+extern U_LONG cache_keyid;
+extern char *cache_key;
+extern int cache_keylen;
+
+/*
+ * Stat counters, imported from data base module
+ */
+extern U_LONG authencryptions;
+extern U_LONG authdecryptions;
+extern U_LONG authkeyuncached;
+extern U_LONG authdecryptok;
+extern U_LONG authnokey;
+
+/*
+ * For our purposes an NTP packet looks like:
+ *
+ *	a variable amount of encrypted data, multiple of 8 bytes, followed by:
+ *	NOCRYPT_OCTETS worth of unencrypted data, followed by:
+ *	BLOCK_OCTETS worth of ciphered checksum.
+ */ 
+#define	NOCRYPT_OCTETS	4
+#define	BLOCK_OCTETS	16
+
+#define	NOCRYPT_LONGS	((NOCRYPT_OCTETS)/sizeof(U_LONG))
+#define	BLOCK_LONGS	((BLOCK_OCTETS)/sizeof(U_LONG))
+
+static MD5_CTX ctx;
+
+/*
+ *  Do first stage of a two stage authenticator generation.
+ */
+
+void
+MD5auth1crypt(keyno, pkt, length)
+    U_LONG keyno;
+    U_LONG *pkt;
+    int length;	/* length of all encrypted data */
+{
+
+    authencryptions++;
+
+    if (keyno != cache_keyid) {
+	authkeyuncached++;
+	if (!authhavekey(keyno)) {
+	    authnokey++;
+	    return;
+	}
+    }
+
+    MD5Init(&ctx);
+    MD5Update(&ctx, cache_key, cache_keylen);
+    MD5Update(&ctx, (char *)pkt, length - 8);
+    /* just leave the partially computed value in the static MD5_CTX */
+}
+
+/*
+ *  Do second state of a two stage authenticator generation.
+ */
+int
+MD5auth2crypt(keyno, pkt, length)
+    U_LONG keyno;
+    U_LONG *pkt;
+    int length;	/* total length of encrypted area */
+{
+    /*
+     *  Don't bother checking the keys.  The first stage would have
+     *  handled that.  Finish up the generation by also including the
+     *  last 8 bytes of the data area.
+     */
+
+    MD5Update(&ctx, (char *)(pkt) + length - 8, 8);
+    MD5Final(&ctx);
+
+    bcopy((char *)ctx.digest, (char *) &pkt[NOCRYPT_LONGS + length/sizeof(U_LONG)],
+	  BLOCK_OCTETS);
+    return 4 + BLOCK_OCTETS;
+}
diff --git a/usr.sbin/xntpd/lib/a_md5decrypt.c b/usr.sbin/xntpd/lib/a_md5decrypt.c
new file mode 100644
index 0000000..892e52e
--- /dev/null
+++ b/usr.sbin/xntpd/lib/a_md5decrypt.c
@@ -0,0 +1,58 @@
+/* authmd5decrypt.c,v 3.1 1993/07/06 01:07:53 jbj Exp
+ *  md5crypt - MD5 based authentication routines
+ */
+
+#include "ntp_types.h"
+#include "ntp_string.h"
+#include "md5.h"
+#include "ntp_stdlib.h"
+
+extern U_LONG cache_keyid;
+extern char *cache_key;
+extern int cache_keylen;
+
+/*
+ * Stat counters, imported from data base module
+ */
+extern U_LONG authencryptions;
+extern U_LONG authdecryptions;
+extern U_LONG authkeyuncached;
+extern U_LONG authdecryptok;
+extern U_LONG authnokey;
+
+/*
+ * For our purposes an NTP packet looks like:
+ *
+ *	a variable amount of encrypted data, multiple of 8 bytes, followed by:
+ *	NOCRYPT_OCTETS worth of unencrypted data, followed by:
+ *	BLOCK_OCTETS worth of ciphered checksum.
+ */ 
+#define	NOCRYPT_OCTETS	4
+#define	BLOCK_OCTETS	16
+
+#define	NOCRYPT_LONGS	((NOCRYPT_OCTETS)/sizeof(U_LONG))
+#define	BLOCK_LONGS	((BLOCK_OCTETS)/sizeof(U_LONG))
+
+int
+MD5authdecrypt(keyno, pkt, length)
+    U_LONG keyno;
+    const U_LONG *pkt;
+    int length;		/* length of variable data in octets */
+{
+    MD5_CTX ctx;
+
+    authdecryptions++;
+
+    if (keyno != cache_keyid) {
+	authkeyuncached++;
+	if (!authhavekey(keyno))
+	    return 0;
+    }
+
+    MD5Init(&ctx);
+    MD5Update(&ctx, cache_key, cache_keylen);
+    MD5Update(&ctx, (char *)pkt, length);
+    MD5Final(&ctx);
+
+    return (0 == bcmp((char *)ctx.digest, (char *)pkt + length + 4, BLOCK_OCTETS));
+}
diff --git a/usr.sbin/xntpd/lib/a_md5encrypt.c b/usr.sbin/xntpd/lib/a_md5encrypt.c
new file mode 100644
index 0000000..a26e8f0
--- /dev/null
+++ b/usr.sbin/xntpd/lib/a_md5encrypt.c
@@ -0,0 +1,68 @@
+/* authmd5encrypt.c,v 3.1 1993/07/06 01:07:54 jbj Exp
+ *  md5crypt - MD5 based authentication routines
+ */
+
+#include "ntp_types.h"
+#include "ntp_string.h"
+#include "md5.h"
+#include "ntp_stdlib.h"
+
+extern U_LONG cache_keyid;
+extern char *cache_key;
+extern int cache_keylen;
+
+/*
+ * Stat counters, imported from data base module
+ */
+extern U_LONG authencryptions;
+extern U_LONG authdecryptions;
+extern U_LONG authkeyuncached;
+extern U_LONG authdecryptok;
+extern U_LONG authnokey;
+
+/*
+ * For our purposes an NTP packet looks like:
+ *
+ *	a variable amount of encrypted data, multiple of 8 bytes, followed by:
+ *	NOCRYPT_OCTETS worth of unencrypted data, followed by:
+ *	BLOCK_OCTETS worth of ciphered checksum.
+ */ 
+#define	NOCRYPT_OCTETS	4
+#define	BLOCK_OCTETS	16
+
+#define	NOCRYPT_LONGS	((NOCRYPT_OCTETS)/sizeof(U_LONG))
+#define	BLOCK_LONGS	((BLOCK_OCTETS)/sizeof(U_LONG))
+
+
+int
+MD5authencrypt(keyno, pkt, length)
+    U_LONG keyno;
+    U_LONG *pkt;
+    int length;		/* length of encrypted portion of packet */
+{
+    MD5_CTX ctx;
+    int len;		/* in 4 byte quantities */
+
+    authencryptions++;
+
+    if (keyno != cache_keyid) {
+	authkeyuncached++;
+	if (!authhavekey(keyno)) {
+	    authnokey++;
+	    return 0;
+	}
+    }
+
+    len = length / sizeof(U_LONG);
+
+    /*
+     *  Generate the authenticator.
+     */
+    MD5Init(&ctx);
+    MD5Update(&ctx, cache_key, cache_keylen);
+    MD5Update(&ctx, (char *)pkt, length);
+    MD5Final(&ctx);
+
+    bcopy((char *)ctx.digest, (char *) &pkt[NOCRYPT_LONGS + len], BLOCK_OCTETS);
+    return 4 + BLOCK_OCTETS;	/* return size of key and MAC  */
+}
diff --git a/usr.sbin/xntpd/lib/adjtimex.c b/usr.sbin/xntpd/lib/adjtimex.c
new file mode 100644
index 0000000..03e9d79
--- /dev/null
+++ b/usr.sbin/xntpd/lib/adjtimex.c
@@ -0,0 +1,15 @@
+/*
+ * Copyright (c) 1983 Regents of the University of California.
+ * All rights reserved.  The Berkeley software License Agreement
+ * specifies the terms and conditions for redistribution.
+ */
+
+#ifndef lint
+_sccsid:.asciz  "11/19/91       ULTRIX  @(#)adjtime.c   6.1"
+#endif not lint
+
+#include "SYS.h"
+
+SYSCALL(adjtimex)
+        ret
+
diff --git a/usr.sbin/xntpd/lib/atoint.c b/usr.sbin/xntpd/lib/atoint.c
new file mode 100644
index 0000000..0e8ea8f
--- /dev/null
+++ b/usr.sbin/xntpd/lib/atoint.c
@@ -0,0 +1,48 @@
+/* atoint.c,v 3.1 1993/07/06 01:07:39 jbj Exp
+ * atoint - convert an ascii string to a signed long, with error checking
+ */
+#include <sys/types.h>
+#include <ctype.h>
+
+#include "ntp_types.h"
+
+int
+atoint(str, ival)
+	const char *str;
+	LONG *ival;
+{
+	register U_LONG u;
+	register const char *cp;
+	register int isneg;
+	register int oflow_digit;
+
+	cp = str;
+
+	if (*cp == '-') {
+		cp++;
+		isneg = 1;
+		oflow_digit = '8';
+	} else {
+		isneg = 0;
+		oflow_digit = '7';
+	}
+
+	if (*cp == '\0')
+		return 0;
+
+	u = 0;
+	while (*cp != '\0') {
+		if (!isdigit(*cp))
+			return 0;
+		if (u > 214748364 || (u == 214748364 && *cp > oflow_digit))
+			return 0;	/* overflow */
+		u = (u << 3) + (u << 1);
+		u += *cp++ - '0';	/* ascii dependent */
+	}
+
+	if (isneg)
+		*ival = -((LONG)u);
+	else 
+		*ival = (LONG)u;
+	return 1;
+}
diff --git a/usr.sbin/xntpd/lib/atolfp.c b/usr.sbin/xntpd/lib/atolfp.c
new file mode 100644
index 0000000..9e2d883
--- /dev/null
+++ b/usr.sbin/xntpd/lib/atolfp.c
@@ -0,0 +1,117 @@
+/* atolfp.c,v 3.1 1993/07/06 01:07:40 jbj Exp
+ * atolfp - convert an ascii string to an l_fp number
+ */
+#include <stdio.h>
+#include <ctype.h>
+
+#include "ntp_fp.h"
+#include "ntp_string.h"
+
+/*
+ * Powers of 10
+ */
+static U_LONG ten_to_the_n[10] = {
+		   0,
+		  10,
+		 100,
+		1000,
+	       10000,
+	      100000,
+	     1000000,
+	    10000000,
+	   100000000,
+	  1000000000,
+};
+
+
+int
+atolfp(str, lfp)
+	const char *str;
+	l_fp *lfp;
+{
+	register const char *cp;
+	register U_LONG dec_i;
+	register U_LONG dec_f;
+	char *ind;
+	int ndec;
+	int isneg;
+	static char *digits = "0123456789";
+
+	isneg = 0;
+	dec_i = dec_f = 0;
+	ndec = 0;
+	cp = str;
+
+	/*
+	 * We understand numbers of the form:
+	 *
+	 * [spaces][-|+][digits][.][digits][spaces|\n|\0]
+	 */
+	while (isspace(*cp))
+		cp++;
+	
+	if (*cp == '-') {
+		cp++;
+		isneg = 1;
+	}
+	
+	if (*cp == '+')
+		cp++;
+
+	if (*cp != '.' && !isdigit(*cp))
+		return 0;
+
+	while (*cp != '\0' && (ind = strchr(digits, *cp)) != NULL) {
+		dec_i = (dec_i << 3) + (dec_i << 1);	/* multiply by 10 */
+		dec_i += (ind - digits);
+		cp++;
+	}
+
+	if (*cp != '\0' && !isspace(*cp)) {
+		if (*cp++ != '.')
+			return 0;
+	
+		while (ndec < 9 && *cp != '\0'
+		    && (ind = strchr(digits, *cp)) != NULL) {
+			ndec++;
+			dec_f = (dec_f << 3) + (dec_f << 1);	/* *10 */
+			dec_f += (ind - digits);
+			cp++;
+		}
+
+		while (isdigit(*cp))
+			cp++;
+		
+		if (*cp != '\0' && !isspace(*cp))
+			return 0;
+	}
+
+	if (ndec > 0) {
+		register U_LONG tmp;
+		register U_LONG bit;
+		register U_LONG ten_fact;
+
+		ten_fact = ten_to_the_n[ndec];
+
+		tmp = 0;
+		bit = 0x80000000;
+		while (bit != 0) {
+			dec_f <<= 1;
+			if (dec_f >= ten_fact) {
+				tmp |= bit;
+				dec_f -= ten_fact;
+			}
+			bit >>= 1;
+		}
+		if ((dec_f << 1) > ten_fact)
+			tmp++;
+		dec_f = tmp;
+	}
+
+	if (isneg)
+		M_NEG(dec_i, dec_f);
+	
+	lfp->l_ui = dec_i;
+	lfp->l_uf = dec_f;
+	return 1;
+}
diff --git a/usr.sbin/xntpd/lib/atouint.c b/usr.sbin/xntpd/lib/atouint.c
new file mode 100644
index 0000000..b27653f
--- /dev/null
+++ b/usr.sbin/xntpd/lib/atouint.c
@@ -0,0 +1,33 @@
+/* atouint.c,v 3.1 1993/07/06 01:07:42 jbj Exp
+ * atouint - convert an ascii string to an unsigned long, with error checking
+ */
+#include <sys/types.h>
+#include <ctype.h>
+
+#include "ntp_types.h"
+
+int
+atouint(str, uval)
+	const char *str;
+	U_LONG *uval;
+{
+	register U_LONG u;
+	register const char *cp;
+
+	cp = str;
+	if (*cp == '\0')
+		return 0;
+
+	u = 0;
+	while (*cp != '\0') {
+		if (!isdigit(*cp))
+			return 0;
+		if (u > 429496729 || (u == 429496729 && *cp >= '6'))
+			return 0;	/* overflow */
+		u = (u << 3) + (u << 1);
+		u += *cp++ - '0';	/* ascii dependent */
+	}
+
+	*uval = u;
+	return 1;
+}
diff --git a/usr.sbin/xntpd/lib/auth12crypt.c b/usr.sbin/xntpd/lib/auth12crypt.c
new file mode 100644
index 0000000..a5d9889
--- /dev/null
+++ b/usr.sbin/xntpd/lib/auth12crypt.c
@@ -0,0 +1,125 @@
+/* auth12crypt.c,v 3.1 1993/07/06 01:07:43 jbj Exp
+ * auth12crypt.c - routines to support two stage NTP encryption
+ */
+#include "ntp_stdlib.h"
+
+/*
+ * For our purposes an NTP packet looks like:
+ *
+ *	a variable amount of encrypted data, multiple of 8 bytes, which
+ *		is encrypted in pass 1, followed by:
+ *	an 8 byte chunk of data which is encrypted in pass 2
+ *	NOCRYPT_OCTETS worth of unencrypted data, followed by:
+ *	BLOCK_OCTETS worth of ciphered checksum.
+ */ 
+#define	NOCRYPT_OCTETS	4
+#define	BLOCK_OCTETS	8
+
+#define	NOCRYPT_LONGS	((NOCRYPT_OCTETS)/sizeof(U_LONG))
+#define	BLOCK_LONGS	((BLOCK_OCTETS)/sizeof(U_LONG))
+
+/*
+ * Imported from the key data base module
+ */
+extern U_LONG cache_keyid;	/* cached key ID */
+extern u_char DEScache_ekeys[];	/* cached decryption keys */
+extern u_char DESzeroekeys[];	/* zero key decryption keys */
+
+/*
+ * Stat counters, from the database module
+ */
+extern U_LONG authencryptions;
+extern U_LONG authkeyuncached;
+extern U_LONG authnokey;
+
+
+/*
+ * auth1crypt - do the first stage of a two stage encryption
+ */
+void
+DESauth1crypt(keyno, pkt, length)
+	U_LONG keyno;
+	U_LONG *pkt;
+	int length;	/* length of all encrypted data */
+{
+	register U_LONG *pd;
+	register int i;
+	register u_char *keys;
+	U_LONG work[2];
+
+	authencryptions++;
+
+	if (keyno == 0) {
+		keys = DESzeroekeys;
+	} else {
+		if (keyno != cache_keyid) {
+			authkeyuncached++;
+			if (!authhavekey(keyno)) {
+				authnokey++;
+				return;
+			}
+		}
+		keys = DEScache_ekeys;
+	}
+
+	/*
+	 * Do the first five encryptions.  Stick the intermediate result
+	 * in the mac field.  The sixth encryption must wait until the
+	 * caller freezes a transmit time stamp, and will be done in stage 2.
+	 */
+	pd = pkt;
+	work[0] = work[1] = 0;
+
+	for (i = (length/BLOCK_OCTETS - 1); i > 0; i--) {
+		work[0] ^= *pd++;
+		work[1] ^= *pd++;
+		DESauth_des(work, keys);
+	}
+
+	/*
+	 * Space to the end of the packet and stick the intermediate
+	 * result in the mac field.
+	 */
+	pd += BLOCK_LONGS + NOCRYPT_LONGS;
+	*pd++ = work[0];
+	*pd = work[1];
+}
+
+
+/*
+ * auth2crypt - do the second stage of a two stage encryption
+ */
+int
+DESauth2crypt(keyno, pkt, length)
+	U_LONG keyno;
+	U_LONG *pkt;
+	int length;	/* total length of encrypted area */
+{
+	register U_LONG *pd;
+	register u_char *keys;
+
+	/*
+	 * Skip the key check.  The call to the first stage should
+	 * have got it.
+	 */
+	if (keyno == 0)
+		keys = DESzeroekeys;
+	else
+		keys = DEScache_ekeys;
+
+	/*
+	 * The mac currently should hold the results of the first `n'
+	 * encryptions.  We xor in the last block in data section and
+	 * do the final encryption in place.
+	 *
+	 * Get a pointer to the MAC block.  XOR in the last two words of
+	 * the data area. Call the encryption routine.
+	 */
+	pd = pkt + (length/sizeof(U_LONG)) + NOCRYPT_LONGS;
+
+	*pd ^= *(pd - NOCRYPT_LONGS - 2);
+	*(pd + 1) ^= *(pd - NOCRYPT_LONGS - 1);
+	DESauth_des(pd, keys);
+
+	return  4 + 8;		/* return size of key number and MAC */
+}
diff --git a/usr.sbin/xntpd/lib/authdecrypt.c b/usr.sbin/xntpd/lib/authdecrypt.c
new file mode 100644
index 0000000..7ff1129
--- /dev/null
+++ b/usr.sbin/xntpd/lib/authdecrypt.c
@@ -0,0 +1,85 @@
+/* authdecrypt.c,v 3.1 1993/07/06 01:07:44 jbj Exp
+ * authdecrypt - routine to decrypt a packet to see if this guy knows our key.
+ */
+#include "ntp_stdlib.h"
+
+/*
+ * For our purposes an NTP packet looks like:
+ *
+ *	a variable amount of unencrypted data, multiple of 8 bytes, followed by:
+ *	NOCRYPT_OCTETS worth of unencrypted data, followed by:
+ *	BLOCK_OCTETS worth of ciphered checksum.
+ */ 
+#define	NOCRYPT_OCTETS	4
+#define	BLOCK_OCTETS	8
+
+#define	NOCRYPT_LONGS	((NOCRYPT_OCTETS)/sizeof(U_LONG))
+#define	BLOCK_LONGS	((BLOCK_OCTETS)/sizeof(U_LONG))
+
+/*
+ * Imported from the key data base module
+ */
+extern U_LONG cache_keyid;	/* cached key ID */
+extern u_char DEScache_dkeys[];	/* cached decryption keys */
+extern u_char DESzerodkeys[];	/* zero key decryption keys */
+
+/*
+ * Stat counters, imported from data base module
+ */
+extern U_LONG authdecryptions;
+extern U_LONG authkeyuncached;
+extern U_LONG authdecryptok;
+
+int
+DESauthdecrypt(keyno, pkt, length)
+	U_LONG keyno;
+	const U_LONG *pkt;
+	int length;	/* length of variable data in octets */
+{
+	register const U_LONG *pd;
+	register int i;
+	register u_char *keys;
+	register int longlen;
+	U_LONG work[2];
+
+	authdecryptions++;
+	
+	if (keyno == 0)
+		keys = DESzerodkeys;
+	else {
+		if (keyno != cache_keyid) {
+			authkeyuncached++;
+			if (!authhavekey(keyno))
+				return 0;
+		}
+		keys = DEScache_dkeys;
+	}
+
+	/*
+	 * Get encryption block data in host byte order and decrypt it.
+	 */
+	longlen = length / sizeof(U_LONG);
+	pd = pkt + longlen;		/* points at NOCRYPT area */
+	work[0] = *(pd + NOCRYPT_LONGS);
+	work[1] = *(pd + NOCRYPT_LONGS + 1);
+
+	if (longlen & 0x1) {
+		DESauth_des(work, keys);
+		work[0] ^= *(--pd);
+	}
+
+	for (i = longlen/2; i > 0; i--) {
+		DESauth_des(work, keys);
+		work[1] ^= *(--pd);
+		work[0] ^= *(--pd);
+	}
+
+	/*
+	 * Success if the encryption data is zero
+	 */
+	if ((work[0] == 0) && (work[1] == 0)) {
+		authdecryptok++;
+		return 1;
+	}
+	return 0;
+}
diff --git a/usr.sbin/xntpd/lib/authdes.c b/usr.sbin/xntpd/lib/authdes.c
new file mode 100644
index 0000000..36077fc
--- /dev/null
+++ b/usr.sbin/xntpd/lib/authdes.c
@@ -0,0 +1,891 @@
+/* authdes.c,v 3.1 1993/07/06 01:07:45 jbj Exp
+ * authdes.c - an implementation of the DES cipher algorithm for NTP
+ */
+#include "ntp_stdlib.h"
+
+#if !defined(XNTP_BIG_ENDIAN) && !defined(XNTP_LITTLE_ENDIAN)
+
+#if defined(XNTP_AUTO_ENDIAN)
+#include <netinet/in.h>
+
+#if BYTE_ORDER == BIG_ENDIAN
+#define XNTP_BIG_ENDIAN
+#endif
+#if BYTE_ORDER == LITTLE_ENDIAN
+#define XNTP_LITTLE_ENDIAN
+#endif
+
+#else	/* AUTO */
+
+#ifdef	WORDS_BIGENDIAN
+#define	XNTP_BIG_ENDIAN	1
+#else
+#define	XNTP_LITTLE_ENDIAN	1
+#endif
+
+#endif	/* AUTO */
+
+#endif	/* !BIG && !LITTLE */
+
+/*
+ * There are two entries in here.  auth_subkeys() called to
+ * compute the encryption and decryption key schedules, while
+ * auth_des() is called to do the actual encryption/decryption
+ */
+
+/*
+ * Byte order woes.  The DES code is sensitive to byte order.  This
+ * used to be resolved by calling ntohl() and htonl() to swap things
+ * around, but this turned out to be quite costly on Vaxes where those
+ * things are actual functions.  The code now straightens out byte
+ * order troubles on its own, with no performance penalty for little
+ * end first machines, but at great expense to cleanliness.
+ */
+#if !defined(XNTP_BIG_ENDIAN) && !defined(XNTP_LITTLE_ENDIAN)
+	/*
+	 * Pick one or the other.
+	 */
+	BYTE_ORDER_NOT_DEFINED_FOR_AUTHENTICATION
+#endif
+
+#if defined(XNTP_BIG_ENDIAN) && defined(XNTP_LITTLE_ENDIAN)
+	/*
+	 * Pick one or the other.
+	 */
+	BYTE_ORDER_NOT_DEFINED_FOR_AUTHENTICATION
+#endif
+
+/*
+ * Key setup.  Here we entirely permute a key, saving the results
+ * for both the encryption and decryption.  Note that while the
+ * decryption subkeys are simply the encryption keys reordered,
+ * we save both so that a common cipher routine may be used.
+ */
+
+/*
+ * Permuted choice 1 tables.  These are used to extract bits
+ * from the left and right parts of the key to form Ci and Di.
+ * The code that uses these tables knows which bits from which
+ * part of each key are used to form Ci and Di.
+ */
+static U_LONG PC1_CL[8] = {
+	0x00000000, 0x00000010, 0x00001000, 0x00001010,
+	0x00100000, 0x00100010, 0x00101000, 0x00101010
+};
+
+static U_LONG PC1_DL[16] = {
+	0x00000000, 0x00100000, 0x00001000, 0x00101000,
+	0x00000010, 0x00100010, 0x00001010, 0x00101010,
+	0x00000001, 0x00100001, 0x00001001, 0x00101001,
+	0x00000011, 0x00100011, 0x00001011, 0x00101011
+};
+
+static U_LONG PC1_CR[16] = {
+	0x00000000, 0x00000001, 0x00000100, 0x00000101,
+	0x00010000, 0x00010001, 0x00010100, 0x00010101,
+	0x01000000, 0x01000001, 0x01000100, 0x01000101,
+	0x01010000, 0x01010001, 0x01010100, 0x01010101
+};
+
+static U_LONG PC1_DR[8] = {
+	0x00000000, 0x01000000, 0x00010000, 0x01010000,
+	0x00000100, 0x01000100, 0x00010100, 0x01010100
+};
+
+
+/*
+ * At the start of some iterations of the key schedule we do
+ * a circular left shift by one place, while for others we do a shift by
+ * two places.  This has bits set for the iterations where we do 2 bit
+ * shifts, starting at the low order bit.
+ */
+#define	TWO_BIT_SHIFTS	0x7efc
+
+/*
+ * Permuted choice 2 tables.  The first actually produces the low order
+ * 24 bits of the subkey Ki from the 28 bit value of Ci.  The second produces
+ * the high order 24 bits from Di.  The tables are indexed by six bit
+ * segments of Ci and Di respectively.  The code is handcrafted to compute
+ * the appropriate 6 bit chunks.
+ *
+ * Note that for ease of computation, the 24 bit values are produced with
+ * six bits going into each byte.
+ */
+static U_LONG PC2_C[4][64] = {
+      { 0x00000000, 0x00040000, 0x01000000, 0x01040000,
+	0x00000400, 0x00040400, 0x01000400, 0x01040400,
+	0x00200000, 0x00240000, 0x01200000, 0x01240000,
+	0x00200400, 0x00240400, 0x01200400, 0x01240400,
+	0x00000001, 0x00040001, 0x01000001, 0x01040001,
+	0x00000401, 0x00040401, 0x01000401, 0x01040401,
+	0x00200001, 0x00240001, 0x01200001, 0x01240001,
+	0x00200401, 0x00240401, 0x01200401, 0x01240401,
+	0x02000000, 0x02040000, 0x03000000, 0x03040000,
+	0x02000400, 0x02040400, 0x03000400, 0x03040400,
+	0x02200000, 0x02240000, 0x03200000, 0x03240000,
+	0x02200400, 0x02240400, 0x03200400, 0x03240400,
+	0x02000001, 0x02040001, 0x03000001, 0x03040001,
+	0x02000401, 0x02040401, 0x03000401, 0x03040401,
+	0x02200001, 0x02240001, 0x03200001, 0x03240001,
+	0x02200401, 0x02240401, 0x03200401, 0x03240401 },
+
+      { 0x00000000, 0x00000002, 0x00000800, 0x00000802,
+	0x08000000, 0x08000002, 0x08000800, 0x08000802,
+	0x00010000, 0x00010002, 0x00010800, 0x00010802,
+	0x08010000, 0x08010002, 0x08010800, 0x08010802,
+	0x00000100, 0x00000102, 0x00000900, 0x00000902,
+	0x08000100, 0x08000102, 0x08000900, 0x08000902,
+	0x00010100, 0x00010102, 0x00010900, 0x00010902,
+	0x08010100, 0x08010102, 0x08010900, 0x08010902,
+	0x00000010, 0x00000012, 0x00000810, 0x00000812,
+	0x08000010, 0x08000012, 0x08000810, 0x08000812,
+	0x00010010, 0x00010012, 0x00010810, 0x00010812,
+	0x08010010, 0x08010012, 0x08010810, 0x08010812,
+	0x00000110, 0x00000112, 0x00000910, 0x00000912,
+	0x08000110, 0x08000112, 0x08000910, 0x08000912,
+	0x00010110, 0x00010112, 0x00010910, 0x00010912,
+	0x08010110, 0x08010112, 0x08010910, 0x08010912 },
+
+      { 0x00000000, 0x04000000, 0x00002000, 0x04002000,
+	0x10000000, 0x14000000, 0x10002000, 0x14002000,
+	0x00000020, 0x04000020, 0x00002020, 0x04002020,
+	0x10000020, 0x14000020, 0x10002020, 0x14002020,
+	0x00080000, 0x04080000, 0x00082000, 0x04082000,
+	0x10080000, 0x14080000, 0x10082000, 0x14082000,
+	0x00080020, 0x04080020, 0x00082020, 0x04082020,
+	0x10080020, 0x14080020, 0x10082020, 0x14082020,
+	0x20000000, 0x24000000, 0x20002000, 0x24002000,
+	0x30000000, 0x34000000, 0x30002000, 0x34002000,
+	0x20000020, 0x24000020, 0x20002020, 0x24002020,
+	0x30000020, 0x34000020, 0x30002020, 0x34002020,
+	0x20080000, 0x24080000, 0x20082000, 0x24082000,
+	0x30080000, 0x34080000, 0x30082000, 0x34082000,
+	0x20080020, 0x24080020, 0x20082020, 0x24082020,
+	0x30080020, 0x34080020, 0x30082020, 0x34082020 },
+
+      { 0x00000000, 0x00100000, 0x00000008, 0x00100008,
+	0x00000200, 0x00100200, 0x00000208, 0x00100208,
+	0x00020000, 0x00120000, 0x00020008, 0x00120008,
+	0x00020200, 0x00120200, 0x00020208, 0x00120208,
+	0x00000004, 0x00100004, 0x0000000c, 0x0010000c,
+	0x00000204, 0x00100204, 0x0000020c, 0x0010020c,
+	0x00020004, 0x00120004, 0x0002000c, 0x0012000c,
+	0x00020204, 0x00120204, 0x0002020c, 0x0012020c,
+	0x00001000, 0x00101000, 0x00001008, 0x00101008,
+	0x00001200, 0x00101200, 0x00001208, 0x00101208,
+	0x00021000, 0x00121000, 0x00021008, 0x00121008,
+	0x00021200, 0x00121200, 0x00021208, 0x00121208,
+	0x00001004, 0x00101004, 0x0000100c, 0x0010100c,
+	0x00001204, 0x00101204, 0x0000120c, 0x0010120c,
+	0x00021004, 0x00121004, 0x0002100c, 0x0012100c,
+	0x00021204, 0x00121204, 0x0002120c, 0x0012120c }
+};
+
+static U_LONG PC2_D[4][64] = {
+      { 0x00000000, 0x00000200, 0x00020000, 0x00020200,
+	0x00000001, 0x00000201, 0x00020001, 0x00020201,
+	0x08000000, 0x08000200, 0x08020000, 0x08020200,
+	0x08000001, 0x08000201, 0x08020001, 0x08020201,
+	0x00200000, 0x00200200, 0x00220000, 0x00220200,
+	0x00200001, 0x00200201, 0x00220001, 0x00220201,
+	0x08200000, 0x08200200, 0x08220000, 0x08220200,
+	0x08200001, 0x08200201, 0x08220001, 0x08220201,
+	0x00000002, 0x00000202, 0x00020002, 0x00020202,
+	0x00000003, 0x00000203, 0x00020003, 0x00020203,
+	0x08000002, 0x08000202, 0x08020002, 0x08020202,
+	0x08000003, 0x08000203, 0x08020003, 0x08020203,
+	0x00200002, 0x00200202, 0x00220002, 0x00220202,
+	0x00200003, 0x00200203, 0x00220003, 0x00220203,
+	0x08200002, 0x08200202, 0x08220002, 0x08220202,
+	0x08200003, 0x08200203, 0x08220003, 0x08220203 },
+
+      { 0x00000000, 0x00000010, 0x20000000, 0x20000010,
+	0x00100000, 0x00100010, 0x20100000, 0x20100010,
+	0x00000800, 0x00000810, 0x20000800, 0x20000810,
+	0x00100800, 0x00100810, 0x20100800, 0x20100810,
+	0x04000000, 0x04000010, 0x24000000, 0x24000010,
+	0x04100000, 0x04100010, 0x24100000, 0x24100010,
+	0x04000800, 0x04000810, 0x24000800, 0x24000810,
+	0x04100800, 0x04100810, 0x24100800, 0x24100810,
+	0x00000004, 0x00000014, 0x20000004, 0x20000014,
+	0x00100004, 0x00100014, 0x20100004, 0x20100014,
+	0x00000804, 0x00000814, 0x20000804, 0x20000814,
+	0x00100804, 0x00100814, 0x20100804, 0x20100814,
+	0x04000004, 0x04000014, 0x24000004, 0x24000014,
+	0x04100004, 0x04100014, 0x24100004, 0x24100014,
+	0x04000804, 0x04000814, 0x24000804, 0x24000814,
+	0x04100804, 0x04100814, 0x24100804, 0x24100814 },
+
+      { 0x00000000, 0x00001000, 0x00010000, 0x00011000,
+	0x02000000, 0x02001000, 0x02010000, 0x02011000,
+	0x00000020, 0x00001020, 0x00010020, 0x00011020,
+	0x02000020, 0x02001020, 0x02010020, 0x02011020,
+	0x00040000, 0x00041000, 0x00050000, 0x00051000,
+	0x02040000, 0x02041000, 0x02050000, 0x02051000,
+	0x00040020, 0x00041020, 0x00050020, 0x00051020,
+	0x02040020, 0x02041020, 0x02050020, 0x02051020,
+	0x00002000, 0x00003000, 0x00012000, 0x00013000,
+	0x02002000, 0x02003000, 0x02012000, 0x02013000,
+	0x00002020, 0x00003020, 0x00012020, 0x00013020,
+	0x02002020, 0x02003020, 0x02012020, 0x02013020,
+	0x00042000, 0x00043000, 0x00052000, 0x00053000,
+	0x02042000, 0x02043000, 0x02052000, 0x02053000,
+	0x00042020, 0x00043020, 0x00052020, 0x00053020,
+	0x02042020, 0x02043020, 0x02052020, 0x02053020 },
+
+      { 0x00000000, 0x00000400, 0x01000000, 0x01000400,
+	0x00000100, 0x00000500, 0x01000100, 0x01000500,
+	0x10000000, 0x10000400, 0x11000000, 0x11000400,
+	0x10000100, 0x10000500, 0x11000100, 0x11000500,
+	0x00080000, 0x00080400, 0x01080000, 0x01080400,
+	0x00080100, 0x00080500, 0x01080100, 0x01080500,
+	0x10080000, 0x10080400, 0x11080000, 0x11080400,
+	0x10080100, 0x10080500, 0x11080100, 0x11080500,
+	0x00000008, 0x00000408, 0x01000008, 0x01000408,
+	0x00000108, 0x00000508, 0x01000108, 0x01000508,
+	0x10000008, 0x10000408, 0x11000008, 0x11000408,
+	0x10000108, 0x10000508, 0x11000108, 0x11000508,
+	0x00080008, 0x00080408, 0x01080008, 0x01080408,
+	0x00080108, 0x00080508, 0x01080108, 0x01080508,
+	0x10080008, 0x10080408, 0x11080008, 0x11080408,
+	0x10080108, 0x10080508, 0x11080108, 0x11080508 }
+};
+
+
+
+/*
+ * Permute the key to give us our key schedule.
+ */
+void
+DESauth_subkeys(key, encryptkeys, decryptkeys)
+	const U_LONG *key;
+	u_char *encryptkeys;
+	u_char *decryptkeys;
+{
+	register U_LONG tmp;
+	register U_LONG c, d;
+	register u_char *ek, *dk;
+	register int two_bit_shifts;
+	register int i;
+
+	/*
+	 * The first permutted choice gives us the 28 bits for C0 and
+	 * 28 for D0.  C0 gets 12 bits from the left key and 16 from
+	 * the right, while D0 gets 16 from the left and 12 from the
+	 * right.  The code knows which bits go where.
+	 */
+	tmp = *key;	/* left part of key */
+	c =  PC1_CL[(tmp >> 29) & 0x7]
+	  | (PC1_CL[(tmp >> 21) & 0x7] << 1)
+	  | (PC1_CL[(tmp >> 13) & 0x7] << 2)
+	  | (PC1_CL[(tmp >>  5) & 0x7] << 3);
+	d =  PC1_DL[(tmp >> 25) & 0xf]
+	  | (PC1_DL[(tmp >> 17) & 0xf] << 1)
+	  | (PC1_DL[(tmp >>  9) & 0xf] << 2)
+	  | (PC1_DL[(tmp >>  1) & 0xf] << 3);
+	
+	tmp = *(key+1);	/* right part of key */
+	c |= PC1_CR[(tmp >> 28) & 0xf]
+	  | (PC1_CR[(tmp >> 20) & 0xf] << 1)
+	  | (PC1_CR[(tmp >> 12) & 0xf] << 2)
+	  | (PC1_CR[(tmp >>  4) & 0xf] << 3);
+	d |= PC1_DR[(tmp >> 25) & 0x7]
+	  | (PC1_DR[(tmp >> 17) & 0x7] << 1)
+	  | (PC1_DR[(tmp >>  9) & 0x7] << 2)
+	  | (PC1_DR[(tmp >>  1) & 0x7] << 3);
+
+	/*
+	 * Now iterate to compute the key schedule.  Note that we
+	 * record the entire set of subkeys in 6 bit chunks since
+	 * they are used that way.  At 6 bits/char, we need
+	 * 48/6 char's/subkey * 16 subkeys/encryption == 128 chars.
+	 * encryptkeys and decryptkeys must be this big.
+	 */
+	ek = encryptkeys;
+	dk = decryptkeys + (8 * 15);
+	two_bit_shifts = TWO_BIT_SHIFTS;
+	for (i = 16; i > 0; i--) {
+		/*
+		 * Do the rotation.  One bit and two bit rotations
+		 * are done separately.  Note C and D are 28 bits.
+		 */
+		if (two_bit_shifts & 0x1) {
+			c = ((c << 2) & 0xffffffc) | (c >> 26);
+			d = ((d << 2) & 0xffffffc) | (d >> 26);
+		} else {
+			c = ((c << 1) & 0xffffffe) | (c >> 27);
+			d = ((d << 1) & 0xffffffe) | (d >> 27);
+		}
+		two_bit_shifts >>= 1;
+
+		/*
+		 * Apply permutted choice 2 to C to get the first
+		 * 24 bits worth of keys.  Note that bits 9, 18, 22
+		 * and 25 (using DES numbering) in C are unused.  The
+		 * shift-mask stuff is done to delete these bits from
+		 * the indices, since this cuts the table size in half.
+		 */
+		tmp = PC2_C[0][((c >> 22) & 0x3f)]
+		    | PC2_C[1][((c >> 15) & 0xf) | ((c >> 16) & 0x30)]
+		    | PC2_C[2][((c >>  4) & 0x3) | ((c >>  9) & 0x3c)]
+		    | PC2_C[3][((c      ) & 0x7) | ((c >>  4) & 0x38)];
+		*ek++ = *dk++ = (u_char)(tmp >> 24);
+		*ek++ = *dk++ = (u_char)(tmp >> 16);
+		*ek++ = *dk++ = (u_char)(tmp >>  8);
+		*ek++ = *dk++ = (u_char)tmp;
+
+		/*
+		 * Apply permutted choice 2 to D to get the other half.
+		 * Here, bits 7, 10, 15 and 26 go unused.  The sqeezing
+		 * actually turns out to be cheaper here.
+		 */
+		tmp = PC2_D[0][((d >> 22) & 0x3f)]
+		    | PC2_D[1][((d >> 14) & 0xf) | ((d >> 15) & 0x30)]
+		    | PC2_D[2][((d >>  7) & 0x3f)]
+		    | PC2_D[3][((d      ) & 0x3) | ((d >>  1) & 0x3c)];
+		*ek++ = *dk++ = (u_char)(tmp >> 24);
+		*ek++ = *dk++ = (u_char)(tmp >> 16);
+		*ek++ = *dk++ = (u_char)(tmp >>  8);
+		*ek++ = *dk++ = (u_char)tmp;
+
+		/*
+		 * We are filling in the decryption subkeys from the end.
+		 * Space it back 16 elements to get to the start of the
+		 * next set.
+		 */
+		dk -= 16;
+	}
+}
+
+/*
+ * The DES algorithm.  This is intended to be fairly speedy at the
+ * expense of some memory.
+ *
+ * This uses all the standard hacks.  The S boxes and the P permutation
+ * are precomputed into one table.  The E box never actually appears
+ * explicitly since it is easy to apply this algorithmically.  The
+ * initial permutation and final (inverse initial) permuation are
+ * computed from tables designed to permute four bits at a time.  This
+ * should run pretty fast on machines with 32 bit words and
+ * bit field/multiple bit shift instructions which are fast.
+ */
+
+/*
+ * The initial permutation array.  This is used to compute both the
+ * left and the right halves of the initial permutation using bytes
+ * from words made from the following operations:
+ *
+ * ((left & 0x55555555) << 1) | (right & 0x55555555)  for left half
+ * (left & 0xaaaaaaaa) | ((right & 0xaaaaaaaa) >> 1)  for right half
+ *
+ * The scheme is that we index into the table using each byte.  The
+ * result from the high order byte is or'd with the result from the
+ * next byte shifted left once is or'd with the result from the next
+ * byte shifted left twice if or'd with the result from the low order
+ * byte shifted left by three.  Clear?
+ */
+static U_LONG IP[256] = {
+	0x00000000, 0x00000010, 0x00000001, 0x00000011,
+	0x00001000, 0x00001010, 0x00001001, 0x00001011,
+	0x00000100, 0x00000110, 0x00000101, 0x00000111,
+	0x00001100, 0x00001110, 0x00001101, 0x00001111,
+	0x00100000, 0x00100010, 0x00100001, 0x00100011,
+	0x00101000, 0x00101010, 0x00101001, 0x00101011,
+	0x00100100, 0x00100110, 0x00100101, 0x00100111,
+	0x00101100, 0x00101110, 0x00101101, 0x00101111,
+	0x00010000, 0x00010010, 0x00010001, 0x00010011,
+	0x00011000, 0x00011010, 0x00011001, 0x00011011,
+	0x00010100, 0x00010110, 0x00010101, 0x00010111,
+	0x00011100, 0x00011110, 0x00011101, 0x00011111,
+	0x00110000, 0x00110010, 0x00110001, 0x00110011,
+	0x00111000, 0x00111010, 0x00111001, 0x00111011,
+	0x00110100, 0x00110110, 0x00110101, 0x00110111,
+	0x00111100, 0x00111110, 0x00111101, 0x00111111,
+	0x10000000, 0x10000010, 0x10000001, 0x10000011,
+	0x10001000, 0x10001010, 0x10001001, 0x10001011,
+	0x10000100, 0x10000110, 0x10000101, 0x10000111,
+	0x10001100, 0x10001110, 0x10001101, 0x10001111,
+	0x10100000, 0x10100010, 0x10100001, 0x10100011,
+	0x10101000, 0x10101010, 0x10101001, 0x10101011,
+	0x10100100, 0x10100110, 0x10100101, 0x10100111,
+	0x10101100, 0x10101110, 0x10101101, 0x10101111,
+	0x10010000, 0x10010010, 0x10010001, 0x10010011,
+	0x10011000, 0x10011010, 0x10011001, 0x10011011,
+	0x10010100, 0x10010110, 0x10010101, 0x10010111,
+	0x10011100, 0x10011110, 0x10011101, 0x10011111,
+	0x10110000, 0x10110010, 0x10110001, 0x10110011,
+	0x10111000, 0x10111010, 0x10111001, 0x10111011,
+	0x10110100, 0x10110110, 0x10110101, 0x10110111,
+	0x10111100, 0x10111110, 0x10111101, 0x10111111,
+	0x01000000, 0x01000010, 0x01000001, 0x01000011,
+	0x01001000, 0x01001010, 0x01001001, 0x01001011,
+	0x01000100, 0x01000110, 0x01000101, 0x01000111,
+	0x01001100, 0x01001110, 0x01001101, 0x01001111,
+	0x01100000, 0x01100010, 0x01100001, 0x01100011,
+	0x01101000, 0x01101010, 0x01101001, 0x01101011,
+	0x01100100, 0x01100110, 0x01100101, 0x01100111,
+	0x01101100, 0x01101110, 0x01101101, 0x01101111,
+	0x01010000, 0x01010010, 0x01010001, 0x01010011,
+	0x01011000, 0x01011010, 0x01011001, 0x01011011,
+	0x01010100, 0x01010110, 0x01010101, 0x01010111,
+	0x01011100, 0x01011110, 0x01011101, 0x01011111,
+	0x01110000, 0x01110010, 0x01110001, 0x01110011,
+	0x01111000, 0x01111010, 0x01111001, 0x01111011,
+	0x01110100, 0x01110110, 0x01110101, 0x01110111,
+	0x01111100, 0x01111110, 0x01111101, 0x01111111,
+	0x11000000, 0x11000010, 0x11000001, 0x11000011,
+	0x11001000, 0x11001010, 0x11001001, 0x11001011,
+	0x11000100, 0x11000110, 0x11000101, 0x11000111,
+	0x11001100, 0x11001110, 0x11001101, 0x11001111,
+	0x11100000, 0x11100010, 0x11100001, 0x11100011,
+	0x11101000, 0x11101010, 0x11101001, 0x11101011,
+	0x11100100, 0x11100110, 0x11100101, 0x11100111,
+	0x11101100, 0x11101110, 0x11101101, 0x11101111,
+	0x11010000, 0x11010010, 0x11010001, 0x11010011,
+	0x11011000, 0x11011010, 0x11011001, 0x11011011,
+	0x11010100, 0x11010110, 0x11010101, 0x11010111,
+	0x11011100, 0x11011110, 0x11011101, 0x11011111,
+	0x11110000, 0x11110010, 0x11110001, 0x11110011,
+	0x11111000, 0x11111010, 0x11111001, 0x11111011,
+	0x11110100, 0x11110110, 0x11110101, 0x11110111,
+	0x11111100, 0x11111110, 0x11111101, 0x11111111
+};
+
+/*
+ * The final permutation array.  Like the IP array, used
+ * to compute both the left and right results from the nibbles
+ * of words computed from:
+ *
+ * ((left & 0x0f0f0f0f) << 4) | (right & 0x0f0f0f0f)  for left result
+ * (left & 0xf0f0f0f0) | ((right & 0xf0f0f0f0) >> 4)  for right result
+ *
+ * The result from the high order byte is shifted left 6 bits and
+ * or'd with the result from the next byte shifted left 4 bits, which
+ * is or'd with the result from the next byte shifted left 2 bits,
+ * which is or'd with the result from the low byte.
+ *
+ * There is one of these for big end machines (the natural order for
+ * DES) and a second for little end machines.  One is a byte swapped
+ * version of the other.
+ */
+#ifndef XNTP_LITTLE_ENDIAN
+	/*
+	 * Big end version
+	 */
+static U_LONG FP[256] = {
+	0x00000000, 0x02000000, 0x00020000, 0x02020000,
+	0x00000200, 0x02000200, 0x00020200, 0x02020200,
+	0x00000002, 0x02000002, 0x00020002, 0x02020002,
+	0x00000202, 0x02000202, 0x00020202, 0x02020202,
+	0x01000000, 0x03000000, 0x01020000, 0x03020000,
+	0x01000200, 0x03000200, 0x01020200, 0x03020200,
+	0x01000002, 0x03000002, 0x01020002, 0x03020002,
+	0x01000202, 0x03000202, 0x01020202, 0x03020202,
+	0x00010000, 0x02010000, 0x00030000, 0x02030000,
+	0x00010200, 0x02010200, 0x00030200, 0x02030200,
+	0x00010002, 0x02010002, 0x00030002, 0x02030002,
+	0x00010202, 0x02010202, 0x00030202, 0x02030202,
+	0x01010000, 0x03010000, 0x01030000, 0x03030000,
+	0x01010200, 0x03010200, 0x01030200, 0x03030200,
+	0x01010002, 0x03010002, 0x01030002, 0x03030002,
+	0x01010202, 0x03010202, 0x01030202, 0x03030202,
+	0x00000100, 0x02000100, 0x00020100, 0x02020100,
+	0x00000300, 0x02000300, 0x00020300, 0x02020300,
+	0x00000102, 0x02000102, 0x00020102, 0x02020102,
+	0x00000302, 0x02000302, 0x00020302, 0x02020302,
+	0x01000100, 0x03000100, 0x01020100, 0x03020100,
+	0x01000300, 0x03000300, 0x01020300, 0x03020300,
+	0x01000102, 0x03000102, 0x01020102, 0x03020102,
+	0x01000302, 0x03000302, 0x01020302, 0x03020302,
+	0x00010100, 0x02010100, 0x00030100, 0x02030100,
+	0x00010300, 0x02010300, 0x00030300, 0x02030300,
+	0x00010102, 0x02010102, 0x00030102, 0x02030102,
+	0x00010302, 0x02010302, 0x00030302, 0x02030302,
+	0x01010100, 0x03010100, 0x01030100, 0x03030100,
+	0x01010300, 0x03010300, 0x01030300, 0x03030300,
+	0x01010102, 0x03010102, 0x01030102, 0x03030102,
+	0x01010302, 0x03010302, 0x01030302, 0x03030302,
+	0x00000001, 0x02000001, 0x00020001, 0x02020001,
+	0x00000201, 0x02000201, 0x00020201, 0x02020201,
+	0x00000003, 0x02000003, 0x00020003, 0x02020003,
+	0x00000203, 0x02000203, 0x00020203, 0x02020203,
+	0x01000001, 0x03000001, 0x01020001, 0x03020001,
+	0x01000201, 0x03000201, 0x01020201, 0x03020201,
+	0x01000003, 0x03000003, 0x01020003, 0x03020003,
+	0x01000203, 0x03000203, 0x01020203, 0x03020203,
+	0x00010001, 0x02010001, 0x00030001, 0x02030001,
+	0x00010201, 0x02010201, 0x00030201, 0x02030201,
+	0x00010003, 0x02010003, 0x00030003, 0x02030003,
+	0x00010203, 0x02010203, 0x00030203, 0x02030203,
+	0x01010001, 0x03010001, 0x01030001, 0x03030001,
+	0x01010201, 0x03010201, 0x01030201, 0x03030201,
+	0x01010003, 0x03010003, 0x01030003, 0x03030003,
+	0x01010203, 0x03010203, 0x01030203, 0x03030203,
+	0x00000101, 0x02000101, 0x00020101, 0x02020101,
+	0x00000301, 0x02000301, 0x00020301, 0x02020301,
+	0x00000103, 0x02000103, 0x00020103, 0x02020103,
+	0x00000303, 0x02000303, 0x00020303, 0x02020303,
+	0x01000101, 0x03000101, 0x01020101, 0x03020101,
+	0x01000301, 0x03000301, 0x01020301, 0x03020301,
+	0x01000103, 0x03000103, 0x01020103, 0x03020103,
+	0x01000303, 0x03000303, 0x01020303, 0x03020303,
+	0x00010101, 0x02010101, 0x00030101, 0x02030101,
+	0x00010301, 0x02010301, 0x00030301, 0x02030301,
+	0x00010103, 0x02010103, 0x00030103, 0x02030103,
+	0x00010303, 0x02010303, 0x00030303, 0x02030303,
+	0x01010101, 0x03010101, 0x01030101, 0x03030101,
+	0x01010301, 0x03010301, 0x01030301, 0x03030301,
+	0x01010103, 0x03010103, 0x01030103, 0x03030103,
+	0x01010303, 0x03010303, 0x01030303, 0x03030303
+};
+#else
+	/*
+	 * Byte swapped for little end machines.
+	 */
+static U_LONG FP[256] = {
+	0x00000000, 0x00000002, 0x00000200, 0x00000202,
+	0x00020000, 0x00020002, 0x00020200, 0x00020202,
+	0x02000000, 0x02000002, 0x02000200, 0x02000202,
+	0x02020000, 0x02020002, 0x02020200, 0x02020202,
+	0x00000001, 0x00000003, 0x00000201, 0x00000203,
+	0x00020001, 0x00020003, 0x00020201, 0x00020203,
+	0x02000001, 0x02000003, 0x02000201, 0x02000203,
+	0x02020001, 0x02020003, 0x02020201, 0x02020203,
+	0x00000100, 0x00000102, 0x00000300, 0x00000302,
+	0x00020100, 0x00020102, 0x00020300, 0x00020302,
+	0x02000100, 0x02000102, 0x02000300, 0x02000302,
+	0x02020100, 0x02020102, 0x02020300, 0x02020302,
+	0x00000101, 0x00000103, 0x00000301, 0x00000303,
+	0x00020101, 0x00020103, 0x00020301, 0x00020303,
+	0x02000101, 0x02000103, 0x02000301, 0x02000303,
+	0x02020101, 0x02020103, 0x02020301, 0x02020303,
+	0x00010000, 0x00010002, 0x00010200, 0x00010202,
+	0x00030000, 0x00030002, 0x00030200, 0x00030202,
+	0x02010000, 0x02010002, 0x02010200, 0x02010202,
+	0x02030000, 0x02030002, 0x02030200, 0x02030202,
+	0x00010001, 0x00010003, 0x00010201, 0x00010203,
+	0x00030001, 0x00030003, 0x00030201, 0x00030203,
+	0x02010001, 0x02010003, 0x02010201, 0x02010203,
+	0x02030001, 0x02030003, 0x02030201, 0x02030203,
+	0x00010100, 0x00010102, 0x00010300, 0x00010302,
+	0x00030100, 0x00030102, 0x00030300, 0x00030302,
+	0x02010100, 0x02010102, 0x02010300, 0x02010302,
+	0x02030100, 0x02030102, 0x02030300, 0x02030302,
+	0x00010101, 0x00010103, 0x00010301, 0x00010303,
+	0x00030101, 0x00030103, 0x00030301, 0x00030303,
+	0x02010101, 0x02010103, 0x02010301, 0x02010303,
+	0x02030101, 0x02030103, 0x02030301, 0x02030303,
+	0x01000000, 0x01000002, 0x01000200, 0x01000202,
+	0x01020000, 0x01020002, 0x01020200, 0x01020202,
+	0x03000000, 0x03000002, 0x03000200, 0x03000202,
+	0x03020000, 0x03020002, 0x03020200, 0x03020202,
+	0x01000001, 0x01000003, 0x01000201, 0x01000203,
+	0x01020001, 0x01020003, 0x01020201, 0x01020203,
+	0x03000001, 0x03000003, 0x03000201, 0x03000203,
+	0x03020001, 0x03020003, 0x03020201, 0x03020203,
+	0x01000100, 0x01000102, 0x01000300, 0x01000302,
+	0x01020100, 0x01020102, 0x01020300, 0x01020302,
+	0x03000100, 0x03000102, 0x03000300, 0x03000302,
+	0x03020100, 0x03020102, 0x03020300, 0x03020302,
+	0x01000101, 0x01000103, 0x01000301, 0x01000303,
+	0x01020101, 0x01020103, 0x01020301, 0x01020303,
+	0x03000101, 0x03000103, 0x03000301, 0x03000303,
+	0x03020101, 0x03020103, 0x03020301, 0x03020303,
+	0x01010000, 0x01010002, 0x01010200, 0x01010202,
+	0x01030000, 0x01030002, 0x01030200, 0x01030202,
+	0x03010000, 0x03010002, 0x03010200, 0x03010202,
+	0x03030000, 0x03030002, 0x03030200, 0x03030202,
+	0x01010001, 0x01010003, 0x01010201, 0x01010203,
+	0x01030001, 0x01030003, 0x01030201, 0x01030203,
+	0x03010001, 0x03010003, 0x03010201, 0x03010203,
+	0x03030001, 0x03030003, 0x03030201, 0x03030203,
+	0x01010100, 0x01010102, 0x01010300, 0x01010302,
+	0x01030100, 0x01030102, 0x01030300, 0x01030302,
+	0x03010100, 0x03010102, 0x03010300, 0x03010302,
+	0x03030100, 0x03030102, 0x03030300, 0x03030302,
+	0x01010101, 0x01010103, 0x01010301, 0x01010303,
+	0x01030101, 0x01030103, 0x01030301, 0x01030303,
+	0x03010101, 0x03010103, 0x03010301, 0x03010303,
+	0x03030101, 0x03030103, 0x03030301, 0x03030303
+};
+#endif
+
+
+/*
+ * The SP table is actually the S boxes and the P permutation
+ * table combined.
+ */
+static U_LONG SP[8][64] = {
+      { 0x00808200, 0x00000000, 0x00008000, 0x00808202,
+	0x00808002, 0x00008202, 0x00000002, 0x00008000,
+	0x00000200, 0x00808200, 0x00808202, 0x00000200,
+	0x00800202, 0x00808002, 0x00800000, 0x00000002,
+	0x00000202, 0x00800200, 0x00800200, 0x00008200,
+	0x00008200, 0x00808000, 0x00808000, 0x00800202,
+	0x00008002, 0x00800002, 0x00800002, 0x00008002,
+	0x00000000, 0x00000202, 0x00008202, 0x00800000,
+	0x00008000, 0x00808202, 0x00000002, 0x00808000,
+	0x00808200, 0x00800000, 0x00800000, 0x00000200,
+	0x00808002, 0x00008000, 0x00008200, 0x00800002,
+	0x00000200, 0x00000002, 0x00800202, 0x00008202,
+	0x00808202, 0x00008002, 0x00808000, 0x00800202,
+	0x00800002, 0x00000202, 0x00008202, 0x00808200,
+	0x00000202, 0x00800200, 0x00800200, 0x00000000,
+	0x00008002, 0x00008200, 0x00000000, 0x00808002 },
+
+      { 0x40084010, 0x40004000, 0x00004000, 0x00084010,
+	0x00080000, 0x00000010, 0x40080010, 0x40004010,
+	0x40000010, 0x40084010, 0x40084000, 0x40000000,
+	0x40004000, 0x00080000, 0x00000010, 0x40080010,
+	0x00084000, 0x00080010, 0x40004010, 0x00000000,
+	0x40000000, 0x00004000, 0x00084010, 0x40080000,
+	0x00080010, 0x40000010, 0x00000000, 0x00084000,
+	0x00004010, 0x40084000, 0x40080000, 0x00004010,
+	0x00000000, 0x00084010, 0x40080010, 0x00080000,
+	0x40004010, 0x40080000, 0x40084000, 0x00004000,
+	0x40080000, 0x40004000, 0x00000010, 0x40084010,
+	0x00084010, 0x00000010, 0x00004000, 0x40000000,
+	0x00004010, 0x40084000, 0x00080000, 0x40000010,
+	0x00080010, 0x40004010, 0x40000010, 0x00080010,
+	0x00084000, 0x00000000, 0x40004000, 0x00004010,
+	0x40000000, 0x40080010, 0x40084010, 0x00084000 },
+
+      { 0x00000104, 0x04010100, 0x00000000, 0x04010004,
+	0x04000100, 0x00000000, 0x00010104, 0x04000100,
+	0x00010004, 0x04000004, 0x04000004, 0x00010000,
+	0x04010104, 0x00010004, 0x04010000, 0x00000104,
+	0x04000000, 0x00000004, 0x04010100, 0x00000100,
+	0x00010100, 0x04010000, 0x04010004, 0x00010104,
+	0x04000104, 0x00010100, 0x00010000, 0x04000104,
+	0x00000004, 0x04010104, 0x00000100, 0x04000000,
+	0x04010100, 0x04000000, 0x00010004, 0x00000104,
+	0x00010000, 0x04010100, 0x04000100, 0x00000000,
+	0x00000100, 0x00010004, 0x04010104, 0x04000100,
+	0x04000004, 0x00000100, 0x00000000, 0x04010004,
+	0x04000104, 0x00010000, 0x04000000, 0x04010104,
+	0x00000004, 0x00010104, 0x00010100, 0x04000004,
+	0x04010000, 0x04000104, 0x00000104, 0x04010000,
+	0x00010104, 0x00000004, 0x04010004, 0x00010100 },
+
+      { 0x80401000, 0x80001040, 0x80001040, 0x00000040,
+	0x00401040, 0x80400040, 0x80400000, 0x80001000,
+	0x00000000, 0x00401000, 0x00401000, 0x80401040,
+	0x80000040, 0x00000000, 0x00400040, 0x80400000,
+	0x80000000, 0x00001000, 0x00400000, 0x80401000,
+	0x00000040, 0x00400000, 0x80001000, 0x00001040,
+	0x80400040, 0x80000000, 0x00001040, 0x00400040,
+	0x00001000, 0x00401040, 0x80401040, 0x80000040,
+	0x00400040, 0x80400000, 0x00401000, 0x80401040,
+	0x80000040, 0x00000000, 0x00000000, 0x00401000,
+	0x00001040, 0x00400040, 0x80400040, 0x80000000,
+	0x80401000, 0x80001040, 0x80001040, 0x00000040,
+	0x80401040, 0x80000040, 0x80000000, 0x00001000,
+	0x80400000, 0x80001000, 0x00401040, 0x80400040,
+	0x80001000, 0x00001040, 0x00400000, 0x80401000,
+	0x00000040, 0x00400000, 0x00001000, 0x00401040 },
+
+      { 0x00000080, 0x01040080, 0x01040000, 0x21000080,
+	0x00040000, 0x00000080, 0x20000000, 0x01040000,
+	0x20040080, 0x00040000, 0x01000080, 0x20040080,
+	0x21000080, 0x21040000, 0x00040080, 0x20000000,
+	0x01000000, 0x20040000, 0x20040000, 0x00000000,
+	0x20000080, 0x21040080, 0x21040080, 0x01000080,
+	0x21040000, 0x20000080, 0x00000000, 0x21000000,
+	0x01040080, 0x01000000, 0x21000000, 0x00040080,
+	0x00040000, 0x21000080, 0x00000080, 0x01000000,
+	0x20000000, 0x01040000, 0x21000080, 0x20040080,
+	0x01000080, 0x20000000, 0x21040000, 0x01040080,
+	0x20040080, 0x00000080, 0x01000000, 0x21040000,
+	0x21040080, 0x00040080, 0x21000000, 0x21040080,
+	0x01040000, 0x00000000, 0x20040000, 0x21000000,
+	0x00040080, 0x01000080, 0x20000080, 0x00040000,
+	0x00000000, 0x20040000, 0x01040080, 0x20000080 },
+
+      { 0x10000008, 0x10200000, 0x00002000, 0x10202008,
+	0x10200000, 0x00000008, 0x10202008, 0x00200000,
+	0x10002000, 0x00202008, 0x00200000, 0x10000008,
+	0x00200008, 0x10002000, 0x10000000, 0x00002008,
+	0x00000000, 0x00200008, 0x10002008, 0x00002000,
+	0x00202000, 0x10002008, 0x00000008, 0x10200008,
+	0x10200008, 0x00000000, 0x00202008, 0x10202000,
+	0x00002008, 0x00202000, 0x10202000, 0x10000000,
+	0x10002000, 0x00000008, 0x10200008, 0x00202000,
+	0x10202008, 0x00200000, 0x00002008, 0x10000008,
+	0x00200000, 0x10002000, 0x10000000, 0x00002008,
+	0x10000008, 0x10202008, 0x00202000, 0x10200000,
+	0x00202008, 0x10202000, 0x00000000, 0x10200008,
+	0x00000008, 0x00002000, 0x10200000, 0x00202008,
+	0x00002000, 0x00200008, 0x10002008, 0x00000000,
+	0x10202000, 0x10000000, 0x00200008, 0x10002008 },
+
+      { 0x00100000, 0x02100001, 0x02000401, 0x00000000,
+	0x00000400, 0x02000401, 0x00100401, 0x02100400,
+	0x02100401, 0x00100000, 0x00000000, 0x02000001,
+	0x00000001, 0x02000000, 0x02100001, 0x00000401,
+	0x02000400, 0x00100401, 0x00100001, 0x02000400,
+	0x02000001, 0x02100000, 0x02100400, 0x00100001,
+	0x02100000, 0x00000400, 0x00000401, 0x02100401,
+	0x00100400, 0x00000001, 0x02000000, 0x00100400,
+	0x02000000, 0x00100400, 0x00100000, 0x02000401,
+	0x02000401, 0x02100001, 0x02100001, 0x00000001,
+	0x00100001, 0x02000000, 0x02000400, 0x00100000,
+	0x02100400, 0x00000401, 0x00100401, 0x02100400,
+	0x00000401, 0x02000001, 0x02100401, 0x02100000,
+	0x00100400, 0x00000000, 0x00000001, 0x02100401,
+	0x00000000, 0x00100401, 0x02100000, 0x00000400,
+	0x02000001, 0x02000400, 0x00000400, 0x00100001 },
+
+      { 0x08000820, 0x00000800, 0x00020000, 0x08020820,
+	0x08000000, 0x08000820, 0x00000020, 0x08000000,
+	0x00020020, 0x08020000, 0x08020820, 0x00020800,
+	0x08020800, 0x00020820, 0x00000800, 0x00000020,
+	0x08020000, 0x08000020, 0x08000800, 0x00000820,
+	0x00020800, 0x00020020, 0x08020020, 0x08020800,
+	0x00000820, 0x00000000, 0x00000000, 0x08020020,
+	0x08000020, 0x08000800, 0x00020820, 0x00020000,
+	0x00020820, 0x00020000, 0x08020800, 0x00000800,
+	0x00000020, 0x08020020, 0x00000800, 0x00020820,
+	0x08000800, 0x00000020, 0x08000020, 0x08020000,
+	0x08020020, 0x08000000, 0x00020000, 0x08000820,
+	0x00000000, 0x08020820, 0x00020020, 0x08000020,
+	0x08020000, 0x08000800, 0x08000820, 0x00000000,
+	0x08020820, 0x00020800, 0x00020800, 0x00000820,
+	0x00000820, 0x00020020, 0x08000000, 0x08020800 }
+};
+
+
+
+/*
+ * DESauth_des - perform an in place DES encryption on 64 bits
+ *
+ * Note that the `data' argument is always in big-end-first
+ * byte order, i.e. *(char *)data is the high order byte of
+ * the 8 byte data word.  We modify the initial and final
+ * permutation computations for little-end-first machines to
+ * swap bytes into the natural host order at the beginning and
+ * back to big-end order at the end.  This is unclean but avoids
+ * a byte swapping performance penalty on Vaxes (which are slow already).
+ */
+void
+DESauth_des(data, subkeys)
+	U_LONG *data;
+	u_char *subkeys;
+{
+	register U_LONG left, right;
+	register U_LONG temp;
+	register u_char *kp;
+	register int i;
+
+	/*
+	 * Do the initial permutation.  The first operation gets
+	 * all the bits which are used to form the left half of the
+	 * permutted result in one word, which is then used to
+	 * index the appropriate table a byte at a time.
+	 */
+	temp = ((*data & 0x55555555) << 1) | (*(data+1) & 0x55555555);
+#ifdef XNTP_LITTLE_ENDIAN
+	/*
+	 * Modify the computation to use the opposite set of bytes.
+	 */
+	left = (IP[(temp >> 24) & 0xff] << 3)
+	     | (IP[(temp >> 16) & 0xff] << 2)
+	     | (IP[(temp >>  8) & 0xff] << 1)
+	     | IP[temp & 0xff];
+#else
+	left = IP[(temp >> 24) & 0xff]
+	     | (IP[(temp >> 16) & 0xff] << 1)
+	     | (IP[(temp >>  8) & 0xff] << 2)
+	     | (IP[temp & 0xff] << 3);
+#endif
+	
+	/*
+	 * Same thing again except for the right half.
+	 */
+	temp = (*data & 0xaaaaaaaa) | ((*(data+1) & 0xaaaaaaaa) >> 1);
+#ifdef XNTP_LITTLE_ENDIAN
+	right = (IP[(temp >> 24) & 0xff] << 3)
+	      | (IP[(temp >> 16) & 0xff] << 2)
+	      | (IP[(temp >>  8) & 0xff] << 1)
+	      | IP[temp & 0xff];
+#else
+	right = IP[(temp >> 24) & 0xff]
+	      | (IP[(temp >> 16) & 0xff] << 1)
+	      | (IP[(temp >>  8) & 0xff] << 2)
+	      | (IP[temp & 0xff] << 3);
+#endif
+	
+	/*
+	 * Do the 16 rounds through the cipher function.  We actually
+	 * do two at a time, one on the left half and one on the right
+	 * half.
+	 */
+	kp = subkeys;
+	for (i = 0; i < 8; i++) {
+		/*
+		 * The E expansion is easy to compute algorithmically.
+		 * Take a look at its form and compare it to
+		 * everything involving temp below.  Note that
+		 * since SP[0-7] don't have any bits in common set
+		 * it is okay to do the successive xor's.
+		 */
+		temp = (right >> 1) | ((right & 1) ? 0x80000000 : 0);
+		left ^= SP[0][((temp >> 26) & 0x3f) ^ *kp++];
+		left ^= SP[1][((temp >> 22) & 0x3f) ^ *kp++];
+		left ^= SP[2][((temp >> 18) & 0x3f) ^ *kp++];
+		left ^= SP[3][((temp >> 14) & 0x3f) ^ *kp++];
+		left ^= SP[4][((temp >> 10) & 0x3f) ^ *kp++];
+		left ^= SP[5][((temp >>  6) & 0x3f) ^ *kp++];
+		left ^= SP[6][((temp >>  2) & 0x3f) ^ *kp++];
+		left ^= SP[7][(((right << 1) | ((right & 0x80000000)?1:0))
+				& 0x3f) ^ *kp++];
+		
+		/*
+		 * Careful here.  Right now `right' is actually the
+		 * left side and `left' is the right side.  Do the
+		 * same thing again, except swap `left' and `right'
+		 */
+		temp = (left >> 1) | ((left & 1) ? 0x80000000 : 0);
+		right ^= SP[0][((temp >> 26) & 0x3f) ^ *kp++];
+		right ^= SP[1][((temp >> 22) & 0x3f) ^ *kp++];
+		right ^= SP[2][((temp >> 18) & 0x3f) ^ *kp++];
+		right ^= SP[3][((temp >> 14) & 0x3f) ^ *kp++];
+		right ^= SP[4][((temp >> 10) & 0x3f) ^ *kp++];
+		right ^= SP[5][((temp >>  6) & 0x3f) ^ *kp++];
+		right ^= SP[6][((temp >>  2) & 0x3f) ^ *kp++];
+		right ^= SP[7][(((left << 1) | ((left & 0x80000000)?1:0))
+				& 0x3f) ^ *kp++];
+
+		/*
+		 * By the time we get here, all is straightened out
+		 * again.  `left' is left and `right' is right.
+		 */
+	}
+
+	/*
+	 * Now the final permutation.  Note this is like the IP above
+	 * except that the data is computed from
+	 *
+ 	 * ((left & 0x0f0f0f0f) << 4) | (right & 0x0f0f0f0f)  for left result
+ 	 * (left & 0xf0f0f0f0) | ((right & 0xf0f0f0f0) >> 4)  for right result
+	 *
+	 * Just to confuse things more, we're supposed to swap the right
+	 * and the left halves before doing this.  Instead, we'll just
+	 * switch which goes where when computing the temporary.
+	 *
+	 * This operation also byte swaps stuff back into big end byte
+	 * order.  This is accomplished by modifying the FP table for
+	 * little end machines, however, so we don't have to worry about
+	 * it here.
+	 */
+	temp = ((right & 0x0f0f0f0f) << 4) | (left & 0x0f0f0f0f);
+	*data = (FP[(temp >> 24) & 0xff] << 6)
+	      | (FP[(temp >> 16) & 0xff] << 4)
+	      | (FP[(temp >>  8) & 0xff] << 2)
+	      |  FP[temp & 0xff];
+
+	temp = (right & 0xf0f0f0f0) | ((left & 0xf0f0f0f0) >> 4);
+	*(data+1) = (FP[(temp >> 24) & 0xff] << 6)
+		  | (FP[(temp >> 16) & 0xff] << 4)
+		  | (FP[(temp >>  8) & 0xff] << 2)
+		  |  FP[temp & 0xff];
+}
diff --git a/usr.sbin/xntpd/lib/authdes.c.export b/usr.sbin/xntpd/lib/authdes.c.export
new file mode 100644
index 0000000..b0323a0
--- /dev/null
+++ b/usr.sbin/xntpd/lib/authdes.c.export
@@ -0,0 +1,40 @@
+/* authdes.c.export,v 3.1 1993/07/06 01:07:48 jbj Exp
+ * authdes.c -  dummy encryption routines for destinations outside the USA.
+ *
+ * Sorry, folks; I hate this, too. Send me your e-mail address in an
+ * envelope bearing a US postmark and I'll send you the decryption key
+ * for the des program normally distributed with Unix in the USA. Outside
+ * the USA you are on your own; however, you should be able quickly to
+ * obtain the source from lots of places, homegrown or otherwise.
+ *
+ * to decrypt the des routine, mumble the following:
+ *
+ * des -d -k key authdes.c.des authdes.c
+ *
+ * , where key is as above, and rebuild. To restore the distribution
+ * to its exportable state, copy this file to authdes.c . 
+ */
+#include <sys/types.h>
+
+/*
+ * This routine is normally called to compute the key schedule.
+ */
+void
+DESauth_subkeys(key, encryptkeys, decryptkeys)
+	U_LONG *key;
+	u_char *encryptkeys;
+	u_char *decryptkeys;
+{
+};
+
+/*
+ * This routine is normally called to encrypt and decrypt the data. This
+ * is done in-place using the Digital Encryption Standard (DES) Cipher-
+ * Block Chaining (CBC) method as described in the NTP specification.
+ */
+void
+DESauth_des(data, subkeys)
+	U_LONG *data;
+	u_char *subkeys;
+{
+};
diff --git a/usr.sbin/xntpd/lib/authencrypt.c b/usr.sbin/xntpd/lib/authencrypt.c
new file mode 100644
index 0000000..66b5281
--- /dev/null
+++ b/usr.sbin/xntpd/lib/authencrypt.c
@@ -0,0 +1,88 @@
+/* authencrypt.c,v 3.1 1993/07/06 01:07:50 jbj Exp
+ * authencrypt - compute and encrypt the mac field in an NTP packet
+ */
+#include "ntp_stdlib.h"
+
+/*
+ * For our purposes an NTP packet looks like:
+ *
+ *	a variable amount of encrypted data, multiple of 8 bytes, followed by:
+ *	NOCRYPT_OCTETS worth of unencrypted data, followed by:
+ *	BLOCK_OCTETS worth of ciphered checksum.
+ */ 
+#define	NOCRYPT_OCTETS	4
+#define	BLOCK_OCTETS	8
+
+#define	NOCRYPT_LONGS	((NOCRYPT_OCTETS)/sizeof(U_LONG))
+#define	BLOCK_LONGS	((BLOCK_OCTETS)/sizeof(U_LONG))
+
+/*
+ * Imported from the key data base module
+ */
+extern U_LONG cache_keyid;	/* cached key ID */
+extern u_char DEScache_ekeys[];	/* cached decryption keys */
+extern u_char DESzeroekeys[];	/* zero key decryption keys */
+
+/*
+ * Stat counters from the database module
+ */
+extern U_LONG authencryptions;
+extern U_LONG authkeyuncached;
+extern U_LONG authnokey;
+
+int
+DESauthencrypt(keyno, pkt, length)
+	U_LONG keyno;
+	U_LONG *pkt;
+	int length;	/* length of encrypted portion of packet */
+{
+	register U_LONG *pd;
+	register int i;
+	register u_char *keys;
+	register int len;
+	U_LONG work[2];
+
+	authencryptions++;
+
+	if (keyno == 0) {
+		keys = DESzeroekeys;
+	} else {
+		if (keyno != cache_keyid) {
+			authkeyuncached++;
+			if (!authhavekey(keyno)) {
+				authnokey++;
+				return 0;
+			}
+		}
+		keys = DEScache_ekeys;
+	}
+
+	/*
+	 * Do the encryption.  Work our way forward in the packet, eight
+	 * bytes at a time, encrypting as we go.  Note that the byte order
+	 * issues are handled by the DES routine itself
+	 */
+	pd = pkt;
+	work[0] = work[1] = 0;
+	len = length / sizeof(U_LONG);
+
+	for (i = (len/2); i > 0; i--) {
+		work[0] ^= *pd++;
+		work[1] ^= *pd++;
+		DESauth_des(work, keys);
+	}
+
+	if (len & 0x1) {
+		work[0] ^= *pd++;
+		DESauth_des(work, keys);
+	}
+
+	/*
+	 * Space past the keyid and stick the result back in the mac field
+	 */
+	pd += NOCRYPT_LONGS;
+	*pd++ = work[0];
+	*pd = work[1];
+
+	return 4 + BLOCK_OCTETS;	/* return size of key and MAC  */
+}
diff --git a/usr.sbin/xntpd/lib/authkeys.c b/usr.sbin/xntpd/lib/authkeys.c
new file mode 100644
index 0000000..2d46eee
--- /dev/null
+++ b/usr.sbin/xntpd/lib/authkeys.c
@@ -0,0 +1,602 @@
+/* authkeys.c,v 3.1 1993/07/06 01:07:51 jbj Exp
+ * authkeys.c - routines to manage the storage of authentication keys
+ */
+#include <stdio.h>
+
+#include "ntp_types.h"
+#include "ntp_string.h"
+#include "ntp_malloc.h"
+#include "ntp_stdlib.h"
+
+/*
+ * Structure to store keys in in the hash table.
+ */
+struct savekey {
+	struct savekey *next;
+	union {
+#ifdef	DES
+	    U_LONG DES_key[2];
+#endif
+#ifdef	MD5
+	    char MD5_key[32];
+#endif
+	} k;
+	U_LONG keyid;
+	u_short flags;
+#ifdef	MD5
+	int keylen;
+#endif
+};
+
+#define	KEY_TRUSTED	0x1	/* this key is trusted */
+#define	KEY_KNOWN	0x2	/* this key is known */
+
+#ifdef	DES
+#define	KEY_DES		0x100	/* this is a DES type key */
+#endif
+
+#ifdef	MD5
+#define	KEY_MD5		0x200	/* this is a MD5 type key */
+#endif
+
+/*
+ * The hash table.  This is indexed by the low order bits of the
+ * keyid.  We make this fairly big for potentially busy servers.
+ */
+#define	HASHSIZE	64
+#define	HASHMASK	((HASHSIZE)-1)
+#define	KEYHASH(keyid)	((keyid) & HASHMASK)
+
+struct savekey *key_hash[HASHSIZE];
+
+U_LONG authkeynotfound;
+U_LONG authkeylookups;
+U_LONG authnumkeys;
+U_LONG authuncached;
+U_LONG authkeyuncached;
+U_LONG authnokey;		/* calls to encrypt with no key */
+U_LONG authencryptions;
+U_LONG authdecryptions;
+U_LONG authdecryptok;
+
+/*
+ * Storage for free key structures.  We malloc() such things but
+ * never free them.
+ */
+struct savekey *authfreekeys;
+int authnumfreekeys;
+
+#define	MEMINC	12		/* number of new free ones to get at once */
+
+
+#ifdef	DES
+/*
+ * Size of the key schedule
+ */
+#define	KEY_SCHED_SIZE	128	/* number of octets to store key schedule */
+
+/*
+ * The zero key, which we always have.  Store the permutted key
+ * zero in here.
+ */
+#define	ZEROKEY_L	0x01010101	/* odd parity zero key */
+#define	ZEROKEY_R	0x01010101	/* right half of same */
+u_char DESzeroekeys[KEY_SCHED_SIZE];
+u_char DESzerodkeys[KEY_SCHED_SIZE];
+u_char DEScache_ekeys[KEY_SCHED_SIZE];
+u_char DEScache_dkeys[KEY_SCHED_SIZE];
+#endif
+
+/*
+ * The key cache.  We cache the last key we looked at here.
+ */
+U_LONG cache_keyid;
+u_short cache_flags;
+
+#ifdef	MD5
+int	cache_keylen;
+char	*cache_key;
+#endif
+
+/*
+ * init_auth - initialize internal data
+ */
+void
+init_auth()
+{
+	U_LONG zerokey[2];
+
+	/*
+	 * Initialize hash table and free list
+	 */
+	bzero((char *)key_hash, sizeof key_hash);
+	cache_flags = cache_keyid = 0;
+
+	authnumfreekeys =  authkeynotfound = authkeylookups = 0;
+	authnumkeys = authuncached = authkeyuncached = authnokey = 0;
+	authencryptions = authdecryptions = authdecryptok = 0;
+
+#ifdef	DES
+	/*
+	 * Initialize the zero key
+	 */
+	zerokey[0] = ZEROKEY_L;
+	zerokey[1] = ZEROKEY_R;
+	/* could just zero all */
+	DESauth_subkeys(zerokey, DESzeroekeys, DESzerodkeys);
+#endif
+}
+
+
+/*
+ * auth_findkey - find a key in the hash table
+ */
+struct savekey *
+auth_findkey(keyno)
+	U_LONG keyno;
+{
+	register struct savekey *sk;
+
+	sk = key_hash[KEYHASH(keyno)];
+	while (sk != 0) {
+		if (keyno == sk->keyid)
+			return sk;
+		sk = sk->next;
+	}
+	return 0;
+}
+
+
+/*
+ * auth_havekey - return whether a key is known
+ */
+int
+auth_havekey(keyno)
+	U_LONG keyno;
+{
+	register struct savekey *sk;
+
+	if (keyno == 0 || (keyno == cache_keyid))
+		return 1;
+
+	sk = key_hash[KEYHASH(keyno)];
+	while (sk != 0) {
+		if (keyno == sk->keyid) {
+			if (sk->flags & KEY_KNOWN)
+				return 1;
+			else {
+				authkeynotfound++;
+				return 0;
+			}
+		}
+		sk = sk->next;
+	}
+	authkeynotfound++;
+	return 0;
+}
+
+
+/*
+ * authhavekey - return whether a key is known.  Permute and cache
+ *		 the key as a side effect.
+ */
+int
+authhavekey(keyno)
+	U_LONG keyno;
+{
+	register struct savekey *sk;
+
+	authkeylookups++;
+	if (keyno == 0 || keyno == cache_keyid)
+		return 1;
+
+	sk = key_hash[KEYHASH(keyno)];
+	while (sk != 0) {
+		if (keyno == sk->keyid)
+			break;
+		sk = sk->next;
+	}
+
+	if (sk == 0 || !(sk->flags & KEY_KNOWN)) {
+		authkeynotfound++;
+		return 0;
+	}
+	
+	cache_keyid = sk->keyid;
+	cache_flags = sk->flags;
+#ifdef	MD5
+	if (sk->flags & KEY_MD5) {
+	    cache_keylen = sk->keylen;
+	    cache_key = (char *) sk->k.MD5_key;	/* XXX */
+	    return 1;
+	}
+#endif
+
+#ifdef	DES
+	if (sk->flags & KEY_DES) {
+	    DESauth_subkeys(sk->k.DES_key, DEScache_ekeys, DEScache_dkeys);
+	    return 1;
+	}
+#endif
+	return 0;
+}
+
+
+/*
+ * auth_moremem - get some more free key structures
+ */
+int
+auth_moremem()
+{
+	register struct savekey *sk;
+	register int i;
+
+	sk = (struct savekey *)malloc(MEMINC * sizeof(struct savekey));
+	if (sk == 0)
+		return 0;
+	
+	for (i = MEMINC; i > 0; i--) {
+		sk->next = authfreekeys;
+		authfreekeys = sk++;
+	}
+	authnumfreekeys += MEMINC;
+	return authnumfreekeys;
+}
+
+
+/*
+ * authtrust - declare a key to be trusted/untrusted
+ */
+void
+authtrust(keyno, trust)
+	U_LONG keyno;
+	int trust;
+{
+	register struct savekey *sk;
+
+	sk = key_hash[KEYHASH(keyno)];
+	while (sk != 0) {
+		if (keyno == sk->keyid)
+			break;
+		sk = sk->next;
+	}
+
+	if (sk == 0 && !trust)
+		return;
+	
+	if (sk != 0) {
+		if (cache_keyid == keyno)
+			cache_flags = cache_keyid = 0;
+
+		if (trust) {
+			sk->flags |= KEY_TRUSTED;
+			return;
+		}
+
+		sk->flags &= ~KEY_TRUSTED;
+		if (!(sk->flags & KEY_KNOWN)) {
+			register struct savekey *skp;
+
+			skp = key_hash[KEYHASH(keyno)];
+			if (skp == sk) {
+				key_hash[KEYHASH(keyno)] = sk->next;
+			} else {
+				while (skp->next != sk)
+					skp = skp->next;
+				skp->next = sk->next;
+			}
+			authnumkeys--;
+
+			sk->next = authfreekeys;
+			authfreekeys = sk;
+			authnumfreekeys++;
+		}
+		return;
+	}
+
+	if (authnumfreekeys == 0)
+		if (auth_moremem() == 0)
+			return;
+
+	sk = authfreekeys;
+	authfreekeys = sk->next;
+	authnumfreekeys--;
+
+	sk->keyid = keyno;
+	sk->flags = KEY_TRUSTED;
+	sk->next = key_hash[KEYHASH(keyno)];
+	key_hash[KEYHASH(keyno)] = sk;
+	authnumkeys++;
+	return;
+}
+
+
+/*
+ * authistrusted - determine whether a key is trusted
+ */
+int
+authistrusted(keyno)
+	U_LONG keyno;
+{
+	register struct savekey *sk;
+
+	if (keyno == cache_keyid)
+		return ((cache_flags & KEY_TRUSTED) != 0);
+
+	authkeyuncached++;
+
+	sk = key_hash[KEYHASH(keyno)];
+	while (sk != 0) {
+		if (keyno == sk->keyid)
+			break;
+		sk = sk->next;
+	}
+
+	if (sk == 0 || !(sk->flags & KEY_TRUSTED))
+		return 0;
+	return 1;
+}
+
+
+
+#ifdef	DES
+/*
+ * DESauth_setkey - set a key into the key array
+ */
+void
+DESauth_setkey(keyno, key)
+	U_LONG keyno;
+	const U_LONG *key;
+{
+	register struct savekey *sk;
+
+	/*
+	 * See if we already have the key.  If so just stick in the
+	 * new value.
+	 */
+	sk = key_hash[KEYHASH(keyno)];
+	while (sk != 0) {
+		if (keyno == sk->keyid) {
+			sk->k.DES_key[0] = key[0];
+			sk->k.DES_key[1] = key[1];
+			sk->flags |= KEY_KNOWN | KEY_DES;
+			if (cache_keyid == keyno)
+				cache_flags = cache_keyid = 0;
+			return;
+		}
+		sk = sk->next;
+	}
+
+	/*
+	 * Need to allocate new structure.  Do it.
+	 */
+	if (authnumfreekeys == 0) {
+		if (auth_moremem() == 0)
+			return;
+	}
+
+	sk = authfreekeys;
+	authfreekeys = sk->next;
+	authnumfreekeys--;
+
+	sk->k.DES_key[0] = key[0];
+	sk->k.DES_key[1] = key[1];
+	sk->keyid = keyno;
+	sk->flags = KEY_KNOWN | KEY_DES;
+	sk->next = key_hash[KEYHASH(keyno)];
+	key_hash[KEYHASH(keyno)] = sk;
+	authnumkeys++;
+	return;
+}
+#endif
+
+#ifdef	MD5
+void
+MD5auth_setkey(keyno, key)
+    U_LONG keyno;
+    const U_LONG *key;
+{
+	register struct savekey *sk;
+
+	/*
+	 * See if we already have the key.  If so just stick in the
+	 * new value.
+	 */
+	sk = key_hash[KEYHASH(keyno)];
+	while (sk != 0) {
+		if (keyno == sk->keyid) {
+			strncpy(sk->k.MD5_key, (char *)key, sizeof(sk->k.MD5_key));
+			if ((sk->keylen = strlen((char *)key)) > 
+			                          sizeof(sk->k.MD5_key))
+			    sk->keylen = sizeof(sk->k.MD5_key);
+
+			sk->flags |= KEY_KNOWN | KEY_MD5;
+			if (cache_keyid == keyno)
+				cache_flags = cache_keyid = 0;
+			return;
+		}
+		sk = sk->next;
+	}
+
+	/*
+	 * Need to allocate new structure.  Do it.
+	 */
+	if (authnumfreekeys == 0) {
+		if (auth_moremem() == 0)
+			return;
+	}
+
+	sk = authfreekeys;
+	authfreekeys = sk->next;
+	authnumfreekeys--;
+
+	strncpy(sk->k.MD5_key, (char *)key, sizeof(sk->k.MD5_key));
+	if ((sk->keylen = strlen((char *)key)) > sizeof(sk->k.MD5_key))
+	    sk->keylen = sizeof(sk->k.MD5_key);
+
+	sk->keyid = keyno;
+	sk->flags = KEY_KNOWN | KEY_MD5;
+	sk->next = key_hash[KEYHASH(keyno)];
+	key_hash[KEYHASH(keyno)] = sk;
+	authnumkeys++;
+	return;
+}
+#endif
+    
+/*
+ * auth_delkeys - delete all known keys, in preparation for rereading
+ *		  the keys file (presumably)
+ */
+void
+auth_delkeys()
+{
+	register struct savekey *sk;
+	register struct savekey **skp;
+	register int i;
+
+	for (i = 0; i < HASHSIZE; i++) {
+		skp = &(key_hash[i]);
+		sk = key_hash[i];
+		while (sk != 0) {
+			sk->flags &= ~(KEY_KNOWN
+#ifdef	MD5
+				       | KEY_MD5
+#endif
+#ifdef	DES
+				       | KEY_DES
+#endif
+				       );
+			if (sk->flags == 0) {
+				*skp = sk->next;
+				authnumkeys--;
+				sk->next = authfreekeys;
+				authfreekeys = sk;
+				authnumfreekeys++;
+				sk = *skp;
+			} else {
+				skp = &(sk->next);
+				sk = sk->next;
+			}
+		}
+	}
+}
+
+
+/*
+ *  auth1crypt - support for two stage encryption, part 1.
+ */
+void
+auth1crypt(keyno, pkt, length)
+	U_LONG keyno;
+	U_LONG *pkt;
+	int length;	/* length of all encrypted data */
+{
+    if (keyno && keyno != cache_keyid) {
+	authkeyuncached++;
+	if (!authhavekey(keyno)) {
+	    authnokey++;
+	    return;
+	}
+    }
+
+#ifdef	DES
+    if (!keyno || (cache_flags & KEY_DES)) {
+	DESauth1crypt(keyno, pkt, length);
+	return;
+    }
+#endif
+
+#ifdef	MD5
+    if (cache_flags & KEY_MD5) {
+	MD5auth1crypt(keyno, pkt, length);
+	return;
+    }
+#endif
+}
+
+
+/*
+ *  auth1crypt - support for two stage encryption, part 1.
+ */
+int
+auth2crypt(keyno, pkt, length)
+	U_LONG keyno;
+	U_LONG *pkt;
+	int length;	/* total length of encrypted area */
+{
+    if (keyno && keyno != cache_keyid) {
+	authkeyuncached++;
+	if (!authhavekey(keyno)) {
+	    authnokey++;
+	    return 0;
+	}
+    }
+
+#ifdef	DES
+    if (!keyno || (cache_flags & KEY_DES))
+	return DESauth2crypt(keyno, pkt, length);
+#endif
+
+#ifdef	MD5
+    if (cache_flags & KEY_MD5)
+	return MD5auth2crypt(keyno, pkt, length);
+#endif
+
+    return 0;
+}
+
+int
+authencrypt(keyno, pkt, length)
+	U_LONG keyno;
+	U_LONG *pkt;
+	int length;	/* length of encrypted portion of packet */
+{
+    int sendlength = 0;
+
+    if (keyno && keyno != cache_keyid) {
+	authkeyuncached++;
+	if (!authhavekey(keyno)) {
+	    authnokey++;
+	    return 0;
+	}
+    }
+
+#ifdef	DES
+    if (!keyno || (cache_flags & KEY_DES))
+	return sendlength = DESauthencrypt(keyno, pkt, length);
+#endif
+
+#ifdef	MD5
+    if (cache_flags & KEY_MD5)
+	return MD5authencrypt(keyno, pkt, length);
+#endif
+    return 0;
+}
+
+
+int
+authdecrypt(keyno, pkt, length)
+    U_LONG keyno;
+    U_LONG *pkt;
+    int length;	/* length of variable data in octets */
+{
+    if (keyno && (keyno != cache_keyid)) {
+	authkeyuncached++;
+	if (!authhavekey(keyno)) {
+	    authnokey++;
+	    return 0;
+	}
+    }
+
+#ifdef	DES
+    if (!keyno || (cache_flags & KEY_DES))
+	return DESauthdecrypt(keyno, pkt, length);
+#endif
+
+#ifdef	MD5
+    if (cache_flags & KEY_MD5)
+	return MD5authdecrypt(keyno, pkt, length);
+#endif
+
+    return 0;
+}
diff --git a/usr.sbin/xntpd/lib/authparity.c b/usr.sbin/xntpd/lib/authparity.c
new file mode 100644
index 0000000..33562cb
--- /dev/null
+++ b/usr.sbin/xntpd/lib/authparity.c
@@ -0,0 +1,58 @@
+/* authparity.c,v 3.1 1993/07/06 01:07:55 jbj Exp
+ * auth_parity - set parity on a key/check for odd parity
+ */
+#include "ntp_stdlib.h"
+
+int
+DESauth_parity(key)
+	U_LONG *key;
+{
+	U_LONG mask;
+	int parity_err;
+	int bitcount;
+	int half;
+	int byte;
+	int i;
+
+	/*
+	 * Go through counting bits in each byte.  Check to see if
+	 * each parity bit was set correctly.  If not, note the error
+	 * and set it right.
+	 */
+	parity_err = 0;
+	for (half = 0; half < 2; half++) {		/* two halves of key */
+		mask = 0x80000000;
+		for (byte = 0; byte < 4; byte++) {	/* 4 bytes per half */
+			bitcount = 0;
+			for (i = 0; i < 7; i++) {	/* 7 data bits / byte */
+				if (key[half] & mask)
+					bitcount++;
+				mask >>= 1;
+			}
+
+			/*
+			 * If bitcount is even, parity must be set.  If
+			 * bitcount is odd, parity must be clear.
+			 */
+			if ((bitcount & 0x1) == 0) {
+				if (!(key[half] & mask)) {
+					parity_err++;
+					key[half] |= mask;
+				}
+			} else {
+				if (key[half] & mask) {
+					parity_err++;
+					key[half] &= ~mask;
+				}
+			}
+			mask >>= 1;
+		}
+	}
+
+	/*
+	 * Return the result of the parity check.
+	 */
+	return (parity_err == 0);
+}
+
+
diff --git a/usr.sbin/xntpd/lib/authreadkeys.c b/usr.sbin/xntpd/lib/authreadkeys.c
new file mode 100644
index 0000000..5800186
--- /dev/null
+++ b/usr.sbin/xntpd/lib/authreadkeys.c
@@ -0,0 +1,191 @@
+/* authreadkeys.c,v 3.1 1993/07/06 01:07:57 jbj Exp
+ * authreadkeys.c - routines to support the reading of the key file
+ */
+#include <stdio.h>
+#include <ctype.h>
+
+#include "ntp_stdlib.h"
+#include "ntp_syslog.h"
+
+#ifdef	DES
+/*
+ * Types of ascii representations for keys.  "Standard" means a 64 bit
+ * hex number in NBS format, i.e. with the low order bit of each byte
+ * a parity bit.  "NTP" means a 64 bit key in NTP format, with the
+ * high order bit of each byte a parity bit.  "Ascii" means a 1-to-8
+ * character string whose ascii representation is used as the key.
+ */
+#define	KEY_TYPE_STD	1
+#define	KEY_TYPE_NTP	2
+#define	KEY_TYPE_ASCII	3
+#endif
+
+#ifdef	MD5
+/*
+ *  Arbitrary LONG string of ASCII characters.
+ */
+#define	KEY_TYPE_MD5	4
+#endif
+
+/*
+ * nexttok - basic internal tokenizing routine
+ */
+static char *
+nexttok(str)
+	char **str;
+{
+	register char *cp;
+	char *starttok;
+
+	cp = *str;
+
+	/*
+	 * Space past white space
+	 */
+	while (*cp == ' ' || *cp == '\t')
+		cp++;
+	
+	/*
+	 * Save this and space to end of token
+	 */
+	starttok = cp;
+	while (*cp != '\0' && *cp != '\n' && *cp != ' '
+	    && *cp != '\t' && *cp != '#')
+		cp++;
+	
+	/*
+	 * If token length is zero return an error, else set end of
+	 * token to zero and return start.
+	 */
+	if (starttok == cp)
+		return 0;
+	
+	if (*cp == ' ' || *cp == '\t')
+		*cp++ = '\0';
+	else
+		*cp = '\0';
+	
+	*str = cp;
+	return starttok;
+}
+
+
+/*
+ * authreadkeys - (re)read keys from a file.
+ */
+int
+authreadkeys(file)
+	const char *file;
+{
+	FILE *fp;
+	char *line;
+	char *token;
+	U_LONG keyno;
+	int keytype;
+	char buf[512];		/* lots of room for line? */
+extern	FILE *	fopen		P((const char *filename, const char *type));
+extern	int	fclose		P((FILE *stream));
+
+	/*
+	 * Open file.  Complain and return if it can't be opened.
+	 */
+	fp = fopen(file, "r");
+	if (fp == NULL) {
+		syslog(LOG_ERR, "can't open key file %s: %m", file);
+		return 0;
+	}
+
+	/*
+	 * Remove all existing keys
+	 */
+	auth_delkeys();
+
+	/*
+	 * Now read lines from the file, looking for key entries
+	 */
+	while ((line = fgets(buf, sizeof buf, fp)) != NULL) {
+		token = nexttok(&line);
+		if (token == 0)
+			continue;
+		
+		/*
+		 * First is key number.  See if it is okay.
+		 */
+		keyno = (U_LONG)atoi(token);
+		if (keyno == 0) {
+			syslog(LOG_ERR,
+			    "cannot change keyid 0, key entry `%s' ignored",
+			    token);
+			continue;
+		}
+
+		/*
+		 * Next is keytype.  See if that is all right.
+		 */
+		token = nexttok(&line);
+		if (token == 0) {
+			syslog(LOG_ERR,
+			    "no key type for key number %d, entry ignored",
+			    keyno);
+			continue;
+		}
+		switch (*token) {
+#ifdef	DES
+		case 'S':
+		case 's':
+		    keytype = KEY_TYPE_STD; break;
+
+		case 'N':
+		case 'n':
+		    keytype = KEY_TYPE_NTP; break;
+
+		case 'A':
+		case 'a':
+		    keytype = KEY_TYPE_ASCII; break;
+#endif
+#ifdef	MD5
+		case 'M':
+		case 'm':
+		    keytype = KEY_TYPE_MD5; break;
+#endif
+		default:
+		    syslog(LOG_ERR,
+			   "invalid key type for key number %d, entry ignored",
+			   keyno);
+		    continue;
+		}
+
+		/*
+		 * Finally, get key and insert it
+		 */
+		token = nexttok(&line);
+		if (token == 0) {
+			syslog(LOG_ERR,
+			    "no key for number %d entry, entry ignored",
+			    keyno);
+		} else {
+		    switch(keytype) {
+#ifdef	DES
+		    case KEY_TYPE_STD:
+		    case KEY_TYPE_NTP:
+		    case KEY_TYPE_ASCII:
+			if (!authusekey(keyno, keytype, token))
+			    syslog(LOG_ERR,
+				 "format/parity error for DES key %d, not used",
+				   keyno);
+			break;
+#endif
+#ifdef	MD5
+		    case KEY_TYPE_MD5:
+			if (!authusekey(keyno, keytype, token))
+			    syslog(LOG_ERR,
+				 "format/parity error for MD5 key %d, not used",
+				   keyno);
+			break;
+#endif
+		    }
+		}
+	}
+	(void) fclose(fp);
+	return 1;
+}
diff --git a/usr.sbin/xntpd/lib/authusekey.c b/usr.sbin/xntpd/lib/authusekey.c
new file mode 100644
index 0000000..0452031
--- /dev/null
+++ b/usr.sbin/xntpd/lib/authusekey.c
@@ -0,0 +1,132 @@
+/* authusekey.c,v 3.1 1993/07/06 01:07:58 jbj Exp
+ * authusekey - decode a key from ascii and use it
+ */
+#include <stdio.h>
+#include <ctype.h>
+
+#include "ntp_types.h"
+#include "ntp_string.h"
+#include "ntp_stdlib.h"
+
+/*
+ * Types of ascii representations for keys.  "Standard" means a 64 bit
+ * hex number in NBS format, i.e. with the low order bit of each byte
+ * a parity bit.  "NTP" means a 64 bit key in NTP format, with the
+ * high order bit of each byte a parity bit.  "Ascii" means a 1-to-8
+ * character string whose ascii representation is used as the key.
+ */
+#ifdef	DES
+#define	KEY_TYPE_STD	1
+#define	KEY_TYPE_NTP	2
+#define	KEY_TYPE_ASCII	3
+
+#define	STD_PARITY_BITS	0x01010101
+
+#endif
+
+#ifdef	MD5
+#define	KEY_TYPE_MD5	4
+#endif
+
+int
+authusekey(keyno, keytype, str)
+	U_LONG keyno;
+	int keytype;
+	const char *str;
+{
+	U_LONG key[2];
+	u_char keybytes[8];
+	const char *cp;
+	char *xdigit;
+	int len;
+	int i;
+	static char *hex = "0123456789abcdef";
+
+	cp = str;
+	len = strlen(cp);
+	if (len == 0)
+		return 0;
+
+	switch(keytype) {
+#ifdef	DES
+	case KEY_TYPE_STD:
+	case KEY_TYPE_NTP:
+		if (len != 16)		/* Lazy.  Should define constant */
+			return 0;
+		/*
+		 * Decode hex key.
+		 */
+		key[0] = 0;
+		key[1] = 0;
+		for (i = 0; i < 16; i++) {
+			if (!isascii(*cp))
+				return 0;
+			xdigit = strchr(hex, isupper(*cp) ? tolower(*cp) : *cp);
+			cp++;
+			if (xdigit == 0)
+				return 0;
+			key[i>>3] <<= 4;
+			key[i>>3] |= (U_LONG)(xdigit - hex) & 0xf;
+		}
+
+		/*
+		 * If this is an NTP format key, put it into NBS format
+		 */
+		if (keytype == KEY_TYPE_NTP) {
+			for (i = 0; i < 2; i++)
+				key[i] = ((key[i] << 1) & ~STD_PARITY_BITS)
+				    | ((key[i] >> 7) & STD_PARITY_BITS);
+		}
+
+		/*
+		 * Check the parity, reject the key if the check fails
+		 */
+		if (!DESauth_parity(key)) {
+			return 0;
+		}
+		
+		/*
+		 * We can't find a good reason not to use this key.
+		 * So use it.
+		 */
+		DESauth_setkey(keyno, key);
+		break;
+	
+	case KEY_TYPE_ASCII:
+		/*
+		 * Make up key from ascii representation
+		 */
+		bzero((char *) keybytes, sizeof(keybytes));
+		for (i = 0; i < 8 && i < len; i++)
+			keybytes[i] = *cp++ << 1;
+		key[0] = (U_LONG)keybytes[0] << 24 | (U_LONG)keybytes[1] << 16
+		    | (U_LONG)keybytes[2] << 8 | (U_LONG)keybytes[3];
+		key[1] = (U_LONG)keybytes[4] << 24 | (U_LONG)keybytes[5] << 16
+		    | (U_LONG)keybytes[6] << 8 | (U_LONG)keybytes[7];
+		
+		/*
+		 * Set parity on key
+		 */
+		(void)DESauth_parity(key);
+
+		/*
+		 * Now set key in.
+		 */
+		DESauth_setkey(keyno, key);
+		break;
+#endif
+
+#ifdef	MD5
+	case KEY_TYPE_MD5:
+	/* XXX FIXME: MD5auth_setkey() casts arg2 back to (char *) */
+		MD5auth_setkey(keyno, (U_LONG *)str);
+		break;
+#endif
+
+	default:
+		/* Oh, well */
+		return 0;
+	}
+
+	return 1;
+}
diff --git a/usr.sbin/xntpd/lib/buftvtots.c b/usr.sbin/xntpd/lib/buftvtots.c
new file mode 100644
index 0000000..d9b484d
--- /dev/null
+++ b/usr.sbin/xntpd/lib/buftvtots.c
@@ -0,0 +1,61 @@
+/* buftvtots.c,v 3.1 1993/07/06 01:07:59 jbj Exp
+ * buftvtots - pull a Unix-format (struct timeval) time stamp out of
+ *	       an octet stream and convert it to a l_fp time stamp.
+ *	       This is useful when using the clock line discipline.
+ */
+#include "ntp_fp.h"
+#include "ntp_unixtime.h"
+
+int
+buftvtots(bufp, ts)
+	const char *bufp;
+	l_fp *ts;
+{
+	register const u_char *bp;
+	register U_LONG sec;
+	register U_LONG usec;
+
+#ifdef XNTP_BIG_ENDIAN
+	bp = (u_char *)bufp;
+
+	sec = (U_LONG)*bp++ & 0xff;
+	sec <<= 8;
+	sec += (U_LONG)*bp++ & 0xff;
+	sec <<= 8;
+	sec += (U_LONG)*bp++ & 0xff;
+	sec <<= 8;
+	sec += (U_LONG)*bp++ & 0xff;
+
+	usec = (U_LONG)*bp++ & 0xff;
+	usec <<= 8;
+	usec += (U_LONG)*bp++ & 0xff;
+	usec <<= 8;
+	usec += (U_LONG)*bp++ & 0xff;
+	usec <<= 8;
+	usec += (U_LONG)*bp & 0xff;
+#else
+	bp = (u_char *)bufp + 7;
+
+	usec = (U_LONG)*bp-- & 0xff;
+	usec <<= 8;
+	usec += (U_LONG)*bp-- & 0xff;
+	usec <<= 8;
+	usec += (U_LONG)*bp-- & 0xff;
+	usec <<= 8;
+	usec += (U_LONG)*bp-- & 0xff;
+
+	sec = (U_LONG)*bp-- & 0xff;
+	sec <<= 8;
+	sec += (U_LONG)*bp-- & 0xff;
+	sec <<= 8;
+	sec += (U_LONG)*bp-- & 0xff;
+	sec <<= 8;
+	sec += (U_LONG)*bp & 0xff;
+#endif
+	if (usec > 999999)
+		return 0;
+
+	ts->l_ui = sec + (U_LONG)JAN_1970;
+	TVUTOTSF(usec, ts->l_uf);
+	return 1;
+}
diff --git a/usr.sbin/xntpd/lib/caljulian.c b/usr.sbin/xntpd/lib/caljulian.c
new file mode 100644
index 0000000..92d6d74
--- /dev/null
+++ b/usr.sbin/xntpd/lib/caljulian.c
@@ -0,0 +1,105 @@
+/* caljulian.c,v 3.1 1993/07/06 01:08:00 jbj Exp
+ * caljulian - determine the Julian date from an NTP time.
+ */
+#include <sys/types.h>
+
+#include "ntp_types.h"
+#include "ntp_calendar.h"
+#include "ntp_stdlib.h"
+
+/*
+ * calmonthtab - month start offsets from the beginning of a cycle.
+ */
+static u_short calmonthtab[12] = {
+	0,						/* March */
+	MAR,						/* April */
+	(MAR+APR),					/* May */
+	(MAR+APR+MAY),					/* June */
+	(MAR+APR+MAY+JUN),				/* July */
+	(MAR+APR+MAY+JUN+JUL),				/* August */
+	(MAR+APR+MAY+JUN+JUL+AUG),			/* September */
+	(MAR+APR+MAY+JUN+JUL+AUG+SEP),			/* October */
+	(MAR+APR+MAY+JUN+JUL+AUG+SEP+OCT),		/* November */
+	(MAR+APR+MAY+JUN+JUL+AUG+SEP+OCT+NOV),		/* December */
+	(MAR+APR+MAY+JUN+JUL+AUG+SEP+OCT+NOV+DEC),	/* January */
+	(MAR+APR+MAY+JUN+JUL+AUG+SEP+OCT+NOV+DEC+JAN),	/* February */
+};
+
+/*
+ * caldaytab - calendar year start day offsets
+ */
+static u_short caldaytab[YEARSPERCYCLE] = {
+	(DAYSPERYEAR - (JAN + FEB)),
+	((DAYSPERYEAR * 2) - (JAN + FEB)),
+	((DAYSPERYEAR * 3) - (JAN + FEB)),
+	((DAYSPERYEAR * 4) - (JAN + FEB)),
+};
+
+void
+caljulian(ntptime, jt)
+	U_LONG ntptime;
+	register struct calendar *jt;
+{
+	register int i;
+	register U_LONG nt;
+	register u_short snt;
+	register int cyear;
+
+	/*
+	 * Find the start of the cycle this is in.
+	 */
+	nt = ntptime;
+	if (nt >= MAR1988) {
+		cyear = CYCLE22;
+		nt -= MAR1988;
+	} else {
+		cyear = 0;
+		nt -= MAR1900;
+	}
+	while (nt >= SECSPERCYCLE) {
+		nt -= SECSPERCYCLE;
+		cyear++;
+	}
+	
+	/*
+	 * Seconds, minutes and hours are too hard to do without
+	 * divides, so we don't.
+	 */
+	jt->second = nt % SECSPERMIN;
+	nt /= SECSPERMIN;		/* nt in minutes */
+	jt->minute = nt % MINSPERHR;
+	snt = nt / MINSPERHR;		/* snt in hours */
+	jt->hour = snt % HRSPERDAY;
+	snt /= HRSPERDAY;		/* nt in days */
+
+	/*
+	 * snt is now the number of days into the cycle, from 0 to 1460.
+	 */
+	cyear <<= 2;
+	if (snt < caldaytab[0]) {
+		jt->yearday = snt + JAN + FEBLEAP + 1;	/* first year is leap */
+	} else {
+		for (i = 1; i < YEARSPERCYCLE; i++)
+			if (snt < caldaytab[i])
+				break;
+		jt->yearday = snt - caldaytab[i-1] + 1;
+		cyear += i;
+	}
+	jt->year = cyear + 1900;
+
+	/*
+	 * One last task, to compute the month and day.  Normalize snt to
+	 * a day within a cycle year.
+	 */
+	while (snt >= DAYSPERYEAR)
+		snt -= DAYSPERYEAR;
+	for (i = 0; i < 11; i++)
+		if (snt < calmonthtab[i+1])
+			break;
+	
+	if (i > 9)
+		jt->month = i - 9;	/* January or February */
+	else
+		jt->month = i + 3;	/* March through December */
+	jt->monthday = snt - calmonthtab[i] + 1;
+}
diff --git a/usr.sbin/xntpd/lib/calleapwhen.c b/usr.sbin/xntpd/lib/calleapwhen.c
new file mode 100644
index 0000000..379643f
--- /dev/null
+++ b/usr.sbin/xntpd/lib/calleapwhen.c
@@ -0,0 +1,61 @@
+/* calleapwhen.c,v 3.1 1993/07/06 01:08:02 jbj Exp
+ * calleapwhen - determine the number of seconds to the next possible
+ *		 leap occurance and the last one.
+ */
+#include <sys/types.h>
+
+#include "ntp_types.h"
+#include "ntp_calendar.h"
+#include "ntp_stdlib.h"
+
+/*
+ * calleaptab - leaps occur at the end of December and June
+ */
+LONG calleaptab[10] = {
+	-(JAN+FEBLEAP)*SECSPERDAY,	/* leap previous to cycle */
+	(MAR+APR+MAY+JUN)*SECSPERDAY,	/* end of June */
+	(MAR+APR+MAY+JUN+JUL+AUG+SEP+OCT+NOV+DEC)*SECSPERDAY, /* end of Dec */
+	(MAR+APR+MAY+JUN)*SECSPERDAY + SECSPERYEAR,
+	(MAR+APR+MAY+JUN+JUL+AUG+SEP+OCT+NOV+DEC)*SECSPERDAY + SECSPERYEAR,
+	(MAR+APR+MAY+JUN)*SECSPERDAY + 2*SECSPERYEAR,
+	(MAR+APR+MAY+JUN+JUL+AUG+SEP+OCT+NOV+DEC)*SECSPERDAY + 2*SECSPERYEAR,
+	(MAR+APR+MAY+JUN)*SECSPERDAY + 3*SECSPERYEAR,
+	(MAR+APR+MAY+JUN+JUL+AUG+SEP+OCT+NOV+DEC)*SECSPERDAY + 3*SECSPERYEAR,
+	(MAR+APR+MAY+JUN+JUL+AUG+SEP+OCT+NOV+DEC+JAN+FEBLEAP+MAR+APR+MAY+JUN)
+	    *SECSPERDAY + 3*SECSPERYEAR,	/* next after current cycle */
+};
+
+void
+calleapwhen(ntpdate, leaplast, leapnext)
+	U_LONG ntpdate;
+	U_LONG *leaplast;
+	U_LONG *leapnext;
+{
+	register U_LONG dateincycle;
+	register int i;
+
+	/*
+	 * Find the offset from the start of the cycle
+	 */
+	dateincycle = ntpdate;
+	if (dateincycle >= MAR1988)
+		dateincycle -= MAR1988;
+	else
+		dateincycle -= MAR1900;
+
+	while (dateincycle >= SECSPERCYCLE)
+		dateincycle -= SECSPERCYCLE;
+
+	/*
+	 * Find where we are with respect to the leap events.
+	 */
+	for (i = 1; i < 9; i++)
+		if (dateincycle < (U_LONG)calleaptab[i])
+			break;
+	
+	/*
+	 * i points at the next leap.  Compute the last and the next.
+	 */
+	*leaplast = (U_LONG)((LONG)dateincycle - calleaptab[i-1]);
+	*leapnext = (U_LONG)(calleaptab[i] - (LONG)dateincycle);
+}
diff --git a/usr.sbin/xntpd/lib/caltontp.c b/usr.sbin/xntpd/lib/caltontp.c
new file mode 100644
index 0000000..f5da0ab
--- /dev/null
+++ b/usr.sbin/xntpd/lib/caltontp.c
@@ -0,0 +1,90 @@
+/* caltontp.c,v 3.1 1993/07/06 01:08:04 jbj Exp
+ * caltontp - convert a julian date to an NTP time
+ */
+#include <sys/types.h>
+
+#include "ntp_types.h"
+#include "ntp_calendar.h"
+#include "ntp_stdlib.h"
+
+/*
+ * calmonthtab - month start offsets from the beginning of a cycle.
+ */
+static u_short calmonthtab[12] = {
+	0,						/* March */
+	MAR,						/* April */
+	(MAR+APR),					/* May */
+	(MAR+APR+MAY),					/* June */
+	(MAR+APR+MAY+JUN),				/* July */
+	(MAR+APR+MAY+JUN+JUL),				/* August */
+	(MAR+APR+MAY+JUN+JUL+AUG),			/* September */
+	(MAR+APR+MAY+JUN+JUL+AUG+SEP),			/* October */
+	(MAR+APR+MAY+JUN+JUL+AUG+SEP+OCT),		/* November */
+	(MAR+APR+MAY+JUN+JUL+AUG+SEP+OCT+NOV),		/* December */
+	(MAR+APR+MAY+JUN+JUL+AUG+SEP+OCT+NOV+DEC),	/* January */
+	(MAR+APR+MAY+JUN+JUL+AUG+SEP+OCT+NOV+DEC+JAN),	/* February */
+};
+
+U_LONG
+caltontp(jt)
+	register const struct calendar *jt;
+{
+	register int cyear;
+	register int resyear;
+	register U_LONG nt;
+	register int yearday;
+
+	/*
+	 * Find the start of the cycle this is in.
+	 */
+	cyear = (int)(jt->year - 1900) >> 2;
+	resyear = (jt->year - 1900) - (cyear << 2);
+	yearday = 0;
+	if (resyear == 0) {
+		if (jt->yearday == 0) {
+			if (jt->month == 1 || jt->month == 2) {
+				cyear--;
+				resyear = 3;
+			}
+		} else {
+			if (jt->yearday <= (u_short)(JAN+FEBLEAP)) {
+				cyear--;
+				resyear = 3;
+				yearday = calmonthtab[10] + jt->yearday;
+			} else {
+				yearday = jt->yearday - (JAN+FEBLEAP);
+			}
+		}
+	} else {
+		if (jt->yearday == 0) {
+			if (jt->month == 1 || jt->month == 2)
+				resyear--;
+		} else {
+			if (jt->yearday <= (u_short)(JAN+FEB)) {
+				resyear--;
+				yearday = calmonthtab[10] + jt->yearday;
+			} else {
+				yearday = jt->yearday - (JAN+FEB);
+			}
+		}
+	}
+
+	if (yearday == 0) {
+		if (jt->month >= 3) {
+			yearday = calmonthtab[jt->month - 3] + jt->monthday;
+		} else {
+			yearday = calmonthtab[jt->month + 9] + jt->monthday;
+		}
+	}
+
+	nt = TIMESDPERC((U_LONG)cyear);
+	while (resyear-- > 0)
+		nt += DAYSPERYEAR;
+	nt += (U_LONG) (yearday - 1);
+
+	nt = TIMES24(nt) + (U_LONG)jt->hour;
+	nt = TIMES60(nt) + (U_LONG)jt->minute;
+	nt = TIMES60(nt) + (U_LONG)jt->second;
+
+	return nt + MAR1900;
+}
diff --git a/usr.sbin/xntpd/lib/calyearstart.c b/usr.sbin/xntpd/lib/calyearstart.c
new file mode 100644
index 0000000..1bb3321
--- /dev/null
+++ b/usr.sbin/xntpd/lib/calyearstart.c
@@ -0,0 +1,62 @@
+/* calyearstart.c,v 3.1 1993/07/06 01:08:06 jbj Exp
+ * calyearstart - determine the NTP time at midnight of January 1 in
+ *		  the year of the given date.
+ */
+#include <sys/types.h>
+
+#include "ntp_types.h"
+#include "ntp_calendar.h"
+#include "ntp_stdlib.h"
+
+/*
+ * calyeartab - year start offsets from the beginning of a cycle
+ */
+U_LONG calyeartab[YEARSPERCYCLE] = {
+	(SECSPERLEAPYEAR-JANFEBLEAP),
+	(SECSPERLEAPYEAR-JANFEBLEAP) + SECSPERYEAR,
+	(SECSPERLEAPYEAR-JANFEBLEAP) + 2*SECSPERYEAR,
+	(SECSPERLEAPYEAR-JANFEBLEAP) + 3*SECSPERYEAR
+};
+
+U_LONG
+calyearstart(dateinyear)
+	register U_LONG dateinyear;
+{
+	register U_LONG cyclestart;
+	register U_LONG nextyear, lastyear;
+	register int i;
+
+	/*
+	 * Find the start of the cycle this is in.
+	 */
+	if (dateinyear >= MAR1988)
+		cyclestart = MAR1988;
+	else
+		cyclestart = MAR1900;
+	while ((cyclestart + SECSPERCYCLE) <= dateinyear)
+		cyclestart += SECSPERCYCLE;
+	
+	/*
+	 * If we're in the first year of the cycle, January 1 is
+	 * two months back from the cyclestart and the year is
+	 * a leap year.
+	 */
+	lastyear = cyclestart + calyeartab[0];
+	if (dateinyear < lastyear)
+		return (cyclestart - JANFEBLEAP);
+
+	/*
+	 * Look for an intermediate year
+	 */
+	for (i = 1; i < YEARSPERCYCLE; i++) {
+		nextyear = cyclestart + calyeartab[i];
+		if (dateinyear < nextyear)
+			return lastyear;
+		lastyear = nextyear;
+	}
+
+	/*
+	 * Not found, must be in last two months of cycle
+	 */
+	return nextyear;
+}
diff --git a/usr.sbin/xntpd/lib/clocktime.c b/usr.sbin/xntpd/lib/clocktime.c
new file mode 100644
index 0000000..36b967e
--- /dev/null
+++ b/usr.sbin/xntpd/lib/clocktime.c
@@ -0,0 +1,131 @@
+/* clocktime.c,v 3.1 1993/07/06 01:08:07 jbj Exp
+ * clocktime - compute the NTP date from a day of year, hour, minute
+ *	       and second.
+ */
+#include "ntp_fp.h"
+#include "ntp_unixtime.h"
+#include "ntp_stdlib.h"
+
+/*
+ * Hacks to avoid excercising the multiplier.  I have no pride.
+ */
+#define	MULBY10(x)	(((x)<<3) + ((x)<<1))
+#define	MULBY60(x)	(((x)<<6) - ((x)<<2))	/* watch overflow */
+#define	MULBY24(x)	(((x)<<4) + ((x)<<3))
+
+/*
+ * Two days, in seconds.
+ */
+#define	TWODAYS		(2*24*60*60)
+
+/*
+ * We demand that the time be within CLOSETIME seconds of the receive
+ * time stamp.  This is about 4 hours, which hopefully should be
+ * wide enough to collect most data, while close enough to keep things
+ * from getting confused.
+ */
+#define	CLOSETIME	(4*60*60)
+
+
+int
+clocktime(yday, hour, minute, second, tzoff, rec_ui, yearstart, ts_ui)
+	int yday;
+	int hour;
+	int minute;
+	int second;
+	int tzoff;
+	U_LONG rec_ui;
+	U_LONG *yearstart;
+	U_LONG *ts_ui;
+{
+	register LONG tmp;
+	register U_LONG date;
+	register U_LONG yst;
+
+	/*
+	 * Compute the offset into the year in seconds.  Note that
+	 * this could come out to be a negative number.
+	 */
+	tmp = (LONG)(MULBY24((yday-1)) + hour + tzoff);
+	tmp = MULBY60(tmp) + (LONG)minute;
+	tmp = MULBY60(tmp) + (LONG)second;
+
+	/*
+	 * Initialize yearstart, if necessary.
+	 */
+	yst = *yearstart;
+	if (yst == 0) {
+		yst = calyearstart(rec_ui);
+		*yearstart = yst;
+	}
+
+	/*
+	 * Now the fun begins.  We demand that the received clock time
+	 * be within CLOSETIME of the receive timestamp, but
+	 * there is uncertainty about the year the timestamp is in.
+	 * Use the current year start for the first check, this should
+	 * work most of the time.
+	 */
+	date = (U_LONG)(tmp + (LONG)yst);
+	if (date < (rec_ui + CLOSETIME) &&
+	    date > (rec_ui - CLOSETIME)) {
+		*ts_ui = date;
+		return 1;
+	}
+
+	/*
+	 * Trouble.  Next check is to see if the year rolled over and, if
+	 * so, try again with the new year's start.
+	 */
+	yst = calyearstart(rec_ui);
+	if (yst != *yearstart) {
+		date = (U_LONG)((LONG)yst + tmp);
+		*ts_ui = date;
+		if (date < (rec_ui + CLOSETIME) &&
+		    date > (rec_ui - CLOSETIME)) {
+			*yearstart = yst;
+			return 1;
+		}
+	}
+
+	/*
+	 * Here we know the year start matches the current system
+	 * time.  One remaining possibility is that the time code
+	 * is in the year previous to that of the system time.  This
+	 * is only worth checking if the receive timestamp is less
+	 * than a couple of days into the new year.
+	 */
+	if ((rec_ui - yst) < TWODAYS) {
+		yst = calyearstart(yst - TWODAYS);
+		if (yst != *yearstart) {
+			date = (U_LONG)(tmp + (LONG)yst);
+			if (date < (rec_ui + CLOSETIME) &&
+			    date > (rec_ui - CLOSETIME)) {
+				*yearstart = yst;
+				*ts_ui = date;
+				return 1;
+			}
+		}
+	}
+
+	/*
+	 * One last possibility is that the time stamp is in the year
+	 * following the year the system is in.  Try this one before
+	 * giving up.
+	 */
+	yst = calyearstart(rec_ui + TWODAYS);
+	if (yst != *yearstart) {
+		date = (U_LONG)((LONG)yst + tmp);
+		if (date < (rec_ui + CLOSETIME) &&
+		    date > (rec_ui - CLOSETIME)) {
+			*yearstart = yst;
+			*ts_ui = date;
+			return 1;
+		}
+	}
+
+	/*
+	 * Give it up.
+	 */
+	return 0;
+}
diff --git a/usr.sbin/xntpd/lib/clocktypes.c b/usr.sbin/xntpd/lib/clocktypes.c
new file mode 100644
index 0000000..f6fc003
--- /dev/null
+++ b/usr.sbin/xntpd/lib/clocktypes.c
@@ -0,0 +1,45 @@
+/* clocktypes.c,v 3.1 1993/07/06 01:08:09 jbj Exp
+ * Data for pretty printing clock types
+ */
+#include <stdio.h>
+
+#include "ntp_fp.h"
+#include "ntp.h"
+#include "lib_strbuf.h"
+#include "ntp_refclock.h"
+
+struct clktype clktypes[] = {
+	{ REFCLK_NONE,		"unspecified type (0)",            "UNKNOWN" },
+	{ REFCLK_LOCALCLOCK,	"local clock synchronization (1)", "LOCAL" },
+	{ REFCLK_WWV_HEATH,	"Heathkit WWV clock (2)",          "WWV_HEATH" },
+	{ REFCLK_WWV_PST,	"Precision Standard Time WWV clock (3)", "WWV_PST" },
+	{ REFCLK_WWVB_SPECTRACOM, "Spectracom WWVB clock (4)",     "WWVB_SPEC" },
+	{ REFCLK_GOES_TRUETIME,	"True Time GPS/GOES clock (5)",    "GPS_GOES_TRUE" },
+	{ REFCLK_IRIG_AUDIO,	"IRIG audio decoder (6)",          "IRIG_AUDIO" },
+	{ REFCLK_CHU,		"Direct synced to CHU (7)",        "CHU" },
+	{ REFCLK_PARSE,		"Generic reference clock driver (8)", "GENERIC" },
+	{ REFCLK_GPS_MX4200,	"Magnavox MX4200 GPS clock (9)",   "GPS_MX4200" },
+	{ REFCLK_GPS_AS2201,	"Austron 2201A GPS clock (10)",    "GPS_AS2201" },
+	{ REFCLK_OMEGA_TRUETIME, "TrueTime OMEGA clock (11)",      "OMEGA_TRUE" },
+	{ REFCLK_IRIG_TPRO,	"Odetics/KSI TPRO IRIG decoder (12)", "IRIG_TPRO" },
+	{ REFCLK_ATOM_LEITCH,	"Leitch CSD 5300 controller (13)", "ATOM_LEITCH" },
+	{ REFCLK_MSF_EES,	"MSF EES M201, UK (14)",           "MSF_EES" },
+	{ -1,			"", "" }
+};
+
+const char *
+clockname(num)
+  int num;
+{
+  register struct clktype *clk;
+  
+  for (clk = clktypes; clk->code != -1; clk++)
+    {
+      if (num == clk->code)
+	{
+	  return clk->abbrev;
+	}
+    }
+
+  return NULL;
+}
diff --git a/usr.sbin/xntpd/lib/decodenetnum.c b/usr.sbin/xntpd/lib/decodenetnum.c
new file mode 100644
index 0000000..32320a2
--- /dev/null
+++ b/usr.sbin/xntpd/lib/decodenetnum.c
@@ -0,0 +1,58 @@
+/* decodenetnum.c,v 3.1 1993/07/06 01:08:11 jbj Exp
+ * decodenetnum - return a net number (this is crude, but careful)
+ */
+#include <sys/types.h>
+#include <ctype.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+
+#include "ntp_stdlib.h"
+
+int
+decodenetnum(num, netnum)
+	const char *num;
+	U_LONG *netnum;
+{
+	register const char *cp;
+	register char *bp;
+	register int i;
+	register int temp;
+	register int eos;
+	char buf[80];		/* will core dump on really stupid stuff */
+
+	cp = num;
+	*netnum = 0;
+
+	if (*cp == '[') {
+		eos = ']';
+		cp++;
+	} else {
+		eos = '\0';
+	}
+
+	for (i = 0; i < 4; i++) {
+		bp = buf;
+		while (isdigit(*cp))
+			*bp++ = *cp++;
+		if (bp == buf)
+			break;
+
+		if (i < 3) {
+			if (*cp++ != '.')
+				break;
+		} else if (*cp != eos)
+			break;
+
+		*bp = '\0';
+		temp = atoi(buf);
+		if (temp > 255)
+			break;
+		*netnum <<= 8;
+		*netnum += temp;
+	}
+	
+	if (i < 4)
+		return 0;
+	*netnum = htonl(*netnum);
+	return 1;
+}
diff --git a/usr.sbin/xntpd/lib/dofptoa.c b/usr.sbin/xntpd/lib/dofptoa.c
new file mode 100644
index 0000000..c6e317f
--- /dev/null
+++ b/usr.sbin/xntpd/lib/dofptoa.c
@@ -0,0 +1,117 @@
+/* dofptoa.c,v 3.1 1993/07/06 01:08:12 jbj Exp
+ * dofptoa - do the grunge work to convert an fp number to ascii
+ */
+#include <stdio.h>
+
+#include "ntp_fp.h"
+#include "lib_strbuf.h"
+#include "ntp_string.h"
+#include "ntp_stdlib.h"
+
+char *
+dofptoa(fpv, neg, ndec, msec)
+	u_fp fpv;
+	int neg;
+	int ndec;
+	int msec;
+{
+	register u_char *cp, *cpend;
+	register U_LONG val;
+	register short dec;
+	u_char cbuf[12];
+	u_char *cpdec;
+	char *buf;
+	char *bp;
+
+	/*
+	 * Get a string buffer before starting
+	 */
+	LIB_GETBUF(buf);
+
+	/*
+	 * Zero out the buffer
+	 */
+	bzero((char *)cbuf, sizeof cbuf);
+
+	/*
+	 * Set the pointers to point at the first
+	 * decimal place.  Get a local copy of the value.
+	 */
+	cp = cpend = &cbuf[5];
+	val = fpv;
+
+	/*
+	 * If we have to, decode the integral part
+	 */
+	if (!(val & 0xffff0000))
+		cp--;
+	else {
+		register u_short sv = (u_short)(val >> 16);
+		register u_short tmp;
+		register u_short ten = 10;
+
+		do {
+			tmp = sv;
+			sv /= ten;
+			*(--cp) = tmp - ((sv<<3) + (sv<<1));
+		} while (sv != 0);
+	}
+
+	/*
+	 * Figure out how much of the fraction to do
+	 */
+	if (msec) {
+		dec = ndec + 3;
+		if (dec < 3)
+			dec = 3;
+		cpdec = &cbuf[8];
+	} else {
+		dec = ndec;
+		cpdec = cpend;
+	}
+
+	if (dec > 6)
+		dec = 6;
+	
+	if (dec > 0) {
+		do {
+			val &= 0xffff;
+			val = (val << 3) + (val << 1);
+			*cpend++ = (u_char)(val >> 16);
+		} while (--dec > 0);
+	}
+
+	if (val & 0x8000) {
+		register u_char *tp;
+		/*
+		 * Round it. Ick.
+		 */
+		tp = cpend;
+		*(--tp) += 1;
+		while (*tp >= 10) {
+			*tp = 0;
+			*(--tp) += 1;
+		}
+	}
+
+	/*
+	 * Remove leading zeroes if necessary
+	 */
+	while (cp < (cpdec -1) && *cp == 0)
+		cp++;
+	
+	/*
+	 * Copy it into the buffer, asciizing as we go.
+	 */
+	bp = buf;
+	if (neg)
+		*bp++ = '-';
+	
+	while (cp < cpend) {
+		if (cp == cpdec)
+			*bp++ = '.';
+		*bp++ = (char)(*cp++ + '0');
+	}
+	*bp = '\0';
+	return buf;
+}
diff --git a/usr.sbin/xntpd/lib/dolfptoa.c b/usr.sbin/xntpd/lib/dolfptoa.c
new file mode 100644
index 0000000..ff34153
--- /dev/null
+++ b/usr.sbin/xntpd/lib/dolfptoa.c
@@ -0,0 +1,162 @@
+/* dolfptoa.c,v 3.1 1993/07/06 01:08:14 jbj Exp
+ * dolfptoa - do the grunge work of converting an l_fp number to decimal
+ */
+#include <stdio.h>
+
+#include "ntp_fp.h"
+#include "lib_strbuf.h"
+#include "ntp_string.h"
+#include "ntp_stdlib.h"
+
+char *
+dolfptoa(fpi, fpv, neg, ndec, msec)
+	U_LONG fpi;
+	U_LONG fpv;
+	int neg;
+	int ndec;
+	int msec;
+{
+	register u_char *cp, *cpend;
+	register U_LONG work_i;
+	register int dec;
+	u_char cbuf[24];
+	u_char *cpdec;
+	char *buf;
+	char *bp;
+
+	/*
+	 * Get a string buffer before starting
+	 */
+	LIB_GETBUF(buf);
+
+	/*
+	 * Zero the character buffer
+	 */
+	bzero((char *) cbuf, sizeof(cbuf));
+
+	/*
+	 * Work on the integral part.  This is biased by what I know
+	 * compiles fairly well for a 68000.
+	 */
+	cp = cpend = &cbuf[10];
+	work_i = fpi;
+	if (work_i & 0xffff0000) {
+		register U_LONG lten = 10;
+		register U_LONG ltmp;
+
+		do {
+			ltmp = work_i;
+			work_i /= lten;
+			ltmp -= (work_i<<3) + (work_i<<1);
+			*--cp = (u_char)ltmp;
+		} while (work_i & 0xffff0000);
+	}
+	if (work_i != 0) {
+		register u_short sten = 10;
+		register u_short stmp;
+		register u_short swork = (u_short)work_i;
+
+		do {
+			stmp = swork;
+			swork /= sten;
+			stmp -= (swork<<3) + (swork<<1);
+			*--cp = (u_char)stmp;
+		} while (swork != 0);
+	}
+
+	/*
+	 * Done that, now deal with the problem of the fraction.  First
+	 * determine the number of decimal places.
+	 */
+	if (msec) {
+		dec = ndec + 3;
+		if (dec < 3)
+			dec = 3;
+		cpdec = &cbuf[13];
+	} else {
+		dec = ndec;
+		if (dec < 0)
+			dec = 0;
+		cpdec = &cbuf[10];
+	}
+	if (dec > 12)
+		dec = 12;
+	
+	/*
+	 * If there's a fraction to deal with, do so.
+	 */
+	if (fpv != 0) {
+		register U_LONG work_f;
+
+		work_f = fpv;
+		while (dec > 0) {
+			register U_LONG tmp_i;
+			register U_LONG tmp_f;
+
+			dec--;
+			/*
+			 * The scheme here is to multiply the
+			 * fraction (0.1234...) by ten.  This moves
+			 * a junk of BCD into the units part.
+			 * record that and iterate.
+			 */
+			work_i = 0;
+			M_LSHIFT(work_i, work_f);
+			tmp_i = work_i;
+			tmp_f = work_f;
+			M_LSHIFT(work_i, work_f);
+			M_LSHIFT(work_i, work_f);
+			M_ADD(work_i, work_f, tmp_i, tmp_f);
+			*cpend++ = (u_char)work_i;
+			if (work_f == 0)
+				break;
+		}
+
+		/*
+		 * Rounding is rotten
+		 */
+		if (work_f & 0x80000000) {
+			register u_char *tp = cpend;
+
+			*(--tp) += 1;
+			while (*tp >= 10) {
+				*tp = 0;
+				*(--tp) += 1;
+			};
+			if (tp < cp)
+				cp = tp;
+		}
+	}
+	cpend += dec;
+
+
+	/*
+	 * We've now got the fraction in cbuf[], with cp pointing at
+	 * the first character, cpend pointing past the last, and
+	 * cpdec pointing at the first character past the decimal.
+	 * Remove leading zeros, then format the number into the
+	 * buffer.
+	 */
+	while (cp < cpdec) {
+		if (*cp != 0)
+			break;
+		cp++;
+	}
+	if (cp == cpdec)
+		--cp;
+
+	bp = buf;
+	if (neg)
+		*bp++ = '-';
+	while (cp < cpend) {
+		if (cp == cpdec)
+			*bp++ = '.';
+		*bp++ = (char)(*cp++ + '0');	/* ascii dependent? */
+	}
+	*bp = '\0';
+
+	/*
+	 * Done!
+	 */
+	return buf;
+}
diff --git a/usr.sbin/xntpd/lib/emalloc.c b/usr.sbin/xntpd/lib/emalloc.c
new file mode 100644
index 0000000..d2a8e78
--- /dev/null
+++ b/usr.sbin/xntpd/lib/emalloc.c
@@ -0,0 +1,20 @@
+/* emalloc.c,v 3.1 1993/07/06 01:08:15 jbj Exp
+ * emalloc - return new memory obtained from the system.  Belch if none.
+ */
+#include "ntp_types.h"
+#include "ntp_malloc.h"
+#include "ntp_stdlib.h"
+#include "ntp_syslog.h"
+
+char *
+emalloc(size)
+	unsigned int size;
+{
+	char *mem;
+
+	if ((mem = (char *)malloc(size)) == 0) {
+		syslog(LOG_ERR, "No more memory!");
+		exit(1);
+	}
+	return mem;
+}
diff --git a/usr.sbin/xntpd/lib/findconfig.c b/usr.sbin/xntpd/lib/findconfig.c
new file mode 100755
index 0000000..8312668
--- /dev/null
+++ b/usr.sbin/xntpd/lib/findconfig.c
@@ -0,0 +1,62 @@
+#ifdef SYS_HPUX
+#include <string.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/utsname.h>
+
+char *
+FindConfig(base)
+    char *base;
+{
+    static char result[BUFSIZ];
+    char hostname[BUFSIZ], *cp;
+    struct stat sbuf; 
+    struct utsname unamebuf; 
+
+    /* All keyed by initial target being a directory */
+    (void) strcpy(result, base);
+    if (stat(result, &sbuf) == 0) {
+	if (S_ISDIR(sbuf.st_mode)) {
+
+	    /* First choice is my hostname */
+	    if (gethostname(hostname, BUFSIZ) >= 0) {
+		(void) sprintf(result, "%s/%s", base, hostname);
+		if (stat(result, &sbuf) == 0) {
+		    goto outahere;
+		} else {
+
+		    /* Second choice is of form default.835 */
+		    (void) uname(&unamebuf);
+		    if (strncmp(unamebuf.machine, "9000/", 5) == 0)
+			cp = unamebuf.machine + 5;
+		    else
+			cp = unamebuf.machine;
+		    (void) sprintf(result, "%s/default.%s", base, cp);
+		    if (stat(result, &sbuf) == 0) {
+			goto outahere;
+		    } else {
+
+			/* Last choice is just default */
+			(void) sprintf(result, "%s/default", base);
+			if (stat(result, &sbuf) == 0) {
+			    goto outahere;
+			} else {
+			    (void) strcpy(result, "/not/found");
+			}
+		    }
+		}
+	    } 
+	} 
+    }
+outahere:
+    return(result);
+}
+#else
+char *
+FindConfig(base)
+    char *base;
+{
+    return base;
+}
+#endif
diff --git a/usr.sbin/xntpd/lib/fptoa.c b/usr.sbin/xntpd/lib/fptoa.c
new file mode 100644
index 0000000..d245e9f
--- /dev/null
+++ b/usr.sbin/xntpd/lib/fptoa.c
@@ -0,0 +1,24 @@
+/* fptoa.c,v 3.1 1993/07/06 01:08:16 jbj Exp
+ * fptoa - return an asciized representation of an s_fp number
+ */
+#include "ntp_fp.h"
+#include "ntp_stdlib.h"
+
+char *
+fptoa(fpv, ndec)
+	s_fp fpv;
+	int ndec;
+{
+	u_fp plusfp;
+	int neg;
+
+	if (fpv < 0) {
+		plusfp = (u_fp)(-fpv);
+		neg = 1;
+	} else {
+		plusfp = (u_fp)fpv;
+		neg = 0;
+	}
+
+	return dofptoa(plusfp, neg, ndec, 0);
+}
diff --git a/usr.sbin/xntpd/lib/fptoms.c b/usr.sbin/xntpd/lib/fptoms.c
new file mode 100644
index 0000000..fb850c5
--- /dev/null
+++ b/usr.sbin/xntpd/lib/fptoms.c
@@ -0,0 +1,23 @@
+/* fptoms.c,v 3.1 1993/07/06 01:08:17 jbj Exp
+ * fptoms - return an asciized s_fp number in milliseconds
+ */
+#include "ntp_fp.h"
+
+char *
+fptoms(fpv, ndec)
+	s_fp fpv;
+	int ndec;
+{
+	u_fp plusfp;
+	int neg;
+
+	if (fpv < 0) {
+		plusfp = (u_fp)(-fpv);
+		neg = 1;
+	} else {
+		plusfp = (u_fp)fpv;
+		neg = 0;
+	}
+
+	return dofptoa(plusfp, neg, ndec, 1);
+}
diff --git a/usr.sbin/xntpd/lib/getopt.c b/usr.sbin/xntpd/lib/getopt.c
new file mode 100644
index 0000000..0ab3c29
--- /dev/null
+++ b/usr.sbin/xntpd/lib/getopt.c
@@ -0,0 +1,106 @@
+/* getopt.c,v 3.1 1993/07/06 01:08:18 jbj Exp
+ * getopt - get option letter from argv
+ *
+ * This is a version of the public domain getopt() implementation by
+ * Henry Spencer, changed for 4.3BSD compatibility (in addition to System V).
+ * It allows rescanning of an option list by setting optind to 0 before
+ * calling.  Thanks to Dennis Ferguson for the appropriate modifications.
+ *
+ * This file is in the Public Domain.
+ */
+
+/*LINTLIBRARY*/
+
+#include <stdio.h>
+
+#include "ntp_stdlib.h"
+
+#ifdef	lint
+#undef	putc
+#define	putc	fputc
+#endif	/* lint */
+
+char	*optarg;	/* Global argument pointer. */
+#ifndef	__convex__
+int	optind = 0;	/* Global argv index. */
+#else	/* __convex__ */
+extern	int	optind;	/* Global argv index. */
+#endif	/* __convex__ */
+
+/*
+ * N.B. use following at own risk
+ */
+#ifndef	__convex__
+int	opterr = 1;	/* for compatibility, should error be printed? */
+#else	/* __convex__ */
+extern	int	opterr;	/* for compatibility, should error be printed? */
+#endif	/* __convex__ */
+int	optopt;		/* for compatibility, option character checked */
+
+static char	*scan = NULL;	/* Private scan pointer. */
+
+/*
+ * Print message about a bad option.  Watch this definition, it's
+ * not a single statement.
+ */
+#define	BADOPT(mess, ch)	if (opterr) { \
+					fputs(argv[0], stderr); \
+					fputs(mess, stderr); \
+					(void) putc(ch, stderr); \
+					(void) putc('\n', stderr); \
+				} \
+				return('?')
+
+int
+getopt_l(argc, argv, optstring)
+	int argc;
+	char *argv[];
+	char *optstring;
+{
+	register char c;
+	register char *place;
+
+	optarg = NULL;
+
+	if (optind == 0) {
+		scan = NULL;
+		optind++;
+	}
+	
+	if (scan == NULL || *scan == '\0') {
+		if (optind >= argc || argv[optind][0] != '-' || argv[optind][1] == '\0')
+			return EOF;
+		if (argv[optind][1] == '-' && argv[optind][2] == '\0') {
+			optind++;
+			return EOF;
+		}
+	
+		scan = argv[optind]+1;
+		optind++;
+	}
+
+	c = *scan++;
+	optopt = c & 0377;
+	for (place = optstring; place != NULL && *place != '\0'; ++place)
+		if (*place == c)
+			break;
+
+	if (place == NULL || *place == '\0' || c == ':' || c == '?') {
+		BADOPT(": unknown option -", c);
+	}
+
+	place++;
+	if (*place == ':') {
+		if (*scan != '\0') {
+			optarg = scan;
+			scan = NULL;
+		} else if (optind >= argc) {
+			BADOPT(": option requires argument -", c);
+		} else {
+			optarg = argv[optind];
+			optind++;
+		}
+	}
+
+	return c&0377;
+}
diff --git a/usr.sbin/xntpd/lib/gettstamp.c b/usr.sbin/xntpd/lib/gettstamp.c
new file mode 100644
index 0000000..19bcb0c
--- /dev/null
+++ b/usr.sbin/xntpd/lib/gettstamp.c
@@ -0,0 +1,29 @@
+/* gettstamp.c,v 3.1 1993/07/06 01:08:20 jbj Exp
+ * gettstamp - return the system time in timestamp format
+ */
+#include <stdio.h>
+#include <sys/time.h>
+
+#include "ntp_fp.h"
+#include "ntp_unixtime.h"
+#include "ntp_stdlib.h"
+
+void
+gettstamp(ts)
+	l_fp *ts;
+{
+	struct timeval tv;
+
+	/*
+	 * Quickly get the time of day and convert it
+	 */
+	(void) GETTIMEOFDAY(&tv, (struct timezone *)NULL);
+	if (tv.tv_usec >= 1000000) {	/* bum solaris */
+		tv.tv_usec -= 1000000;
+		tv.tv_sec++;
+	}
+	TVTOTS(&tv, ts);
+	ts->l_uf += TS_ROUNDBIT;	/* guaranteed not to overflow */
+	ts->l_ui += JAN_1970;
+	ts->l_uf &= TS_MASK;
+}
diff --git a/usr.sbin/xntpd/lib/hextoint.c b/usr.sbin/xntpd/lib/hextoint.c
new file mode 100644
index 0000000..90329c4
--- /dev/null
+++ b/usr.sbin/xntpd/lib/hextoint.c
@@ -0,0 +1,38 @@
+/* hextoint.c,v 3.1 1993/07/06 01:08:21 jbj Exp
+ * hextoint - convert an ascii string in hex to an unsigned
+ *	      long, with error checking
+ */
+#include <ctype.h>
+
+#include "ntp_stdlib.h"
+
+int
+hextoint(str, ival)
+	const char *str;
+	U_LONG *ival;
+{
+	register U_LONG u;
+	register const char *cp;
+
+	cp = str;
+
+	if (*cp == '\0')
+		return 0;
+
+	u = 0;
+	while (*cp != '\0') {
+		if (!isxdigit(*cp))
+			return 0;
+		if (u >= 0x10000000)
+			return 0;	/* overflow */
+		u <<= 4;
+		if (*cp <= '9')		/* very ascii dependent */
+			u += *cp++ - '0';
+		else if (*cp >= 'a')
+			u += *cp++ - 'a' + 10;
+		else
+			u += *cp++ - 'A' + 10;
+	}
+	*ival = u;
+	return 1;
+}
diff --git a/usr.sbin/xntpd/lib/hextolfp.c b/usr.sbin/xntpd/lib/hextolfp.c
new file mode 100644
index 0000000..6473c7c
--- /dev/null
+++ b/usr.sbin/xntpd/lib/hextolfp.c
@@ -0,0 +1,66 @@
+/* hextolfp.c,v 3.1 1993/07/06 01:08:22 jbj Exp
+ * hextolfp - convert an ascii hex string to an l_fp number
+ */
+#include <stdio.h>
+#include <ctype.h>
+
+#include "ntp_fp.h"
+#include "ntp_string.h"
+#include "ntp_stdlib.h"
+
+int
+hextolfp(str, lfp)
+	const char *str;
+	l_fp *lfp;
+{
+	register const char *cp;
+	register const char *cpstart;
+	register U_LONG dec_i;
+	register U_LONG dec_f;
+	char *ind = NULL;
+	static char *digits = "0123456789abcdefABCDEF";
+
+	dec_i = dec_f = 0;
+	cp = str;
+
+	/*
+	 * We understand numbers of the form:
+	 *
+	 * [spaces]8_hex_digits[.]8_hex_digits[spaces|\n|\0]
+	 */
+	while (isspace(*cp))
+		cp++;
+	
+	cpstart = cp;
+	while (*cp != '\0' && (cp - cpstart) < 8 &&
+	    (ind = strchr(digits, *cp)) != NULL) {
+		dec_i = dec_i << 4;	/* multiply by 16 */
+		dec_i += ((ind - digits) > 15) ? (ind - digits) - 6
+		    : (ind - digits);
+		cp++;
+	}
+
+	if ((cp - cpstart) < 8 || ind == NULL)
+		return 0;
+	if (*cp == '.')
+		cp++;
+
+	cpstart = cp;
+	while (*cp != '\0' && (cp - cpstart) < 8 &&
+	    (ind = strchr(digits, *cp)) != NULL) {
+		dec_f = dec_f << 4;	/* multiply by 16 */
+		dec_f += ((ind - digits) > 15) ? (ind - digits) - 6
+		    : (ind - digits);
+		cp++;
+	}
+
+	if ((cp - cpstart) < 8 || ind == NULL)
+		return 0;
+	
+	if (*cp != '\0' && !isspace(*cp))
+		return 0;
+
+	lfp->l_ui = dec_i;
+	lfp->l_uf = dec_f;
+	return 1;
+}
diff --git a/usr.sbin/xntpd/lib/humandate.c b/usr.sbin/xntpd/lib/humandate.c
new file mode 100644
index 0000000..464ed6b
--- /dev/null
+++ b/usr.sbin/xntpd/lib/humandate.c
@@ -0,0 +1,61 @@
+/* humandate.c,v 3.1 1993/07/06 01:08:24 jbj Exp
+ * humandate - convert an NTP (or the current) time to something readable
+ */
+#include <stdio.h>
+
+#include "ntp_fp.h"
+#include "ntp_unixtime.h"
+#include "lib_strbuf.h"
+#include "ntp_stdlib.h"
+
+#ifdef NTP_POSIX_SOURCE
+#include <time.h>
+#endif
+
+static char *months[] = {
+        "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+        "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
+};
+static char *days[] = {
+        "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
+};
+
+char *
+humandate(ntptime)
+	U_LONG ntptime;
+{
+	char *bp;
+	struct tm *tm;
+	U_LONG sec;
+
+	LIB_GETBUF(bp);
+	
+	sec = ntptime - JAN_1970;
+	tm = localtime((LONG *)&sec);
+
+	(void) sprintf(bp, "%s, %s %2d %4d %2d:%02d:%02d",
+	    days[tm->tm_wday], months[tm->tm_mon], tm->tm_mday,
+	    1900+tm->tm_year, tm->tm_hour, tm->tm_min, tm->tm_sec);
+	
+	return bp;
+}
+
+
+/* This is used in msyslog.c; we don't want to clutter up the log with
+   the year and day of the week, etc.; just the minimal date and time.  */
+
+char *
+humanlogtime()
+{
+	char *bp;
+	time_t cursec = time((time_t *) 0);
+	struct tm *tm = localtime(&cursec);
+	
+	LIB_GETBUF(bp);
+	
+	(void) sprintf(bp, "%2d %s %02d:%02d:%02d",
+		tm->tm_mday, months[tm->tm_mon],
+		tm->tm_hour, tm->tm_min, tm->tm_sec);
+		
+	return bp;
+}
diff --git a/usr.sbin/xntpd/lib/inttoa.c b/usr.sbin/xntpd/lib/inttoa.c
new file mode 100644
index 0000000..25ce26c
--- /dev/null
+++ b/usr.sbin/xntpd/lib/inttoa.c
@@ -0,0 +1,19 @@
+/* inttoa.c,v 3.1 1993/07/06 01:08:25 jbj Exp
+ * inttoa - return an asciized signed integer
+ */
+#include <stdio.h>
+
+#include "lib_strbuf.h"
+#include "ntp_stdlib.h"
+
+char *
+inttoa(ival)
+	LONG ival;
+{
+	register char *buf;
+
+	LIB_GETBUF(buf);
+
+	(void) sprintf(buf, "%ld", ival);
+	return buf;
+}
diff --git a/usr.sbin/xntpd/lib/lib_strbuf.c b/usr.sbin/xntpd/lib/lib_strbuf.c
new file mode 100644
index 0000000..15661ab
--- /dev/null
+++ b/usr.sbin/xntpd/lib/lib_strbuf.c
@@ -0,0 +1,21 @@
+/* lib_strbuf.c,v 3.1 1993/07/06 01:08:27 jbj Exp
+ * lib_strbuf - library string storage
+ */
+
+#include "lib_strbuf.h"
+
+/*
+ * Storage declarations
+ */
+char lib_stringbuf[LIB_NUMBUFS][LIB_BUFLENGTH];
+int lib_nextbuf;
+
+
+/*
+ * initialization routine.  Might be needed if the code is ROMized.
+ */
+void
+init_lib()
+{
+	lib_nextbuf = 0;
+}
diff --git a/usr.sbin/xntpd/lib/lib_strbuf.h b/usr.sbin/xntpd/lib/lib_strbuf.h
new file mode 100644
index 0000000..20720fd
--- /dev/null
+++ b/usr.sbin/xntpd/lib/lib_strbuf.h
@@ -0,0 +1,22 @@
+/* lib_strbuf.h,v 3.1 1993/07/06 01:08:28 jbj Exp
+ * lib_strbuf.h - definitions for routines which use the common string buffers
+ */
+
+/*
+ * Sizes of things
+ */
+#define	LIB_NUMBUFS	20
+#define	LIB_BUFLENGTH	80
+
+/*
+ * Macro to get a pointer to the next buffer
+ */
+#define	LIB_GETBUF(buf) \
+	do { \
+		buf = &lib_stringbuf[lib_nextbuf][0]; \
+		if (++lib_nextbuf >= LIB_NUMBUFS) \
+			lib_nextbuf = 0; \
+	} while (0)
+
+extern char lib_stringbuf[LIB_NUMBUFS][LIB_BUFLENGTH];
+extern int lib_nextbuf;
diff --git a/usr.sbin/xntpd/lib/machines.c b/usr.sbin/xntpd/lib/machines.c
new file mode 100644
index 0000000..f7a400c
--- /dev/null
+++ b/usr.sbin/xntpd/lib/machines.c
@@ -0,0 +1,118 @@
+/*
+ * provide special support for peculiar architectures
+ *
+ * Real bummers unite !
+ */
+
+#ifdef SYS_PTX
+#include <sys/types.h>
+#include <sys/procstats.h>
+int settimeofday(tvp)
+	struct timeval *tvp;
+{
+	return stime(&tvp->tv_sec);	/* lie as bad as SysVR4 */
+}
+
+int gettimeofday(tvp)
+	struct timeval *tvp;
+{
+	/*
+	 * hi, this is Sequents sneak path to get to a clock
+	 * this is also the most logical syscall for such a function
+	 */
+	return get_process_stats(tvp, PS_SELF, (struct procstats *) 0,
+				 (struct procstats *) 0);
+}
+#endif
+
+#ifdef SYS_HPUX
+/* hpux.c,v 3.1 1993/07/06 01:08:23 jbj Exp
+ * hpux.c -- compatibility routines for HP-UX.
+ * XXX many of these are not needed anymore.
+ */
+#include "ntp_machine.h"
+
+#ifdef	HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#include <stdio.h>
+
+#include "ntp_stdlib.h"
+
+#if (SYS_HPUX < 8)
+char 
+*index(s, c)
+register char *s;
+register int c;
+{
+    return strchr (s, c);
+}
+
+
+char 
+*rindex(s, c)
+register char *s;
+register int c;
+{
+    return strrchr (s, c);
+}
+
+
+int 
+bcmp(a, b, count)
+register char *a, *b;
+register int count;
+{
+    return memcmp (a, b, count);
+}
+
+
+void 
+bcopy(from, to, count)
+register char *from;
+register char *to;
+register int count;
+{
+   if ((to == from) || (count <= 0))
+       return;
+
+   if ((to > from) && (to <= (from + count))) {
+       to += count;
+       from += count;
+
+       do {
+	   *--to = *--from;
+       }   while (--count);
+   }
+   else {
+       do {
+	   *to++ = *from++;
+       }   while (--count);
+   }
+}
+
+
+void 
+bzero(area, count)
+register char *area;
+register int count;
+{
+    memset(area, 0, count);
+}
+#endif
+
+
+getdtablesize()
+{
+    return(sysconf(_SC_OPEN_MAX));
+}
+
+
+int 
+setlinebuf(a_stream)
+    FILE *a_stream;
+{
+    return setvbuf(a_stream, (char *) NULL, _IOLBF, 0);
+}
+
+#endif
diff --git a/usr.sbin/xntpd/lib/md5.c b/usr.sbin/xntpd/lib/md5.c
new file mode 100644
index 0000000..77644cb
--- /dev/null
+++ b/usr.sbin/xntpd/lib/md5.c
@@ -0,0 +1,322 @@
+/* md5.c,v 3.1 1993/07/06 01:08:29 jbj Exp
+ ***********************************************************************
+ ** md5.c -- the source code for MD5 routines                         **
+ ** RSA Data Security, Inc. MD5 Message-Digest Algorithm              **
+ ** Created: 2/17/90 RLR                                              **
+ ** Revised: 1/91 SRD,AJ,BSK,JT Reference C Version                   **
+ ** Revised (for MD5): RLR 4/27/91                                    **
+ **   -- G modified to have y&~z instead of y&z                       **
+ **   -- FF, GG, HH modified to add in last register done             **
+ **   -- Access pattern: round 2 works mod 5, round 3 works mod 3     **
+ **   -- distinct additive constant for each step                     **
+ **   -- round 4 added, working mod 7                                 **
+ ***********************************************************************
+ */
+
+/*
+ ***********************************************************************
+ ** Copyright (C) 1990, RSA Data Security, Inc. All rights reserved.  **
+ **                                                                   **
+ ** License to copy and use this software is granted provided that    **
+ ** it is identified as the "RSA Data Security, Inc. MD5 Message-     **
+ ** Digest Algorithm" in all material mentioning or referencing this  **
+ ** software or this function.                                        **
+ **                                                                   **
+ ** License is also granted to make and use derivative works          **
+ ** provided that such works are identified as "derived from the RSA  **
+ ** Data Security, Inc. MD5 Message-Digest Algorithm" in all          **
+ ** material mentioning or referencing the derived work.              **
+ **                                                                   **
+ ** RSA Data Security, Inc. makes no representations concerning       **
+ ** either the merchantability of this software or the suitability    **
+ ** of this software for any particular purpose.  It is provided "as  **
+ ** is" without express or implied warranty of any kind.              **
+ **                                                                   **
+ ** These notices must be retained in any copies of any part of this  **
+ ** documentation and/or software.                                    **
+ ***********************************************************************
+ */
+
+#include "md5.h"
+
+/*
+ ***********************************************************************
+ **  Message-digest routines:                                         **
+ **  To form the message digest for a message M                       **
+ **    (1) Initialize a context buffer mdContext using MD5Init        **
+ **    (2) Call MD5Update on mdContext and M                          **
+ **    (3) Call MD5Final on mdContext                                 **
+ **  The message digest is now in mdContext->digest[0...15]           **
+ ***********************************************************************
+ */
+
+/* forward declaration */
+static void Transform ();
+
+#ifdef	__STDC__
+static const
+#else
+static
+#endif
+unsigned char PADDING[64] = {
+  0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+/* F, G, H and I are basic MD5 functions */
+#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
+#define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
+#define H(x, y, z) ((x) ^ (y) ^ (z))
+#define I(x, y, z) ((y) ^ ((x) | (~z)))
+
+/* ROTATE_LEFT rotates x left n bits */
+#if	defined(FAST_MD5) && defined(__GNUC__) && defined(mc68000)
+/*
+ * If we're on a 68000 based CPU and using a GNU C compiler with
+ * inline assembly code, we can speed this up a bit.
+ */
+inline UINT4 ROTATE_LEFT(UINT4 x, int n)
+{   
+    asm("roll %2,%0" : "=d" (x) : "0" (x), "Ir" (n));
+    return x;
+}
+#else
+#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
+#endif
+
+
+/* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4 */
+/* Rotation is separate from addition to prevent recomputation */
+#define FF(a, b, c, d, x, s, ac) \
+  {(a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); \
+   (a) = ROTATE_LEFT ((a), (s)); \
+   (a) += (b); \
+  }
+#define GG(a, b, c, d, x, s, ac) \
+  {(a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \
+   (a) = ROTATE_LEFT ((a), (s)); \
+   (a) += (b); \
+  }
+#define HH(a, b, c, d, x, s, ac) \
+  {(a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \
+   (a) = ROTATE_LEFT ((a), (s)); \
+   (a) += (b); \
+  }
+#define II(a, b, c, d, x, s, ac) \
+  {(a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \
+   (a) = ROTATE_LEFT ((a), (s)); \
+   (a) += (b); \
+  }
+
+/* The routine MD5Init initializes the message-digest context
+   mdContext. All fields are set to zero.
+ */
+void MD5Init (mdContext)
+MD5_CTX *mdContext;
+{
+  mdContext->i[0] = mdContext->i[1] = (UINT4)0;
+
+  /* Load magic initialization constants.
+   */
+  mdContext->buf[0] = (UINT4)0x67452301;
+  mdContext->buf[1] = (UINT4)0xefcdab89;
+  mdContext->buf[2] = (UINT4)0x98badcfe;
+  mdContext->buf[3] = (UINT4)0x10325476;
+}
+
+/* The routine MD5Update updates the message-digest context to
+   account for the presence of each of the characters inBuf[0..inLen-1]
+   in the message whose digest is being computed.
+ */
+void MD5Update (mdContext, inBuf, inLen)
+MD5_CTX *mdContext;
+unsigned char *inBuf;
+unsigned int inLen;
+{
+  UINT4 in[16];
+  int mdi;
+  unsigned int i, ii;
+
+  /* compute number of bytes mod 64 */
+  mdi = (int)((mdContext->i[0] >> 3) & 0x3F);
+
+  /* update number of bits */
+  if ((mdContext->i[0] + ((UINT4)inLen << 3)) < mdContext->i[0])
+    mdContext->i[1]++;
+  mdContext->i[0] += ((UINT4)inLen << 3);
+  mdContext->i[1] += ((UINT4)inLen >> 29);
+
+  while (inLen--) {
+    /* add new character to buffer, increment mdi */
+    mdContext->in[mdi++] = *inBuf++;
+
+    /* transform if necessary */
+    if (mdi == 0x40) {
+      for (i = 0, ii = 0; i < 16; i++, ii += 4)
+        in[i] = (((UINT4)mdContext->in[ii+3]) << 24) |
+                (((UINT4)mdContext->in[ii+2]) << 16) |
+                (((UINT4)mdContext->in[ii+1]) << 8) |
+                ((UINT4)mdContext->in[ii]);
+      Transform (mdContext->buf, in);
+      mdi = 0;
+    }
+  }
+}
+
+/* The routine MD5Final terminates the message-digest computation and
+   ends with the desired message digest in mdContext->digest[0...15].
+ */
+
+void MD5Final (mdContext)
+MD5_CTX *mdContext;
+{
+  UINT4 in[16];
+  int mdi;
+  unsigned int i, ii;
+  unsigned int padLen;
+
+  /* save number of bits */
+  in[14] = mdContext->i[0];
+  in[15] = mdContext->i[1];
+
+  /* compute number of bytes mod 64 */
+  mdi = (int)((mdContext->i[0] >> 3) & 0x3F);
+
+  /* pad out to 56 mod 64 */
+  padLen = (mdi < 56) ? (56 - mdi) : (120 - mdi);
+  MD5Update (mdContext, PADDING, padLen);
+
+  /* append length in bits and transform */
+  for (i = 0, ii = 0; i < 14; i++, ii += 4)
+    in[i] = (((UINT4)mdContext->in[ii+3]) << 24) |
+            (((UINT4)mdContext->in[ii+2]) << 16) |
+            (((UINT4)mdContext->in[ii+1]) << 8) |
+            ((UINT4)mdContext->in[ii]);
+  Transform (mdContext->buf, in);
+
+  /* store buffer in digest */
+  for (i = 0, ii = 0; i < 4; i++, ii += 4) {
+    mdContext->digest[ii] = (unsigned char)(mdContext->buf[i] & 0xFF);
+    mdContext->digest[ii+1] =
+      (unsigned char)((mdContext->buf[i] >> 8) & 0xFF);
+    mdContext->digest[ii+2] =
+      (unsigned char)((mdContext->buf[i] >> 16) & 0xFF);
+    mdContext->digest[ii+3] =
+      (unsigned char)((mdContext->buf[i] >> 24) & 0xFF);
+  }
+}
+
+/* Basic MD5 step. Transforms buf based on in.
+ */
+static void Transform (buf, in)
+UINT4 *buf;
+UINT4 *in;
+{
+  UINT4 a = buf[0], b = buf[1], c = buf[2], d = buf[3];
+
+  /* Round 1 */
+#define S11 7
+#define S12 12
+#define S13 17
+#define S14 22
+
+  FF ( a, b, c, d, in[ 0], S11, 0xd76aa478); /* 1 */
+  FF ( d, a, b, c, in[ 1], S12, 0xe8c7b756); /* 2 */
+  FF ( c, d, a, b, in[ 2], S13, 0x242070db); /* 3 */
+  FF ( b, c, d, a, in[ 3], S14, 0xc1bdceee); /* 4 */
+  FF ( a, b, c, d, in[ 4], S11, 0xf57c0faf); /* 5 */
+  FF ( d, a, b, c, in[ 5], S12, 0x4787c62a); /* 6 */
+  FF ( c, d, a, b, in[ 6], S13, 0xa8304613); /* 7 */
+  FF ( b, c, d, a, in[ 7], S14, 0xfd469501); /* 8 */
+  FF ( a, b, c, d, in[ 8], S11, 0x698098d8); /* 9 */
+  FF ( d, a, b, c, in[ 9], S12, 0x8b44f7af); /* 10 */
+  FF ( c, d, a, b, in[10], S13, 0xffff5bb1); /* 11 */
+  FF ( b, c, d, a, in[11], S14, 0x895cd7be); /* 12 */
+  FF ( a, b, c, d, in[12], S11, 0x6b901122); /* 13 */
+  FF ( d, a, b, c, in[13], S12, 0xfd987193); /* 14 */
+  FF ( c, d, a, b, in[14], S13, 0xa679438e); /* 15 */
+  FF ( b, c, d, a, in[15], S14, 0x49b40821); /* 16 */
+
+  /* Round 2 */
+#define S21 5
+#define S22 9
+#define S23 14
+#define S24 20
+  GG ( a, b, c, d, in[ 1], S21, 0xf61e2562); /* 17 */
+  GG ( d, a, b, c, in[ 6], S22, 0xc040b340); /* 18 */
+  GG ( c, d, a, b, in[11], S23, 0x265e5a51); /* 19 */
+  GG ( b, c, d, a, in[ 0], S24, 0xe9b6c7aa); /* 20 */
+  GG ( a, b, c, d, in[ 5], S21, 0xd62f105d); /* 21 */
+  GG ( d, a, b, c, in[10], S22,  0x2441453); /* 22 */
+  GG ( c, d, a, b, in[15], S23, 0xd8a1e681); /* 23 */
+  GG ( b, c, d, a, in[ 4], S24, 0xe7d3fbc8); /* 24 */
+  GG ( a, b, c, d, in[ 9], S21, 0x21e1cde6); /* 25 */
+  GG ( d, a, b, c, in[14], S22, 0xc33707d6); /* 26 */
+  GG ( c, d, a, b, in[ 3], S23, 0xf4d50d87); /* 27 */
+  GG ( b, c, d, a, in[ 8], S24, 0x455a14ed); /* 28 */
+  GG ( a, b, c, d, in[13], S21, 0xa9e3e905); /* 29 */
+  GG ( d, a, b, c, in[ 2], S22, 0xfcefa3f8); /* 30 */
+  GG ( c, d, a, b, in[ 7], S23, 0x676f02d9); /* 31 */
+  GG ( b, c, d, a, in[12], S24, 0x8d2a4c8a); /* 32 */
+
+  /* Round 3 */
+#define S31 4
+#define S32 11
+#define S33 16
+#define S34 23
+  HH ( a, b, c, d, in[ 5], S31, 0xfffa3942); /* 33 */
+  HH ( d, a, b, c, in[ 8], S32, 0x8771f681); /* 34 */
+  HH ( c, d, a, b, in[11], S33, 0x6d9d6122); /* 35 */
+  HH ( b, c, d, a, in[14], S34, 0xfde5380c); /* 36 */
+  HH ( a, b, c, d, in[ 1], S31, 0xa4beea44); /* 37 */
+  HH ( d, a, b, c, in[ 4], S32, 0x4bdecfa9); /* 38 */
+  HH ( c, d, a, b, in[ 7], S33, 0xf6bb4b60); /* 39 */
+  HH ( b, c, d, a, in[10], S34, 0xbebfbc70); /* 40 */
+  HH ( a, b, c, d, in[13], S31, 0x289b7ec6); /* 41 */
+  HH ( d, a, b, c, in[ 0], S32, 0xeaa127fa); /* 42 */
+  HH ( c, d, a, b, in[ 3], S33, 0xd4ef3085); /* 43 */
+  HH ( b, c, d, a, in[ 6], S34,  0x4881d05); /* 44 */
+  HH ( a, b, c, d, in[ 9], S31, 0xd9d4d039); /* 45 */
+  HH ( d, a, b, c, in[12], S32, 0xe6db99e5); /* 46 */
+  HH ( c, d, a, b, in[15], S33, 0x1fa27cf8); /* 47 */
+  HH ( b, c, d, a, in[ 2], S34, 0xc4ac5665); /* 48 */
+
+  /* Round 4 */
+#define S41 6
+#define S42 10
+#define S43 15
+#define S44 21
+  II ( a, b, c, d, in[ 0], S41, 0xf4292244); /* 49 */
+  II ( d, a, b, c, in[ 7], S42, 0x432aff97); /* 50 */
+  II ( c, d, a, b, in[14], S43, 0xab9423a7); /* 51 */
+  II ( b, c, d, a, in[ 5], S44, 0xfc93a039); /* 52 */
+  II ( a, b, c, d, in[12], S41, 0x655b59c3); /* 53 */
+  II ( d, a, b, c, in[ 3], S42, 0x8f0ccc92); /* 54 */
+  II ( c, d, a, b, in[10], S43, 0xffeff47d); /* 55 */
+  II ( b, c, d, a, in[ 1], S44, 0x85845dd1); /* 56 */
+  II ( a, b, c, d, in[ 8], S41, 0x6fa87e4f); /* 57 */
+  II ( d, a, b, c, in[15], S42, 0xfe2ce6e0); /* 58 */
+  II ( c, d, a, b, in[ 6], S43, 0xa3014314); /* 59 */
+  II ( b, c, d, a, in[13], S44, 0x4e0811a1); /* 60 */
+  II ( a, b, c, d, in[ 4], S41, 0xf7537e82); /* 61 */
+  II ( d, a, b, c, in[11], S42, 0xbd3af235); /* 62 */
+  II ( c, d, a, b, in[ 2], S43, 0x2ad7d2bb); /* 63 */
+  II ( b, c, d, a, in[ 9], S44, 0xeb86d391); /* 64 */
+
+  buf[0] += a;
+  buf[1] += b;
+  buf[2] += c;
+  buf[3] += d;
+}
+
+/*
+ ***********************************************************************
+ ** End of md5.c                                                      **
+ ******************************** (cut) ********************************
+ */
diff --git a/usr.sbin/xntpd/lib/mfptoa.c b/usr.sbin/xntpd/lib/mfptoa.c
new file mode 100644
index 0000000..4e513d2
--- /dev/null
+++ b/usr.sbin/xntpd/lib/mfptoa.c
@@ -0,0 +1,22 @@
+/* mfptoa.c,v 3.1 1993/07/06 01:08:30 jbj Exp
+ * mfptoa - Return an asciized representation of a signed LONG fp number
+ */
+#include "ntp_fp.h"
+#include "ntp_stdlib.h"
+
+char *
+mfptoa(fpi, fpf, ndec)
+	U_LONG fpi;
+	U_LONG fpf;
+	int ndec;
+{
+	int isneg;
+
+	if (M_ISNEG(fpi, fpf)) {
+		isneg = 1;
+		M_NEG(fpi, fpf);
+	} else
+		isneg = 0;
+
+	return dolfptoa(fpi, fpf, isneg, ndec, 0);
+}
diff --git a/usr.sbin/xntpd/lib/mfptoms.c b/usr.sbin/xntpd/lib/mfptoms.c
new file mode 100644
index 0000000..f686d41
--- /dev/null
+++ b/usr.sbin/xntpd/lib/mfptoms.c
@@ -0,0 +1,22 @@
+/* mfptoms.c,v 3.1 1993/07/06 01:08:31 jbj Exp
+ * mfptoms - Return an asciized signed LONG fp number in milliseconds
+ */
+#include "ntp_fp.h"
+#include "ntp_stdlib.h"
+
+char *
+mfptoms(fpi, fpf, ndec)
+	U_LONG fpi;
+	U_LONG fpf;
+	int ndec;
+{
+	int isneg;
+
+	if (M_ISNEG(fpi, fpf)) {
+		isneg = 1;
+		M_NEG(fpi, fpf);
+	} else
+		isneg = 0;
+
+	return dolfptoa(fpi, fpf, isneg, ndec, 1);
+}
diff --git a/usr.sbin/xntpd/lib/modetoa.c b/usr.sbin/xntpd/lib/modetoa.c
new file mode 100644
index 0000000..4833271
--- /dev/null
+++ b/usr.sbin/xntpd/lib/modetoa.c
@@ -0,0 +1,33 @@
+/* modetoa.c,v 3.1 1993/07/06 01:08:33 jbj Exp
+ * modetoa - return an asciized mode
+ */
+#include <stdio.h>
+
+#include "lib_strbuf.h"
+#include "ntp_stdlib.h"
+
+char *
+modetoa(mode)
+	int mode;
+{
+	char *bp;
+	static char *modestrings[] = {
+		"unspec",
+		"sym_active",
+		"sym_passive",
+		"client",
+		"server",
+		"broadcast",
+		"control",
+		"private",
+		"bclient",
+	};
+
+	if (mode < 0 || mode >= (sizeof modestrings)/sizeof(char *)) {
+		LIB_GETBUF(bp);
+		(void)sprintf(bp, "mode#%d", mode);
+		return bp;
+	}
+
+	return modestrings[mode];
+}
diff --git a/usr.sbin/xntpd/lib/mstolfp.c b/usr.sbin/xntpd/lib/mstolfp.c
new file mode 100644
index 0000000..8a642cf
--- /dev/null
+++ b/usr.sbin/xntpd/lib/mstolfp.c
@@ -0,0 +1,99 @@
+/* mstolfp.c,v 3.1 1993/07/06 01:08:34 jbj Exp
+ * mstolfp - convert an ascii string in milliseconds to an l_fp number
+ */
+#include <stdio.h>
+#include <ctype.h>
+
+#include "ntp_fp.h"
+#include "ntp_stdlib.h"
+
+int
+mstolfp(str, lfp)
+	const char *str;
+	l_fp *lfp;
+{
+	register const char *cp;
+	register char *bp;
+	register const char *cpdec;
+	char buf[100];
+
+	/*
+	 * We understand numbers of the form:
+	 *
+	 * [spaces][-][digits][.][digits][spaces|\n|\0]
+	 *
+	 * This is one enormous hack.  Since I didn't feel like
+	 * rewriting the decoding routine for milliseconds, what
+	 * is essentially done here is to make a copy of the string
+	 * with the decimal moved over three places so the seconds
+	 * decoding routine can be used.
+	 */
+	bp = buf;
+	cp = str;
+	while (isspace(*cp))
+		cp++;
+	
+	if (*cp == '-') {
+		*bp++ = '-';
+		cp++;
+	}
+
+	if (*cp != '.' && !isdigit(*cp))
+		return 0;
+
+
+	/*
+	 * Search forward for the decimal point or the end of the string.
+	 */
+	cpdec = cp;
+	while (isdigit(*cpdec))
+		cpdec++;
+
+	/*
+	 * Found something.  If we have more than three digits copy the
+	 * excess over, else insert a leading 0.
+	 */
+	if ((cpdec - cp) > 3) {
+		do {
+			*bp++ = (char)*cp++;
+		} while ((cpdec - cp) > 3);
+	} else {
+		*bp++ = '0';
+	}
+
+	/*
+	 * Stick the decimal in.  If we've got less than three digits in
+	 * front of the millisecond decimal we insert the appropriate number
+	 * of zeros.
+	 */
+	*bp++ = '.';
+	if ((cpdec - cp) < 3) {
+		register int i = 3 - (cpdec - cp);
+
+		do {
+			*bp++ = '0';
+		} while (--i > 0);
+	}
+
+	/*
+	 * Copy the remainder up to the millisecond decimal.  If cpdec
+	 * is pointing at a decimal point, copy in the trailing number too.
+	 */
+	while (cp < cpdec)
+		*bp++ = (char)*cp++;
+	
+	if (*cp == '.') {
+		cp++;
+		while (isdigit(*cp))
+			*bp++ = (char)*cp++;
+	}
+	*bp = '\0';
+
+	/*
+	 * Check to make sure the string is properly terminated.  If
+	 * so, give the buffer to the decoding routine.
+	 */
+	if (*cp != '\0' && !isspace(*cp))
+		return 0;
+	return atolfp(buf, lfp);
+}
diff --git a/usr.sbin/xntpd/lib/msutotsf.c b/usr.sbin/xntpd/lib/msutotsf.c
new file mode 100644
index 0000000..412cfbd
--- /dev/null
+++ b/usr.sbin/xntpd/lib/msutotsf.c
@@ -0,0 +1,35 @@
+/* msutotsf.c,v 3.1 1993/07/06 01:08:35 jbj Exp
+ * msutotsf - tables for converting from a subsecond millisecond value
+ *	      to a time stamp fraction.
+ */
+#include <sys/types.h>
+
+#include "ntp_types.h"
+
+/*
+ * Index each of these tables with five bits of the (less than) 10
+ * bit millisecond value.  Note that the tables are rounded (not
+ * truncated).  The error in the result will thus be +-1 low order
+ * bit in the time stamp fraction.
+ */
+U_LONG msutotsflo[32] = {
+	0x00000000, 0x00418937, 0x0083126f, 0x00c49ba6,
+	0x010624dd, 0x0147ae14, 0x0189374c, 0x01cac083,
+	0x020c49ba, 0x024dd2f2, 0x028f5c29, 0x02d0e560,
+	0x03126e98, 0x0353f7cf, 0x03958106, 0x03d70a3d,
+	0x04189375, 0x045a1cac, 0x049ba5e3, 0x04dd2f1b,
+	0x051eb852, 0x05604189, 0x05a1cac1, 0x05e353f8,
+	0x0624dd2f, 0x06666666, 0x06a7ef9e, 0x06e978d5,
+	0x072b020c, 0x076c8b44, 0x07ae147b, 0x07ef9db2
+};
+
+U_LONG msutotsfhi[32] = {
+	0x00000000, 0x083126e9, 0x10624dd3, 0x189374bc,
+	0x20c49ba6, 0x28f5c28f, 0x3126e979, 0x39581062,
+	0x4189374c, 0x49ba5e35, 0x51eb851f, 0x5a1cac08,
+	0x624dd2f2, 0x6a7ef9db, 0x72b020c5, 0x7ae147ae,
+	0x83126e98, 0x8b439581, 0x9374bc6a, 0x9ba5e354,
+	0xa3d70a3d, 0xac083127, 0xb4395810, 0xbc6a7efa,
+	0xc49ba5e3, 0xcccccccd, 0xd4fdf3b6, 0xdd2f1aa0,
+	0xe5604189, 0xed916873, 0xf5c28f5c, 0xfdf3b646
+};
diff --git a/usr.sbin/xntpd/lib/msyslog.c b/usr.sbin/xntpd/lib/msyslog.c
new file mode 100644
index 0000000..a8df27d
--- /dev/null
+++ b/usr.sbin/xntpd/lib/msyslog.c
@@ -0,0 +1,107 @@
+/* msyslog.c,v 3.1 1993/07/06 01:08:36 jbj Exp
+ * msyslog - either send a message to the terminal or print it on
+ *	     the standard output.
+ *
+ * Converted to use varargs, much better ... jks
+ */
+#include <stdio.h>
+#include <errno.h>
+
+/* alternative, as Solaris 2.x defines __STDC__ as 0 in a largely standard
+   conforming environment
+   #if __STDC__ || (defined(SOLARIS) && defined(__STDC__))
+*/
+#ifdef __STDC__
+#include <stdarg.h>
+#else
+#include <varargs.h>
+#endif
+
+#include "ntp_types.h"
+#include "ntp_string.h"
+#include "ntp_syslog.h"
+#include "ntp_stdlib.h"
+
+#undef syslog
+
+int syslogit = 1;
+FILE *syslog_file = NULL;
+
+extern	int errno;
+extern	char *progname;
+
+#if defined(__STDC__)
+void msyslog(int level, char *fmt, ...)
+#else
+/*VARARGS*/
+void msyslog(va_alist)
+	va_dcl
+#endif
+{
+#ifndef __STDC__
+	int level;
+	char *fmt;
+#endif
+	va_list ap;
+	char buf[1025], nfmt[256], xerr[50], *err;
+	register int c, l;
+	register char *n, *f, *prog;
+	extern int sys_nerr;
+	extern char *sys_errlist[];
+	int olderrno;
+
+#ifdef __STDC__
+	va_start(ap, fmt);
+#else
+	va_start(ap);
+
+	level = va_arg(ap, int);
+	fmt = va_arg(ap, char *);
+#endif
+
+	olderrno = errno;
+	n = nfmt;
+	f = fmt;
+	while ((c = *f++) != '\0' && c != '\n' && n < &nfmt[252]) {
+		if (c != '%') {
+			*n++ = c;
+			continue;
+		}
+		if ((c = *f++) != 'm') {
+			*n++ = '%';
+			*n++ = c;
+			continue;
+		}
+		if ((unsigned)olderrno > sys_nerr)
+			sprintf((err = xerr), "error %d", olderrno);
+		else
+			err = sys_errlist[olderrno];
+		if (n + (l = strlen(err)) < &nfmt[254]) {
+			strcpy(n, err);
+			n += strlen(err);
+		}
+	}
+	*n++ = '\n';
+	*n = '\0';
+
+	vsprintf(buf, nfmt, ap);
+	if (syslogit)
+		syslog(level, buf);
+	else {
+		extern char * humanlogtime P((void));
+
+	        FILE *out_file = syslog_file ? syslog_file
+  	                                  : level <= LOG_ERR ? stderr : stdout;
+  	        /* syslog() provides the timestamp, so if we're not using
+  	           syslog, we must provide it. */
+		prog = strrchr(progname, '/');
+		if (prog == NULL)
+		  prog = progname;
+		else
+		  prog++;
+		(void) fprintf(out_file, "%s ", humanlogtime ());
+                (void) fprintf(out_file, "%s: %s", prog, buf);
+		fflush (out_file);
+	}
+	va_end(ap);
+}
diff --git a/usr.sbin/xntpd/lib/numtoa.c b/usr.sbin/xntpd/lib/numtoa.c
new file mode 100644
index 0000000..c36885d
--- /dev/null
+++ b/usr.sbin/xntpd/lib/numtoa.c
@@ -0,0 +1,24 @@
+/* numtoa.c,v 3.1 1993/07/06 01:08:38 jbj Exp
+ * numtoa - return asciized network numbers store in local array space
+ */
+#include <stdio.h>
+
+#include "ntp_fp.h"
+#include "lib_strbuf.h"
+#include "ntp_stdlib.h"
+
+char *
+numtoa(num)
+	U_LONG num;
+{
+	register U_LONG netnum;
+	register char *buf;
+
+	netnum = ntohl(num);
+	LIB_GETBUF(buf);
+
+	(void) sprintf(buf, "%d.%d.%d.%d", (netnum>>24)&0xff,
+	    (netnum>>16)&0xff, (netnum>>8)&0xff, netnum&0xff);
+
+	return buf;
+}
diff --git a/usr.sbin/xntpd/lib/numtohost.c b/usr.sbin/xntpd/lib/numtohost.c
new file mode 100644
index 0000000..c8b532f
--- /dev/null
+++ b/usr.sbin/xntpd/lib/numtohost.c
@@ -0,0 +1,39 @@
+/* numtohost.c,v 3.1 1993/07/06 01:08:40 jbj Exp
+ * numtohost - convert network number to host name.
+ */
+#include <string.h>
+#include <netdb.h>
+
+#include "ntp_fp.h"
+#include "lib_strbuf.h"
+#include "ntp_stdlib.h"
+
+#define	LOOPBACKNET	0x7f000000
+#define	LOOPBACKHOST	0x7f000001
+#define	LOOPBACKNETMASK	0xff000000
+
+char *
+numtohost(netnum)
+	U_LONG netnum;
+{
+	char *bp;
+	struct hostent *hp;
+
+	/*
+	 * This is really gross, but saves lots of hanging looking for
+	 * hostnames for the radio clocks.  Don't bother looking up
+	 * addresses on the loopback network except for the loopback
+	 * host itself.
+	 */
+	if ((((ntohl(netnum) & LOOPBACKNETMASK) == LOOPBACKNET)
+	    && (ntohl(netnum) != LOOPBACKHOST))
+	    || ((hp = gethostbyaddr((char *)&netnum, sizeof netnum, AF_INET))
+	      == 0))
+		return numtoa(netnum);
+	
+	LIB_GETBUF(bp);
+	
+	bp[LIB_BUFLENGTH-1] = '\0';
+	(void) strncpy(bp, hp->h_name, LIB_BUFLENGTH-1);
+	return bp;
+}
diff --git a/usr.sbin/xntpd/lib/octtoint.c b/usr.sbin/xntpd/lib/octtoint.c
new file mode 100644
index 0000000..1f25b1d
--- /dev/null
+++ b/usr.sbin/xntpd/lib/octtoint.c
@@ -0,0 +1,34 @@
+/* octtoint.c,v 3.1 1993/07/06 01:08:41 jbj Exp
+ * octtoint - convert an ascii string in octal to an unsigned
+ *	      long, with error checking
+ */
+#include <stdio.h>
+#include <ctype.h>
+
+#include "ntp_stdlib.h"
+
+int
+octtoint(str, ival)
+	const char *str;
+	U_LONG *ival;
+{
+	register U_LONG u;
+	register const char *cp;
+
+	cp = str;
+
+	if (*cp == '\0')
+		return 0;
+
+	u = 0;
+	while (*cp != '\0') {
+		if (!isdigit(*cp) || *cp == '8' || *cp == '9')
+			return 0;
+		if (u >= 0x20000000)
+			return 0;	/* overflow */
+		u <<= 3;
+		u += *cp++ - '0';	/* ascii dependent */
+	}
+	*ival = u;
+	return 1;
+}
diff --git a/usr.sbin/xntpd/lib/prettydate.c b/usr.sbin/xntpd/lib/prettydate.c
new file mode 100644
index 0000000..ad679bd
--- /dev/null
+++ b/usr.sbin/xntpd/lib/prettydate.c
@@ -0,0 +1,44 @@
+/* prettydate.c,v 3.1 1993/07/06 01:08:42 jbj Exp
+ * prettydate - convert a time stamp to something readable
+ */
+#include <stdio.h>
+
+#include "ntp_fp.h"
+#include "ntp_unixtime.h"
+#include "lib_strbuf.h"
+#include "ntp_stdlib.h"
+
+#ifdef NTP_POSIX_SOURCE
+#include <time.h>
+#endif
+
+char *
+prettydate(ts)
+	l_fp *ts;
+{
+	char *bp;
+	struct tm *tm;
+	U_LONG sec;
+	U_LONG msec;
+	static char *months[] = {
+		"Jan", "Feb", "Mar", "Apr", "May", "Jun",
+		"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
+	};
+	static char *days[] = {
+		"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
+	};
+
+	LIB_GETBUF(bp);
+	
+	sec = ts->l_ui - JAN_1970;
+	msec = ts->l_uf / 4294967;	/* fract / (2**32/1000) */
+
+	tm = localtime((LONG *)&sec);
+
+	(void) sprintf(bp, "%08x.%08x  %s, %s %2d %4d %2d:%02d:%02d.%03d",
+	    ts->l_ui, ts->l_uf, days[tm->tm_wday], months[tm->tm_mon],
+	    tm->tm_mday, 1900+tm->tm_year, tm->tm_hour, tm->tm_min,
+	    tm->tm_sec, msec);
+	
+	return bp;
+}
diff --git a/usr.sbin/xntpd/lib/ranny.c b/usr.sbin/xntpd/lib/ranny.c
new file mode 100644
index 0000000..2a47e03
--- /dev/null
+++ b/usr.sbin/xntpd/lib/ranny.c
@@ -0,0 +1,97 @@
+/* ranny.c,v 3.1 1993/07/06 01:08:43 jbj Exp
+ * Random number generator is:
+ *
+ *	Copyright 1988 by Rayan S. Zachariassen, all rights reserved.
+ *	This will be free software, but only when it is finished.
+ *
+ * Used in xntp by permission of the author.  If copyright is
+ * annoying to you, read no further.  Instead, look up the reference,
+ * write me an equivalent to this and send it back to me.
+ */
+
+/*
+ * Random number generator; see Knuth Vol 2. 2nd ed. p.27 (section 3.2.2)
+ */
+#include "ntp_stdlib.h"
+
+extern	time_t	time		P((time_t *loc));
+
+/*
+ * 55 random numbers, not all even.  Note we don't initialize ran_y
+ * directly since I have had thoughts of putting this in an EPROM
+ */
+static U_LONG ran_y[55];
+
+static U_LONG init_ran_y[55] = {
+	1860909544, 231033423, 437666411, 1349655137, 2014584962,
+	504613712, 656256107, 1246027206, 573713775, 643466871,
+	540235388, 1630565153, 443649364, 729302839, 1933991552,
+	944681982, 949111118, 406212522, 1065063137, 1712954727,
+	73280612, 787623973, 1874130997, 801658492, 73395958,
+	739165367, 596047144, 490055249, 1131094323, 662727104,
+	483614097, 844520219, 893760527, 921280508, 46691708,
+	760861842, 1425894220, 702947816, 2006889048, 1999607995,
+	1346414687, 399640789, 1482689501, 1790064052, 1128943628,
+	1269197405, 587262386, 2078054746, 1675409928, 1652325524,
+	1643525825, 1748690540, 292465849, 1370173174, 402865384
+};
+
+static int ran_j;
+static int ran_k;
+
+
+/*
+ * ranp2 - return a random integer in the range 0 .. (1<<m)-1
+ */
+U_LONG
+ranp2(m)
+	int m;
+{
+	U_LONG r;
+
+	ran_y[ran_k] += ran_y[ran_j];	/* overflow does a mod */
+	r = ran_y[ran_k];
+	if (ran_k-- == 0) ran_k = 54;
+	if (ran_j-- == 0) ran_j = 54;
+	return (r & ((1<<m)-1));
+}
+
+#ifdef notdef
+/*
+ * ranny - return a random integer in the range 0 .. m-1
+ */
+U_LONG
+ranny(m)
+	u_int m;
+{
+	unsigned LONG r;
+
+	ran_y[ran_k] += ran_y[ran_j];	/* overflow does a mod */
+	r = ran_y[ran_k];
+	if (ran_k-- == 0) ran_k = 54;
+	if (ran_j-- == 0) ran_j = 54;
+	return (r % m);
+}
+#endif /* notdef */
+
+/*
+ * init_random - do initialization of random number routine
+ */
+void
+init_random()
+{
+	register int i;
+	register time_t now;
+
+	ran_j = 23;
+	ran_k = 54;
+
+	/*
+	 * Randomize the seed array some more.  The time of day
+	 * should be initialized by now.
+	 */
+	now = (time_t)(time((time_t *)0))|01;
+
+	for (i = 0; i < 55; ++i)
+		ran_y[i] = now * init_ran_y[i];	/* overflow does a mod */
+}
diff --git a/usr.sbin/xntpd/lib/refnumtoa.c b/usr.sbin/xntpd/lib/refnumtoa.c
new file mode 100644
index 0000000..31175d9
--- /dev/null
+++ b/usr.sbin/xntpd/lib/refnumtoa.c
@@ -0,0 +1,34 @@
+/* refnumtoa.c,v 3.1 1993/07/06 01:08:44 jbj Exp
+ * refnumtoa - return asciized refclock addresses stored in local array space
+ */
+#include <stdio.h>
+
+#include "ntp_fp.h"
+#include "lib_strbuf.h"
+#include "ntp_stdlib.h"
+
+char *
+refnumtoa(num)
+	U_LONG num;
+{
+	register U_LONG netnum;
+	register char *buf;
+	register const char *rclock;
+	
+	netnum = ntohl(num);
+	
+	LIB_GETBUF(buf);
+
+	rclock = clockname((int)((netnum>>8)&0xff));
+
+	if (rclock != NULL)
+	  {
+	    (void) sprintf(buf, "%s(%d)", clockname((int)((netnum>>8)&0xff)), netnum&0xff);
+	  }
+	else
+	  {
+	    (void) sprintf(buf, "REFCLK(%d,%d)", (netnum>>8)&0xff, netnum&0xff);
+	  }
+
+	return buf;
+}
diff --git a/usr.sbin/xntpd/lib/syssignal.c b/usr.sbin/xntpd/lib/syssignal.c
new file mode 100644
index 0000000..f8abfdd
--- /dev/null
+++ b/usr.sbin/xntpd/lib/syssignal.c
@@ -0,0 +1,45 @@
+#include <stdio.h>
+#include <sys/types.h>
+#include <signal.h>
+
+#include "ntp_stdlib.h"
+
+#if defined(NTP_POSIX_SOURCE)
+#include <errno.h>
+
+extern int errno;
+
+void
+signal_no_reset(sig, func)
+int sig;
+void (*func)();
+{
+    int n;
+    struct sigaction vec;
+
+    vec.sa_handler = func;
+    sigemptyset(&vec.sa_mask);
+    vec.sa_flags = 0;
+
+    while (1) {
+        n = sigaction(sig, &vec, NULL);
+	if (n == -1 && errno == EINTR) continue;
+	break;
+    }
+    if (n == -1) {
+	perror("sigaction");
+        exit(1);
+    }
+}
+
+#else
+RETSIGTYPE
+signal_no_reset(sig, func)
+int sig;
+RETSIGTYPE (*func)();
+{
+    signal(sig, func);
+
+}
+#endif
+
diff --git a/usr.sbin/xntpd/lib/systime.c b/usr.sbin/xntpd/lib/systime.c
new file mode 100644
index 0000000..99e715a
--- /dev/null
+++ b/usr.sbin/xntpd/lib/systime.c
@@ -0,0 +1,371 @@
+/* systime.c,v 3.1 1993/07/06 01:08:46 jbj Exp
+ * systime -- routines to fiddle a UNIX clock.
+ */
+#include <sys/types.h>
+#include <sys/time.h>
+#if defined(SYS_HPUX) || defined(sgi) || defined(__bsdi__)
+#include <sys/param.h>
+#include <utmp.h>
+#endif
+
+#ifdef SYS_LINUX
+#include <sys/timex.h>
+#endif
+
+#include "ntp_fp.h"
+#include "ntp_syslog.h"
+#include "ntp_unixtime.h"
+#include "ntp_stdlib.h"
+
+#if defined(STEP_SLEW)
+#define SLEWALWAYS
+#endif
+
+extern int debug;
+
+/*
+ * These routines (init_systime, get_systime, step_systime, adj_systime)
+ * implement an interface between the (more or less) system independent
+ * bits of NTP and the peculiarities of dealing with the Unix system
+ * clock.  These routines will run with good precision fairly independently
+ * of your kernel's value of tickadj.  I couldn't tell the difference
+ * between tickadj==40 and tickadj==5 on a microvax, though I prefer
+ * to set tickadj == 500/hz when in doubt.  At your option you
+ * may compile this so that your system's clock is always slewed to the
+ * correct time even for large corrections.  Of course, all of this takes
+ * a lot of code which wouldn't be needed with a reasonable tickadj and
+ * a willingness to let the clock be stepped occasionally.  Oh well.
+ */
+
+/*
+ * Clock variables.  We round calls to adjtime() to adj_precision
+ * microseconds, and limit the adjustment to tvu_maxslew microseconds
+ * (tsf_maxslew fractional sec) in one adjustment interval.  As we are
+ * thus limited in the speed and precision with which we can adjust the
+ * clock, we compensate by keeping the known "error" in the system time
+ * in sys_clock_offset.  This is added to timestamps returned by get_systime().
+ * We also remember the clock precision we computed from the kernel in
+ * case someone asks us.
+ */
+	LONG adj_precision;	/* adj precision in usec (tickadj) */
+	LONG tvu_maxslew;	/* maximum adjust doable in 1<<CLOCK_ADJ sec (usec) */
+
+	U_LONG tsf_maxslew;	/* same as above, as LONG format */
+
+	LONG sys_clock;
+	l_fp sys_clock_offset;	/* correction for current system time */
+
+/*
+ * get_systime - return the system time in timestamp format
+ * As a side effect, update sys_clock.
+ */
+void
+get_systime(ts)
+	l_fp *ts;
+{
+	struct timeval tv;
+
+#if !defined(SLEWALWAYS)
+	/*
+	 * Quickly get the time of day and convert it
+	 */
+	(void) GETTIMEOFDAY(&tv, (struct timezone *)0);
+	TVTOTS(&tv, ts);
+	ts->l_uf += TS_ROUNDBIT;	/* guaranteed not to overflow */
+#else
+	/*
+	 * Get the time of day, convert to time stamp format
+	 * and add in the current time offset.  Then round
+	 * appropriately.
+	 */
+	(void) GETTIMEOFDAY(&tv, (struct timezone *)0);
+	TVTOTS(&tv, ts);
+	L_ADD(ts, &sys_clock_offset);
+	if (ts->l_uf & TS_ROUNDBIT)
+		L_ADDUF(ts, (unsigned LONG) TS_ROUNDBIT);
+#endif	/* !defined(SLEWALWAYS) */
+	ts->l_ui += JAN_1970;
+	ts->l_uf &= TS_MASK;
+
+	sys_clock = ts->l_ui;
+}
+
+/*
+ * step_systime - do a step adjustment in the system time (at least from
+ *		  NTP's point of view.
+ */
+int
+step_systime(ts)
+	l_fp *ts;
+{
+#ifdef SLEWALWAYS 
+#ifdef STEP_SLEW
+	register U_LONG tmp_ui;
+	register U_LONG tmp_uf;
+	int isneg;
+	int n;
+
+	/*
+	 * Take the absolute value of the offset
+	 */
+	tmp_ui = ts->l_ui;
+	tmp_uf = ts->l_uf;
+	if (M_ISNEG(tmp_ui, tmp_uf)) {
+		M_NEG(tmp_ui, tmp_uf);
+		isneg = 1;
+	} else
+		isneg = 0;
+
+	if (tmp_ui >= 3) {		/* Step it and slew we  might win */
+             n = step_systime_real(ts);
+	     if (!n) return n;
+	     if (isneg) 
+		ts->l_ui = ~0;
+	     else
+		ts->l_ui = ~0;
+	}
+#endif
+        /*
+         * Just add adjustment into the current offset.  The update
+         * routine will take care of bringing the system clock into
+         * line.
+         */
+	L_ADD(&sys_clock_offset, ts);
+	return 1;
+#else /* SLEWALWAYS  */
+        return step_systime_real(ts);
+#endif	/* SLEWALWAYS */
+}
+
+int	max_no_complete	= 20;
+
+/*
+ * adj_systime - called once every 1<<CLOCK_ADJ seconds to make system time
+ *		 adjustments.
+ */
+int
+adj_systime(ts)
+	l_fp *ts;
+{
+	register unsigned LONG offset_i, offset_f;
+	register LONG temp;
+	register unsigned LONG residual;
+	register int isneg = 0;
+	struct timeval adjtv, oadjtv;
+	l_fp oadjts;
+	LONG adj = ts->l_f;
+	int rval;
+
+	adjtv.tv_sec = adjtv.tv_usec = 0;
+
+	/*
+	 * Move the current offset into the registers
+	 */
+	offset_i = sys_clock_offset.l_ui;
+	offset_f = sys_clock_offset.l_uf;
+
+	/*
+	 * Add the new adjustment into the system offset.  Adjust the
+	 * system clock to minimize this.
+	 */
+	M_ADDF(offset_i, offset_f, adj);
+	if (M_ISNEG(offset_i, offset_f)) {
+		isneg = 1;
+		M_NEG(offset_i, offset_f);
+	}
+#ifdef DEBUG
+	if (debug > 4)
+		syslog(LOG_DEBUG, "adj_systime(%s): offset = %s%s\n",
+		    mfptoa((adj<0?-1:0), adj, 9), isneg?"-":"",
+		    umfptoa(offset_i, offset_f, 9));
+#endif
+
+	adjtv.tv_sec = 0;
+	if (offset_i > 0 || offset_f >= tsf_maxslew) {
+		/*
+		 * Slew is bigger than we can complete in
+		 * the adjustment interval.  Make a maximum
+		 * sized slew and reduce sys_clock_offset by this
+		 * much.
+		 */
+		M_SUBUF(offset_i, offset_f, tsf_maxslew);
+		if (!isneg) {
+			adjtv.tv_usec = tvu_maxslew;
+		} else {
+			adjtv.tv_usec = -tvu_maxslew;
+			M_NEG(offset_i, offset_f);
+		}
+
+#ifdef DEBUG
+		if (debug > 4)
+			syslog(LOG_DEBUG,
+			    "maximum slew: %s%s, remainder = %s\n",
+			    isneg?"-":"", umfptoa(0, tsf_maxslew, 9),
+			    mfptoa(offset_i, offset_f, 9));
+#endif
+	} else {
+		/*
+		 * We can do this slew in the time period.  Do our
+		 * best approximation (rounded), save residual for
+		 * next adjustment.
+		 *
+		 * Note that offset_i is guaranteed to be 0 here.
+		 */
+		TSFTOTVU(offset_f, temp);
+#ifndef ADJTIME_IS_ACCURATE
+		/*
+		 * Round value to be an even multiple of adj_precision
+		 */
+		residual = temp % adj_precision;
+		temp -= residual;
+		if (residual << 1 >= adj_precision)
+			temp += adj_precision;
+#endif /* ADJTIME_IS_ACCURATE */
+		TVUTOTSF(temp, residual);
+		M_SUBUF(offset_i, offset_f, residual);
+		if (isneg) {
+			adjtv.tv_usec = -temp;
+			M_NEG(offset_i, offset_f);
+		} else {
+			adjtv.tv_usec = temp;
+		}
+#ifdef DEBUG
+		if (debug > 4)
+			syslog(LOG_DEBUG,
+		"slew adjtv = %s, adjts = %s, sys_clock_offset = %s\n",
+			    tvtoa(&adjtv), umfptoa(0, residual, 9),
+			    mfptoa(offset_i, offset_f, 9));
+#endif
+	}
+
+	sys_clock_offset.l_ui = offset_i;
+	sys_clock_offset.l_uf = offset_f;
+
+	if (adjtime(&adjtv, &oadjtv) < 0) {
+		syslog(LOG_ERR, "Can't do time adjustment: %m");
+		rval = 0;
+	} else
+		rval = 1;
+
+#ifdef DEBUGRS6000
+	syslog(LOG_ERR, "adj_systime(%s): offset = %s%s\n",
+		    mfptoa((adj<0?-1:0), adj, 9), isneg?"-":"",
+		    umfptoa(offset_i, offset_f, 9));
+	syslog(LOG_ERR, "%d %d %d %d\n", (int) adjtv.tv_sec,
+		(int) adjtv.tv_usec, (int) oadjtv.tv_sec, (int)
+		oadjtv.tv_usec);
+#endif /* DEBUGRS6000 */
+
+	if ((oadjtv.tv_sec != 0 || oadjtv.tv_usec != 0) && (max_no_complete > 0)) {
+		sTVTOTS(&oadjtv, &oadjts);
+		L_ADD(&sys_clock_offset, &oadjts);
+		syslog(LOG_WARNING, "Previous time adjustment didn't complete");
+#ifdef DEBUG
+		if (debug > 4)
+			syslog(LOG_DEBUG,
+			    "Previous adjtime() incomplete, residual = %s\n",
+			    tvtoa(&oadjtv));
+#endif
+		if (--max_no_complete == 0) syslog(LOG_WARNING,
+			"*** No more 'Prev time adj didn't complete'");
+	}
+	return(rval);
+}
+
+
+/*
+ * This is used by ntpdate even when xntpd does not use it! WLJ
+ */
+int
+step_systime_real(ts)
+	l_fp *ts;
+{
+	struct timeval timetv, adjtv;
+	int isneg = 0;
+#if defined(SYS_HPUX)
+	struct utmp ut;
+	time_t oldtime;
+#endif
+
+	/*
+	 * We can afford to be sloppy here since if this is called
+	 * the time is really screwed and everything is being reset.
+	 */
+	L_ADD(&sys_clock_offset, ts);
+
+	if (L_ISNEG(&sys_clock_offset)) {
+		isneg = 1;
+		L_NEG(&sys_clock_offset);
+	}
+	TSTOTV(&sys_clock_offset, &adjtv);
+
+	(void) GETTIMEOFDAY(&timetv, (struct timezone *)0);
+#if defined(SYS_HPUX)
+	oldtime = timetv.tv_sec;
+#endif
+#ifdef DEBUG
+	if (debug > 3)
+		syslog(LOG_DEBUG, "step: %s, sys_clock_offset = %s, adjtv = %s, timetv = %s\n",
+		    lfptoa(ts, 9), lfptoa(&sys_clock_offset, 9), tvtoa(&adjtv),
+		    utvtoa(&timetv));
+#endif
+	if (isneg) {
+		timetv.tv_sec -= adjtv.tv_sec;
+		timetv.tv_usec -= adjtv.tv_usec;
+		if (timetv.tv_usec < 0) {
+			timetv.tv_sec--;
+			timetv.tv_usec += 1000000;
+		}
+	} else {
+		timetv.tv_sec += adjtv.tv_sec;
+		timetv.tv_usec += adjtv.tv_usec;
+		if (timetv.tv_usec >= 1000000) {
+			timetv.tv_sec++;
+			timetv.tv_usec -= 1000000;
+		}
+	}
+	if (SETTIMEOFDAY(&timetv, (struct timezone *)0) != 0) {
+		syslog(LOG_ERR, "Can't set time of day: %m");
+		return 0;
+	}
+#ifdef DEBUG
+	if (debug > 3)
+		syslog(LOG_DEBUG, "step: new timetv = %s\n", utvtoa(&timetv));
+#endif
+	sys_clock_offset.l_ui = sys_clock_offset.l_uf = 0;
+#if defined(SYS_HPUX)
+#if (SYS_HPUX < 10)
+	/*
+	 * CHECKME: is this correct when called by ntpdate?????
+	 */
+	_clear_adjtime();
+#endif
+	/*
+	 * Write old and new time entries in utmp and wtmp if step adjustment
+	 * is greater than one second.
+	 */
+	if (oldtime != timetv.tv_sec) {
+		bzero((char *)&ut, sizeof(ut));
+		ut.ut_type = OLD_TIME;
+		ut.ut_time = oldtime;
+		(void)strcpy(ut.ut_line, OTIME_MSG);
+		pututline(&ut);
+		setutent();
+		ut.ut_type = NEW_TIME;
+		ut.ut_time = timetv.tv_sec;
+		(void)strcpy(ut.ut_line, NTIME_MSG);
+		pututline(&ut);
+		utmpname(WTMP_FILE);
+		ut.ut_type = OLD_TIME;
+		ut.ut_time = oldtime;
+		(void)strcpy(ut.ut_line, OTIME_MSG);
+		pututline(&ut);
+		ut.ut_type = NEW_TIME;
+		ut.ut_time = timetv.tv_sec;
+		(void)strcpy(ut.ut_line, NTIME_MSG);
+		pututline(&ut);
+		endutent();
+	}
+#endif
+	return 1;
+}
diff --git a/usr.sbin/xntpd/lib/tsftomsu.c b/usr.sbin/xntpd/lib/tsftomsu.c
new file mode 100644
index 0000000..b916114
--- /dev/null
+++ b/usr.sbin/xntpd/lib/tsftomsu.c
@@ -0,0 +1,37 @@
+/* tsftomsu.c,v 3.1 1993/07/06 01:08:47 jbj Exp
+ * tsftomsu - convert from a time stamp fraction to milliseconds
+ */
+#include "ntp_fp.h"
+#include "ntp_stdlib.h"
+
+int
+tsftomsu(tsf, round)
+	U_LONG tsf;
+	int round;
+{
+	register U_LONG val_ui, val_uf;
+	register U_LONG tmp_ui, tmp_uf;
+	register int i;
+
+	/*
+	 * Essentially, multiply by 10 three times in l_fp form.
+	 * The integral part is the milliseconds.
+	 */
+	val_ui = 0;
+	val_uf = tsf;
+	for (i = 3; i > 0; i--) {
+		M_LSHIFT(val_ui, val_uf);
+		tmp_ui = val_ui;
+		tmp_uf = val_uf;
+		M_LSHIFT(val_ui, val_uf);
+		M_LSHIFT(val_ui, val_uf);
+		M_ADD(val_ui, val_uf, tmp_ui, tmp_uf);
+	}
+
+	/*
+	 * Round the value if need be, then return it.
+	 */
+	if (round && (val_uf & 0x80000000))
+		val_ui++;
+	return (int)val_ui;
+}
diff --git a/usr.sbin/xntpd/lib/tstotod.c b/usr.sbin/xntpd/lib/tstotod.c
new file mode 100644
index 0000000..a78aea1
--- /dev/null
+++ b/usr.sbin/xntpd/lib/tstotod.c
@@ -0,0 +1,21 @@
+#ifdef	ELIMINATE
+/* tstotod.c,v 3.1 1993/07/06 01:08:48 jbj Exp
+ * tstotod - compute calendar time given an NTP timestamp
+ */
+#include <stdio.h>
+
+#include "ntp_fp.h"
+#include "ntp_calendar.h"
+#include "ntp_stdlib.h"
+
+void
+tstotod(ts, tod)
+	l_fp *ts;
+	struct calendar *tod;
+{
+	register U_LONG cyclesecs;
+
+	cyclesecs = ts.l_ui - MAR_1900;		/* bump forward to March 1900 */
+
+}
+#endif	/* ELIMINATE */
diff --git a/usr.sbin/xntpd/lib/tstotv.c b/usr.sbin/xntpd/lib/tstotv.c
new file mode 100644
index 0000000..c9b0d1c
--- /dev/null
+++ b/usr.sbin/xntpd/lib/tstotv.c
@@ -0,0 +1,135 @@
+/* tstotv.c,v 3.1 1993/07/06 01:08:49 jbj Exp
+ * tstotv - tables for converting from NTP time stamps to struct timeval
+ */
+
+#include "ntp_types.h"
+
+/*
+ * Tables to convert from a time stamp fraction to usecs.  Note that
+ * the units of these tables are actually (usec<<3).  We carry three
+ * guard bits so that the result can be properly truncated (or rounded)
+ * to be correct to the least significant bit.
+ *
+ * These tables are rounded.
+ */
+
+LONG tstoushi[256] = {
+	0x000000, 0x007a12, 0x00f424, 0x016e36,
+	0x01e848, 0x02625a, 0x02dc6c, 0x03567e,
+	0x03d090, 0x044aa2, 0x04c4b4, 0x053ec6,
+	0x05b8d8, 0x0632ea, 0x06acfc, 0x07270e,
+	0x07a120, 0x081b32, 0x089544, 0x090f56,
+	0x098968, 0x0a037a, 0x0a7d8c, 0x0af79e,
+	0x0b71b0, 0x0bebc2, 0x0c65d4, 0x0cdfe6,
+	0x0d59f8, 0x0dd40a, 0x0e4e1c, 0x0ec82e,
+	0x0f4240, 0x0fbc52, 0x103664, 0x10b076,
+	0x112a88, 0x11a49a, 0x121eac, 0x1298be,
+	0x1312d0, 0x138ce2, 0x1406f4, 0x148106,
+	0x14fb18, 0x15752a, 0x15ef3c, 0x16694e,
+	0x16e360, 0x175d72, 0x17d784, 0x185196,
+	0x18cba8, 0x1945ba, 0x19bfcc, 0x1a39de,
+	0x1ab3f0, 0x1b2e02, 0x1ba814, 0x1c2226,
+	0x1c9c38, 0x1d164a, 0x1d905c, 0x1e0a6e,
+	0x1e8480, 0x1efe92, 0x1f78a4, 0x1ff2b6,
+	0x206cc8, 0x20e6da, 0x2160ec, 0x21dafe,
+	0x225510, 0x22cf22, 0x234934, 0x23c346,
+	0x243d58, 0x24b76a, 0x25317c, 0x25ab8e,
+	0x2625a0, 0x269fb2, 0x2719c4, 0x2793d6,
+	0x280de8, 0x2887fa, 0x29020c, 0x297c1e,
+	0x29f630, 0x2a7042, 0x2aea54, 0x2b6466,
+	0x2bde78, 0x2c588a, 0x2cd29c, 0x2d4cae,
+	0x2dc6c0, 0x2e40d2, 0x2ebae4, 0x2f34f6,
+	0x2faf08, 0x30291a, 0x30a32c, 0x311d3e,
+	0x319750, 0x321162, 0x328b74, 0x330586,
+	0x337f98, 0x33f9aa, 0x3473bc, 0x34edce,
+	0x3567e0, 0x35e1f2, 0x365c04, 0x36d616,
+	0x375028, 0x37ca3a, 0x38444c, 0x38be5e,
+	0x393870, 0x39b282, 0x3a2c94, 0x3aa6a6,
+	0x3b20b8, 0x3b9aca, 0x3c14dc, 0x3c8eee,
+	0x3d0900, 0x3d8312, 0x3dfd24, 0x3e7736,
+	0x3ef148, 0x3f6b5a, 0x3fe56c, 0x405f7e,
+	0x40d990, 0x4153a2, 0x41cdb4, 0x4247c6,
+	0x42c1d8, 0x433bea, 0x43b5fc, 0x44300e,
+	0x44aa20, 0x452432, 0x459e44, 0x461856,
+	0x469268, 0x470c7a, 0x47868c, 0x48009e,
+	0x487ab0, 0x48f4c2, 0x496ed4, 0x49e8e6,
+	0x4a62f8, 0x4add0a, 0x4b571c, 0x4bd12e,
+	0x4c4b40, 0x4cc552, 0x4d3f64, 0x4db976,
+	0x4e3388, 0x4ead9a, 0x4f27ac, 0x4fa1be,
+	0x501bd0, 0x5095e2, 0x510ff4, 0x518a06,
+	0x520418, 0x527e2a, 0x52f83c, 0x53724e,
+	0x53ec60, 0x546672, 0x54e084, 0x555a96,
+	0x55d4a8, 0x564eba, 0x56c8cc, 0x5742de,
+	0x57bcf0, 0x583702, 0x58b114, 0x592b26,
+	0x59a538, 0x5a1f4a, 0x5a995c, 0x5b136e,
+	0x5b8d80, 0x5c0792, 0x5c81a4, 0x5cfbb6,
+	0x5d75c8, 0x5defda, 0x5e69ec, 0x5ee3fe,
+	0x5f5e10, 0x5fd822, 0x605234, 0x60cc46,
+	0x614658, 0x61c06a, 0x623a7c, 0x62b48e,
+	0x632ea0, 0x63a8b2, 0x6422c4, 0x649cd6,
+	0x6516e8, 0x6590fa, 0x660b0c, 0x66851e,
+	0x66ff30, 0x677942, 0x67f354, 0x686d66,
+	0x68e778, 0x69618a, 0x69db9c, 0x6a55ae,
+	0x6acfc0, 0x6b49d2, 0x6bc3e4, 0x6c3df6,
+	0x6cb808, 0x6d321a, 0x6dac2c, 0x6e263e,
+	0x6ea050, 0x6f1a62, 0x6f9474, 0x700e86,
+	0x708898, 0x7102aa, 0x717cbc, 0x71f6ce,
+	0x7270e0, 0x72eaf2, 0x736504, 0x73df16,
+	0x745928, 0x74d33a, 0x754d4c, 0x75c75e,
+	0x764170, 0x76bb82, 0x773594, 0x77afa6,
+	0x7829b8, 0x78a3ca, 0x791ddc, 0x7997ee
+};
+
+LONG tstousmid[256] = {
+	0x0000, 0x007a, 0x00f4, 0x016e, 0x01e8, 0x0262, 0x02dc, 0x0356,
+	0x03d1, 0x044b, 0x04c5, 0x053f, 0x05b9, 0x0633, 0x06ad, 0x0727,
+	0x07a1, 0x081b, 0x0895, 0x090f, 0x0989, 0x0a03, 0x0a7e, 0x0af8,
+	0x0b72, 0x0bec, 0x0c66, 0x0ce0, 0x0d5a, 0x0dd4, 0x0e4e, 0x0ec8,
+	0x0f42, 0x0fbc, 0x1036, 0x10b0, 0x112b, 0x11a5, 0x121f, 0x1299,
+	0x1313, 0x138d, 0x1407, 0x1481, 0x14fb, 0x1575, 0x15ef, 0x1669,
+	0x16e3, 0x175d, 0x17d8, 0x1852, 0x18cc, 0x1946, 0x19c0, 0x1a3a,
+	0x1ab4, 0x1b2e, 0x1ba8, 0x1c22, 0x1c9c, 0x1d16, 0x1d90, 0x1e0a,
+	0x1e84, 0x1eff, 0x1f79, 0x1ff3, 0x206d, 0x20e7, 0x2161, 0x21db,
+	0x2255, 0x22cf, 0x2349, 0x23c3, 0x243d, 0x24b7, 0x2531, 0x25ac,
+	0x2626, 0x26a0, 0x271a, 0x2794, 0x280e, 0x2888, 0x2902, 0x297c,
+	0x29f6, 0x2a70, 0x2aea, 0x2b64, 0x2bde, 0x2c59, 0x2cd3, 0x2d4d,
+	0x2dc7, 0x2e41, 0x2ebb, 0x2f35, 0x2faf, 0x3029, 0x30a3, 0x311d,
+	0x3197, 0x3211, 0x328b, 0x3306, 0x3380, 0x33fa, 0x3474, 0x34ee,
+	0x3568, 0x35e2, 0x365c, 0x36d6, 0x3750, 0x37ca, 0x3844, 0x38be,
+	0x3938, 0x39b3, 0x3a2d, 0x3aa7, 0x3b21, 0x3b9b, 0x3c15, 0x3c8f,
+	0x3d09, 0x3d83, 0x3dfd, 0x3e77, 0x3ef1, 0x3f6b, 0x3fe5, 0x405f,
+	0x40da, 0x4154, 0x41ce, 0x4248, 0x42c2, 0x433c, 0x43b6, 0x4430,
+	0x44aa, 0x4524, 0x459e, 0x4618, 0x4692, 0x470c, 0x4787, 0x4801,
+	0x487b, 0x48f5, 0x496f, 0x49e9, 0x4a63, 0x4add, 0x4b57, 0x4bd1,
+	0x4c4b, 0x4cc5, 0x4d3f, 0x4db9, 0x4e34, 0x4eae, 0x4f28, 0x4fa2,
+	0x501c, 0x5096, 0x5110, 0x518a, 0x5204, 0x527e, 0x52f8, 0x5372,
+	0x53ec, 0x5466, 0x54e1, 0x555b, 0x55d5, 0x564f, 0x56c9, 0x5743,
+	0x57bd, 0x5837, 0x58b1, 0x592b, 0x59a5, 0x5a1f, 0x5a99, 0x5b13,
+	0x5b8d, 0x5c08, 0x5c82, 0x5cfc, 0x5d76, 0x5df0, 0x5e6a, 0x5ee4,
+	0x5f5e, 0x5fd8, 0x6052, 0x60cc, 0x6146, 0x61c0, 0x623a, 0x62b5,
+	0x632f, 0x63a9, 0x6423, 0x649d, 0x6517, 0x6591, 0x660b, 0x6685,
+	0x66ff, 0x6779, 0x67f3, 0x686d, 0x68e7, 0x6962, 0x69dc, 0x6a56,
+	0x6ad0, 0x6b4a, 0x6bc4, 0x6c3e, 0x6cb8, 0x6d32, 0x6dac, 0x6e26,
+	0x6ea0, 0x6f1a, 0x6f94, 0x700f, 0x7089, 0x7103, 0x717d, 0x71f7,
+	0x7271, 0x72eb, 0x7365, 0x73df, 0x7459, 0x74d3, 0x754d, 0x75c7,
+	0x7641, 0x76bc, 0x7736, 0x77b0, 0x782a, 0x78a4, 0x791e, 0x7998
+};
+
+LONG tstouslo[128] = {
+	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+	0x08, 0x09, 0x0a, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
+	0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,
+	0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e,
+	0x1f, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25,
+	0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d,
+	0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x33, 0x34,
+	0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c,
+	0x3d, 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x44,
+	0x45, 0x46, 0x47, 0x48, 0x48, 0x49, 0x4a, 0x4b,
+	0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53,
+	0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b,
+	0x5c, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62,
+	0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
+	0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x71,
+	0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79
+};
diff --git a/usr.sbin/xntpd/lib/tvtoa.c b/usr.sbin/xntpd/lib/tvtoa.c
new file mode 100644
index 0000000..778caa1
--- /dev/null
+++ b/usr.sbin/xntpd/lib/tvtoa.c
@@ -0,0 +1,33 @@
+/* tvtoa.c,v 3.1 1993/07/06 01:08:50 jbj Exp
+ * tvtoa - return an asciized representation of a struct timeval
+ */
+#include <stdio.h>
+#include <sys/time.h>
+
+#include "lib_strbuf.h"
+#include "ntp_stdlib.h"
+
+char *
+tvtoa(tv)
+	struct timeval *tv;
+{
+	register char *buf;
+	register U_LONG sec;
+	register U_LONG usec;
+	register int isneg;
+
+	if (tv->tv_sec < 0 || tv->tv_usec < 0) {
+		sec = -tv->tv_sec;
+		usec = -tv->tv_usec;
+		isneg = 1;
+	} else {
+		sec = tv->tv_sec;
+		usec = tv->tv_usec;
+		isneg = 0;
+	}
+
+	LIB_GETBUF(buf);
+
+	(void) sprintf(buf, "%s%lu.%06lu", (isneg?"-":""), sec, usec);
+	return buf;
+}
diff --git a/usr.sbin/xntpd/lib/tvtots.c b/usr.sbin/xntpd/lib/tvtots.c
new file mode 100644
index 0000000..befc480
--- /dev/null
+++ b/usr.sbin/xntpd/lib/tvtots.c
@@ -0,0 +1,159 @@
+/* tvtots.c,v 3.1 1993/07/06 01:08:51 jbj Exp
+ * tvtots - tables for converting from Unix struct timeval's to
+ *	    NTP time stamp format.
+ */
+#include <sys/types.h>
+
+#include "ntp_types.h"
+
+/*
+ * Tables to calculate time stamp fractions from usecs.  The entries
+ * in these tables are offset into using each of the two low order
+ * bytes plus the next 4 bits in a usec value (from a struct timeval).
+ * These are summed to produce the time stamp fraction.
+ *
+ * Note that these tables are rounded (not truncated) to the nearest
+ * low order bit in the fraction.  The timestamp computed should be
+ * +- 1.5 low order bits.
+ */
+
+U_LONG ustotslo[256] = {
+	0x00000000, 0x000010c7, 0x0000218e, 0x00003255,
+	0x0000431c, 0x000053e3, 0x000064aa, 0x00007571,
+	0x00008638, 0x000096ff, 0x0000a7c6, 0x0000b88d,
+	0x0000c954, 0x0000da1b, 0x0000eae2, 0x0000fba9,
+	0x00010c6f, 0x00011d36, 0x00012dfd, 0x00013ec4,
+	0x00014f8b, 0x00016052, 0x00017119, 0x000181e0,
+	0x000192a7, 0x0001a36e, 0x0001b435, 0x0001c4fc,
+	0x0001d5c3, 0x0001e68a, 0x0001f751, 0x00020818,
+	0x000218df, 0x000229a6, 0x00023a6d, 0x00024b34,
+	0x00025bfb, 0x00026cc2, 0x00027d89, 0x00028e50,
+	0x00029f17, 0x0002afde, 0x0002c0a5, 0x0002d16c,
+	0x0002e233, 0x0002f2fa, 0x000303c0, 0x00031487,
+	0x0003254e, 0x00033615, 0x000346dc, 0x000357a3,
+	0x0003686a, 0x00037931, 0x000389f8, 0x00039abf,
+	0x0003ab86, 0x0003bc4d, 0x0003cd14, 0x0003dddb,
+	0x0003eea2, 0x0003ff69, 0x00041030, 0x000420f7,
+	0x000431be, 0x00044285, 0x0004534c, 0x00046413,
+	0x000474da, 0x000485a1, 0x00049668, 0x0004a72f,
+	0x0004b7f6, 0x0004c8bd, 0x0004d984, 0x0004ea4b,
+	0x0004fb12, 0x00050bd8, 0x00051c9f, 0x00052d66,
+	0x00053e2d, 0x00054ef4, 0x00055fbb, 0x00057082,
+	0x00058149, 0x00059210, 0x0005a2d7, 0x0005b39e,
+	0x0005c465, 0x0005d52c, 0x0005e5f3, 0x0005f6ba,
+	0x00060781, 0x00061848, 0x0006290f, 0x000639d6,
+	0x00064a9d, 0x00065b64, 0x00066c2b, 0x00067cf2,
+	0x00068db9, 0x00069e80, 0x0006af47, 0x0006c00e,
+	0x0006d0d5, 0x0006e19c, 0x0006f263, 0x00070329,
+	0x000713f0, 0x000724b7, 0x0007357e, 0x00074645,
+	0x0007570c, 0x000767d3, 0x0007789a, 0x00078961,
+	0x00079a28, 0x0007aaef, 0x0007bbb6, 0x0007cc7d,
+	0x0007dd44, 0x0007ee0b, 0x0007fed2, 0x00080f99,
+	0x00082060, 0x00083127, 0x000841ee, 0x000852b5,
+	0x0008637c, 0x00087443, 0x0008850a, 0x000895d1,
+	0x0008a698, 0x0008b75f, 0x0008c826, 0x0008d8ed,
+	0x0008e9b4, 0x0008fa7b, 0x00090b41, 0x00091c08,
+	0x00092ccf, 0x00093d96, 0x00094e5d, 0x00095f24,
+	0x00096feb, 0x000980b2, 0x00099179, 0x0009a240,
+	0x0009b307, 0x0009c3ce, 0x0009d495, 0x0009e55c,
+	0x0009f623, 0x000a06ea, 0x000a17b1, 0x000a2878,
+	0x000a393f, 0x000a4a06, 0x000a5acd, 0x000a6b94,
+	0x000a7c5b, 0x000a8d22, 0x000a9de9, 0x000aaeb0,
+	0x000abf77, 0x000ad03e, 0x000ae105, 0x000af1cc,
+	0x000b0292, 0x000b1359, 0x000b2420, 0x000b34e7,
+	0x000b45ae, 0x000b5675, 0x000b673c, 0x000b7803,
+	0x000b88ca, 0x000b9991, 0x000baa58, 0x000bbb1f,
+	0x000bcbe6, 0x000bdcad, 0x000bed74, 0x000bfe3b,
+	0x000c0f02, 0x000c1fc9, 0x000c3090, 0x000c4157,
+	0x000c521e, 0x000c62e5, 0x000c73ac, 0x000c8473,
+	0x000c953a, 0x000ca601, 0x000cb6c8, 0x000cc78f,
+	0x000cd856, 0x000ce91d, 0x000cf9e4, 0x000d0aaa,
+	0x000d1b71, 0x000d2c38, 0x000d3cff, 0x000d4dc6,
+	0x000d5e8d, 0x000d6f54, 0x000d801b, 0x000d90e2,
+	0x000da1a9, 0x000db270, 0x000dc337, 0x000dd3fe,
+	0x000de4c5, 0x000df58c, 0x000e0653, 0x000e171a,
+	0x000e27e1, 0x000e38a8, 0x000e496f, 0x000e5a36,
+	0x000e6afd, 0x000e7bc4, 0x000e8c8b, 0x000e9d52,
+	0x000eae19, 0x000ebee0, 0x000ecfa7, 0x000ee06e,
+	0x000ef135, 0x000f01fb, 0x000f12c2, 0x000f2389,
+	0x000f3450, 0x000f4517, 0x000f55de, 0x000f66a5,
+	0x000f776c, 0x000f8833, 0x000f98fa, 0x000fa9c1,
+	0x000fba88, 0x000fcb4f, 0x000fdc16, 0x000fecdd,
+	0x000ffda4, 0x00100e6b, 0x00101f32, 0x00102ff9,
+	0x001040c0, 0x00105187, 0x0010624e, 0x00107315,
+	0x001083dc, 0x001094a3, 0x0010a56a, 0x0010b631,
+};
+
+U_LONG ustotsmid[256] = {
+	0x00000000, 0x0010c6f8, 0x00218def, 0x003254e7,
+	0x00431bde, 0x0053e2d6, 0x0064a9ce, 0x007570c5,
+	0x008637bd, 0x0096feb4, 0x00a7c5ac, 0x00b88ca4,
+	0x00c9539b, 0x00da1a93, 0x00eae18a, 0x00fba882,
+	0x010c6f7a, 0x011d3671, 0x012dfd69, 0x013ec460,
+	0x014f8b58, 0x01605250, 0x01711947, 0x0181e03f,
+	0x0192a736, 0x01a36e2e, 0x01b43526, 0x01c4fc1d,
+	0x01d5c315, 0x01e68a0c, 0x01f75104, 0x020817fc,
+	0x0218def3, 0x0229a5eb, 0x023a6ce3, 0x024b33da,
+	0x025bfad2, 0x026cc1c9, 0x027d88c1, 0x028e4fb9,
+	0x029f16b0, 0x02afdda8, 0x02c0a49f, 0x02d16b97,
+	0x02e2328f, 0x02f2f986, 0x0303c07e, 0x03148775,
+	0x03254e6d, 0x03361565, 0x0346dc5c, 0x0357a354,
+	0x03686a4b, 0x03793143, 0x0389f83b, 0x039abf32,
+	0x03ab862a, 0x03bc4d21, 0x03cd1419, 0x03dddb11,
+	0x03eea208, 0x03ff6900, 0x04102ff7, 0x0420f6ef,
+	0x0431bde7, 0x044284de, 0x04534bd6, 0x046412cd,
+	0x0474d9c5, 0x0485a0bd, 0x049667b4, 0x04a72eac,
+	0x04b7f5a3, 0x04c8bc9b, 0x04d98393, 0x04ea4a8a,
+	0x04fb1182, 0x050bd879, 0x051c9f71, 0x052d6669,
+	0x053e2d60, 0x054ef458, 0x055fbb4f, 0x05708247,
+	0x0581493f, 0x05921036, 0x05a2d72e, 0x05b39e25,
+	0x05c4651d, 0x05d52c15, 0x05e5f30c, 0x05f6ba04,
+	0x060780fb, 0x061847f3, 0x06290eeb, 0x0639d5e2,
+	0x064a9cda, 0x065b63d2, 0x066c2ac9, 0x067cf1c1,
+	0x068db8b8, 0x069e7fb0, 0x06af46a8, 0x06c00d9f,
+	0x06d0d497, 0x06e19b8e, 0x06f26286, 0x0703297e,
+	0x0713f075, 0x0724b76d, 0x07357e64, 0x0746455c,
+	0x07570c54, 0x0767d34b, 0x07789a43, 0x0789613a,
+	0x079a2832, 0x07aaef2a, 0x07bbb621, 0x07cc7d19,
+	0x07dd4410, 0x07ee0b08, 0x07fed200, 0x080f98f7,
+	0x08205fef, 0x083126e6, 0x0841edde, 0x0852b4d6,
+	0x08637bcd, 0x087442c5, 0x088509bc, 0x0895d0b4,
+	0x08a697ac, 0x08b75ea3, 0x08c8259b, 0x08d8ec92,
+	0x08e9b38a, 0x08fa7a82, 0x090b4179, 0x091c0871,
+	0x092ccf68, 0x093d9660, 0x094e5d58, 0x095f244f,
+	0x096feb47, 0x0980b23e, 0x09917936, 0x09a2402e,
+	0x09b30725, 0x09c3ce1d, 0x09d49514, 0x09e55c0c,
+	0x09f62304, 0x0a06e9fb, 0x0a17b0f3, 0x0a2877ea,
+	0x0a393ee2, 0x0a4a05da, 0x0a5accd1, 0x0a6b93c9,
+	0x0a7c5ac1, 0x0a8d21b8, 0x0a9de8b0, 0x0aaeafa7,
+	0x0abf769f, 0x0ad03d97, 0x0ae1048e, 0x0af1cb86,
+	0x0b02927d, 0x0b135975, 0x0b24206d, 0x0b34e764,
+	0x0b45ae5c, 0x0b567553, 0x0b673c4b, 0x0b780343,
+	0x0b88ca3a, 0x0b999132, 0x0baa5829, 0x0bbb1f21,
+	0x0bcbe619, 0x0bdcad10, 0x0bed7408, 0x0bfe3aff,
+	0x0c0f01f7, 0x0c1fc8ef, 0x0c308fe6, 0x0c4156de,
+	0x0c521dd5, 0x0c62e4cd, 0x0c73abc5, 0x0c8472bc,
+	0x0c9539b4, 0x0ca600ab, 0x0cb6c7a3, 0x0cc78e9b,
+	0x0cd85592, 0x0ce91c8a, 0x0cf9e381, 0x0d0aaa79,
+	0x0d1b7171, 0x0d2c3868, 0x0d3cff60, 0x0d4dc657,
+	0x0d5e8d4f, 0x0d6f5447, 0x0d801b3e, 0x0d90e236,
+	0x0da1a92d, 0x0db27025, 0x0dc3371d, 0x0dd3fe14,
+	0x0de4c50c, 0x0df58c03, 0x0e0652fb, 0x0e1719f3,
+	0x0e27e0ea, 0x0e38a7e2, 0x0e496ed9, 0x0e5a35d1,
+	0x0e6afcc9, 0x0e7bc3c0, 0x0e8c8ab8, 0x0e9d51b0,
+	0x0eae18a7, 0x0ebedf9f, 0x0ecfa696, 0x0ee06d8e,
+	0x0ef13486, 0x0f01fb7d, 0x0f12c275, 0x0f23896c,
+	0x0f345064, 0x0f45175c, 0x0f55de53, 0x0f66a54b,
+	0x0f776c42, 0x0f88333a, 0x0f98fa32, 0x0fa9c129,
+	0x0fba8821, 0x0fcb4f18, 0x0fdc1610, 0x0fecdd08,
+	0x0ffda3ff, 0x100e6af7, 0x101f31ee, 0x102ff8e6,
+	0x1040bfde, 0x105186d5, 0x10624dcd, 0x107314c4,
+	0x1083dbbc, 0x1094a2b4, 0x10a569ab, 0x10b630a3,
+};
+
+U_LONG ustotshi[16] = {
+	0x00000000, 0x10c6f79a, 0x218def35, 0x3254e6cf,
+	0x431bde6a, 0x53e2d604, 0x64a9cd9f, 0x7570c539,
+	0x8637bcd3, 0x96feb46e, 0xa7c5ac08, 0xb88ca3a3,
+	0xc9539b3d, 0xda1a92d7, 0xeae18a72, 0xfba8820c,
+};
diff --git a/usr.sbin/xntpd/lib/uglydate.c b/usr.sbin/xntpd/lib/uglydate.c
new file mode 100644
index 0000000..308c703
--- /dev/null
+++ b/usr.sbin/xntpd/lib/uglydate.c
@@ -0,0 +1,53 @@
+/* uglydate.c,v 3.1 1993/07/06 01:08:53 jbj Exp
+ * uglydate - convert a time stamp to something barely readable
+ *	      The string returned is 37 characters long.
+ */
+#include <stdio.h>
+
+#include "ntp_fp.h"
+#include "ntp_unixtime.h"
+#include "lib_strbuf.h"
+#include "ntp_stdlib.h"
+#ifdef NTP_POSIX_SOURCE
+#include <time.h>
+#endif
+
+char *
+uglydate(ts)
+	l_fp *ts;
+{
+	char *bp;
+	char *timep;
+	struct tm *tm;
+	U_LONG sec;
+	U_LONG msec;
+	int year;
+
+	timep = ulfptoa(ts, 6);		/* returns max 17 characters */
+
+	LIB_GETBUF(bp);
+	
+	sec = ts->l_ui - JAN_1970;
+	msec = ts->l_uf / 4294967;	/* fract / (2**32/1000) */
+	tm = gmtime((LONG *)&sec);
+	if (ts->l_ui == 0) {
+		/*
+		 * Probably not a real good thing to do.  Oh, well.
+		 */
+		year = 0;
+		tm->tm_yday = 0;
+		tm->tm_hour = 0;
+		tm->tm_min = 0;
+		tm->tm_sec = 0;
+	} else {
+		year = tm->tm_year;
+		while (year >= 100)
+			year -= 100;
+	}
+
+	(void) sprintf(bp, "%17s %02d:%03d:%02d:%02d:%02d.%03d",
+	    timep, year, tm->tm_yday, tm->tm_hour, tm->tm_min,
+	    tm->tm_sec, msec);
+
+	return bp;
+}
diff --git a/usr.sbin/xntpd/lib/uinttoa.c b/usr.sbin/xntpd/lib/uinttoa.c
new file mode 100644
index 0000000..ce29390
--- /dev/null
+++ b/usr.sbin/xntpd/lib/uinttoa.c
@@ -0,0 +1,19 @@
+/* uinttoa.c,v 3.1 1993/07/06 01:08:54 jbj Exp
+ * uinttoa - return an asciized unsigned integer
+ */
+#include <stdio.h>
+
+#include "lib_strbuf.h"
+#include "ntp_stdlib.h"
+
+char *
+uinttoa(uval)
+	U_LONG uval;
+{
+	register char *buf;
+
+	LIB_GETBUF(buf);
+
+	(void) sprintf(buf, "%lu", uval);
+	return buf;
+}
diff --git a/usr.sbin/xntpd/lib/utvtoa.c b/usr.sbin/xntpd/lib/utvtoa.c
new file mode 100644
index 0000000..b573f18
--- /dev/null
+++ b/usr.sbin/xntpd/lib/utvtoa.c
@@ -0,0 +1,21 @@
+/* utvtoa.c,v 3.1 1993/07/06 01:08:55 jbj Exp
+ * utvtoa - return an asciized representation of an unsigned struct timeval
+ */
+#include <stdio.h>
+#include <sys/time.h>
+
+#include "lib_strbuf.h"
+#include "ntp_stdlib.h"
+
+char *
+utvtoa(tv)
+	struct timeval *tv;
+{
+	register char *buf;
+
+	LIB_GETBUF(buf);
+	
+	(void) sprintf(buf, "%lu.%06lu", (U_LONG)tv->tv_sec,
+	    (U_LONG)tv->tv_usec);
+	return buf;
+}