This commit was manufactured by cvs2svn to create branch 'MACKERRAS'.

8 files changed, 2711 insertions, 0 deletions

diff --git a/usr.sbin/pppd/RELNOTES b/usr.sbin/pppd/RELNOTES
new file mode 100644
index 0000000..b993de2
--- /dev/null
+++ b/usr.sbin/pppd/RELNOTES
@@ -0,0 +1,295 @@
+		pppd-2.1.1 release notes
+		Paul Mackerras   27 May 1994
+
+This file details the new and changed features in pppd since version 1.3.
+Briefly:
+	- the protocol code has been updated to conform with
+	  RFCs 1548, 1549, 1332 and 1334
+	- security has been improved
+	- functionality has been improved in various ways.
+
+
+NEW FEATURES
+
+* The option negotiation automaton has been updated to RFC1548.  LCP
+now rejects the Quality Protocol option, since LQR is not implemented
+yet.  IPCP now uses the IP-Address option, and falls back to the old
+IP-Addresses option if the IP-Address option is rejected.  IPCP also
+uses the new form of the VJ-Compression option.
+
+RFC1548 defines the "passive" option to mean that the automaton
+outputs configure-request packets initially, but does not close down
+if no answer is received.  A valid configure-request received will
+restart the negotiation.  The "silent" option has been added with the
+old meaning of "passive", i.e. the automaton will not output
+configure-requests until it receives a valid one from the peer.
+
+* More systems are supported: in addition to SunOS 4.x and BSD/Net-2
+derived systems, Ultrix and Linux are supported, thanks to Robert
+Olsson, Per Sundstrom, Michael Callahan and Al Longyear.
+
+* Options can be taken from files as well as the command line.  pppd
+reads options from the files /etc/ppp/options and ~/.ppprc before
+looking at the command line, and /etc/ppp/options.<ttyname> after
+interpreting the options on the command line.  An options file is
+parsed into a series of words, delimited by whitespace.  Whitespace
+can be included in a word by enclosing the word in quotes (").
+Backslash (\) quotes the following character.  A hash (#) starts a
+comment, which continues until the end of the line.  In addition, the
+`file' option causes pppd to read options from a file.  pppd will
+report and error and exit if ~/.ppprc or the file given as the
+argument to the `file' option cannot be read by the user who invoked
+pppd.
+
+* On those systems, such as NetBSD, where the serial line speed is
+stored in the termios structure in bits per second (i.e. B9600 ==
+9600), it is possible to set any speed.
+
+* If desired, pppd will output LCP echo-request frames periodically
+while the link is up, and take the link down if no replies are
+received to a user-configurable number of echo-requests.  This can be
+used to detect that the serial connection has been broken on those
+systems which don't have hardware modem control lines.
+
+AUTHENTICATION
+
+Previous versions of pppd have provided no control over which IP
+addresses the peer can use.  Thus it is possible for the peer to
+impersonate another host on the local network, leading to various
+security holes.  In addition, the authentication mechanisms were quite
+weak: if the peer refused to agree to authenticate, pppd would print a
+warning message but still allow the link to come up.  The CHAP
+implementation also appeared to be quite broken (has anybody actually
+used it?).  
+
+This new version of pppd addresses these problems.  My aim has been to
+provide system administrators with sufficient access control that PPP
+access to a server machine can be provided to legitimate users without
+fear of compromising the security of the server or the network it's
+on.  In part this is provided by the /etc/ppp/options file, where the
+administrator can place options to require authentication which cannot
+be disabled by users.  Thus the new pppd can made setuid-root and run
+by users.
+
+The behaviour where pppd refuses to run unless the /etc/ppp/options
+file is present and readable by pppd is now the default behaviour.  If
+you really want pppd to run without the presence of the
+/etc/ppp/options file, you will have to include -DREQ_SYSOPTIONS=0 on
+the compilation command line.
+
+The options related to authentication are:
+
+    auth	Require authentication from the peer.  If neither
+		+chap or +pap is also given, either CHAP or PAP
+		authentication will be accepted.
+    +chap	Require CHAP authentication from the peer.
+    +pap	Require PAP authentication from the peer.
+    -chap	Don't agree to authenticate ourselves with the peer
+		using CHAP.
+    -pap	Don't agree to authenticate ourselves using PAP.
+    +ua <f>	Get username and password for authenticating ourselves
+		with the peer using PAP from file <f>.
+    name <n>	Use <n> as the local name for authentication.
+    usehostname	Use this machine's hostname as the local name for
+		authentication.
+    remotename <n>  Use <n> as the name of the peer for authentication.
+    login	If the peer authenticates using PAP, check the
+		supplied username and password against the system
+		password database, and make a wtmp entry.
+    user <n>	Use <n> as the username for authenticating ourselves
+		using PAP.
+
+The defaults are to agree to authenticate if requested, and to not
+require authentication from the peer.  However, pppd will not agree to
+authenticate itself with a particular protocol if it has no secrets
+which could be used to do so.
+
+Authentication is based on secrets, which are selected from secrets
+files (/etc/ppp/pap-secrets for PAP, /etc/ppp/chap-secrets for CHAP).
+Both secrets files have the same format, and both can store secrets
+for several combinations of server (authenticating peer) and client
+(peer being authenticated).  Note that each end can be both a server
+and client, and that different protocols can be used in the two
+directions if desired.
+
+A secrets file is parsed into words as for a options file.  A secret
+is specified by a line containing at least 3 words, in the order
+client, server, secret.  Any following words on the same line are
+taken to be a list of acceptable IP addresses for that client.  If
+there are only 3 words on the line, it is assumed that any IP address
+is OK; to disallow all IP addresses, use "-".  If the secret starts
+with an `@', what follows is assumed to be the name of a file from
+which to read the secret.  A "*" as the client or server name matches
+any name.  When selecting a secret, pppd takes the best match, i.e.
+the match with the fewest wildcards.
+
+Thus a secrets file contains both secrets for use in authenticating
+other hosts, plus secrets which we use for authenticating ourselves to
+others.  Which secret to use is chosen based on the names of the host
+(the `local name') and its peer (the `remote name').  The local name
+is set as follows:
+
+	if the `usehostname' option is given,
+	then the local name is the hostname of this machine
+		(with the domain appended, if given)
+
+	else if the `name' option is given,
+	then use the argument of the first `name' option seen
+
+	else if the local IP address is specified with a
+		host name (e.g. `sirius:')
+	then use that host name
+
+	else use the hostname of this machine
+		(with the domain appended, if given)
+
+When authenticating ourselves using PAP, there is also a `username'
+which is the local name by default, but can be set with the `user'
+option or the `+ua' option.
+
+The remote name is set as follows:
+
+	if the `remotename' option is given,
+	then use the argument of the last `remotename' option seen
+
+	else if the remote IP address is specified with a
+		host name (e.g. `avago:')
+	then use that host name
+
+	else the remote name is the null string "".
+
+Secrets are selected from the PAP secrets file as follows:
+
+- For authenticating the peer, look for a secret with client ==
+username specified in the PAP authenticate-request, and server ==
+local name.
+
+- For authenticating ourselves to the peer, look for a secret with
+client == our username, server == remote name.
+
+When authenticating the peer with PAP, a secret of "" matches any
+password supplied by the peer.  If the password doesn't match the
+secret, the password is encrypted using crypt() and checked against
+the secret again; thus secrets for authenticating the peer can be
+stored in encrypted form.  If the `login' option was specified, the
+username and password are also checked against the system password
+database.  Thus, the system administrator can set up the pap-secrets
+file to allow PPP access only to certain users, and to restrict the
+set of IP addresses that each user can use.
+
+Secrets are selected from the CHAP secrets file as follows:
+
+- For authenticating the peer, look for a secret with client == name
+specified in the CHAP-Response message, and server == local name.
+
+- For authenticating ourselves to the peer, look for a secret with
+client == local name, and server == name specified in the
+CHAP-Challenge message.
+
+Authentication must be satisfactorily completed before IPCP (or any
+other Network Control Protocol) can be started.  If authentication
+fails, pppd will terminated the link (by closing LCP).  If IPCP
+negotiates an unacceptable IP address for the remote host, IPCP will
+be closed.  IP packets cannot be sent or received until IPCP is
+successfully opened.
+
+(some examples needed here perhaps)
+
+
+ROUTING
+
+Setting the addresses on a ppp interface is sufficient to create a
+host route to the remote end of the link.  Sometimes it is desirable
+to add a default route through the remote host, as in the case of a
+machine whose only connection to the Internet is through the ppp
+interface.  The `defaultroute' option causes pppd to create such a
+default route when IPCP comes up, and delete it when the link is
+terminated.
+
+In some cases it is desirable to use proxy ARP, for example on a
+server machine connected to a LAN, in order to allow other hosts to
+communicate with the remote host.  The `proxyarp' option causes pppd
+to look for a network interface (an interface supporting broadcast and
+ARP, which is up and not a point-to-point or loopback interface) on
+the same subnet as the remote host.  If found, pppd creates a
+permanent, published ARP entry with the IP address of the remote host
+and the hardware address of the network interface found.
+
+
+OTHER NEW AND CHANGED OPTIONS
+
+    modem		Use modem control lines (not fully implemented
+			yet)
+    local		Don't use modem control lines
+    persist		Keep reopening connection (not fully
+			implemented yet)
+
+    lcp-restart <n>	Set timeout for LCP retransmissions to <n>
+			seconds (default 3 seconds)
+    lcp-max-terminate <n> Set maximum number of LCP terminate-request
+			transmissions (default 2)
+    lcp-max-configure <n> Set maximum number of LCP configure-request
+			transmissions (default 10)
+    lcp-max-failure <n>	Set maximum number of LCP configure-Naks sent
+			before converting to configure-rejects
+			(default 10)
+
+    ipcp-restart <n>	Set timeout for IPCP retransmissions to <n>
+			seconds (default 3 seconds)
+    ipcp-max-terminate <n> Set maximum number of IPCP
+			terminate-request transmissions (default 2)
+    ipcp-max-configure <n> Set maximum number of IPCP
+			configure-request transmissions (default 10)
+    ipcp-max-failure <n> Set maximum number of IPCP configure-Naks
+			sent before converting to configure-rejects
+			(default 10)
+
+    upap-restart <n>	Set timeout for PAP retransmissions to
+			<n> seconds (default 3 seconds)
+    upap-max-authreq <n> Set maximum number of Authenticate-request
+			retransmissions (default 10)
+
+    chap-restart <n>	Set timeout for CHAP retransmissions to
+			<n> seconds (default 3 seconds)
+    chap-max-challenge <n> Set maximum number of CHAP Challenge
+			retransmissions (default 10)
+    chap-interval <n>	Set the interval between CHAP rechallenges
+			(default 0, meaning infinity)
+
+The -ua option no longer exists.
+
+
+SOFTWARE RESTRUCTURING
+
+Many of the source files for pppd have changed significantly from
+ppp-1.3, upon which it is based.  In particular:
+
+- the macros for system-dependent operations in pppd.h have mostly
+been removed.  Instead these operations are performed by procedures in
+sys-bsd.c (for BSD-4.4ish systems like NetBSD, 386BSD, etc.) or
+sys-str.c (for SunOS-based systems using STREAMS).  (I got sick of
+having to recompile everything every time I wanted to change one of
+those horrible macros.)
+
+- most of the system-dependent code in main.c has also been removed to
+sys-bsd.c and sys-str.c.
+
+- the option processing code in main.c has been removed to options.c.
+
+- the authentication code in main.c has been removed to auth.c, which
+also contains substantial amounts of new code.
+
+- fsm.c has changed significantly, and lcp.c, ipcp.c, and upap.c have
+changed somewhat.  chap.c has also changed significantly.
+
+
+STILL TO DO
+
+* sort out appropriate modem control and implement the persist option
+properly; add an `answer' option for auto-answering a modem.
+
+* add an inactivity timeout and demand dialing.
+
+* implement link quality monitoring.
+
+* implement other network control protocols.
diff --git a/usr.sbin/pppd/args.h b/usr.sbin/pppd/args.h
new file mode 100644
index 0000000..e879838
--- /dev/null
+++ b/usr.sbin/pppd/args.h
@@ -0,0 +1,12 @@
+/*
+ * neat macro from ka9q to "do the right thing" with ansi prototypes
+ * $Id: args.h,v 1.1 1993/11/11 03:54:25 paulus Exp $
+ */
+
+#ifndef __ARGS
+#ifdef __STDC__
+#define __ARGS(x)       x
+#else
+#define __ARGS(x)       ()
+#endif
+#endif
diff --git a/usr.sbin/pppd/callout.h b/usr.sbin/pppd/callout.h
new file mode 100644
index 0000000..115d01c
--- /dev/null
+++ b/usr.sbin/pppd/callout.h
@@ -0,0 +1,18 @@
+/* Note:  This is a copy of /usr/include/sys/callout.h with the c_func */
+/* member of struct callout changed from a pointer to a function of type int*/
+/* to a pointer to a function of type void (generic pointer) as per */
+/* ANSI C */
+
+/* $Id: callout.h,v 1.1 1993/11/11 03:54:25 paulus Exp $ */
+
+#ifndef _ppp_callout_h
+#define _ppp_callout_h
+
+struct	callout {
+	int	c_time;		/* incremental time */
+	caddr_t	c_arg;		/* argument to routine */
+	void	(*c_func)();	/* routine (changed to void (*)() */
+	struct	callout *c_next;
+};
+
+#endif /*!_ppp_callout_h*/
diff --git a/usr.sbin/pppd/lock.c b/usr.sbin/pppd/lock.c
new file mode 100644
index 0000000..0fbbef3
--- /dev/null
+++ b/usr.sbin/pppd/lock.c
@@ -0,0 +1,122 @@
+/*
+ * lock.c - lock/unlock the serial device.
+ *
+ * This code is derived from chat.c.
+ */
+
+static char rcsid[] = "$Id: lock.c,v 1.1 1994/04/18 23:41:52 paulus Exp $";
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <syslog.h>
+
+#ifdef sun
+# if defined(SUNOS) && SUNOS >= 41
+# ifndef HDB
+#  define	HDB
+# endif
+# endif
+#endif
+
+#ifndef LOCK_DIR
+# ifdef __NetBSD__
+# define	PIDSTRING
+# define	LOCK_PREFIX	"/var/spool/lock/LCK.."
+# else
+#  ifdef HDB
+#   define	PIDSTRING
+#   define	LOCK_PREFIX	"/usr/spool/locks/LCK.."
+#  else /* HDB */
+#   define	LOCK_PREFIX	"/usr/spool/uucp/LCK.."
+#  endif /* HDB */
+# endif
+#endif /* LOCK_DIR */
+
+static char *lock_file;
+
+/*
+ *	Create a lock file for the named lock device
+ */
+int
+lock(dev)
+    char *dev;
+{
+    char hdb_lock_buffer[12];
+    int fd, pid, n;
+    char *p;
+
+    if ((p = strrchr(dev, '/')) != NULL)
+	dev = p + 1;
+    lock_file = malloc(strlen(LOCK_PREFIX) + strlen(dev) + 1);
+    if (lock_file == NULL)
+	novm("lock file name");
+    strcat(strcpy(lock_file, LOCK_PREFIX), dev);
+
+    while ((fd = open(lock_file, O_EXCL | O_CREAT | O_RDWR, 0644)) < 0) {
+	if (errno == EEXIST
+	    && (fd = open(lock_file, O_RDONLY, 0)) >= 0) {
+	    /* Read the lock file to find out who has the device locked */
+#ifdef PIDSTRING
+	    n = read(fd, hdb_lock_buffer, 11);
+	    if (n > 0) {
+		hdb_lock_buffer[n] = 0;
+		pid = atoi(hdb_lock_buffer);
+	    }
+#else
+	    n = read(fd, &pid, sizeof(pid));
+#endif
+	    if (n <= 0) {
+		syslog(LOG_ERR, "Can't read pid from lock file %s", lock_file);
+		close(fd);
+	    } else {
+		if (kill(pid, 0) == -1 && errno == ESRCH) {
+		    /* pid no longer exists - remove the lock file */
+		    if (unlink(lock_file) == 0) {
+			close(fd);
+			syslog(LOG_NOTICE, "Removed stale lock on %s (pid %d)",
+			       dev, pid);
+			continue;
+		    } else
+			syslog(LOG_WARNING, "Couldn't remove stale lock on %s",
+			       dev);
+		} else
+		    syslog(LOG_NOTICE, "Device %s is locked by pid %d",
+			   dev, pid);
+	    }
+	    close(fd);
+	} else
+	    syslog(LOG_ERR, "Can't create lock file %s: %m", lock_file);
+	free(lock_file);
+	lock_file = NULL;
+	return -1;
+    }
+
+# ifdef PIDSTRING
+    sprintf(hdb_lock_buffer, "%10d\n", getpid());
+    write(fd, hdb_lock_buffer, 11);
+# else
+    pid = getpid();
+    write(fd, &pid, sizeof pid);
+# endif
+
+    close(fd);
+    return 0;
+}
+
+/*
+ *	Remove our lockfile
+ */
+unlock()
+{
+    if (lock_file) {
+	unlink(lock_file);
+	free(lock_file);
+	lock_file = NULL;
+    }
+}
+
diff --git a/usr.sbin/pppd/ppp.h b/usr.sbin/pppd/ppp.h
new file mode 100644
index 0000000..3d8f870
--- /dev/null
+++ b/usr.sbin/pppd/ppp.h
@@ -0,0 +1,41 @@
+/*
+ * ppp.h - PPP global declarations.
+ *
+ * Copyright (c) 1989 Carnegie Mellon University.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by Carnegie Mellon University.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * $Id: ppp.h,v 1.1 1993/11/11 03:54:25 paulus Exp $
+ */
+
+#ifndef __PPP_H__
+#define __PPP_H__
+
+#define NPPP	1		/* One PPP interface supported (per process) */
+
+/*
+ * Data Link Layer header = Address, Control, Protocol.
+ */
+#define ALLSTATIONS	0xff	/* All-Stations Address */
+#define UI		0x03	/* Unnumbered Information */
+#define LCP		0xc021	/* Link Control Protocol */
+#define IPCP		0x8021	/* IP Control Protocol */
+#define UPAP		0xc023	/* User/Password Authentication Protocol */
+#define CHAP            0xc223  /* Crytpographic Handshake Protocol */
+#define LQR		0xc025	/* Link Quality Report protocol */
+#define IP_VJ_COMP	0x002d	/* VJ TCP compressed IP packet */
+#define DLLHEADERLEN	(sizeof (u_char) + sizeof (u_char) + sizeof (u_short))
+#define MTU		1500	/* Default MTU */
+
+#endif /* __PPP_H__ */
diff --git a/usr.sbin/pppd/sys-linux.c b/usr.sbin/pppd/sys-linux.c
new file mode 100644
index 0000000..306ae4a
--- /dev/null
+++ b/usr.sbin/pppd/sys-linux.c
@@ -0,0 +1,830 @@
+/*
+ * sys-linux.c - System-dependent procedures for setting up
+ * PPP interfaces on Linux systems
+ *
+ * Copyright (c) 1989 Carnegie Mellon University.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by Carnegie Mellon University.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+/*
+ * TODO:
+ */
+
+#include <stdio.h>
+#include <syslog.h>
+#include <string.h>
+#include <time.h>
+#include <memory.h>
+#include <utmp.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <sys/errno.h>
+#include <mntent.h>
+
+#include <net/if.h>
+#include <linux/ppp.h>
+#include <linux/route.h>
+#include <linux/if_ether.h>
+#include <netinet/in.h>
+#include <signal.h>
+
+#include "pppd.h"
+#include "ppp.h"
+#include "fsm.h"
+#include "ipcp.h"
+
+static int initdisc = -1;	/* Initial TTY discipline */
+static int prev_kdebugflag = 0;
+extern int kdebugflag;
+extern u_long netmask;
+
+#define MAX_IFS		32
+
+/* prototypes */
+void die         __ARGS((int));
+
+/*
+ * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
+ * if it exists.
+ */
+
+#define SET_SA_FAMILY(addr, family)			\
+    memset ((char *) &(addr), '\0', sizeof(addr));	\
+    addr.sa_family = (family);
+
+/*
+ * set_kdebugflag - Define the debugging level for the kernel
+ */
+
+int set_kdebugflag (int requested_level)
+{
+    if (ioctl(fd, PPPIOCGDEBUG, &prev_kdebugflag) < 0) {
+	syslog(LOG_ERR, "ioctl(PPPIOCGDEBUG): %m");
+	return (0);
+    }
+
+    if (prev_kdebugflag != requested_level) {
+	if (ioctl(fd, PPPIOCSDEBUG, &requested_level) < 0) {
+	    syslog (LOG_ERR, "ioctl(PPPIOCSDEBUG): %m");
+	    return (0);
+	}
+        syslog(LOG_INFO, "set kernel debugging level to %d", requested_level);
+    }
+    return (1);
+}
+
+/*
+ * establish_ppp - Turn the serial port into a ppp interface.
+ */
+
+void establish_ppp (void)
+{
+    int pppdisc = N_PPP;
+    int sig	= SIGIO;
+
+    if (ioctl(fd, PPPIOCSINPSIG, &sig) == -1) {
+	syslog(LOG_ERR, "ioctl(PPPIOCSINPSIG): %m");
+	die(1);
+    }
+
+    if (ioctl(fd, TIOCEXCL, 0) < 0) {
+	syslog (LOG_WARNING, "ioctl(TIOCEXCL): %m");
+    }
+
+    if (ioctl(fd, TIOCGETD, &initdisc) < 0) {
+	syslog(LOG_ERR, "ioctl(TIOCGETD): %m");
+	die (1);
+    }
+    
+    if (ioctl(fd, TIOCSETD, &pppdisc) < 0) {
+	syslog(LOG_ERR, "ioctl(TIOCSETD): %m");
+	die (1);
+    }
+
+    if (ioctl(fd, PPPIOCGUNIT, &ifunit) < 0) {
+	syslog(LOG_ERR, "ioctl(PPPIOCGUNIT): %m");
+	die (1);
+    }
+
+    set_kdebugflag (kdebugflag);
+}
+
+/*
+ * disestablish_ppp - Restore the serial port to normal operation.
+ * This shouldn't call die() because it's called from die().
+ */
+
+void disestablish_ppp(void)
+{
+    int x;
+    char *s;
+
+    if (initdisc >= 0) {
+        set_kdebugflag (prev_kdebugflag);
+	/*
+	 * Check whether the link seems not to be 8-bit clean.
+	 */
+	if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
+	    s = NULL;
+	    switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
+	    case SC_RCV_B7_0:
+		s = "bit 7 set to 1";
+		break;
+	    case SC_RCV_B7_1:
+		s = "bit 7 set to 0";
+		break;
+	    case SC_RCV_EVNP:
+		s = "odd parity";
+		break;
+	    case SC_RCV_ODDP:
+		s = "even parity";
+		break;
+	    }
+	    if (s != NULL) {
+		syslog(LOG_WARNING, "Serial link is not 8-bit clean:");
+		syslog(LOG_WARNING, "All received characters had %s", s);
+	    }
+	}
+
+    if (ioctl(fd, TIOCSETD, &initdisc) < 0)
+        syslog(LOG_ERR, "ioctl(TIOCSETD): %m");
+
+    if (ioctl(fd, TIOCNXCL, 0) < 0)
+        syslog (LOG_WARNING, "ioctl(TIOCNXCL): %m");
+
+    initdisc = -1;
+    }
+}
+
+/*
+ * output - Output PPP packet.
+ */
+
+void output (int unit, unsigned char *p, int len)
+{
+    if (unit != 0)
+	MAINDEBUG((LOG_WARNING, "output: unit != 0!"));
+
+    if (debug)
+        log_packet(p, len, "sent ");
+    
+    if (write(fd, p, len) < 0) {
+        syslog(LOG_ERR, "write: %m");
+	die(1);
+    }
+}
+
+/*
+ * read_packet - get a PPP packet from the serial device.
+ */
+
+int read_packet (unsigned char *buf)
+{
+    int len;
+  
+    len = read(fd, buf, MTU + DLLHEADERLEN);
+    if (len < 0) {
+	if (errno == EWOULDBLOCK) {
+#if 0
+	    MAINDEBUG((LOG_DEBUG, "read(fd): EWOULDBLOCK"));
+#endif
+	    return -1;
+	}
+	syslog(LOG_ERR, "read(fd): %m");
+	die(1);
+    }
+    return len;
+}
+
+/*
+ * ppp_send_config - configure the transmit characteristics of
+ * the ppp interface.
+ */
+void ppp_send_config (int unit,int mtu,u_long asyncmap,int pcomp,int accomp)
+{
+    u_int x;
+    struct ifreq ifr;
+  
+    MAINDEBUG ((LOG_DEBUG, "send_config: mtu = %d\n", mtu));
+    strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
+    ifr.ifr_mtu = mtu;
+    if (ioctl(s, SIOCSIFMTU, (caddr_t) &ifr) < 0) {
+	syslog(LOG_ERR, "ioctl(SIOCSIFMTU): %m");
+	quit();
+    }
+
+    MAINDEBUG ((LOG_DEBUG, "send_config: asyncmap = %lx\n", asyncmap));
+    if (ioctl(fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
+        syslog(LOG_ERR, "ioctl(PPPIOCSASYNCMAP): %m");
+	quit();
+    }
+    
+    if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
+	syslog(LOG_ERR, "ioctl (PPPIOCGFLAGS): %m");
+	quit();
+    }
+
+    x = pcomp  ? x | SC_COMP_PROT : x & ~SC_COMP_PROT;
+    x = accomp ? x | SC_COMP_AC   : x & ~SC_COMP_AC;
+
+    MAINDEBUG ((LOG_DEBUG, "send_config: flags = %x\n", x));
+    if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &x) < 0) {
+	syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS): %m");
+	quit();
+    }
+}
+
+/*
+ * ppp_set_xaccm - set the extended transmit ACCM for the interface.
+ */
+void
+ppp_set_xaccm(unit, accm)
+    int unit;
+    ext_accm accm;
+{
+    MAINDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
+		accm[0], accm[1], accm[2], accm[3]));
+    if (ioctl(fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY)
+	syslog(LOG_WARNING, "ioctl(set extended ACCM): %m");
+}
+
+/*
+ * ppp_recv_config - configure the receive-side characteristics of
+ * the ppp interface.
+ */
+void ppp_recv_config (int unit,int mru,u_long asyncmap,int pcomp,int accomp)
+{
+    u_int x;
+
+    MAINDEBUG ((LOG_DEBUG, "recv_config: mru = %d\n", mru));
+    if (ioctl(fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
+	syslog(LOG_ERR, "ioctl(PPPIOCSMRU): %m");
+
+    MAINDEBUG ((LOG_DEBUG, "recv_config: asyncmap = %lx\n", asyncmap));
+    if (ioctl(fd, PPPIOCRASYNCMAP, (caddr_t) &asyncmap) < 0) {
+        syslog(LOG_ERR, "ioctl(PPPIOCRASYNCMAP): %m");
+	quit();
+    }
+  
+    if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
+	syslog(LOG_ERR, "ioctl (PPPIOCGFLAGS): %m");
+	quit();
+    }
+
+    x = !accomp? x | SC_REJ_COMP_AC: x &~ SC_REJ_COMP_AC;
+    MAINDEBUG ((LOG_DEBUG, "recv_config: flags = %x\n", x));
+    if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &x) < 0) {
+	syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS): %m");
+	quit();
+    }
+}
+
+/*
+ * sifvjcomp - config tcp header compression
+ */
+
+int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
+{
+    u_int x;
+
+    if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
+	syslog(LOG_ERR, "ioctl (PPPIOCGFLAGS): %m");
+	return 0;
+    }
+
+    x = vjcomp  ? x | SC_COMP_TCP     : x &~ SC_COMP_TCP;
+    x = cidcomp ? x & ~SC_NO_TCP_CCID : x | SC_NO_TCP_CCID;
+
+    if(ioctl(fd, PPPIOCSFLAGS, (caddr_t) &x) < 0) {
+	syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS): %m");
+	return 0;
+    }
+
+    if (vjcomp) {
+        if (ioctl (fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
+	    syslog (LOG_ERR, "ioctl(PPPIOCSFLAGS): %m");
+	    return 0;
+        }
+    }
+
+    return 1;
+}
+
+/*
+ * sifup - Config the interface up and enable IP packets to pass.
+ */
+
+int sifup (int u)
+{
+    struct ifreq ifr;
+
+    strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
+    if (ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
+	syslog(LOG_ERR, "ioctl (SIOCGIFFLAGS): %m");
+	return 0;
+    }
+
+    ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
+    if (ioctl(s, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
+	syslog(LOG_ERR, "ioctl(SIOCSIFFLAGS): %m");
+	return 0;
+    }
+    return 1;
+}
+
+/*
+ * sifdown - Config the interface down and disable IP.
+ */
+
+int sifdown (int u)
+{
+    struct ifreq ifr;
+
+    strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
+    if (ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
+	syslog(LOG_ERR, "ioctl (SIOCGIFFLAGS): %m");
+	return 0;
+    }
+
+    ifr.ifr_flags &= ~IFF_UP;
+    ifr.ifr_flags |= IFF_POINTOPOINT;
+    if (ioctl(s, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
+	syslog(LOG_ERR, "ioctl(SIOCSIFFLAGS): %m");
+	return 0;
+    }
+    return 1;
+}
+
+/*
+ * sifaddr - Config the interface IP addresses and netmask.
+ */
+
+int sifaddr (int unit, int our_adr, int his_adr, int net_mask)
+{
+    struct ifreq   ifr; 
+    struct rtentry rt;
+    
+    SET_SA_FAMILY (ifr.ifr_addr,    AF_INET); 
+    SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET); 
+    SET_SA_FAMILY (ifr.ifr_netmask, AF_INET); 
+
+    strncpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
+/*
+ *  Set our IP address
+ */
+    ((struct sockaddr_in *) &ifr.ifr_addr)->sin_addr.s_addr = our_adr;
+    if (ioctl(s, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
+	if (errno != EEXIST)
+	    syslog (LOG_ERR, "ioctl(SIOCAIFADDR): %m");
+        else
+	    syslog (LOG_WARNING, "ioctl(SIOCAIFADDR): Address already exists");
+        return (0);
+    } 
+/*
+ *  Set the gateway address
+ */
+    ((struct sockaddr_in *) &ifr.ifr_dstaddr)->sin_addr.s_addr = his_adr;
+    if (ioctl(s, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
+	syslog (LOG_ERR, "ioctl(SIOCSIFDSTADDR): %m"); 
+	return (0);
+    } 
+/*
+ *  Set the netmask
+ */
+    if (net_mask != 0) {
+	((struct sockaddr_in *) &ifr.ifr_netmask)->sin_addr.s_addr = net_mask;
+	if (ioctl(s, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
+	    syslog (LOG_ERR, "ioctl(SIOCSIFNETMASK): %m"); 
+	    return (0);
+        } 
+    }
+/*
+ *  Add the device route
+ */
+    memset (&rt, '\0', sizeof (rt));
+
+    SET_SA_FAMILY (rt.rt_dst,     AF_INET);
+    SET_SA_FAMILY (rt.rt_gateway, AF_INET);
+    rt.rt_dev = ifname;  /* MJC */
+
+    ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = 0;
+    ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr     = his_adr;
+    rt.rt_flags = RTF_UP | RTF_HOST;
+
+    if (ioctl(s, SIOCADDRT, &rt) < 0) {
+        syslog (LOG_ERR, "ioctl(SIOCADDRT) device route: %m");
+        return (0);
+    }
+    return 1;
+}
+
+/*
+ * cifaddr - Clear the interface IP addresses, and delete routes
+ * through the interface if possible.
+ */
+
+int cifaddr (int unit, int our_adr, int his_adr)
+{
+    struct rtentry rt;
+/*
+ *  Delete the route through the device
+ */
+    memset (&rt, '\0', sizeof (rt));
+
+    SET_SA_FAMILY (rt.rt_dst,     AF_INET);
+    SET_SA_FAMILY (rt.rt_gateway, AF_INET);
+    rt.rt_dev = ifname;  /* MJC */
+
+    ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = 0;
+    ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr     = his_adr;
+    rt.rt_flags = RTF_UP | RTF_HOST;
+
+    if (ioctl(s, SIOCDELRT, &rt) < 0) {
+        syslog (LOG_ERR, "ioctl(SIOCDELRT) device route: %m");
+        return (0);
+    }
+    return 1;
+}
+
+/*
+ * path_to_route - determine the path to the proc file system data
+ */
+
+FILE *route_fd = (FILE *) 0;
+static char route_buffer [100];
+
+static char *path_to_route (void);
+static int open_route_table (void);
+static void close_route_table (void);
+static int read_route_table (struct rtentry *rt);
+static int defaultroute_exists (void);
+
+/*
+ * path_to_route - find the path to the route tables in the proc file system
+ */
+
+static char *path_to_route (void)
+{
+    struct mntent *mntent;
+    FILE *fp;
+
+    fp = fopen (MOUNTED, "r");
+    if (fp != 0) {
+        while ((mntent = getmntent (fp)) != 0) {
+	    if (strcmp (mntent->mnt_type, MNTTYPE_IGNORE) == 0)
+	        continue;
+
+	    if (strcmp (mntent->mnt_type, "proc") == 0) {
+	        strncpy (route_buffer, mntent->mnt_dir,
+			 sizeof (route_buffer)-10);
+		route_buffer [sizeof (route_buffer)-10] = '\0';
+		strcat (route_buffer, "/net/route");
+
+		fclose (fp);
+		return (route_buffer);
+	    }
+	}
+	fclose (fp);
+    }
+    syslog (LOG_ERR, "proc file system not mounted");
+    return 0;
+}
+
+/*
+ * open_route_table - open the interface to the route table
+ */
+
+static int open_route_table (void)
+{
+    char *path;
+
+    if (route_fd != (FILE *) 0)
+        close_route_table();
+
+    path = path_to_route();
+    if (path == NULL)
+        return 0;
+
+    route_fd = fopen (path, "r");
+    if (route_fd == (FILE *) 0) {
+        syslog (LOG_ERR, "can not open %s: %m", path);
+        return 0;
+    }
+
+    /* read and discard the header line. */
+    if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0) {
+        close_route_table();
+	return 0;
+    }
+    return 1;
+}
+
+/*
+ * close_route_table - close the interface to the route table
+ */
+
+static void close_route_table (void)
+{
+    if (route_fd != (FILE *) 0) {
+        fclose (route_fd);
+        route_fd = (FILE *) 0;
+    }
+}
+
+/*
+ * read_route_table - read the next entry from the route table
+ */
+
+static int read_route_table (struct rtentry *rt)
+{
+    static char delims[] = " \t\n";
+    char *dev_ptr, *ptr, *dst_ptr, *gw_ptr, *flag_ptr;
+
+    if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
+        return 0;
+
+    memset (rt, '\0', sizeof (struct rtentry));
+
+    dev_ptr  = strtok (route_buffer, delims); /* interface name */
+    dst_ptr  = strtok (NULL,         delims); /* destination address */
+    gw_ptr   = strtok (NULL,         delims); /* gateway */
+    flag_ptr = strtok (NULL,         delims); /* flags */
+#if 0
+    ptr      = strtok (NULL,         delims); /* reference count */
+    ptr      = strtok (NULL,         delims); /* useage count */
+    ptr      = strtok (NULL,         delims); /* metric */
+    ptr      = strtok (NULL,         delims); /* mask */
+#endif
+
+    ((struct sockaddr_in *) &rt->rt_dst)->sin_addr.s_addr =
+      strtoul (dst_ptr, NULL, 16);
+
+    ((struct sockaddr_in *) &rt->rt_gateway)->sin_addr.s_addr =
+      strtoul (gw_ptr, NULL, 16);
+
+    rt->rt_flags = (short) strtoul (flag_ptr, NULL, 16);
+    rt->rt_dev   = dev_ptr;
+
+    return 1;
+}
+
+/*
+ * defaultroute_exists - determine if there is a default route
+ */
+
+static int defaultroute_exists (void)
+{
+    struct rtentry rt;
+    int    result = 0;
+
+    if (!open_route_table())
+        return 0;
+
+    while (read_route_table(&rt) != 0) {
+        if (rt.rt_flags & RTF_UP == 0)
+	    continue;
+
+        if (((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr == 0L) {
+	    syslog (LOG_ERR,
+		    "ppp not replacing existing default route to %s[%s]",
+		    rt.rt_dev,
+		    inet_ntoa (((struct sockaddr_in *) &rt.rt_gateway)->
+			       sin_addr.s_addr));
+	    result = 1;
+	    break;
+	}
+    }
+    close_route_table();
+    return result;
+}
+
+/*
+ * sifdefaultroute - assign a default route through the address given.
+ */
+
+int sifdefaultroute (int unit, int gateway)
+{
+    struct rtentry rt;
+
+    if (defaultroute_exists())
+        return 0;
+
+    memset (&rt, '\0', sizeof (rt));
+    SET_SA_FAMILY (rt.rt_dst,     AF_INET);
+    SET_SA_FAMILY (rt.rt_gateway, AF_INET);
+    ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = gateway;
+    
+    rt.rt_flags = RTF_UP | RTF_GATEWAY;
+    if (ioctl(s, SIOCADDRT, &rt) < 0) {
+	syslog (LOG_ERR, "default route ioctl(SIOCADDRT): %m");
+	return 0;
+    }
+    return 1;
+}
+
+/*
+ * cifdefaultroute - delete a default route through the address given.
+ */
+
+int cifdefaultroute (int unit, int gateway)
+{
+    struct rtentry rt;
+  
+    SET_SA_FAMILY (rt.rt_dst,     AF_INET);
+    SET_SA_FAMILY (rt.rt_gateway, AF_INET);
+    ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = gateway;
+    
+    rt.rt_flags = RTF_UP | RTF_GATEWAY;
+    if (ioctl(s, SIOCDELRT, &rt) < 0) {
+	syslog (LOG_ERR, "default route ioctl(SIOCDELRT): %m");
+	return 0;
+    }
+    return 1;
+}
+
+/*
+ * sifproxyarp - Make a proxy ARP entry for the peer.
+ */
+
+int sifproxyarp (int unit, u_long his_adr)
+{
+    struct arpreq arpreq;
+
+    memset (&arpreq, '\0', sizeof(arpreq));
+/*
+ * Get the hardware address of an interface on the same subnet
+ * as our local address.
+ */
+    if (!get_ether_addr(his_adr, &arpreq.arp_ha)) {
+	syslog(LOG_ERR, "Cannot determine ethernet address for proxy ARP");
+	return 0;
+    }
+    
+    SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
+    ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = his_adr;
+    arpreq.arp_flags = ATF_PERM | ATF_PUBL;
+    
+    if (ioctl(s, SIOCSARP, (caddr_t)&arpreq) < 0) {
+	syslog(LOG_ERR, "ioctl(SIOCSARP): %m");
+	return 0;
+    }
+    return 1;
+}
+
+/*
+ * cifproxyarp - Delete the proxy ARP entry for the peer.
+ */
+
+int cifproxyarp (int unit, u_long his_adr)
+{
+    struct arpreq arpreq;
+  
+    memset (&arpreq, '\0', sizeof(arpreq));
+    SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
+    
+    ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = his_adr;
+    if (ioctl(s, SIOCDARP, (caddr_t)&arpreq) < 0) {
+	syslog(LOG_WARNING, "ioctl(SIOCDARP): %m");
+	return 0;
+    }
+    return 1;
+}
+     
+/*
+ * get_ether_addr - get the hardware address of an interface on the
+ * the same subnet as ipaddr.
+ */
+
+int get_ether_addr (u_long ipaddr, struct sockaddr *hwaddr)
+{
+    struct ifreq *ifr, *ifend, *ifp;
+    int i;
+    u_long ina, mask;
+    struct sockaddr_dl *dla;
+    struct ifreq ifreq;
+    struct ifconf ifc;
+    struct ifreq ifs[MAX_IFS];
+    
+    ifc.ifc_len = sizeof(ifs);
+    ifc.ifc_req = ifs;
+    if (ioctl(s, SIOCGIFCONF, &ifc) < 0) {
+	syslog(LOG_ERR, "ioctl(SIOCGIFCONF): %m");
+	return 0;
+    }
+    MAINDEBUG ((LOG_DEBUG, "proxy arp: scanning %d interfaces for IP %s",
+		ifc.ifc_len / sizeof(struct ifreq), ip_ntoa(ipaddr)));
+/*
+ * Scan through looking for an interface with an Internet
+ * address on the same subnet as `ipaddr'.
+ */
+    ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
+    for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
+	if (ifr->ifr_addr.sa_family == AF_INET) {
+	    ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
+	    strncpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
+            MAINDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
+			ifreq.ifr_name));
+/*
+ * Check that the interface is up, and not point-to-point
+ * or loopback.
+ */
+	    if (ioctl(s, SIOCGIFFLAGS, &ifreq) < 0)
+		continue;
+	    if ((ifreq.ifr_flags &
+		 (IFF_UP|IFF_BROADCAST|IFF_POINTOPOINT|IFF_LOOPBACK|IFF_NOARP))
+		!= (IFF_UP|IFF_BROADCAST))
+		continue;
+/*
+ * Get its netmask and check that it's on the right subnet.
+ */
+	    if (ioctl(s, SIOCGIFNETMASK, &ifreq) < 0)
+	        continue;
+	    mask = ((struct sockaddr_in *) &ifreq.ifr_addr)->sin_addr.s_addr;
+	    MAINDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
+			ip_ntoa(ina), ntohl(mask)));
+	    if (((ipaddr ^ ina) & mask) != 0)
+	        continue;
+	    break;
+	}
+    }
+    
+    if (ifr >= ifend)
+        return 0;
+
+    syslog(LOG_INFO, "found interface %s for proxy arp", ifreq.ifr_name);
+/*
+ * Now get the hardware address.
+ */
+    if (ioctl (s, SIOCGIFHWADDR, &ifreq) < 0) {
+        syslog(LOG_ERR, "SIOCGIFHWADDR(%s): %m", ifreq.ifr_name);
+        return 0;
+    }
+
+    hwaddr->sa_family = ARPHRD_ETHER;
+#ifndef old_ifr_hwaddr
+    memcpy (&hwaddr->sa_data, &ifreq.ifr_hwaddr, ETH_ALEN);
+#else
+    memcpy (&hwaddr->sa_data, &ifreq.ifr_hwaddr.sa_data, ETH_ALEN);
+#endif
+
+    MAINDEBUG ((LOG_DEBUG,
+		"proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x",
+		(int) ((unsigned char *) &hwaddr->sa_data)[0],
+		(int) ((unsigned char *) &hwaddr->sa_data)[1],
+		(int) ((unsigned char *) &hwaddr->sa_data)[2],
+		(int) ((unsigned char *) &hwaddr->sa_data)[3],
+		(int) ((unsigned char *) &hwaddr->sa_data)[4],
+		(int) ((unsigned char *) &hwaddr->sa_data)[5]));
+    return 1;
+}
+
+/*
+ * ppp_available - check whether the system has any ppp interfaces
+ * (in fact we check whether we can do an ioctl on ppp0).
+ */
+
+int ppp_available(void)
+{
+    int s, ok;
+    struct ifreq ifr;
+    
+    s = socket(AF_INET, SOCK_DGRAM, 0);
+    if (s < 0)
+	return 1;		/* can't tell - maybe we're not root */
+    
+    strncpy(ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
+    ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
+    close(s);
+    
+    return ok;
+}
+
+int
+logwtmp(line, name, host)
+	char *line, *name, *host;
+{
+    struct utmp ut;
+
+    memset (&ut, 0, sizeof (ut));
+    (void)strncpy(ut.ut_line, line, sizeof(ut.ut_line));
+    (void)strncpy(ut.ut_name, name, sizeof(ut.ut_name));
+    (void)strncpy(ut.ut_host, host, sizeof(ut.ut_host));
+    (void)time(&ut.ut_time);
+	
+    pututline (&ut);		/* Write the line to the proper place */
+    endutent();			/* Indicate operation is complete */
+}
diff --git a/usr.sbin/pppd/sys-str.c b/usr.sbin/pppd/sys-str.c
new file mode 100644
index 0000000..c197d4b
--- /dev/null
+++ b/usr.sbin/pppd/sys-str.c
@@ -0,0 +1,730 @@
+/*
+ * sys-str.c - System-dependent procedures for setting up
+ * PPP interfaces on systems which use the STREAMS ppp interface.
+ *
+ * Copyright (c) 1989 Carnegie Mellon University.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by Carnegie Mellon University.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+/*
+ * TODO:
+ */
+
+#include <stdio.h>
+#include <errno.h>
+#include <syslog.h>
+#include <fcntl.h>
+#include <string.h>
+#include <time.h>
+#include <utmp.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <sys/stream.h>
+#include <sys/stropts.h>
+
+#include <net/if.h>
+#include <net/route.h>
+#include <net/if_arp.h>
+#include <netinet/in.h>
+
+#include "pppd.h"
+#include "ppp.h"
+#include <net/ppp_str.h>
+
+#ifndef ifr_mtu
+#define ifr_mtu		ifr_metric
+#endif
+
+#define	MAXMODULES	10	/* max number of module names to save */
+static struct	modlist {
+    char	modname[FMNAMESZ+1];
+} str_modules[MAXMODULES];
+static int	str_module_count = 0;
+static int	pushed_ppp;
+
+extern int hungup;		/* has the physical layer been disconnected? */
+extern int kdebugflag;
+
+#define PAI_FLAGS_B7_0		0x100
+#define PAI_FLAGS_B7_1		0x200
+#define PAI_FLAGS_PAR_EVEN	0x400
+#define PAI_FLAGS_PAR_ODD	0x800
+#define PAI_FLAGS_HIBITS	0xF00
+
+/*
+ * ppp_available - check if this kernel supports PPP.
+ */
+int
+ppp_available()
+{
+    int fd, ret;
+
+    fd = open("/dev/tty", O_RDONLY, 0);
+    if (fd < 0)
+	return 1;		/* can't find out - assume we have ppp */
+    ret = ioctl(fd, I_FIND, "pppasync") >= 0;
+    close(fd);
+    return ret;
+}
+
+
+/*
+ * establish_ppp - Turn the serial port into a ppp interface.
+ */
+void
+establish_ppp()
+{
+    /* go through and save the name of all the modules, then pop em */
+    for (;;) { 
+	if (ioctl(fd, I_LOOK, str_modules[str_module_count].modname) < 0 ||
+	    ioctl(fd, I_POP, 0) < 0)
+	    break;
+	MAINDEBUG((LOG_DEBUG, "popped stream module : %s",
+		   str_modules[str_module_count].modname));
+	str_module_count++;
+    }
+
+    /* now push the async/fcs module */
+    if (ioctl(fd, I_PUSH, "pppasync") < 0) {
+	syslog(LOG_ERR, "ioctl(I_PUSH, ppp_async): %m");
+	die(1);
+    }
+    /* finally, push the ppp_if module that actually handles the */
+    /* network interface */ 
+    if (ioctl(fd, I_PUSH, "pppif") < 0) {
+	syslog(LOG_ERR, "ioctl(I_PUSH, ppp_if): %m");
+	die(1);
+    }
+    pushed_ppp = 1;
+    if (ioctl(fd, I_SETSIG, S_INPUT) < 0) {
+	syslog(LOG_ERR, "ioctl(I_SETSIG, S_INPUT): %m");
+	die(1);
+    }
+    /* read mode, message non-discard mode */
+    if (ioctl(fd, I_SRDOPT, RMSGN) < 0) {
+	syslog(LOG_ERR, "ioctl(I_SRDOPT, RMSGN): %m");
+	die(1);
+    }
+    /* Flush any waiting messages, or we'll never get SIGPOLL */
+    if (ioctl(fd, I_FLUSH, FLUSHRW) < 0) {
+	syslog(LOG_ERR, "ioctl(I_FLUSH, FLUSHRW): %m");
+	die(1);
+    }
+    /*
+     * Find out which interface we were given.
+     * (ppp_if handles this ioctl)
+     */
+    if (ioctl(fd, SIOCGETU, &ifunit) < 0) {
+	syslog(LOG_ERR, "ioctl(SIOCGETU): %m");
+	die(1);
+    }
+
+    /* Set debug flags in driver */
+    if (ioctl(fd, SIOCSIFDEBUG, &kdebugflag) < 0) {
+	syslog(LOG_ERR, "ioctl(SIOCSIFDEBUG): %m");
+    }
+}
+
+/*
+ * disestablish_ppp - Restore the serial port to normal operation.
+ * It attempts to reconstruct the stream with the previously popped
+ * modules.  This shouldn't call die() because it's called from die().
+ */
+void
+disestablish_ppp()
+{
+    int flags;
+    char *s;
+
+    if (hungup) {
+	/* we can't push or pop modules after the stream has hung up */
+	str_module_count = 0;
+	return;
+    }
+
+    if (pushed_ppp) {
+	/*
+	 * Check whether the link seems not to be 8-bit clean.
+	 */
+	if (ioctl(fd, SIOCGIFDEBUG, (caddr_t) &flags) == 0) {
+	    s = NULL;
+	    switch (~flags & PAI_FLAGS_HIBITS) {
+	    case PAI_FLAGS_B7_0:
+		s = "bit 7 set to 1";
+		break;
+	    case PAI_FLAGS_B7_1:
+		s = "bit 7 set to 0";
+		break;
+	    case PAI_FLAGS_PAR_EVEN:
+		s = "odd parity";
+		break;
+	    case PAI_FLAGS_PAR_ODD:
+		s = "even parity";
+		break;
+	    }
+	    if (s != NULL) {
+		syslog(LOG_WARNING, "Serial link is not 8-bit clean:");
+		syslog(LOG_WARNING, "All received characters had %s", s);
+	    }
+	}
+    }
+
+    while (ioctl(fd, I_POP, 0) == 0)	/* pop any we pushed */
+	;
+    pushed_ppp = 0;
+  
+    for (; str_module_count > 0; str_module_count--) {
+	if (ioctl(fd, I_PUSH, str_modules[str_module_count-1].modname)) {
+	    syslog(LOG_WARNING, "str_restore: couldn't push module %s: %m",
+		   str_modules[str_module_count-1].modname);
+	} else {
+	    MAINDEBUG((LOG_INFO, "str_restore: pushed module %s",
+		       str_modules[str_module_count-1].modname));
+	}
+    }
+}
+
+
+/*
+ * output - Output PPP packet.
+ */
+void
+output(unit, p, len)
+    int unit;
+    u_char *p;
+    int len;
+{
+    struct strbuf	str;
+
+    if (unit != 0)
+	MAINDEBUG((LOG_WARNING, "output: unit != 0!"));
+    if (debug)
+	log_packet(p, len, "sent ");
+
+    str.len = len;
+    str.buf = (caddr_t) p;
+    if(putmsg(fd, NULL, &str, 0) < 0) {
+	syslog(LOG_ERR, "putmsg: %m");
+	die(1);
+    }
+}
+
+
+/*
+ * read_packet - get a PPP packet from the serial device.
+ */
+int
+read_packet(buf)
+    u_char *buf;
+{
+    struct strbuf str;
+    int len, i;
+
+    str.maxlen = MTU+DLLHEADERLEN;
+    str.buf = (caddr_t) buf;
+    i = 0;
+    len = getmsg(fd, NULL, &str, &i);
+    if (len < 0) {
+	if (errno == EAGAIN || errno == EWOULDBLOCK) {
+	    return -1;
+	}
+	syslog(LOG_ERR, "getmsg(fd) %m");
+	die(1);
+    }
+    if (len) 
+	MAINDEBUG((LOG_DEBUG, "getmsg returned 0x%x",len));
+
+    if (str.len < 0) {
+	MAINDEBUG((LOG_DEBUG, "getmsg short return length %d", str.len));
+	return -1;
+    }
+
+    return str.len;
+}
+
+
+/*
+ * ppp_send_config - configure the transmit characteristics of
+ * the ppp interface.
+ */
+void
+ppp_send_config(unit, mtu, asyncmap, pcomp, accomp)
+    int unit, mtu;
+    u_long asyncmap;
+    int pcomp, accomp;
+{
+    char c;
+    struct ifreq ifr;
+
+    strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
+    ifr.ifr_mtu = mtu;
+    if (ioctl(s, SIOCSIFMTU, (caddr_t) &ifr) < 0) {
+	syslog(LOG_ERR, "ioctl(SIOCSIFMTU): %m");
+	quit();
+    }
+
+    if(ioctl(fd, SIOCSIFASYNCMAP, (caddr_t) &asyncmap) < 0) {
+	syslog(LOG_ERR, "ioctl(SIOCSIFASYNCMAP): %m");
+	quit();
+    }
+
+    c = (pcomp? 1: 0);
+    if(ioctl(fd, SIOCSIFCOMPPROT, &c) < 0) {
+	syslog(LOG_ERR, "ioctl(SIOCSIFCOMPPROT): %m");
+	quit();
+    }
+
+    c = (accomp? 1: 0);
+    if(ioctl(fd, SIOCSIFCOMPAC, &c) < 0) {
+	syslog(LOG_ERR, "ioctl(SIOCSIFCOMPAC): %m");
+	quit();
+    }
+}
+
+
+/*
+ * ppp_set_xaccm - set the extended transmit ACCM for the interface.
+ */
+void
+ppp_set_xaccm(unit, accm)
+    int unit;
+    ext_accm accm;
+{
+    if (ioctl(fd, SIOCSIFXASYNCMAP, accm) < 0 && errno != ENOTTY)
+	syslog(LOG_WARNING, "ioctl(set extended ACCM): %m");
+}
+
+
+/*
+ * ppp_recv_config - configure the receive-side characteristics of
+ * the ppp interface.
+ */
+void
+ppp_recv_config(unit, mru, asyncmap, pcomp, accomp)
+    int unit, mru;
+    u_long asyncmap;
+    int pcomp, accomp;
+{
+    char c;
+
+    if (ioctl(fd, SIOCSIFMRU, &mru) < 0) {
+	syslog(LOG_ERR, "ioctl(SIOCSIFMRU): %m");
+    }
+
+    if (ioctl(fd, SIOCSIFRASYNCMAP, (caddr_t) &asyncmap) < 0) {
+	syslog(LOG_ERR, "ioctl(SIOCSIFRASYNCMAP): %m");
+    }
+
+    c = 2 + (pcomp? 1: 0);
+    if(ioctl(fd, SIOCSIFCOMPPROT, &c) < 0) {
+	syslog(LOG_ERR, "ioctl(SIOCSIFCOMPPROT): %m");
+    }
+
+    c = 2 + (accomp? 1: 0);
+    if (ioctl(fd, SIOCSIFCOMPAC, &c) < 0) {
+	syslog(LOG_ERR, "ioctl(SIOCSIFCOMPAC): %m");
+    }
+}
+
+/*
+ * sifvjcomp - config tcp header compression
+ */
+int
+sifvjcomp(u, vjcomp, cidcomp, maxcid)
+    int u, vjcomp, cidcomp, maxcid;
+{
+    char x;
+
+    x = (vjcomp? 1: 0) + (cidcomp? 0: 2) + (maxcid << 4);
+    if (ioctl(fd, SIOCSIFVJCOMP, (caddr_t) &x) < 0) {
+	syslog(LOG_ERR, "ioctl(SIOCSIFVJCOMP): %m");
+	return 0;
+    }
+    return 1;
+}
+
+/*
+ * sifup - Config the interface up.
+ */
+int
+sifup(u)
+    int u;
+{
+    struct ifreq ifr;
+
+    strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
+    if (ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
+	syslog(LOG_ERR, "ioctl (SIOCGIFFLAGS): %m");
+	return 0;
+    }
+    ifr.ifr_flags |= IFF_UP;
+    if (ioctl(s, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
+	syslog(LOG_ERR, "ioctl(SIOCSIFFLAGS): %m");
+	return 0;
+    }
+    return 1;
+}
+
+/*
+ * sifdown - Config the interface down.
+ */
+int
+sifdown(u)
+    int u;
+{
+    struct ifreq ifr;
+    strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
+    if (ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
+	syslog(LOG_ERR, "ioctl (SIOCGIFFLAGS): %m");
+	return 0;
+    }
+    ifr.ifr_flags &= ~IFF_UP;
+    if (ioctl(s, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
+	syslog(LOG_ERR, "ioctl(SIOCSIFFLAGS): %m");
+	return 0;
+    }
+    return 1;
+}
+
+/*
+ * SET_SA_FAMILY - initialize a struct sockaddr, setting the sa_family field.
+ */
+#define SET_SA_FAMILY(addr, family)		\
+    BZERO((char *) &(addr), sizeof(addr));	\
+    addr.sa_family = (family);
+
+/*
+ * sifaddr - Config the interface IP addresses and netmask.
+ */
+int
+sifaddr(u, o, h, m)
+    int u;
+    u_long o, h, m;
+{
+    int ret;
+    struct ifreq ifr;
+
+    ret = 1;
+    strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
+    SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
+    ((struct sockaddr_in *) &ifr.ifr_addr)->sin_addr.s_addr = o;
+    if (ioctl(s, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
+	syslog(LOG_ERR, "ioctl(SIOCSIFADDR): %m");
+	ret = 0;
+    }
+    ((struct sockaddr_in *) &ifr.ifr_dstaddr)->sin_addr.s_addr = h;
+    if (ioctl(s, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
+	syslog(LOG_ERR, "ioctl(SIOCSIFDSTADDR): %m");
+	ret = 0;
+    }
+    if (m != 0) {
+	((struct sockaddr_in *) &ifr.ifr_addr)->sin_addr.s_addr = m;
+	syslog(LOG_INFO, "Setting interface mask to %s\n", ip_ntoa(m));
+	if (ioctl(s, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
+	    syslog(LOG_ERR, "ioctl(SIOCSIFNETMASK): %m");
+	    ret = 0;
+	}
+    }
+    return ret;
+}
+
+/*
+ * cifaddr - Clear the interface IP addresses, and delete routes
+ * through the interface if possible.
+ */
+int
+cifaddr(u, o, h)
+    int u;
+    u_long o, h;
+{
+    struct rtentry rt;
+
+    SET_SA_FAMILY(rt.rt_dst, AF_INET);
+    ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr = h;
+    SET_SA_FAMILY(rt.rt_gateway, AF_INET);
+    ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = o;
+    rt.rt_flags = RTF_HOST;
+    if (ioctl(s, SIOCDELRT, (caddr_t) &rt) < 0) {
+	syslog(LOG_ERR, "ioctl(SIOCDELRT): %m");
+	return 0;
+    }
+    return 1;
+}
+
+/*
+ * sifdefaultroute - assign a default route through the address given.
+ */
+int
+sifdefaultroute(u, g)
+    int u;
+    u_long g;
+{
+    struct rtentry rt;
+
+    SET_SA_FAMILY(rt.rt_dst, AF_INET);
+    SET_SA_FAMILY(rt.rt_gateway, AF_INET);
+    ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = g;
+    rt.rt_flags = RTF_GATEWAY;
+    if (ioctl(s, SIOCADDRT, &rt) < 0) {
+	syslog(LOG_ERR, "default route ioctl(SIOCADDRT): %m");
+	return 0;
+    }
+    return 1;
+}
+
+/*
+ * cifdefaultroute - delete a default route through the address given.
+ */
+int
+cifdefaultroute(u, g)
+    int u;
+    u_long g;
+{
+    struct rtentry rt;
+
+    SET_SA_FAMILY(rt.rt_dst, AF_INET);
+    SET_SA_FAMILY(rt.rt_gateway, AF_INET);
+    ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = g;
+    rt.rt_flags = RTF_GATEWAY;
+    if (ioctl(s, SIOCDELRT, &rt) < 0) {
+	syslog(LOG_ERR, "default route ioctl(SIOCDELRT): %m");
+	return 0;
+    }
+    return 1;
+}
+
+/*
+ * sifproxyarp - Make a proxy ARP entry for the peer.
+ */
+int
+sifproxyarp(unit, hisaddr)
+    int unit;
+    u_long hisaddr;
+{
+    struct arpreq arpreq;
+
+    BZERO(&arpreq, sizeof(arpreq));
+
+    /*
+     * Get the hardware address of an interface on the same subnet
+     * as our local address.
+     */
+    if (!get_ether_addr(hisaddr, &arpreq.arp_ha)) {
+	syslog(LOG_WARNING, "Cannot determine ethernet address for proxy ARP");
+	return 0;
+    }
+
+    SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
+    ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = hisaddr;
+    arpreq.arp_flags = ATF_PERM | ATF_PUBL;
+    if (ioctl(s, SIOCSARP, (caddr_t)&arpreq) < 0) {
+	syslog(LOG_ERR, "ioctl(SIOCSARP): %m");
+	return 0;
+    }
+
+    return 1;
+}
+
+/*
+ * cifproxyarp - Delete the proxy ARP entry for the peer.
+ */
+int
+cifproxyarp(unit, hisaddr)
+    int unit;
+    u_long hisaddr;
+{
+    struct arpreq arpreq;
+
+    BZERO(&arpreq, sizeof(arpreq));
+    SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
+    ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = hisaddr;
+    if (ioctl(s, SIOCDARP, (caddr_t)&arpreq) < 0) {
+	syslog(LOG_ERR, "ioctl(SIOCDARP): %m");
+	return 0;
+    }
+    return 1;
+}
+
+/*
+ * get_ether_addr - get the hardware address of an interface on the
+ * the same subnet as ipaddr.  Code borrowed from myetheraddr.c
+ * in the cslip-2.6 distribution, which is subject to the following
+ * copyright notice (which also applies to logwtmp below):
+ *
+ * Copyright (c) 1990, 1992 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that: (1) source code distributions
+ * retain the above copyright notice and this paragraph in its entirety, (2)
+ * distributions including binary code include the above copyright notice and
+ * this paragraph in its entirety in the documentation or other materials
+ * provided with the distribution, and (3) all advertising materials mentioning
+ * features or use of this software display the following acknowledgement:
+ * ``This product includes software developed by the University of California,
+ * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
+ * the University nor the names of its contributors may be used to endorse
+ * or promote products derived from this software without specific prior
+ * written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#include <fcntl.h>
+#include <nlist.h>
+#include <kvm.h>
+#include <arpa/inet.h>
+
+/* XXX SunOS 4.1 defines this and 3.5 doesn't... */
+#ifdef _nlist_h
+#define SUNOS4
+#endif
+
+#ifdef SUNOS4
+#include <netinet/in_var.h>
+#endif
+#include <netinet/if_ether.h>
+
+/* Cast a struct sockaddr to a structaddr_in */
+#define SATOSIN(sa) ((struct sockaddr_in *)(sa))
+
+/* Determine if "bits" is set in "flag" */
+#define ALLSET(flag, bits) (((flag) & (bits)) == (bits))
+
+static struct nlist nl[] = {
+#define N_IFNET 0
+	{ "_ifnet" },
+	{ 0 }
+};
+
+static void kread();
+
+int
+get_ether_addr(ipaddr, hwaddr)
+    u_long ipaddr;
+    struct sockaddr *hwaddr;
+{
+    register kvm_t *kd;
+    register struct ifnet *ifp;
+    register struct arpcom *ac;
+    struct arpcom arpcom;
+    struct in_addr *inp;
+#ifdef SUNOS4
+    register struct ifaddr *ifa;
+    register struct in_ifaddr *in;
+    union {
+	struct ifaddr ifa;
+	struct in_ifaddr in;
+    } ifaddr;
+#endif
+    u_long addr, mask;
+
+    /* Open kernel memory for reading */
+    kd = kvm_open(0, 0, 0, O_RDONLY, NULL);
+    if (kd == 0) {
+	syslog(LOG_ERR, "kvm_open: %m");
+	return 0;
+    }
+
+    /* Fetch namelist */
+    if (kvm_nlist(kd, nl) != 0) {
+	syslog(LOG_ERR, "kvm_nlist failed");
+	return 0;
+    }
+
+    ac = &arpcom;
+    ifp = &arpcom.ac_if;
+#ifdef SUNOS4
+    ifa = &ifaddr.ifa;
+    in = &ifaddr.in;
+#endif
+
+    if (kvm_read(kd, nl[N_IFNET].n_value, (char *)&addr, sizeof(addr))
+	!= sizeof(addr)) {
+	syslog(LOG_ERR, "error reading ifnet addr");
+	return 0;
+    }
+    for ( ; addr; addr = (u_long)ifp->if_next) {
+	if (kvm_read(kd, addr, (char *)ac, sizeof(*ac)) != sizeof(*ac)) {
+	    syslog(LOG_ERR, "error reading ifnet");
+	    return 0;
+	}
+
+	/* Only look at configured, broadcast interfaces */
+	if (!ALLSET(ifp->if_flags, IFF_UP | IFF_BROADCAST))
+	    continue;
+#ifdef SUNOS4
+	/* This probably can't happen... */
+	if (ifp->if_addrlist == 0)
+	    continue;
+#endif
+
+	/* Get interface ip address */
+#ifdef SUNOS4
+	if (kvm_read(kd, (u_long)ifp->if_addrlist, (char *)&ifaddr,
+		     sizeof(ifaddr)) != sizeof(ifaddr)) {
+	    syslog(LOG_ERR, "error reading ifaddr");
+	    return 0;
+	}
+	inp = &SATOSIN(&ifa->ifa_addr)->sin_addr;
+#else
+	inp = &SATOSIN(&ifp->if_addr)->sin_addr;
+#endif
+
+	/* Check if this interface on the right subnet */
+#ifdef SUNOS4
+	mask = in->ia_subnetmask;
+#else
+	mask = ifp->if_subnetmask;
+#endif
+	if ((ipaddr & mask) != (inp->s_addr & mask))
+	    continue;
+
+	/* Copy out the local ethernet address */
+	hwaddr->sa_family = AF_UNSPEC;
+	BCOPY((caddr_t) &arpcom.ac_enaddr, hwaddr->sa_data,
+	      sizeof(arpcom.ac_enaddr));
+	return 1;		/* success! */
+    }
+
+    /* couldn't find one */
+    return 0;
+}
+
+#define	WTMPFILE	"/usr/adm/wtmp"
+
+int
+logwtmp(line, name, host)
+    char *line, *name, *host;
+{
+    int fd;
+    struct stat buf;
+    struct utmp ut;
+
+    if ((fd = open(WTMPFILE, O_WRONLY|O_APPEND, 0)) < 0)
+	return;
+    if (!fstat(fd, &buf)) {
+	(void)strncpy(ut.ut_line, line, sizeof(ut.ut_line));
+	(void)strncpy(ut.ut_name, name, sizeof(ut.ut_name));
+	(void)strncpy(ut.ut_host, host, sizeof(ut.ut_host));
+	(void)time(&ut.ut_time);
+	if (write(fd, (char *)&ut, sizeof(struct utmp)) != sizeof(struct utmp))
+	    (void)ftruncate(fd, buf.st_size);
+    }
+    close(fd);
+}
diff --git a/usr.sbin/pppd/sys-ultrix.c b/usr.sbin/pppd/sys-ultrix.c
new file mode 100644
index 0000000..ca8f2a4
--- /dev/null
+++ b/usr.sbin/pppd/sys-ultrix.c
@@ -0,0 +1,663 @@
+/*
+ * sys-ultrix.c - System-dependent procedures for setting up
+ * PPP interfaces on Ultrix systems.
+ *
+ * Copyright (c) 1989 Carnegie Mellon University.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by Carnegie Mellon University.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#ifndef lint
+static char rcsid[] = "$Id: sys-ultrix.c,v 1.4 1994/05/25 06:30:49 paulus Exp $";
+#endif
+
+/*
+ * TODO:
+ */
+
+#include <syslog.h>
+#include <utmp.h>
+#include <sys/types.h>
+#include <sys/file.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <sys/time.h>
+#include <sys/errno.h>
+#include <sys/stat.h>
+
+#include <net/if.h>
+
+#include <net/if_ppp.h>
+#include <net/route.h>
+#include <netinet/in.h>
+
+#include "pppd.h"
+#include "ppp.h"
+
+static int initdisc = -1;		/* Initial TTY discipline */
+extern int kdebugflag;
+
+/*
+ * establish_ppp - Turn the serial port into a ppp interface.
+ */
+void
+establish_ppp()
+{
+    int pppdisc = PPPDISC;
+    int x;
+
+    if (ioctl(fd, TIOCGETD, &initdisc) < 0) {
+	syslog(LOG_ERR, "ioctl(TIOCGETD): %m");
+	die(1);
+    }
+    if (ioctl(fd, TIOCSETD, &pppdisc) < 0) {
+	syslog(LOG_ERR, "ioctl(TIOCSETD): %m");
+	die(1);
+    }
+
+    /*
+     * Find out which interface we were given.
+     */
+    if (ioctl(fd, PPPIOCGUNIT, &ifunit) < 0) {	
+	syslog(LOG_ERR, "ioctl(PPPIOCGUNIT): %m");
+	die(1);
+    }
+
+    /*
+     * Enable debug in the driver if requested.
+     */
+    if (kdebugflag) {
+	if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
+	    syslog(LOG_WARNING, "ioctl (PPPIOCGFLAGS): %m");
+	} else {
+	    x |= (kdebugflag & 0xFF) * SC_DEBUG;
+	    if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &x) < 0)
+		syslog(LOG_WARNING, "ioctl(PPPIOCSFLAGS): %m");
+	}
+    }
+}
+
+
+/*
+ * disestablish_ppp - Restore the serial port to normal operation.
+ * This shouldn't call die() because it's called from die().
+ */
+void
+disestablish_ppp()
+{
+    int x;
+    char *s;
+
+    if (initdisc >= 0) {
+	/*
+	 * Check whether the link seems not to be 8-bit clean.
+	 */
+	if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
+	    s = NULL;
+	    switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
+	    case SC_RCV_B7_0:
+		s = "bit 7 set to 1";
+		break;
+	    case SC_RCV_B7_1:
+		s = "bit 7 set to 0";
+		break;
+	    case SC_RCV_EVNP:
+		s = "odd parity";
+		break;
+	    case SC_RCV_ODDP:
+		s = "even parity";
+		break;
+	    }
+	    if (s != NULL) {
+		syslog(LOG_WARNING, "Serial link is not 8-bit clean:");
+		syslog(LOG_WARNING, "All received characters had %s", s);
+	    }
+	}
+	if (ioctl(fd, TIOCSETD, &initdisc) < 0)
+	    syslog(LOG_ERR, "ioctl(TIOCSETD): %m");
+    }
+}
+
+
+/*
+ * output - Output PPP packet.
+ */
+void
+output(unit, p, len)
+    int unit;
+    u_char *p;
+    int len;
+{
+    if (unit != 0)
+	MAINDEBUG((LOG_WARNING, "output: unit != 0!"));
+    if (debug)
+	log_packet(p, len, "sent ");
+
+    if (write(fd, p, len) < 0) {
+	syslog(LOG_ERR, "write: %m");
+	die(1);
+    }
+}
+
+
+/*
+ * read_packet - get a PPP packet from the serial device.
+ */
+int
+read_packet(buf)
+    u_char *buf;
+{
+    int len;
+
+    if ((len = read(fd, buf, MTU + DLLHEADERLEN)) < 0) {
+	if (errno == EWOULDBLOCK) {
+	    MAINDEBUG((LOG_DEBUG, "read(fd): EWOULDBLOCK"));
+	    return -1;
+	}
+	syslog(LOG_ERR, "read(fd): %m");
+	die(1);
+    }
+    return len;
+}
+
+
+/*
+ * ppp_send_config - configure the transmit characteristics of
+ * the ppp interface.
+ */
+void
+ppp_send_config(unit, mtu, asyncmap, pcomp, accomp)
+    int unit, mtu;
+    u_long asyncmap;
+    int pcomp, accomp;
+{
+    u_int x;
+    struct ifreq ifr;
+
+    strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
+    ifr.ifr_mtu = mtu;
+    if (ioctl(s, SIOCSIFMTU, (caddr_t) &ifr) < 0) {
+	syslog(LOG_ERR, "ioctl(SIOCSIFMTU): %m");
+	quit();
+    }
+
+    if (ioctl(fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
+	syslog(LOG_ERR, "ioctl(PPPIOCSASYNCMAP): %m");
+	quit();
+    }
+
+    if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
+	syslog(LOG_ERR, "ioctl (PPPIOCGFLAGS): %m");
+	quit();
+    }
+    x = pcomp? x | SC_COMP_PROT: x &~ SC_COMP_PROT;
+    x = accomp? x | SC_COMP_AC: x &~ SC_COMP_AC;
+    if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &x) < 0) {
+	syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS): %m");
+	quit();
+    }
+}
+
+
+/*
+ * ppp_set_xaccm - set the extended transmit ACCM for the interface.
+ */
+void
+ppp_set_xaccm(unit, accm)
+    int unit;
+    ext_accm accm;
+{
+    if (ioctl(fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY)
+	syslog(LOG_WARNING, "ioctl(set extended ACCM): %m");
+}
+
+
+/*
+ * ppp_recv_config - configure the receive-side characteristics of
+ * the ppp interface.
+ */
+void
+ppp_recv_config(unit, mru, asyncmap, pcomp, accomp)
+    int unit, mru;
+    u_long asyncmap;
+    int pcomp, accomp;
+{
+    int x;
+
+    if (ioctl(fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
+	syslog(LOG_ERR, "ioctl(PPPIOCSMRU): %m");
+	quit();
+    }
+    if (ioctl(fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
+	syslog(LOG_ERR, "ioctl(PPPIOCSRASYNCMAP): %m");
+	quit();
+    }
+    if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
+	syslog(LOG_ERR, "ioctl (PPPIOCGFLAGS): %m");
+	quit();
+    }
+    x = !accomp? x | SC_REJ_COMP_AC: x &~ SC_REJ_COMP_AC;
+    if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &x) < 0) {
+	syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS): %m");
+	quit();
+    }
+}
+
+/*
+ * sifvjcomp - config tcp header compression
+ */
+int
+sifvjcomp(u, vjcomp, cidcomp, maxcid)
+    int u, vjcomp, cidcomp, maxcid;
+{
+    u_int x;
+
+    if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
+	syslog(LOG_ERR, "ioctl (PPPIOCGFLAGS): %m");
+	return 0;
+    }
+    x = vjcomp ? x | SC_COMP_TCP: x &~ SC_COMP_TCP;
+    x = cidcomp? x & ~SC_NO_TCP_CCID: x | SC_NO_TCP_CCID;
+    if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &x) < 0) {
+	syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS): %m");
+	return 0;
+    }
+    if (ioctl(fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
+	syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS): %m");
+	return 0;
+    }
+    return 1;
+}
+
+/*
+ * sifup - Config the interface up and enable IP packets to pass.
+ */
+int
+sifup(u)
+{
+    struct ifreq ifr;
+    u_int x;
+
+    strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
+    if (ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
+	syslog(LOG_ERR, "ioctl (SIOCGIFFLAGS): %m");
+	return 0;
+    }
+    ifr.ifr_flags |= IFF_UP;
+    if (ioctl(s, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
+	syslog(LOG_ERR, "ioctl(SIOCSIFFLAGS): %m");
+	return 0;
+    }
+    if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
+	syslog(LOG_ERR, "ioctl (PPPIOCGFLAGS): %m");
+	return 0;
+    }
+    x |= SC_ENABLE_IP;
+    if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &x) < 0) {
+	syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS): %m");
+	return 0;
+    }
+    return 1;
+}
+
+/*
+ * sifdown - Config the interface down and disable IP.
+ */
+int
+sifdown(u)
+{
+    struct ifreq ifr;
+    u_int x;
+    int rv;
+
+    rv = 1;
+    if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
+	syslog(LOG_ERR, "ioctl (PPPIOCGFLAGS): %m");
+	rv = 0;
+    } else {
+	x &= ~SC_ENABLE_IP;
+	if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &x) < 0) {
+	    syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS): %m");
+	    rv = 0;
+	}
+    }
+    strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
+    if (ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
+	syslog(LOG_ERR, "ioctl (SIOCGIFFLAGS): %m");
+	rv = 0;
+    } else {
+	ifr.ifr_flags &= ~IFF_UP;
+	if (ioctl(s, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
+	    syslog(LOG_ERR, "ioctl(SIOCSIFFLAGS): %m");
+	    rv = 0;
+	}
+    }
+    return rv;
+}
+
+/*
+ * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
+ * if it exists.
+ */
+#define SET_SA_FAMILY(addr, family)             \
+    BZERO((char *) &(addr), sizeof(addr));      \
+    addr.sa_family = (family); 
+
+/*
+ * sifaddr - Config the interface IP addresses and netmask.
+ */
+int
+sifaddr(u, o, h, m)
+{
+    int ret;
+    struct ifreq ifr;
+
+    ret = 1;
+    strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
+    SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
+    ((struct sockaddr_in *) &ifr.ifr_addr)->sin_addr.s_addr = o;
+    if (ioctl(s, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
+        syslog(LOG_ERR, "ioctl(SIOCSIFADDR): %m");
+        ret = 0;
+    }
+    ((struct sockaddr_in *) &ifr.ifr_dstaddr)->sin_addr.s_addr = h;
+    if (ioctl(s, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
+        syslog(LOG_ERR, "ioctl(SIOCSIFDSTADDR): %m");
+        ret = 0;
+    }
+    if (m != 0) {
+        ((struct sockaddr_in *) &ifr.ifr_addr)->sin_addr.s_addr = m;
+        syslog(LOG_INFO, "Setting interface mask to %s\n", ip_ntoa(m));
+        if (ioctl(s, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
+            syslog(LOG_ERR, "ioctl(SIOCSIFNETMASK): %m");
+            ret = 0;
+        }
+    }
+    return ret;
+}
+
+/*
+ * cifaddr - Clear the interface IP addresses, and delete routes
+ * through the interface if possible.
+ */
+int
+cifaddr(u, o, h)
+{
+    struct rtentry rt;
+
+    SET_SA_FAMILY(rt.rt_dst, AF_INET);
+    ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr = h;
+    SET_SA_FAMILY(rt.rt_gateway, AF_INET);
+    ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = o;
+    rt.rt_flags = RTF_HOST;
+    if (ioctl(s, SIOCDELRT, (caddr_t) &rt) < 0) {
+        syslog(LOG_ERR, "ioctl(SIOCDELRT): %m");
+        return 0;
+    }
+    return 1;
+}
+
+/*
+ * sifdefaultroute - assign a default route through the address given.
+ */
+int
+sifdefaultroute(u, g)
+{
+    struct rtentry rt;
+
+    SET_SA_FAMILY(rt.rt_dst, AF_INET);
+    SET_SA_FAMILY(rt.rt_gateway, AF_INET);
+    ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = g;
+    rt.rt_flags = RTF_GATEWAY;
+    if (ioctl(s, SIOCADDRT, &rt) < 0) {
+        syslog(LOG_ERR, "default route ioctl(SIOCADDRT): %m");
+        return 0;
+    }
+    return 1;
+}
+
+/*
+ * cifdefaultroute - delete a default route through the address given.
+ */
+int
+cifdefaultroute(u, g)
+{
+    struct rtentry rt;
+
+    SET_SA_FAMILY(rt.rt_dst, AF_INET);
+    SET_SA_FAMILY(rt.rt_gateway, AF_INET);
+    ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = g;
+    rt.rt_flags = RTF_GATEWAY;
+    if (ioctl(s, SIOCDELRT, &rt) < 0)
+        syslog(LOG_WARNING, "default route ioctl(SIOCDELRT): %m");
+}
+
+/*
+ * sifproxyarp - Make a proxy ARP entry for the peer.
+ */
+int
+sifproxyarp(unit, hisaddr)
+    int unit;
+    u_long hisaddr;
+{
+    struct arpreq arpreq;
+
+    BZERO(&arpreq, sizeof(arpreq));
+
+    /*
+     * Get the hardware address of an interface on the same subnet
+     * as our local address.
+     */
+    if (!get_ether_addr(hisaddr, &arpreq.arp_ha)) {
+	syslog(LOG_ERR, "Cannot determine ethernet address for proxy ARP");
+	return 0;
+    }
+
+    SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
+    ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = hisaddr;
+    arpreq.arp_flags = ATF_PERM | ATF_PUBL;
+    if (ioctl(s, SIOCSARP, (caddr_t)&arpreq) < 0) {
+	syslog(LOG_ERR, "ioctl(SIOCSARP): %m");
+	return 0;
+    }
+
+    return 1;
+}
+
+/*
+ * cifproxyarp - Delete the proxy ARP entry for the peer.
+ */
+int
+cifproxyarp(unit, hisaddr)
+    int unit;
+    u_long hisaddr;
+{
+    struct arpreq arpreq;
+
+    BZERO(&arpreq, sizeof(arpreq));
+    SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
+    ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = hisaddr;
+    if (ioctl(s, SIOCDARP, (caddr_t)&arpreq) < 0) {
+	syslog(LOG_WARNING, "ioctl(SIOCDARP): %m");
+	return 0;
+    }
+    return 1;
+}
+
+/*
+ * get_ether_addr - get the hardware address of an interface on the
+ * the same subnet as ipaddr.
+ */
+#define MAX_IFS		32
+
+int
+get_ether_addr(ipaddr, hwaddr)
+    u_long ipaddr;
+    struct sockaddr *hwaddr;
+{
+    struct ifreq *ifr, *ifend, *ifp;
+    u_long ina, mask;
+    struct sockaddr_dl *dla;
+    struct ifreq ifreq;
+    struct ifconf ifc;
+    struct ifreq ifs[MAX_IFS];
+
+    ifc.ifc_len = sizeof(ifs);
+    ifc.ifc_req = ifs;
+    if (ioctl(s, SIOCGIFCONF, &ifc) < 0) {
+        syslog(LOG_ERR, "ioctl(SIOCGIFCONF): %m");
+        return 0;
+    }
+
+    /*
+     * Scan through looking for an interface with an Internet
+     * address on the same subnet as `ipaddr'.
+     */
+    ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
+    for (ifr = ifc.ifc_req; ifr < ifend; ) {
+        if (ifr->ifr_addr.sa_family == AF_INET) {
+            ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
+            strncpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
+            /*
+             * Check that the interface is up, and not point-to-point
+             * or loopback.
+             */
+            if (ioctl(s, SIOCGIFFLAGS, &ifreq) < 0)
+                continue;
+            if ((ifreq.ifr_flags &
+                 (IFF_UP|IFF_BROADCAST|IFF_POINTOPOINT|IFF_LOOPBACK|IFF_NOARP))
+                 != (IFF_UP|IFF_BROADCAST))
+                continue;
+            /*
+             * Get its netmask and check that it's on the right subnet.
+             */
+            if (ioctl(s, SIOCGIFNETMASK, &ifreq) < 0)
+                continue;
+            mask = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
+            if ((ipaddr & mask) != (ina & mask))
+                continue;
+
+            break;
+        }
+        ifr = (struct ifreq *) ((char *)&ifr->ifr_addr + sizeof(struct sockaddr)
+);
+    }
+
+    if (ifr >= ifend)
+        return 0;
+    syslog(LOG_DEBUG, "found interface %s for proxy arp", ifr->ifr_name);
+
+    /*
+     * Now scan through again looking for a link-level address
+     * for this interface.
+     */
+    ifp = ifr;
+    for (ifr = ifc.ifc_req; ifr < ifend; ) {
+        if (strcmp(ifp->ifr_name, ifr->ifr_name) == 0
+            && ifr->ifr_addr.sa_family == AF_DLI) {
+/*          && ifr->ifr_addr.sa_family == AF_LINK) { Per! Kolla !!! ROHACK */
+            /*
+             * Found the link-level address - copy it out
+             */
+            dla = (struct sockaddr_dl *)&ifr->ifr_addr;
+            hwaddr->sa_family = AF_UNSPEC;
+            BCOPY(dla, hwaddr->sa_data, sizeof(hwaddr->sa_data));
+            return 1;
+        }
+        ifr = (struct ifreq *) ((char *)&ifr->ifr_addr + sizeof(struct sockaddr)
+);
+    }
+
+    return 0;
+}
+
+
+/*
+ * ppp_available - check whether the system has any ppp interfaces
+ * (in fact we check whether we can do an ioctl on ppp0).
+ */
+
+int
+ppp_available()
+{
+    int s, ok;
+    struct ifreq ifr;
+
+    if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
+	return 1;		/* can't tell - maybe we're not root */
+
+    strncpy(ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
+    ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
+    close(s);
+
+    return ok;
+}
+
+
+/*
+  Seems like strdup() is not part of string package in Ultrix.
+  If I understood the man-page on the sun this should work.
+
+  Robert Olsson
+*/
+
+char *strdup( in ) char *in;
+{
+  char* dup;
+  if(! (dup = (char *) malloc( strlen( in ) +1 ))) return NULL;
+  (void) strcpy( dup, in );
+  return dup;
+}
+
+/*
+ * This logwtmp() implementation is subject to the following copyright:
+ *
+ * Copyright (c) 1988 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#define	WTMPFILE	"/usr/adm/wtmp"
+
+int
+logwtmp(line, name, host)
+    char *line, *name, *host;
+{
+    int fd;
+    struct stat buf;
+    struct utmp ut;
+
+    if ((fd = open(WTMPFILE, O_WRONLY|O_APPEND, 0)) < 0)
+	return;
+    if (!fstat(fd, &buf)) {
+	(void)strncpy(ut.ut_line, line, sizeof(ut.ut_line));
+	(void)strncpy(ut.ut_name, name, sizeof(ut.ut_name));
+	(void)strncpy(ut.ut_host, host, sizeof(ut.ut_host));
+	(void)time(&ut.ut_time);
+	if (write(fd, (char *)&ut, sizeof(struct utmp)) != sizeof(struct utmp))
+	    (void)ftruncate(fd, buf.st_size);
+    }
+    close(fd);
+}