o Redesign the layering mechanism and make the aliasing code part of

  the layering.

  We now ``stack'' layers as soon as we open the device (when we figure
  out what we're dealing with).  A static set of `dispatch' routines are
  also declared for dealing with incoming packets after they've been
  `pulled' up through the stacked layers.

  Physical devices are now assigned handlers based on the device type
  when they're opened.  For the moment there are three device types;
  ttys, execs and tcps.

o Increment version number to 2.2
o Make an entry in [uw]tmp for non-tty -direct invocations (after
  pap/chap authentication).
o Make throughput counters quad_t's
o Account for the absolute number of mbuf malloc()s and free()s in
  ``show mem''.
o ``show modem'' becomes ``show physical''.

1 files changed, 676 insertions, 64 deletions

diff --git a/usr.sbin/ppp/physical.c b/usr.sbin/ppp/physical.c
index 48a2770..31ed65e 100644
--- a/usr.sbin/ppp/physical.c
+++ b/usr.sbin/ppp/physical.c
@@ -16,51 +16,593 @@
  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  *
- *  $Id: physical.c,v 1.7 1999/01/10 01:26:29 brian Exp $
+ *  $Id: physical.c,v 1.8 1999/04/27 00:23:56 brian Exp $
  *
  */
 
+#include <sys/param.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <netinet/in_systm.h>
+#include <netinet/ip.h>
+#include <sys/un.h>
+
+#include <errno.h>
+#include <fcntl.h>
+#include <paths.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <sys/tty.h>	/* TIOCOUTQ */
+#include <sys/uio.h>
+#include <sys/wait.h>
 #include <time.h>
 #include <unistd.h>
 #include <utmp.h>
-#include <sys/tty.h>
+#if defined(__OpenBSD__) || defined(__NetBSD__)
+#include <sys/ioctl.h>
+#include <util.h>
+#else
+#include <libutil.h>
+#endif
 
+#include "layer.h"
+#ifndef NOALIAS
+#include "alias_cmd.h"
+#endif
+#include "proto.h"
+#include "acf.h"
+#include "vjcomp.h"
 #include "defs.h"
+#include "command.h"
 #include "mbuf.h"
+#include "log.h"
+#include "id.h"
 #include "timer.h"
+#include "fsm.h"
 #include "lqr.h"
 #include "hdlc.h"
-#include "throughput.h"
-#include "fsm.h"
 #include "lcp.h"
+#include "throughput.h"
+#include "sync.h"
 #include "async.h"
+#include "iplist.h"
+#include "slcompress.h"
+#include "ipcp.h"
+#include "filter.h"
+#include "descriptor.h"
 #include "ccp.h"
 #include "link.h"
-#include "descriptor.h"
 #include "physical.h"
-#include "log.h"
-#include "id.h"
+#include "mp.h"
+#ifndef NORADIUS
+#include "radius.h"
+#endif
+#include "bundle.h"
+#include "prompt.h"
+#include "chat.h"
+#include "auth.h"
+#include "chap.h"
+#include "cbcp.h"
+#include "datalink.h"
+#include "tcp.h"
+#include "exec.h"
+#include "tty.h"
+
+
+static int physical_DescriptorWrite(struct descriptor *, struct bundle *,
+                                    const fd_set *);
+static void physical_DescriptorRead(struct descriptor *, struct bundle *,
+                                    const fd_set *);
+
+static const struct device *handlers[] = {
+  &ttydevice, &tcpdevice, &execdevice
+};
+
+#define NHANDLERS (sizeof handlers / sizeof handlers[0])
+
+static int
+physical_UpdateSet(struct descriptor *d, fd_set *r, fd_set *w, fd_set *e,
+                   int *n)
+{
+  return physical_doUpdateSet(d, r, w, e, n, 0);
+}
+
+struct physical *
+physical_Create(struct datalink *dl, int type)
+{
+  struct physical *p;
+
+  p = (struct physical *)malloc(sizeof(struct physical));
+  if (!p)
+    return NULL;
+
+  p->link.type = PHYSICAL_LINK;
+  p->link.name = dl->name;
+  p->link.len = sizeof *p;
+  throughput_init(&p->link.throughput);
+
+  memset(p->link.Queue, '\0', sizeof p->link.Queue);
+  memset(p->link.proto_in, '\0', sizeof p->link.proto_in);
+  memset(p->link.proto_out, '\0', sizeof p->link.proto_out);
+  link_EmptyStack(&p->link);
+
+  memset(&p->Timer, '\0', sizeof p->Timer);
+  p->handler = NULL;
+  p->desc.type = PHYSICAL_DESCRIPTOR;
+  p->desc.UpdateSet = physical_UpdateSet;
+  p->desc.IsSet = physical_IsSet;
+  p->desc.Read = physical_DescriptorRead;
+  p->desc.Write = physical_DescriptorWrite;
+  p->type = type;
 
-/* External calls - should possibly be moved inline */
-extern int IntToSpeed(int);
+  hdlc_Init(&p->hdlc, &p->link.lcp);
+  async_Init(&p->async);
+
+  p->fd = -1;
+  p->out = NULL;
+  p->connect_count = 0;
+  p->dl = dl;
+  p->input.sz = 0;
+  *p->name.full = '\0';
+  p->name.base = p->name.full;
+
+  p->Utmp = 0;
+  p->session_owner = (pid_t)-1;
+
+  p->cfg.rts_cts = MODEM_CTSRTS;
+  p->cfg.speed = MODEM_SPEED;
+  p->cfg.parity = CS8;
+  memcpy(p->cfg.devlist, MODEM_LIST, sizeof MODEM_LIST);
+  p->cfg.ndev = NMODEMS;
+  p->cfg.cd.required = 0;
+  p->cfg.cd.delay = DEF_CDDELAY;
+
+  lcp_Init(&p->link.lcp, dl->bundle, &p->link, &dl->fsmp);
+  ccp_Init(&p->link.ccp, dl->bundle, &p->link, &dl->fsmp);
+
+  return p;
+}
+
+static const struct parity {
+  const char *name;
+  const char *name1;
+  int set;
+} validparity[] = {
+  { "even", "P_EVEN", CS7 | PARENB },
+  { "odd", "P_ODD", CS7 | PARENB | PARODD },
+  { "none", "P_ZERO", CS8 },
+  { NULL, 0 },
+};
+
+static int
+GetParityValue(const char *str)
+{
+  const struct parity *pp;
+
+  for (pp = validparity; pp->name; pp++) {
+    if (strcasecmp(pp->name, str) == 0 ||
+	strcasecmp(pp->name1, str) == 0) {
+      return pp->set;
+    }
+  }
+  return (-1);
+}
+
+int
+physical_SetParity(struct physical *p, const char *str)
+{
+  struct termios rstio;
+  int val;
+
+  val = GetParityValue(str);
+  if (val > 0) {
+    p->cfg.parity = val;
+    if (p->fd >= 0) {
+      tcgetattr(p->fd, &rstio);
+      rstio.c_cflag &= ~(CSIZE | PARODD | PARENB);
+      rstio.c_cflag |= val;
+      tcsetattr(p->fd, TCSADRAIN, &rstio);
+    }
+    return 0;
+  }
+  log_Printf(LogWARN, "%s: %s: Invalid parity\n", p->link.name, str);
+  return -1;
+}
+
+int
+physical_GetSpeed(struct physical *p)
+{
+  if (p->handler && p->handler->speed)
+    return (*p->handler->speed)(p);
 
+  return 115200;
+}
 
 int
-physical_GetFD(struct physical *phys) {
-   return phys->fd;
+physical_SetSpeed(struct physical *p, int speed)
+{
+  if (IntToSpeed(speed) != B0) {
+      p->cfg.speed = speed;
+      return 1;
+  }
+
+  return 0;
 }
 
 int
-physical_IsSync(struct physical *phys) {
-   return phys->cfg.speed == 0;
+physical_Raw(struct physical *p)
+{
+  if (p->handler && p->handler->raw)
+    return (*p->handler->raw)(p);
+
+  return 1;
 }
 
-const char *physical_GetDevice(struct physical *phys)
+void
+physical_Offline(struct physical *p)
 {
-   return phys->name.full;
+  if (p->handler && p->handler->offline)
+    (*p->handler->offline)(p);
+  log_Printf(LogPHASE, "%s: Disconnected!\n", p->link.name);
+}
+
+static void
+physical_ReallyClose(struct physical *p)
+{
+  int newsid;
+
+  log_Printf(LogDEBUG, "%s: Really close %d\n", p->link.name, p->fd);
+  if (p->fd >= 0) {
+    timer_Stop(&p->Timer);
+    if (p->Utmp) {
+      ID0logout(p->name.base);
+      p->Utmp = 0;
+    }
+    newsid = tcgetpgrp(p->fd) == getpgrp();
+    close(p->fd);
+    p->fd = -1;
+    log_SetTtyCommandMode(p->dl);
+    throughput_stop(&p->link.throughput);
+    throughput_log(&p->link.throughput, LogPHASE, p->link.name);
+    if (p->session_owner != (pid_t)-1) {
+      ID0kill(p->session_owner, SIGHUP);
+      p->session_owner = (pid_t)-1;
+    }
+    if (newsid)
+      bundle_setsid(p->dl->bundle, 0);
+    if (p->handler && p->handler->postclose)
+      (*p->handler->postclose)(p);
+    p->handler = NULL;
+  }
+  *p->name.full = '\0';
+  p->name.base = p->name.full;
+}
+
+void
+physical_Close(struct physical *p)
+{
+  if (p->fd < 0)
+    return;
+
+  log_Printf(LogDEBUG, "%s: Close\n", p->link.name);
+
+  if (p->handler && p->handler->cooked)
+    (*p->handler->cooked)(p);
+
+  physical_ReallyClose(p);
+}
+
+void
+physical_Destroy(struct physical *p)
+{
+  physical_Close(p);
+  free(p);
+}
+
+static int
+physical_DescriptorWrite(struct descriptor *d, struct bundle *bundle,
+                         const fd_set *fdset)
+{
+  struct physical *p = descriptor2physical(d);
+  int nw, result = 0;
+
+  if (p->out == NULL)
+    p->out = link_Dequeue(&p->link);
+
+  if (p->out) {
+    nw = physical_Write(p, MBUF_CTOP(p->out), p->out->cnt);
+    log_Printf(LogDEBUG, "%s: DescriptorWrite: wrote %d(%d) to %d\n",
+               p->link.name, nw, p->out->cnt, p->fd);
+    if (nw > 0) {
+      p->out->cnt -= nw;
+      p->out->offset += nw;
+      if (p->out->cnt == 0)
+	p->out = mbuf_FreeSeg(p->out);
+      result = 1;
+    } else if (nw < 0) {
+      if (errno != EAGAIN) {
+	log_Printf(LogPHASE, "%s: write (%d): %s\n", p->link.name,
+                   p->fd, strerror(errno));
+        datalink_Down(p->dl, CLOSE_NORMAL);
+      }
+      result = 1;
+    }
+    /* else we shouldn't really have been called !  select() is broken ! */
+  }
+
+  return result;
+}
+
+int
+physical_ShowStatus(struct cmdargs const *arg)
+{
+  struct physical *p = arg->cx->physical;
+  const char *dev;
+  int n;
+
+  prompt_Printf(arg->prompt, "Name: %s\n", p->link.name);
+  prompt_Printf(arg->prompt, " State:           ");
+  if (p->fd < 0)
+    prompt_Printf(arg->prompt, "closed\n");
+  else if (p->handler && p->handler->openinfo)
+    prompt_Printf(arg->prompt, "open (%s)\n", (*p->handler->openinfo)(p));
+  else
+    prompt_Printf(arg->prompt, "open\n");
+
+  prompt_Printf(arg->prompt, " Device:          %s",
+                *p->name.full ?  p->name.full :
+                p->type == PHYS_DIRECT ? "unknown" : "N/A");
+  if (p->session_owner != (pid_t)-1)
+    prompt_Printf(arg->prompt, " (session owner: %d)", (int)p->session_owner);
+
+  prompt_Printf(arg->prompt, "\n Link Type:       %s\n", mode2Nam(p->type));
+  prompt_Printf(arg->prompt, " Connect Count:   %d\n", p->connect_count);
+#ifdef TIOCOUTQ
+  if (p->fd >= 0 && ioctl(p->fd, TIOCOUTQ, &n) >= 0)
+      prompt_Printf(arg->prompt, " Physical outq:   %d\n", n);
+#endif
+
+  prompt_Printf(arg->prompt, " Queued Packets:  %d\n",
+                link_QueueLen(&p->link));
+  prompt_Printf(arg->prompt, " Phone Number:    %s\n", arg->cx->phone.chosen);
+
+  prompt_Printf(arg->prompt, "\nDefaults:\n");
+
+  prompt_Printf(arg->prompt, " Device List:     ");
+  dev = p->cfg.devlist;
+  for (n = 0; n < p->cfg.ndev; n++) {
+    if (n)
+      prompt_Printf(arg->prompt, ", ");
+    prompt_Printf(arg->prompt, "\"%s\"", dev);
+    dev += strlen(dev) + 1;
+  }
+  
+  prompt_Printf(arg->prompt, "\n Characteristics: ");
+  if (physical_IsSync(arg->cx->physical))
+    prompt_Printf(arg->prompt, "sync");
+  else
+    prompt_Printf(arg->prompt, "%dbps", p->cfg.speed);
+
+  switch (p->cfg.parity & CSIZE) {
+  case CS7:
+    prompt_Printf(arg->prompt, ", cs7");
+    break;
+  case CS8:
+    prompt_Printf(arg->prompt, ", cs8");
+    break;
+  }
+  if (p->cfg.parity & PARENB) {
+    if (p->cfg.parity & PARODD)
+      prompt_Printf(arg->prompt, ", odd parity");
+    else
+      prompt_Printf(arg->prompt, ", even parity");
+  } else
+    prompt_Printf(arg->prompt, ", no parity");
+
+  prompt_Printf(arg->prompt, ", CTS/RTS %s\n", (p->cfg.rts_cts ? "on" : "off"));
+
+  prompt_Printf(arg->prompt, " CD check delay:  %d second%s",
+                p->cfg.cd.delay, p->cfg.cd.delay == 1 ? "" : "s");
+  if (p->cfg.cd.required)
+    prompt_Printf(arg->prompt, " (required!)\n\n");
+  else
+    prompt_Printf(arg->prompt, "\n\n");
+
+  throughput_disp(&p->link.throughput, arg->prompt);
+
+  return 0;
+}
+
+static void
+physical_DescriptorRead(struct descriptor *d, struct bundle *bundle,
+                     const fd_set *fdset)
+{
+  struct physical *p = descriptor2physical(d);
+  u_char *rbuff;
+  int n, found;
+
+  rbuff = p->input.buf + p->input.sz;
+
+  /* something to read */
+  n = physical_Read(p, rbuff, sizeof p->input.buf - p->input.sz);
+  log_Printf(LogDEBUG, "%s: DescriptorRead: read %d/%d from %d\n",
+             p->link.name, n, (int)(sizeof p->input.buf - p->input.sz), p->fd);
+  if (n <= 0) {
+    if (n < 0)
+      log_Printf(LogPHASE, "%s: read (%d): %s\n", p->link.name, p->fd,
+                 strerror(errno));
+    else
+      log_Printf(LogPHASE, "%s: read (%d): Got zero bytes\n",
+                 p->link.name, p->fd);
+    datalink_Down(p->dl, CLOSE_NORMAL);
+    return;
+  }
+
+  log_DumpBuff(LogASYNC, "ReadFromModem", rbuff, n);
+  rbuff -= p->input.sz;
+  n += p->input.sz;
+
+  if (p->link.lcp.fsm.state <= ST_CLOSED) {
+    if (p->type != PHYS_DEDICATED) {
+      found = hdlc_Detect((u_char const **)&rbuff, n, physical_IsSync(p));
+      if (rbuff != p->input.buf)
+        log_WritePrompts(p->dl, "%.*s", (int)(rbuff - p->input.buf),
+                         p->input.buf);
+      p->input.sz = n - (rbuff - p->input.buf);
+
+      if (found) {
+        /* LCP packet is detected. Turn ourselves into packet mode */
+        log_Printf(LogPHASE, "%s: PPP packet detected, coming up\n",
+                   p->link.name);
+        log_SetTtyCommandMode(p->dl);
+        datalink_Up(p->dl, 0, 1);
+        link_PullPacket(&p->link, rbuff, p->input.sz, bundle);
+        p->input.sz = 0;
+      } else
+        bcopy(rbuff, p->input.buf, p->input.sz);
+    } else
+      /* In -dedicated mode, we just discard input until LCP is started */
+      p->input.sz = 0;
+  } else if (n > 0)
+    link_PullPacket(&p->link, rbuff, n, bundle);
+}
+
+struct physical *
+iov2physical(struct datalink *dl, struct iovec *iov, int *niov, int maxiov,
+             int fd)
+{
+  struct physical *p;
+  int len, h;
+
+  p = (struct physical *)iov[(*niov)++].iov_base;
+  p->link.name = dl->name;
+  throughput_init(&p->link.throughput);
+  memset(&p->Timer, '\0', sizeof p->Timer);
+  memset(p->link.Queue, '\0', sizeof p->link.Queue);
+
+  p->desc.UpdateSet = physical_UpdateSet;
+  p->desc.IsSet = physical_IsSet;
+  p->desc.Read = physical_DescriptorRead;
+  p->desc.Write = physical_DescriptorWrite;
+  p->type = PHYS_DIRECT;
+  p->dl = dl;
+  len = strlen(_PATH_DEV);
+  p->name.base = strncmp(p->name.full, _PATH_DEV, len) ?
+                        p->name.full : p->name.full + len;
+  p->out = NULL;
+  p->connect_count = 1;
+
+  if (p->handler) {
+    for (h = 0; h < NHANDLERS; h++)
+      if (p->handler == (const struct device *)(long)handlers[h]->type) {
+        p->handler = handlers[h];
+        break;
+      }
+    if (h == NHANDLERS) {
+      log_Printf(LogERROR, "iov2physical: Can't find device hander !\n");
+      p->handler = NULL;
+    }
+  }
+
+  p->link.lcp.fsm.bundle = dl->bundle;
+  p->link.lcp.fsm.link = &p->link;
+  memset(&p->link.lcp.fsm.FsmTimer, '\0', sizeof p->link.lcp.fsm.FsmTimer);
+  memset(&p->link.lcp.fsm.OpenTimer, '\0', sizeof p->link.lcp.fsm.OpenTimer);
+  memset(&p->link.lcp.fsm.StoppedTimer, '\0',
+         sizeof p->link.lcp.fsm.StoppedTimer);
+  p->link.lcp.fsm.parent = &dl->fsmp;
+  lcp_SetupCallbacks(&p->link.lcp);
+
+  p->link.ccp.fsm.bundle = dl->bundle;
+  p->link.ccp.fsm.link = &p->link;
+  /* Our in.state & out.state are NULL (no link-level ccp yet) */
+  memset(&p->link.ccp.fsm.FsmTimer, '\0', sizeof p->link.ccp.fsm.FsmTimer);
+  memset(&p->link.ccp.fsm.OpenTimer, '\0', sizeof p->link.ccp.fsm.OpenTimer);
+  memset(&p->link.ccp.fsm.StoppedTimer, '\0',
+         sizeof p->link.ccp.fsm.StoppedTimer);
+  p->link.ccp.fsm.parent = &dl->fsmp;
+  ccp_SetupCallbacks(&p->link.ccp);
+
+  p->hdlc.lqm.owner = &p->link.lcp;
+  p->hdlc.ReportTimer.state = TIMER_STOPPED;
+  p->hdlc.lqm.timer.state = TIMER_STOPPED;
+
+  p->fd = fd;
+
+  if (p->hdlc.lqm.method && p->hdlc.lqm.timer.load)
+    lqr_reStart(&p->link.lcp);
+  hdlc_StartTimer(&p->hdlc);
+
+  throughput_start(&p->link.throughput, "physical throughput",
+                   Enabled(dl->bundle, OPT_THROUGHPUT));
+  if (p->handler && p->handler->restored)
+    (*p->handler->restored)(p);
+
+  return p;
+}
+
+int
+physical2iov(struct physical *p, struct iovec *iov, int *niov, int maxiov,
+             pid_t newpid)
+{
+  if (p) {
+    hdlc_StopTimer(&p->hdlc);
+    lqr_StopTimer(p);
+    timer_Stop(&p->link.lcp.fsm.FsmTimer);
+    timer_Stop(&p->link.ccp.fsm.FsmTimer);
+    timer_Stop(&p->link.lcp.fsm.OpenTimer);
+    timer_Stop(&p->link.ccp.fsm.OpenTimer);
+    timer_Stop(&p->link.lcp.fsm.StoppedTimer);
+    timer_Stop(&p->link.ccp.fsm.StoppedTimer);
+    if (p->handler)
+      p->handler = (const struct device *)(long)p->handler->type;
+    if (p->Timer.state != TIMER_STOPPED) {
+      timer_Stop(&p->Timer);
+      p->Timer.state = TIMER_RUNNING;	/* Special - see iov2physical() */
+    }
+    if (tcgetpgrp(p->fd) == getpgrp())
+      p->session_owner = getpid();      /* So I'll eventually get HUP'd */
+    timer_Stop(&p->link.throughput.Timer);
+    physical_ChangedPid(p, newpid);
+  }
+
+  if (*niov >= maxiov) {
+    log_Printf(LogERROR, "physical2iov: No room for physical !\n");
+    if (p)
+      free(p);
+    return -1;
+  }
+
+  iov[*niov].iov_base = p ? p : malloc(sizeof *p);
+  iov[*niov].iov_len = sizeof *p;
+  (*niov)++;
+
+  return p ? p->fd : 0;
+}
+
+void
+physical_ChangedPid(struct physical *p, pid_t newpid)
+{
+  if (p->fd >= 0 && p->type != PHYS_DIRECT) {
+    int res;
+
+    if ((res = ID0uu_lock_txfr(p->name.base, newpid)) != UU_LOCK_OK)
+      log_Printf(LogPHASE, "uu_lock_txfr: %s\n", uu_lockerr(res));
+  }
+}
+
+int
+physical_IsSync(struct physical *p)
+{
+   return p->cfg.speed == 0;
+}
+
+const char *physical_GetDevice(struct physical *p)
+{
+   return p->name.full;
 }
 
 void
@@ -78,44 +620,36 @@ physical_SetDeviceList(struct physical *p, int argc, const char *const *argv)
   p->cfg.ndev = f;
 }
 
-
-int
-physical_SetSpeed(struct physical *phys, int speed) {
-   if (IntToSpeed(speed) != B0) {
-      phys->cfg.speed = speed;
-      return 1;
-   } else {
-      return 0;
-   }
-}
-
 void
-physical_SetSync(struct physical *phys) {
-   phys->cfg.speed = 0;
+physical_SetSync(struct physical *p)
+{
+   p->cfg.speed = 0;
 }
 
-
 int
-physical_SetRtsCts(struct physical *phys, int enable) {
-   phys->cfg.rts_cts = enable ? 1 : 0;
+physical_SetRtsCts(struct physical *p, int enable)
+{
+   p->cfg.rts_cts = enable ? 1 : 0;
    return 1;
 }
 
 /* Encapsulation for a read on the FD.  Avoids some exposure, and
    concentrates control. */
 ssize_t
-physical_Read(struct physical *phys, void *buf, size_t nbytes) {
-   return read(phys->fd, buf, nbytes);
+physical_Read(struct physical *p, void *buf, size_t nbytes)
+{
+   return read(p->fd, buf, nbytes);
 }
 
 ssize_t
-physical_Write(struct physical *phys, const void *buf, size_t nbytes) {
-   return write(phys->fd, buf, nbytes);
+physical_Write(struct physical *p, const void *buf, size_t nbytes)
+{
+   return write(p->fd, buf, nbytes);
 }
 
 int
-physical_UpdateSet(struct descriptor *d, fd_set *r, fd_set *w, fd_set *e,
-                   int *n, int force)
+physical_doUpdateSet(struct descriptor *d, fd_set *r, fd_set *w, fd_set *e,
+                     int *n, int force)
 {
   struct physical *p = descriptor2physical(d);
   int sets;
@@ -179,34 +713,21 @@ physical_IsSet(struct descriptor *d, const fd_set *fdset)
 }
 
 void
-physical_Login(struct physical *phys, const char *name)
-{
-  if (phys->type == PHYS_DIRECT && phys->isatty) {
-    if (phys->Utmp)
-      log_Printf(LogERROR, "Oops, already logged in on %s\n", phys->name.base);
-    else {
-      struct utmp ut;
-      const char *connstr;
-
-      memset(&ut, 0, sizeof ut);
-      time(&ut.ut_time);
-      strncpy(ut.ut_name, name, sizeof ut.ut_name);
-      strncpy(ut.ut_line, phys->name.base, sizeof ut.ut_line);
-      if ((connstr = getenv("CONNECT")))
-        /* mgetty sets this to the connection speed */
-        strncpy(ut.ut_host, connstr, sizeof ut.ut_host);
-      ID0login(&ut);
-      phys->Utmp = 1;
-    }
-  }
-}
-
-void
-physical_Logout(struct physical *phys)
+physical_Login(struct physical *p, const char *name)
 {
-  if (phys->Utmp) {
-    ID0logout(phys->name.base);
-    phys->Utmp = 0;
+  if (p->type == PHYS_DIRECT && !p->Utmp) {
+    struct utmp ut;
+    const char *connstr;
+
+    memset(&ut, 0, sizeof ut);
+    time(&ut.ut_time);
+    strncpy(ut.ut_name, name, sizeof ut.ut_name);
+    strncpy(ut.ut_line, p->name.base, sizeof ut.ut_line);
+    if ((connstr = getenv("CONNECT")))
+      /* mgetty sets this to the connection speed */
+      strncpy(ut.ut_host, connstr, sizeof ut.ut_host);
+    ID0login(&ut);
+    p->Utmp = 1;
   }
 }
 
@@ -233,3 +754,94 @@ physical_DeleteQueue(struct physical *p)
   }
   link_DeleteQueue(&p->link);
 }
+
+void
+physical_SetDevice(struct physical *p, const char *name)
+{
+  int len = strlen(_PATH_DEV);
+
+  strncpy(p->name.full, name, sizeof p->name.full - 1);
+  p->name.full[sizeof p->name.full - 1] = '\0';
+  p->name.base = *p->name.full == '!' ?  p->name.full + 1 :
+                 strncmp(p->name.full, _PATH_DEV, len) ?
+                 p->name.full : p->name.full + len;
+}
+
+static void
+physical_Found(struct physical *p)
+{
+  throughput_start(&p->link.throughput, "physical throughput",
+                   Enabled(p->dl->bundle, OPT_THROUGHPUT));
+  p->connect_count++;
+  p->input.sz = 0;
+
+  log_Printf(LogPHASE, "%s: Connected!\n", p->link.name);
+}
+
+int
+physical_Open(struct physical *p, struct bundle *bundle)
+{
+  int devno, h;
+  char *dev;
+
+  if (p->fd >= 0)
+    log_Printf(LogDEBUG, "%s: Open: Modem is already open!\n", p->link.name);
+    /* We're going back into "term" mode */
+  else if (p->type == PHYS_DIRECT) {
+    if (tty_OpenStdin(p)) {
+      physical_Found(p);
+      p->handler = &ttydevice;
+    } else {
+      log_Printf(LogDEBUG, "%s: physical_Open: stdin is not a tty\n",
+                 p->link.name);
+      physical_SetDevice(p, "");
+      physical_SetupStack(p, 0);
+      physical_Found(p);
+      return p->fd = STDIN_FILENO;
+    }
+  } else {
+    dev = p->cfg.devlist;
+    devno = 0;
+    while (devno < p->cfg.ndev && p->fd < 0) {
+      physical_SetDevice(p, dev);
+
+      for (h = 0; h < NHANDLERS; h++)
+        if (handlers[h]->open && (*handlers[h]->open)(p)) {
+          p->handler = handlers[h];
+          physical_Found(p);
+        }
+
+      if (p->fd < 0)
+	log_Printf(LogWARN, "%s: Device (%s) must begin with a '/',"
+                   " a '!' or be a host:port pair\n", p->link.name,
+                   p->name.full);
+      dev += strlen(dev) + 1;
+      devno++;
+    }
+  }
+
+  return p->fd;
+}
+
+void
+physical_SetupStack(struct physical *p, int forceasync)
+{
+  link_EmptyStack(&p->link);
+  if (!forceasync && physical_IsSync(p))
+    link_Stack(&p->link, &synclayer);
+  else {
+    link_Stack(&p->link, &asynclayer);
+    link_Stack(&p->link, &hdlclayer);
+  }
+  link_Stack(&p->link, &acflayer);
+  link_Stack(&p->link, &protolayer);
+  link_Stack(&p->link, &lqrlayer);
+  link_Stack(&p->link, &ccplayer);
+  link_Stack(&p->link, &vjlayer);
+#ifndef NOALIAS
+  link_Stack(&p->link, &aliaslayer);
+#endif
+  if (forceasync && physical_IsSync(p))
+    log_Printf(LogWARN, "Sync device setting ignored for ``%s'' device\n",
+               p->handler ? p->handler->name : "unknown");
+}