old DLPI doesn't have dl_sap_length
[ppp.git] / pppd / sys-svr4.c
index ce24dc4dac1c84115967333e7cb7061bc7c19434..716c2bd9d3e787472a6fb287c032a62aafb5a3ee 100644 (file)
  */
 
 #ifndef lint
-static char rcsid[] = "$Id: sys-svr4.c,v 1.1 1995/05/19 03:08:27 paulus Exp $";
+static char rcsid[] = "$Id: sys-svr4.c,v 1.8 1995/12/11 05:18:39 paulus Exp $";
 #endif
 
+#include <limits.h>
 #include <stdio.h>
 #include <stddef.h>
 #include <stdlib.h>
+#include <alloca.h>
+#include <ctype.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <termios.h>
+#ifndef CRTSCTS
+#include <sys/termiox.h>
+#endif
+#include <signal.h>
+#include <utmpx.h>
 #include <sys/types.h>
 #include <sys/ioccom.h>
 #include <sys/stream.h>
@@ -43,9 +51,14 @@ static char rcsid[] = "$Id: sys-svr4.c,v 1.1 1995/05/19 03:08:27 paulus Exp $";
 #include <sys/socket.h>
 #include <sys/sockio.h>
 #include <sys/syslog.h>
+#include <sys/sysmacros.h>
 #include <sys/systeminfo.h>
 #include <sys/dlpi.h>
+#include <sys/stat.h>
+#include <sys/mkdev.h>
 #include <net/if.h>
+#include <net/if_arp.h>
+#include <net/route.h>
 #include <net/ppp_defs.h>
 #include <net/pppio.h>
 #include <netinet/in.h>
@@ -59,6 +72,11 @@ static int   ipmuxid = -1;
 
 static int     restore_term;
 static struct termios inittermios;
+#ifndef CRTSCTS
+static struct termiox inittermiox;
+#endif
+static struct winsize wsinfo;  /* Initial window size info */
+static pid_t   tty_sid;        /* original session ID for terminal */
 
 static int     link_mtu, link_mru;
 
@@ -66,6 +84,20 @@ static int   link_mtu, link_mru;
 static int     tty_nmodules;
 static char    tty_modules[NMODULES][FMNAMESZ+1];
 
+static int     if_is_up;       /* Interface has been marked up */
+static u_int32_t default_route_gateway;        /* Gateway for default route added */
+static u_int32_t proxy_arp_addr;       /* Addr for proxy arp entry added */
+
+/* Prototypes for procedures local to this file. */
+static int translate_speed __P((int));
+static int baud_rate_of __P((int));
+static int get_ether_addr __P((u_int32_t, struct sockaddr *));
+static int get_hw_addr __P((char *, struct sockaddr *));
+static int dlpi_attach __P((int, int));
+static int dlpi_info_req __P((int));
+static int dlpi_get_reply __P((int, union DL_primitives *, int, int));
+static int strioctl __P((int, int, void *, int, int));
+
 /*
  * sys_init - System-dependent initialization.
  */
@@ -84,6 +116,24 @@ sys_init()
     }
 }
 
+/*
+ * sys_cleanup - restore any system state we modified before exiting:
+ * mark the interface down, delete default route and/or proxy arp entry.
+ * This should call die() because it's called from die().
+ */
+void
+sys_cleanup()
+{
+    struct ifreq ifr;
+
+    if (if_is_up)
+       sifdown(0);
+    if (default_route_gateway)
+       cifdefaultroute(0, default_route_gateway);
+    if (proxy_arp_addr)
+       cifproxyarp(0, proxy_arp_addr);
+}
+
 /*
  * daemon - Detach us from controlling terminal session.
  */
@@ -128,7 +178,9 @@ note_debug_level()
 int
 ppp_available()
 {
-    return access("/dev/ppp", R_OK) >= 0;
+    struct stat buf;
+
+    return stat("/dev/ppp", &buf) >= 0;
 }
 
 /*
@@ -137,13 +189,27 @@ ppp_available()
 void
 establish_ppp()
 {
-    int i;
+    int i, ifd, x;
+#ifndef sun
+    struct ifreq ifr;
+    struct {
+       union DL_primitives prim;
+       char space[64];
+    } reply;
+#endif
+
+    if (default_device)
+       tty_sid = getsid((pid_t)0);
 
     pppfd = open("/dev/ppp", O_RDWR | O_NONBLOCK, 0);
     if (pppfd < 0) {
        syslog(LOG_ERR, "Can't open /dev/ppp: %m");
        die(1);
     }
+    if (kdebugflag) {
+       x = PPPDBG_LOG + PPPDBG_DRIVER;
+       strioctl(pppfd, PPPIO_DEBUG, &x, sizeof(int), 0);
+    }
 
     /* Assign a new PPA and get its unit number. */
     if (strioctl(pppfd, PPPIO_NEWPPA, &ifunit, 0, sizeof(int)) < 0) {
@@ -151,6 +217,51 @@ establish_ppp()
        die(1);
     }
 
