diff options
Diffstat (limited to 'usr.sbin/xntpd/lib')
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; +} |