+    /*
+     * Open the ppp device again and link it under the ip multiplexor.
+     * IP will assign a unit number which hopefully is the same as ifunit.
+     * I don't know any way to be certain they will be the same. :-(
+     */
+    ifd = open("/dev/ppp", O_RDWR, 0);
+    if (ifd < 0) {
+       syslog(LOG_ERR, "Can't open /dev/ppp (2): %m");
+       die(1);
+    }
+    if (kdebugflag) {
+       x = PPPDBG_LOG + PPPDBG_DRIVER;
+       strioctl(ifd, PPPIO_DEBUG, &x, sizeof(int), 0);
+    }
+#ifdef sun
+    if (ioctl(ifd, I_PUSH, "ip") < 0) {
+       syslog(LOG_ERR, "Can't push IP module: %m");
+       close(ifd);
+       die(1);
+    }
+#else
+    if (dlpi_attach(ifd, ifunit) < 0 ||
+       dlpi_get_reply(ifd, &reply.prim, DL_OK_ACK, sizeof(reply)) < 0) {
+       syslog(LOG_ERR, "Can't attach to ppp%d: %m", ifunit);
+       close(ifd);
+       die(1);
+    }
+#endif
+    ipmuxid = ioctl(ipfd, I_LINK, ifd);
+    close(ifd);
+    if (ipmuxid < 0) {
+       syslog(LOG_ERR, "Can't link PPP device to IP: %m");
+       die(1);
+    }
+
+#ifndef sun
+    /* Set the interface name for the link. */
+    (void) sprintf (ifr.ifr_name, "ppp%d", ifunit);
+    ifr.ifr_metric = ipmuxid;
+    if (strioctl(ipfd, SIOCSIFNAME, (char *)&ifr, sizeof ifr, 0) < 0) {
+       syslog(LOG_ERR, "Can't set interface name %s: %m", ifr.ifr_name);
+       die(1);
+    }
+#endif
+
     /* Pop any existing modules off the tty stream. */
     for (i = 0;; ++i)
        if (ioctl(fd, I_LOOK, tty_modules[i]) < 0
@@ -184,9 +295,17 @@ disestablish_ppp()
 {
     int i;
 
+    if (ipmuxid > 0) {
+        if (ioctl(ipfd, I_UNLINK, ipmuxid) < 0) {
+           if (!hungup)
+               syslog(LOG_ERR, "Can't unlink PPP from IP: %m");
+        }
+    }
+
     if (fdmuxid >= 0) {
        if (ioctl(pppfd, I_UNLINK, fdmuxid) < 0) {
-           syslog(LOG_ERR, "Can't unlink tty from PPP mux: %m");
+           if (!hungup)
+               syslog(LOG_ERR, "Can't unlink tty from PPP mux: %m");
        }
        fdmuxid = -1;
 
@@ -198,6 +317,16 @@ disestablish_ppp()
                    syslog(LOG_ERR, "Couldn't restore tty module %s: %m",
                           tty_modules[i]);
        }
+       if (hungup && default_device && tty_sid > 0) {
+           /*
+            * If we have received a hangup, we need to send a SIGHUP
+            * to the terminal's controlling process.  The reason is
+            * that the original stream head for the terminal hasn't
+            * seen the M_HANGUP message (it went up through the ppp
+            * driver to the stream head for our fd to /dev/ppp).
+            */
+           kill(tty_sid, SIGHUP);
+       }
     }
 }
 
@@ -279,7 +408,7 @@ struct speed {
 /*
  * Translate from bits/second to a speed_t.
  */
-int
+static int
 translate_speed(bps)
     int bps;
 {
@@ -297,7 +426,7 @@ translate_speed(bps)
 /*
  * Translate from a speed_t to bits/second.
  */
-int
+static int
 baud_rate_of(speed)
     int speed;
 {
@@ -316,25 +445,50 @@ baud_rate_of(speed)
  * at the requested speed, etc.  If `local' is true, set CLOCAL
  * regardless of whether the modem option was specified.
  */
+void
 set_up_tty(fd, local)
     int fd, local;
 {
     int speed;
     struct termios tios;
+#if !defined (CRTSCTS)
+    struct termiox tiox;
+#endif
 
     if (tcgetattr(fd, &tios) < 0) {
        syslog(LOG_ERR, "tcgetattr: %m");
        die(1);
     }
 
-    if (!restore_term)
+#ifndef CRTSCTS
+    if (ioctl (fd, TCGETX, &tiox) < 0) {
+       syslog (LOG_ERR, "TCGETX: %m");
+       die (1);
+    }
+#endif
+
+    if (!restore_term) {
        inittermios = tios;
+#ifndef CRTSCTS
+       inittermiox = tiox;
+#endif
+       ioctl(fd, TIOCGWINSZ, &wsinfo);
+    }
 
     tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
+#ifdef CRTSCTS
     if (crtscts > 0)
        tios.c_cflag |= CRTSCTS;
     else if (crtscts < 0)
        tios.c_cflag &= ~CRTSCTS;
+#else
+    if (crtscts > 0) {
+       tiox.x_hflag |= RTSXOFF|CTSXON;
+    }
+    else if (crtscts < 0) {
+       tiox.x_hflag &= ~(RTSXOFF|CTSXON);
+    }
+#endif
 
     tios.c_cflag |= CS8 | CREAD | HUPCL;
     if (local || !modem)
@@ -345,8 +499,8 @@ set_up_tty(fd, local)
     tios.c_cc[VMIN] = 1;
     tios.c_cc[VTIME] = 0;
 
-    if (crtscts == 2) {
-       tios.c_iflag |= IXOFF;
+    if (crtscts == -2) {
+       tios.c_iflag |= IXON | IXOFF;
        tios.c_cc[VSTOP] = 0x13;        /* DC3 = XOFF = ^S */
        tios.c_cc[VSTART] = 0x11;       /* DC1 = XON  = ^Q */
     }
@@ -373,6 +527,13 @@ set_up_tty(fd, local)
        die(1);
     }
 
+#ifndef CRTSCTS
+    if (ioctl (fd, TCSETXF, &tiox) < 0){
+       syslog (LOG_ERR, "TCSETXF: %m");
+       die (1);
+    }
+#endif
+
     baud_rate = inspeed = baud_rate_of(speed);
     restore_term = 1;
 }
@@ -394,8 +555,15 @@ restore_tty()
            inittermios.c_lflag &= ~(ECHO | ECHONL);
        }
        if (tcsetattr(fd, TCSAFLUSH, &inittermios) < 0)
-           if (errno != ENXIO)
+           if (!hungup && errno != ENXIO)
                syslog(LOG_WARNING, "tcsetattr: %m");
+#ifndef CRTSCTS
+       if (ioctl (fd, TCSETXF, &inittermiox) < 0){
+           if (!hungup && errno != ENXIO)
+               syslog (LOG_ERR, "TCSETXF: %m");
+       }
+#endif
+       ioctl(fd, TIOCSWINSZ, &wsinfo);
        restore_term = 0;
     }
 }
@@ -404,6 +572,7 @@ restore_tty()
  * setdtr - control the DTR line on the serial port.
  * This is called from die(), so it shouldn't call die().
  */
+void
 setdtr(fd, on)
 int fd, on;
 {
@@ -422,17 +591,24 @@ output(unit, p, len)
     int len;
 {
     struct strbuf data;
+    int retries;
+    struct pollfd pfd;
 
     if (debug)
        log_packet(p, len, "sent ");
 
     data.len = len;
     data.buf = (caddr_t) p;
-    if (putmsg(pppfd, NULL, &data, 0) < 0) {
-       if (errno != ENXIO) {
-           syslog(LOG_ERR, "Couldn't send packet: %m");
-           die(1);
+    retries = 4;
+    while (putmsg(pppfd, NULL, &data, 0) < 0) {
+       if (--retries < 0 || (errno != EWOULDBLOCK && errno != EAGAIN)) {
+           if (errno != ENXIO)
+               syslog(LOG_ERR, "Couldn't send packet: %m");
+           break;
        }
+       pfd.fd = fd;
+       pfd.events = POLLOUT;
+       poll(&pfd, 1, 250);     /* wait for up to 0.25 seconds */
     }
 }
 
@@ -441,6 +617,7 @@ output(unit, p, len)
  * for the length of time specified by *timo (indefinite
  * if timo is NULL).
  */
+void
 wait_input(timo)
     struct timeval *timo;
 {
@@ -465,29 +642,34 @@ read_packet(buf)
 {
     struct strbuf ctrl, data;
     int flags, len;
-    unsigned char ctrlbuf[sizeof(union DL_primitives)];
+    unsigned char ctrlbuf[sizeof(union DL_primitives) + 64];
+
+    for (;;) {
+       data.maxlen = PPP_MRU + PPP_HDRLEN;
+       data.buf = (caddr_t) buf;
+       ctrl.maxlen = sizeof(ctrlbuf);
+       ctrl.buf = (caddr_t) ctrlbuf;
+       flags = 0;
+       len = getmsg(pppfd, &ctrl, &data, &flags);
+       if (len < 0) {
+           if (errno = EAGAIN || errno == EINTR)
+               return -1;
+           syslog(LOG_ERR, "Error reading packet: %m");
+           die(1);
+       }
 
-    data.maxlen = PPP_MRU + PPP_HDRLEN;
-    data.buf = (caddr_t) buf;
-    ctrl.maxlen = sizeof(ctrlbuf);
-    ctrl.buf = (caddr_t) ctrlbuf;
-    flags = 0;
-    len = getmsg(pppfd, &ctrl, &data, &flags);
-    if (len < 0) {
-       if (errno = EAGAIN || errno == EINTR)
-           return -1;
-       syslog(LOG_ERR, "Error reading packet: %m");
-       die(1);
-    }
+       if (ctrl.len <= 0)
+           return data.len;
 
-    if (ctrl.len > 0) {
        /*
         * Got a M_PROTO or M_PCPROTO message.  Interpret it
         * as a DLPI primitive.
         */
-    }
+       if (debug)
+           syslog(LOG_DEBUG, "got dlpi prim 0x%x, len=%d",
+                  ((union DL_primitives *)ctrlbuf)->dl_primitive, ctrl.len);
 
-    return data.len;
+    }
 }
 
 /*
@@ -502,7 +684,10 @@ ppp_send_config(unit, mtu, asyncmap, pcomp, accomp)
 {
     int cf[2];
 
+    link_mtu = mtu;
     if (strioctl(pppfd, PPPIO_MTU, &mtu, sizeof(mtu), 0) < 0) {
+       if (hungup && errno == ENXIO)
+           return;
        syslog(LOG_ERR, "Couldn't set MTU: %m");
     }
     if (strioctl(pppfd, PPPIO_XACCM, &asyncmap, sizeof(asyncmap), 0) < 0) {
@@ -513,7 +698,6 @@ ppp_send_config(unit, mtu, asyncmap, pcomp, accomp)
     if (strioctl(pppfd, PPPIO_CFLAGS, cf, sizeof(cf), sizeof(int)) < 0) {
        syslog(LOG_ERR, "Couldn't set prot/AC compression: %m");
     }
-    link_mtu = mtu;
 }
 
 /*
@@ -525,7 +709,8 @@ ppp_set_xaccm(unit, accm)
     ext_accm accm;
 {
     if (strioctl(pppfd, PPPIO_XACCM, accm, sizeof(ext_accm), 0) < 0) {
-       syslog(LOG_WARNING, "Couldn't set extended ACCM: %m");
+       if (!hungup || errno != ENXIO)
+           syslog(LOG_WARNING, "Couldn't set extended ACCM: %m");
     }
 }
 
@@ -541,7 +726,10 @@ ppp_recv_config(unit, mru, asyncmap, pcomp, accomp)
 {
     int cf[2];
 
+    link_mru = mru;
     if (strioctl(pppfd, PPPIO_MRU, &mru, sizeof(mru), 0) < 0) {
+       if (hungup && errno == ENXIO)
+           return;
        syslog(LOG_ERR, "Couldn't set MRU: %m");
     }
     if (strioctl(pppfd, PPPIO_RACCM, &asyncmap, sizeof(asyncmap), 0) < 0) {
@@ -552,19 +740,21 @@ ppp_recv_config(unit, mru, asyncmap, pcomp, accomp)
     if (strioctl(pppfd, PPPIO_CFLAGS, cf, sizeof(cf), sizeof(int)) < 0) {
        syslog(LOG_ERR, "Couldn't set prot/AC decompression: %m");
     }
-    link_mru = mru;
 }
 
 /*
  * ccp_test - ask kernel whether a given compression method
  * is acceptable for use.
  */
+int
 ccp_test(unit, opt_ptr, opt_len, for_transmit)
     int unit, opt_len, for_transmit;
     u_char *opt_ptr;
 {
-    return strioctl(pppfd, (for_transmit? PPPIO_XCOMP: PPPIO_RCOMP),
-                   opt_ptr, opt_len, 0) >= 0;
+    if (strioctl(pppfd, (for_transmit? PPPIO_XCOMP: PPPIO_RCOMP),
+                opt_ptr, opt_len, 0) >= 0)
+       return 1;
+    return (errno == ENOSR)? 0: -1;
 }
 
 /*
@@ -579,7 +769,8 @@ ccp_flags_set(unit, isopen, isup)
     cf[0] = (isopen? CCP_ISOPEN: 0) + (isup? CCP_ISUP: 0);
     cf[1] = CCP_ISOPEN | CCP_ISUP | CCP_ERROR | CCP_FATALERROR;
     if (strioctl(pppfd, PPPIO_CFLAGS, cf, sizeof(cf), sizeof(int)) < 0) {
-       syslog(LOG_ERR, "Couldn't set kernel CCP state: %m");
+       if (!hungup || errno != ENXIO)
+           syslog(LOG_ERR, "Couldn't set kernel CCP state: %m");
     }
 }
 
@@ -596,7 +787,8 @@ ccp_fatal_error(unit)
 
     cf[0] = cf[1] = 0;
     if (strioctl(pppfd, PPPIO_CFLAGS, cf, sizeof(cf), sizeof(int)) < 0) {
-       syslog(LOG_ERR, "Couldn't get compression flags: %m");
+       if (errno != ENXIO && errno != EINVAL)
+           syslog(LOG_ERR, "Couldn't get compression flags: %m");
        return 0;
     }
     return cf[0] & CCP_FATALERROR;
@@ -640,10 +832,6 @@ sifup(u)
 {
     struct ifreq ifr;
 
-    if (ipmuxid < 0) {
-       syslog(LOG_DEBUG, "sifup: not plumbed!");
-       return 0;
-    }
     strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
     if (ioctl(ipfd, SIOCGIFFLAGS, &ifr) < 0) {
        syslog(LOG_ERR, "Couldn't mark interface up (get): %m");
@@ -654,6 +842,7 @@ sifup(u)
        syslog(LOG_ERR, "Couldn't mark interface up (set): %m");
        return 0;
     }
+    if_is_up = 1;
     return 1;
 }
 
@@ -678,9 +867,12 @@ sifdown(u)
        syslog(LOG_ERR, "Couldn't mark interface down (set): %m");
        return 0;
     }
+    if_is_up = 0;
     return 1;
 }
 
+#define INET_ADDR(x)   (((struct sockaddr_in *) &(x))->sin_addr.s_addr)
+
 /*
  * sifaddr - Config the interface IP addresses and netmask.
  */
@@ -689,40 +881,22 @@ sifaddr(u, o, h, m)
     int u;
     u_int32_t o, h, m;
 {
-    int fd;
     struct ifreq ifr;
 
-    fd = open("/dev/ppp", O_RDWR, 0);
-    if (fd < 0) {
-       syslog(LOG_ERR, "Can't open /dev/ppp (2): %m");
-       die(1);
-    }
-    if (ioctl(fd, I_PUSH, "ip") < 0) {
-       syslog(LOG_ERR, "Can't push IP module: %m");
-       close(fd);
-       return 0;
-    }
-    ipmuxid = ioctl(ipfd, I_LINK, fd);
-    close(fd);
-    if (ipmuxid < 0) {
-       syslog(LOG_ERR, "Can't link PPP device to IP: %m");
-       return 0;
-    }
-
     memset(&ifr, 0, sizeof(ifr));
     strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
     ifr.ifr_addr.sa_family = AF_INET;
-    ((struct sockaddr_in *) &ifr.ifr_addr)->sin_addr.s_addr = o;
+    INET_ADDR(ifr.ifr_addr) = o;
     if (ioctl(ipfd, SIOCSIFADDR, &ifr) < 0) {
        syslog(LOG_ERR, "Couldn't set local IP address: %m");
     }
     ifr.ifr_dstaddr.sa_family = AF_INET;
-    ((struct sockaddr_in *) &ifr.ifr_dstaddr)->sin_addr.s_addr = h;
+    INET_ADDR(ifr.ifr_dstaddr) = h;
     if (ioctl(ipfd, SIOCSIFDSTADDR, &ifr) < 0) {
        syslog(LOG_ERR, "Couldn't set remote IP address: %m");
     }
     ifr.ifr_addr.sa_family = AF_INET;
-    ((struct sockaddr_in *) &ifr.ifr_addr)->sin_addr.s_addr = m;
+    INET_ADDR(ifr.ifr_addr) = m;
     if (ioctl(ipfd, SIOCSIFNETMASK, &ifr) < 0) {
        syslog(LOG_ERR, "Couldn't set IP netmask: %m");
     }
@@ -743,6 +917,7 @@ cifaddr(u, o, h)
     int u;
     u_int32_t o, h;
 {
+#if 0
     if (ipmuxid >= 0) {
        if (ioctl(ipfd, I_UNLINK, ipmuxid) < 0) {
            syslog(LOG_ERR, "Can't remove ppp interface unit: %m");
@@ -750,6 +925,7 @@ cifaddr(u, o, h)
        }
        ipmuxid = -1;
     }
+#endif
     return 1;
 }
 
@@ -761,6 +937,20 @@ sifdefaultroute(u, g)
     int u;
     u_int32_t g;
 {
+    struct rtentry rt;
+
+    rt.rt_dst.sa_family = AF_INET;
+    INET_ADDR(rt.rt_dst) = 0;
+    rt.rt_gateway.sa_family = AF_INET;
+    INET_ADDR(rt.rt_gateway) = g;
+    rt.rt_flags = RTF_GATEWAY;
+
+    if (ioctl(ipfd, SIOCADDRT, &rt) < 0) {
+       syslog(LOG_ERR, "Can't add default route: %m");
+       return 0;
+    }
+
+    default_route_gateway = g;
     return 1;
 }
 
@@ -772,6 +962,20 @@ cifdefaultroute(u, g)
     int u;
     u_int32_t g;
 {
+    struct rtentry rt;
+
+    rt.rt_dst.sa_family = AF_INET;
+    INET_ADDR(rt.rt_dst) = 0;
+    rt.rt_gateway.sa_family = AF_INET;
+    INET_ADDR(rt.rt_gateway) = g;
+    rt.rt_flags = RTF_GATEWAY;
+
+    if (ioctl(ipfd, SIOCDELRT, &rt) < 0) {
+       syslog(LOG_ERR, "Can't delete default route: %m");
+       return 0;
+    }
+
+    default_route_gateway = 0;
     return 1;
 }
 
@@ -783,6 +987,21 @@ sifproxyarp(unit, hisaddr)
     int unit;
     u_int32_t hisaddr;
 {
+    struct arpreq arpreq;
+
+    memset(&arpreq, 0, sizeof(arpreq));
+    if (!get_ether_addr(hisaddr, &arpreq.arp_ha))
+       return 0;
+
+    arpreq.arp_pa.sa_family = AF_INET;
+    INET_ADDR(arpreq.arp_pa) = hisaddr;
+    arpreq.arp_flags = ATF_PERM | ATF_PUBL;
+    if (ioctl(ipfd, SIOCSARP, (caddr_t) &arpreq) < 0) {
+       syslog(LOG_ERR, "Couldn't set proxy ARP entry: %m");
+       return 0;
+    }
+
+    proxy_arp_addr = hisaddr;
     return 1;
 }
 
@@ -794,6 +1013,17 @@ cifproxyarp(unit, hisaddr)
     int unit;
     u_int32_t hisaddr;
 {
+    struct arpreq arpreq;
+
+    memset(&arpreq, 0, sizeof(arpreq));
+    arpreq.arp_pa.sa_family = AF_INET;
+    INET_ADDR(arpreq.arp_pa) = hisaddr;
+    if (ioctl(ipfd, SIOCDARP, (caddr_t)&arpreq) < 0) {
+       syslog(LOG_ERR, "Couldn't delete proxy ARP entry: %m");
+       return 0;
+    }
+
+    proxy_arp_addr = 0;
     return 1;
 }
 
@@ -803,11 +1033,205 @@ cifproxyarp(unit, hisaddr)
  */
 #define MAX_IFS                32
 
-int
+static int
 get_ether_addr(ipaddr, hwaddr)
     u_int32_t ipaddr;
-    struct sockaddr_dl *hwaddr;
+    struct sockaddr *hwaddr;
 {
+    struct ifreq *ifr, *ifend, ifreq;
+    int nif;
+    struct ifconf ifc;
+    u_int32_t ina, mask;
+
+    /*
+     * Scan through the system's network interfaces.
+     */
+#ifdef SIOCGIFNUM
+    if (ioctl(ipfd, SIOCGIFNUM, &nif) < 0)
+#endif
+       nif = MAX_IFS;
+    ifc.ifc_len = nif * sizeof(struct ifreq);
+    ifc.ifc_buf = (caddr_t) alloca(ifc.ifc_len);
+    if (ifc.ifc_req == 0)
+       return 0;
+    if (ioctl(ipfd, SIOCGIFCONF, &ifc) < 0) {
+       syslog(LOG_WARNING, "Couldn't get system interface list: %m");
+       return 0;
+    }
+    ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
+    for (ifr = ifc.ifc_req; ifr < ifend; ++ifr) {
+       if (ifr->ifr_addr.sa_family != AF_INET)
+           continue;
+       /*
+        * Check that the interface is up, and not point-to-point or loopback.
+        */
+       strncpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
+       if (ioctl(ipfd, 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(ipfd, SIOCGIFNETMASK, &ifreq) < 0)
+           continue;
+       ina = INET_ADDR(ifr->ifr_addr);
+       mask = INET_ADDR(ifreq.ifr_addr);
+       if ((ipaddr & mask) == (ina & mask))
+           break;
+    }
+
+    if (ifr >= ifend) {
+       syslog(LOG_WARNING, "No suitable interface found for proxy ARP");
+       return 0;
+    }
+
+    syslog(LOG_INFO, "found interface %s for proxy ARP", ifr->ifr_name);
+    if (!get_hw_addr(ifr->ifr_name, hwaddr)) {
+       syslog(LOG_ERR, "Couldn't get hardware address for %s", ifr->ifr_name);
+       return 0;
+    }
+
+    return 1;
+}
+
+/*
+ * get_hw_addr - obtain the hardware address for a named interface.
+ */
+static int
+get_hw_addr(name, hwaddr)
+    char *name;
+    struct sockaddr *hwaddr;
+{
+    char *p, *q;
+    int unit, iffd, adrlen;
+    unsigned char *adrp;
+    char ifdev[24];
+    struct {
+       union DL_primitives prim;
+       char space[64];
+    } reply;
+
+    /*
+     * We have to open the device and ask it for its hardware address.
+     * First split apart the device name and unit.
+     */
+    strcpy(ifdev, "/dev/");
+    q = ifdev + 5;             /* strlen("/dev/") */
+    while (*name != 0 && !isdigit(*name))
+       *q++ = *name++;
+    *q = 0;
+    unit = atoi(name);
+
+    /*
+     * Open the device and do a DLPI attach and phys_addr_req.
+     */
+    iffd = open(ifdev, O_RDWR);
+    if (iffd < 0) {
+       syslog(LOG_ERR, "Can't open %s: %m", ifdev);
+       return 0;
+    }
+    if (dlpi_attach(iffd, unit) < 0
+       || dlpi_get_reply(iffd, &reply.prim, DL_OK_ACK, sizeof(reply)) < 0
+       || dlpi_info_req(iffd) < 0
+       || dlpi_get_reply(iffd, &reply.prim, DL_INFO_ACK, sizeof(reply)) < 0) {
+       close(iffd);
+       return 0;
+    }
+
+    adrlen = reply.prim.info_ack.dl_addr_length;
+    adrp = (unsigned char *)&reply + reply.prim.info_ack.dl_addr_offset;
+#if DL_CURRENT_VERSION >= 2
+    if (reply.prim.info_ack.dl_sap_length < 0)
+       adrlen += reply.prim.info_ack.dl_sap_length;
+    else
+       adrp += reply.prim.info_ack.dl_sap_length;
+#endif
+    hwaddr->sa_family = AF_UNSPEC;
+    memcpy(hwaddr->sa_data, adrp, adrlen);
+
+    return 1;
+}
+
+static int
+dlpi_attach(fd, ppa)
+    int fd, ppa;
+{
+    dl_attach_req_t req;
+    struct strbuf buf;
+
+    req.dl_primitive = DL_ATTACH_REQ;
+    req.dl_ppa = ppa;
+    buf.len = sizeof(req);
+    buf.buf = (void *) &req;
+    return putmsg(fd, &buf, NULL, RS_HIPRI);
+}
+
+static int
+dlpi_info_req(fd)
+    int fd;
+{
+    dl_info_req_t req;
+    struct strbuf buf;
+
+    req.dl_primitive = DL_INFO_REQ;
+    buf.len = sizeof(req);
+    buf.buf = (void *) &req;
+    return putmsg(fd, &buf, NULL, RS_HIPRI);
+}
+
+static int
+dlpi_get_reply(fd, reply, expected_prim, maxlen)
+    union DL_primitives *reply;
+    int fd, expected_prim, maxlen;
+{
+    struct strbuf buf;
+    int flags, n;
+    struct pollfd pfd;
+
+    /*
+     * Use poll to wait for a message with a timeout.
+     */
+    pfd.fd = fd;
+    pfd.events = POLLIN | POLLPRI;
+    do {
+       n = poll(&pfd, 1, 1000);
+    } while (n == -1 && errno == EINTR);
+    if (n <= 0)
+       return -1;
+
+    /*
+     * Get the reply.
+     */
+    buf.maxlen = maxlen;
+    buf.buf = (void *) reply;
+    flags = 0;
+    if (getmsg(fd, &buf, NULL, &flags) < 0)
+       return -1;
+
+    if (buf.len < sizeof(ulong)) {
+       if (debug)
+           syslog(LOG_DEBUG, "dlpi response short (len=%d)\n", buf.len);
+       return -1;
+    }
+
+    if (reply->dl_primitive == expected_prim)
+       return 0;
+
+    if (debug) {
+       if (reply->dl_primitive == DL_ERROR_ACK) {
+           syslog(LOG_DEBUG, "dlpi error %d (unix errno %d) for prim %x\n",
+                  reply->error_ack.dl_errno, reply->error_ack.dl_unix_errno,
+                  reply->error_ack.dl_error_primitive);
+       } else {
+           syslog(LOG_DEBUG, "dlpi unexpected response prim %x\n",
+                  reply->dl_primitive);
+       }
+    }
+
+    return -1;
 }
 
 /*
@@ -840,10 +1264,12 @@ GetMask(addr)
     /*
      * Scan through the system's network interfaces.
      */
+#ifdef SIOCGIFNUM
     if (ioctl(ipfd, SIOCGIFNUM, &nif) < 0)
+#endif
        nif = MAX_IFS;
     ifc.ifc_len = nif * sizeof(struct ifreq);
-    ifc.ifc_req = alloca(ifc.ifc_len);
+    ifc.ifc_buf = (caddr_t) alloca(ifc.ifc_len);
     if (ifc.ifc_req == 0)
        return mask;
     if (ioctl(ipfd, SIOCGIFCONF, &ifc) < 0) {
@@ -857,7 +1283,7 @@ GetMask(addr)
         */
        if (ifr->ifr_addr.sa_family != AF_INET)
            continue;
-       ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
+       ina = INET_ADDR(ifr->ifr_addr);
        if ((ntohl(ina) & nmask) != (addr & nmask))
            continue;
        /*
@@ -874,7 +1300,7 @@ GetMask(addr)
         */
        if (ioctl(ipfd, SIOCGIFNETMASK, &ifreq) < 0)
            continue;
-       mask |= ((struct sockaddr_in *)&ifreq.ifr_addr)->sin_addr.s_addr;
+       mask |= INET_ADDR(ifreq.ifr_addr);
     }
 
     return mask;
@@ -887,6 +1313,21 @@ int
 logwtmp(line, name, host)
     char *line, *name, *host;
 {
+    static struct utmpx utmpx;
+
+    if (name[0] != 0) {
+       /* logging in */
+       strncpy(utmpx.ut_user, name, sizeof(utmpx.ut_user));
+       strncpy(utmpx.ut_id, ifname, sizeof(utmpx.ut_id));
+       strncpy(utmpx.ut_line, line, sizeof(utmpx.ut_line));
+       utmpx.ut_pid = getpid();
+       utmpx.ut_type = USER_PROCESS;
+    } else {
+       utmpx.ut_type = DEAD_PROCESS;
+    }
+    gettimeofday(&utmpx.ut_tv, NULL);
+    updwtmpx("/var/adm/wtmpx", &utmpx);
+    return 0;
 }
 
 /*
@@ -901,13 +1342,13 @@ gethostid()
        syslog(LOG_ERR, "sysinfo: %m");
        return 0;
     }
-    return strtol(buf, NULL, 16);
+    return (int) strtoul(buf, NULL, 16);
 }
 
-int
+static int
 strioctl(fd, cmd, ptr, ilen, olen)
     int fd, cmd, ilen, olen;
-    char *ptr;
+    void *ptr;
 {
     struct strioctl str;
 
@@ -923,15 +1364,79 @@ strioctl(fd, cmd, ptr, ilen, olen)
     return 0;
 }
 
+/*
+ * lock - create a lock file for the named lock device
+ */
+
+#define LOCK_PREFIX    "/var/spool/locks/LK."
+static char lock_file[40];     /* name of lock file created */
+
 int
 lock(dev)
     char *dev;
 {
+    int n, fd, pid;
+    struct stat sbuf;
+    char ascii_pid[12];
+
+    if (stat(dev, &sbuf) < 0) {
+       syslog(LOG_ERR, "Can't get device number for %s: %m", dev);
+       return -1;
+    }
+    if ((sbuf.st_mode & S_IFMT) != S_IFCHR) {
+       syslog(LOG_ERR, "Can't lock %s: not a character device", dev);
+       return -1;
+    }
+    sprintf(lock_file, "%s%03d.%03d.%03d", LOCK_PREFIX, major(sbuf.st_dev),
+           major(sbuf.st_rdev), minor(sbuf.st_rdev));
+
+    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 */
+           n = read(fd, ascii_pid, 11);
+           if (n <= 0) {
+               syslog(LOG_ERR, "Can't read pid from lock file %s", lock_file);
+               close(fd);
+           } else {
+               ascii_pid[n] = 0;
+               pid = atoi(ascii_pid);
+               if (pid > 0 && 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);
+       lock_file[0] = 0;
+       return -1;
+    }
+
+    sprintf(ascii_pid, "%10d\n", getpid());
+    write(fd, ascii_pid, 11);
+
+    close(fd);
     return 1;
 }
 
-int
+/*
+ * unlock - remove our lockfile
+ */
+void
 unlock()
 {
-    return 1;
+    if (lock_file[0]) {
+       unlink(lock_file);
+       lock_file[0] = 0;
+    }
 }