usr.sbin/ppp/tty.c

   1 /*-
   2  * Copyright (c) 1999 Brian Somers <brian@Awfulhak.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * $FreeBSD: src/usr.sbin/ppp/tty.c,v 1.21.2.3 2002/09/01 02:12:32 brian Exp $
  27  */
  28
  29 #include <sys/param.h>
  30 #include <sys/un.h>
  31 #if defined(__OpenBSD__) || defined(__NetBSD__)
  32 #include <sys/ioctl.h>
  33 #endif
  34
  35 #include <errno.h>
  36 #include <fcntl.h>
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39 #include <string.h>
  40 #include <sysexits.h>
  41 #include <sys/uio.h>
  42 #include <termios.h>
  43 #include <ttyent.h>
  44 #include <unistd.h>
  45 #ifndef NONETGRAPH
  46 #include <netgraph.h>
  47 #include <netgraph/ng_async.h>
  48 #include <netgraph/ng_message.h>
  49 #include <netgraph/ng_ppp.h>
  50 #include <netgraph/ng_tty.h>
  51 #endif
  52
  53 #include "layer.h"
  54 #include "defs.h"
  55 #include "mbuf.h"
  56 #include "log.h"
  57 #include "timer.h"
  58 #include "lqr.h"
  59 #include "hdlc.h"
  60 #include "throughput.h"
  61 #include "fsm.h"
  62 #include "lcp.h"
  63 #include "ccp.h"
  64 #include "link.h"
  65 #include "async.h"
  66 #include "descriptor.h"
  67 #include "physical.h"
  68 #include "mp.h"
  69 #include "chat.h"
  70 #include "auth.h"
  71 #include "chap.h"
  72 #include "cbcp.h"
  73 #include "datalink.h"
  74 #include "main.h"
  75 #include "id.h"
  76 #include "tty.h"
  77
  78 #if defined(__mac68k__) || defined(__macppc__)
  79 #undef  CRTS_IFLOW
  80 #undef  CCTS_OFLOW
  81 #define CRTS_IFLOW      CDTRCTS
  82 #define CCTS_OFLOW      CDTRCTS
  83 #endif
  84
  85 #define Online(dev)     ((dev)->mbits & TIOCM_CD)
  86
  87 struct ttydevice {
  88   struct device dev;            /* What struct physical knows about */
  89   struct pppTimer Timer;        /* CD checks */
  90   int mbits;                    /* Current DCD status */
  91   int carrier_seconds;          /* seconds before CD is *required* */
  92 #ifndef NONETGRAPH
  93   struct {
  94     int speed;                  /* Pre-line-discipline speed */
  95     int fd;                     /* Pre-line-discipline fd */
  96     int disc;                   /* Old line-discipline */
  97   } real;
  98   char hook[sizeof NG_ASYNC_HOOK_SYNC]; /* our ng_socket hook */
  99   int cs;                       /* A netgraph control socket (maybe) */
 100 #endif
 101   struct termios ios;           /* To be able to reset from raw mode */
 102 };
 103
 104 #define device2tty(d) ((d)->type == TTY_DEVICE ? (struct ttydevice *)d : NULL)
 105
 106 int
 107 tty_DeviceSize(void)
 108 {
 109   return sizeof(struct ttydevice);
 110 }
 111
 112 /*
 113  * tty_Timeout() watches the DCD signal and mentions it if it's status
 114  * changes.
 115  */
 116 static void
 117 tty_Timeout(void *data)
 118 {
 119   struct physical *p = data;
 120   struct ttydevice *dev = device2tty(p->handler);
 121   int ombits, change;
 122
 123   timer_Stop(&dev->Timer);
 124   dev->Timer.load = SECTICKS;           /* Once a second please */
 125   timer_Start(&dev->Timer);
 126   ombits = dev->mbits;
 127
 128   if (p->fd >= 0) {
 129     if (ioctl(p->fd, TIOCMGET, &dev->mbits) < 0) {
 130       /* we must be a pty ? */
 131       if (p->cfg.cd.necessity != CD_DEFAULT)
 132         log_Printf(LogWARN, "%s: Carrier ioctl not supported, "
 133                    "using ``set cd off''\n", p->link.name);
 134       timer_Stop(&dev->Timer);
 135       dev->mbits = TIOCM_CD;
 136       return;
 137     }
 138   } else
 139     dev->mbits = 0;
 140
 141   if (ombits == -1) {
 142     /* First time looking for carrier */
 143     if (Online(dev))
 144       log_Printf(LogPHASE, "%s: %s: CD detected\n", p->link.name, p->name.full);
 145     else if (++dev->carrier_seconds >= dev->dev.cd.delay) {
 146       if (dev->dev.cd.necessity == CD_REQUIRED)
 147         log_Printf(LogPHASE, "%s: %s: Required CD not detected\n",
 148                    p->link.name, p->name.full);
 149       else {
 150         log_Printf(LogPHASE, "%s: %s doesn't support CD\n",
 151                    p->link.name, p->name.full);
 152         dev->mbits = TIOCM_CD;          /* Dodgy null-modem cable ? */
 153       }
 154       timer_Stop(&dev->Timer);
 155       /* tty_AwaitCarrier() will notice */
 156     } else {
 157       /* Keep waiting */
 158       log_Printf(LogDEBUG, "%s: %s: Still no carrier (%d/%d)\n",
 159                  p->link.name, p->name.full, dev->carrier_seconds,
 160                  dev->dev.cd.delay);
 161       dev->mbits = -1;
 162     }
 163   } else {
 164     change = ombits ^ dev->mbits;
 165     if (change & TIOCM_CD) {
 166       if (dev->mbits & TIOCM_CD)
 167         log_Printf(LogDEBUG, "%s: offline -> online\n", p->link.name);
 168       else {
 169         log_Printf(LogDEBUG, "%s: online -> offline\n", p->link.name);
 170         log_Printf(LogPHASE, "%s: Carrier lost\n", p->link.name);
 171         datalink_Down(p->dl, CLOSE_NORMAL);
 172         timer_Stop(&dev->Timer);
 173       }
 174     } else
 175       log_Printf(LogDEBUG, "%s: Still %sline\n", p->link.name,
 176                  Online(dev) ? "on" : "off");
 177   }
 178 }
 179
 180 static void
 181 tty_StartTimer(struct physical *p)
 182 {
 183   struct ttydevice *dev = device2tty(p->handler);
 184
 185   timer_Stop(&dev->Timer);
 186   dev->Timer.load = SECTICKS;
 187   dev->Timer.func = tty_Timeout;
 188   dev->Timer.name = "tty CD";
 189   dev->Timer.arg = p;
 190   log_Printf(LogDEBUG, "%s: Using tty_Timeout [%p]\n",
 191              p->link.name, tty_Timeout);
 192   timer_Start(&dev->Timer);
 193 }
 194
 195 static int
 196 tty_AwaitCarrier(struct physical *p)
 197 {
 198   struct ttydevice *dev = device2tty(p->handler);
 199
 200   if (dev->dev.cd.necessity == CD_NOTREQUIRED || physical_IsSync(p))
 201     return CARRIER_OK;
 202
 203   if (dev->mbits == -1) {
 204     if (dev->Timer.state == TIMER_STOPPED) {
 205       dev->carrier_seconds = 0;
 206       tty_StartTimer(p);
 207     }
 208     return CARRIER_PENDING;                     /* Not yet ! */
 209   }
 210
 211   return Online(dev) ? CARRIER_OK : CARRIER_LOST;
 212 }
 213
 214 #ifdef NONETGRAPH
 215 #define tty_SetAsyncParams      NULL
 216 #define tty_Write               NULL
 217 #define tty_Read                NULL
 218 #else
 219
 220 static int
 221 isngtty(struct ttydevice *dev)
 222 {
 223   return dev->real.fd != -1;
 224 }
 225
 226 static void
 227 tty_SetAsyncParams(struct physical *p, u_int32_t mymap, u_int32_t hismap)
 228 {
 229   struct ttydevice *dev = device2tty(p->handler);
 230   char asyncpath[NG_PATHLEN + 1];
 231   struct ng_async_cfg cfg;
 232
 233   if (isngtty(dev)) {
 234     /* Configure the async converter node */
 235
 236     snprintf(asyncpath, sizeof asyncpath, ".:%s", dev->hook);
 237     memset(&cfg, 0, sizeof cfg);
 238     cfg.enabled = 1;
 239     cfg.accm = mymap | hismap;
 240     cfg.amru = MAX_MTU;
 241     cfg.smru = MAX_MRU;
 242     log_Printf(LogDEBUG, "Configure async node at %s\n", asyncpath);
 243     if (NgSendMsg(dev->cs, asyncpath, NGM_ASYNC_COOKIE,
 244                   NGM_ASYNC_CMD_SET_CONFIG, &cfg, sizeof cfg) < 0)
 245       log_Printf(LogWARN, "%s: Can't configure async node at %s\n",
 246                  p->link.name, asyncpath);
 247   } else
 248     /* No netgraph node, just config the async layer */
 249     async_SetLinkParams(&p->async, mymap, hismap);
 250 }
 251
 252 static int
 253 LoadLineDiscipline(struct physical *p)
 254 {
 255   struct ttydevice *dev = device2tty(p->handler);
 256   u_char rbuf[sizeof(struct ng_mesg) + sizeof(struct nodeinfo)];
 257   struct ng_mesg *reply;
 258   struct nodeinfo *info;
 259   char ttypath[NG_NODELEN + 1];
 260   struct ngm_mkpeer ngm;
 261   struct ngm_connect ngc;
 262   int ldisc, cs, ds, hot, speed;
 263
 264   /*
 265    * Don't use the netgraph line discipline for now.  Using it works, but
 266    * carrier cannot be detected via TIOCMGET and the device doesn't become
 267    * selectable with 0 bytes to read when carrier is lost :(
 268    */
 269   return 0;
 270
 271   reply = (struct ng_mesg *)rbuf;
 272   info = (struct nodeinfo *)reply->data;
 273
 274   loadmodules(LOAD_VERBOSLY, "netgraph", "ng_tty", "ng_async", "ng_socket",
 275               NULL);
 276
 277   /* Get the speed before loading the line discipline */
 278   speed = physical_GetSpeed(p);
 279
 280   if (ioctl(p->fd, TIOCGETD, &dev->real.disc) < 0) {
 281     log_Printf(LogDEBUG, "%s: Couldn't get tty line discipline\n",
 282                p->link.name);
 283     return 0;
 284   }
 285   ldisc = NETGRAPHDISC;
 286   if (ID0ioctl(p->fd, TIOCSETD, &ldisc) < 0) {
 287     log_Printf(LogDEBUG, "%s: Couldn't set NETGRAPHDISC line discipline\n",
 288                p->link.name);
 289     return 0;
 290   }
 291
 292   /* Get the name of the tty node */
 293   if (ioctl(p->fd, NGIOCGINFO, info) < 0) {
 294     log_Printf(LogWARN, "%s: ioctl(NGIOCGINFO): %s\n", p->link.name,
 295                strerror(errno));
 296     ID0ioctl(p->fd, TIOCSETD, &dev->real.disc);
 297     return 0;
 298   }
 299   snprintf(ttypath, sizeof ttypath, "%s:", info->name);
 300
 301   /* Create a socket node for our endpoint (and to send messages via) */
 302   if (ID0NgMkSockNode(NULL, &cs, &ds) == -1) {
 303     log_Printf(LogWARN, "%s: NgMkSockNode: %s\n", p->link.name,
 304                strerror(errno));
 305     ID0ioctl(p->fd, TIOCSETD, &dev->real.disc);
 306     return 0;
 307   }
 308
 309   /* Set the ``hot char'' on the TTY node */
 310   hot = HDLC_SYN;
 311   log_Printf(LogDEBUG, "%s: Set tty hotchar to 0x%02x\n", p->link.name, hot);
 312   if (NgSendMsg(cs, ttypath, NGM_TTY_COOKIE,
 313       NGM_TTY_SET_HOTCHAR, &hot, sizeof hot) < 0) {
 314     log_Printf(LogWARN, "%s: Can't set hot char\n", p->link.name);
 315     goto failed;
 316   }
 317
 318   /* Attach an async converter node */
 319   snprintf(ngm.type, sizeof ngm.type, "%s", NG_ASYNC_NODE_TYPE);
 320   snprintf(ngm.ourhook, sizeof ngm.ourhook, "%s", NG_TTY_HOOK);
 321   snprintf(ngm.peerhook, sizeof ngm.peerhook, "%s", NG_ASYNC_HOOK_ASYNC);
 322   log_Printf(LogDEBUG, "%s: Send mkpeer async:%s to %s:%s\n", p->link.name,
 323              ngm.peerhook, ttypath, ngm.ourhook);
 324   if (NgSendMsg(cs, ttypath, NGM_GENERIC_COOKIE,
 325       NGM_MKPEER, &ngm, sizeof ngm) < 0) {
 326     log_Printf(LogWARN, "%s: Can't create %s node\n", p->link.name,
 327                NG_ASYNC_NODE_TYPE);
 328     goto failed;
 329   }
 330
 331   /* Connect the async node to our socket */
 332   snprintf(ngc.path, sizeof ngc.path, "%s%s", ttypath, NG_TTY_HOOK);
 333   snprintf(ngc.peerhook, sizeof ngc.peerhook, "%s", NG_ASYNC_HOOK_SYNC);
 334   memcpy(ngc.ourhook, ngc.peerhook, sizeof ngc.ourhook);
 335   log_Printf(LogDEBUG, "%s: Send connect %s:%s to .:%s\n", p->link.name,
 336              ngc.path, ngc.peerhook, ngc.ourhook);
 337   if (NgSendMsg(cs, ".:", NGM_GENERIC_COOKIE, NGM_CONNECT,
 338       &ngc, sizeof ngc) < 0) {
 339     log_Printf(LogWARN, "%s: Can't connect .:%s -> %s.%s: %s\n",
 340                p->link.name, ngc.ourhook, ngc.path, ngc.peerhook,
 341                strerror(errno));
 342     goto failed;
 343   }
 344
 345   /* Get the async node id */
 346   if (NgSendMsg(cs, ngc.path, NGM_GENERIC_COOKIE, NGM_NODEINFO, NULL, 0) < 0) {
 347     log_Printf(LogWARN, "%s: Can't request async node info at %s: %s\n",
 348                p->link.name, ngc.path, strerror(errno));
 349     goto failed;
 350   }
 351   if (NgRecvMsg(cs, reply, sizeof rbuf, NULL) < 0) {
 352     log_Printf(LogWARN, "%s: Can't obtain async node info at %s: %s\n",
 353                p->link.name, ngc.path, strerror(errno));
 354     goto failed;
 355   }
 356
 357   /* All done, set up our device state */
 358   snprintf(dev->hook, sizeof dev->hook, "%s", ngc.ourhook);
 359   dev->cs = cs;
 360   dev->real.fd = p->fd;
 361   p->fd = ds;
 362   dev->real.speed = speed;
 363   physical_SetSync(p);
 364
 365   tty_SetAsyncParams(p, 0xffffffff, 0xffffffff);
 366   physical_SetupStack(p, dev->dev.name, PHYSICAL_NOFORCE);
 367   log_Printf(LogPHASE, "%s: Loaded netgraph tty line discipline\n",
 368              p->link.name);
 369
 370   return 1;
 371
 372 failed:
 373   ID0ioctl(p->fd, TIOCSETD, &dev->real.disc);
 374   close(ds);
 375   close(cs);
 376
 377   return 0;
 378 }
 379
 380 static void
 381 UnloadLineDiscipline(struct physical *p)
 382 {
 383   struct ttydevice *dev = device2tty(p->handler);
 384
 385   if (isngtty(dev)) {
 386 log_Printf(LogPHASE, "back to speed %d\n", dev->real.speed);
 387     if (!physical_SetSpeed(p, dev->real.speed))
 388       log_Printf(LogWARN, "Couldn't reset tty speed to %d\n", dev->real.speed);
 389     dev->real.speed = 0;
 390     close(p->fd);
 391     p->fd = dev->real.fd;
 392     dev->real.fd = -1;
 393     close(dev->cs);
 394     dev->cs = -1;
 395     *dev->hook = '\0';
 396     if (ID0ioctl(p->fd, TIOCSETD, &dev->real.disc) == 0) {
 397       physical_SetupStack(p, dev->dev.name, PHYSICAL_NOFORCE);
 398       log_Printf(LogPHASE, "%s: Unloaded netgraph tty line discipline\n",
 399                  p->link.name);
 400     } else
 401       log_Printf(LogWARN, "%s: Failed to unload netgraph tty line discipline\n",
 402                  p->link.name);
 403   }
 404 }
 405
 406 static ssize_t
 407 tty_Write(struct physical *p, const void *v, size_t n)
 408 {
 409   struct ttydevice *dev = device2tty(p->handler);
 410
 411   if (isngtty(dev))
 412     return NgSendData(p->fd, dev->hook, v, n) == -1 ? -1 : n;
 413   else
 414     return write(p->fd, v, n);
 415 }
 416
 417 static ssize_t
 418 tty_Read(struct physical *p, void *v, size_t n)
 419 {
 420   struct ttydevice *dev = device2tty(p->handler);
 421   char hook[sizeof NG_ASYNC_HOOK_SYNC];
 422
 423   if (isngtty(dev))
 424     return NgRecvData(p->fd, v, n, hook);
 425   else
 426     return read(p->fd, v, n);
 427 }
 428
 429 #endif /* NETGRAPH */
 430
 431 static int
 432 tty_Raw(struct physical *p)
 433 {
 434   struct ttydevice *dev = device2tty(p->handler);
 435   struct termios ios;
 436   int oldflag;
 437
 438   log_Printf(LogDEBUG, "%s: Entering tty_Raw\n", p->link.name);
 439
 440   if (p->type != PHYS_DIRECT && p->fd >= 0 && !Online(dev))
 441     log_Printf(LogDEBUG, "%s: Raw: descriptor = %d, mbits = %x\n",
 442               p->link.name, p->fd, dev->mbits);
 443
 444   if (!physical_IsSync(p)) {
 445 #ifndef NONETGRAPH
 446     if (!LoadLineDiscipline(p))
 447 #endif
 448     {
 449       tcgetattr(p->fd, &ios);
 450       cfmakeraw(&ios);
 451       if (p->cfg.rts_cts)
 452         ios.c_cflag |= CLOCAL | CCTS_OFLOW | CRTS_IFLOW;
 453       else
 454         ios.c_cflag |= CLOCAL;
 455
 456       if (p->type != PHYS_DEDICATED)
 457         ios.c_cflag |= HUPCL;
 458
 459       if (tcsetattr(p->fd, TCSANOW, &ios) == -1)
 460         log_Printf(LogWARN, "%s: tcsetattr: Failed configuring device\n",
 461                    p->link.name);
 462     }
 463   }
 464
 465   oldflag = fcntl(p->fd, F_GETFL, 0);
 466   if (oldflag < 0)
 467     return 0;
 468   fcntl(p->fd, F_SETFL, oldflag | O_NONBLOCK);
 469
 470   return 1;
 471 }
 472
 473 static void
 474 tty_Offline(struct physical *p)
 475 {
 476   struct ttydevice *dev = device2tty(p->handler);
 477
 478   if (p->fd >= 0) {
 479     timer_Stop(&dev->Timer);
 480     dev->mbits &= ~TIOCM_DTR;   /* XXX: Hmm, what's this supposed to do ? */
 481     if (Online(dev)) {
 482       struct termios tio;
 483
 484       tcgetattr(p->fd, &tio);
 485       if (cfsetspeed(&tio, B0) == -1 || tcsetattr(p->fd, TCSANOW, &tio) == -1)
 486         log_Printf(LogWARN, "%s: Unable to set physical to speed 0\n",
 487                    p->link.name);
 488     }
 489   }
 490 }
 491
 492 static void
 493 tty_Cooked(struct physical *p)
 494 {
 495   struct ttydevice *dev = device2tty(p->handler);
 496   int oldflag;
 497
 498   tty_Offline(p);       /* In case of emergency close()s */
 499
 500   tcflush(p->fd, TCIOFLUSH);
 501
 502   if (!physical_IsSync(p) && tcsetattr(p->fd, TCSAFLUSH, &dev->ios) == -1)
 503     log_Printf(LogWARN, "%s: tcsetattr: Unable to restore device settings\n",
 504                p->link.name);
 505
 506 #ifndef NONETGRAPH
 507   UnloadLineDiscipline(p);
 508 #endif
 509
 510   if ((oldflag = fcntl(p->fd, F_GETFL, 0)) != -1)
 511     fcntl(p->fd, F_SETFL, oldflag & ~O_NONBLOCK);
 512 }
 513
 514 static void
 515 tty_StopTimer(struct physical *p)
 516 {
 517   struct ttydevice *dev = device2tty(p->handler);
 518
 519   timer_Stop(&dev->Timer);
 520 }
 521
 522 static void
 523 tty_Free(struct physical *p)
 524 {
 525   struct ttydevice *dev = device2tty(p->handler);
 526
 527   tty_Offline(p);       /* In case of emergency close()s */
 528   free(dev);
 529 }
 530
 531 static int
 532 tty_Speed(struct physical *p)
 533 {
 534   struct termios ios;
 535
 536   if (tcgetattr(p->fd, &ios) == -1)
 537     return 0;
 538
 539   return SpeedToInt(cfgetispeed(&ios));
 540 }
 541
 542 static const char *
 543 tty_OpenInfo(struct physical *p)
 544 {
 545   struct ttydevice *dev = device2tty(p->handler);
 546   static char buf[13];
 547
 548   if (Online(dev))
 549     strcpy(buf, "with");
 550   else
 551     strcpy(buf, "no");
 552   strcat(buf, " carrier");
 553
 554   return buf;
 555 }
 556
 557 static int
 558 tty_Slot(struct physical *p)
 559 {
 560   struct ttyent *ttyp;
 561   int slot;
 562
 563   setttyent();
 564   for (slot = 1; (ttyp = getttyent()); ++slot)
 565     if (!strcmp(ttyp->ty_name, p->name.base)) {
 566       endttyent();
 567       return slot;
 568     }
 569
 570   endttyent();
 571   return -1;
 572 }
 573
 574 static void
 575 tty_device2iov(struct device *d, struct iovec *iov, int *niov,
 576                int maxiov, int *auxfd, int *nauxfd)
 577 {
 578   struct ttydevice *dev = device2tty(d);
 579   int sz = physical_MaxDeviceSize();
 580
 581   iov[*niov].iov_base = realloc(d, sz);
 582   if (iov[*niov].iov_base == NULL) {
 583     log_Printf(LogALERT, "Failed to allocate memory: %d\n", sz);
 584     AbortProgram(EX_OSERR);
 585   }
 586   iov[*niov].iov_len = sz;
 587   (*niov)++;
 588
 589 #ifndef NONETGRAPH
 590   if (dev->cs >= 0) {
 591     *auxfd = dev->cs;
 592     (*nauxfd)++;
 593   }
 594 #endif
 595
 596   if (dev->Timer.state != TIMER_STOPPED) {
 597     timer_Stop(&dev->Timer);
 598     dev->Timer.state = TIMER_RUNNING;
 599   }
 600 }
 601
 602 static struct device basettydevice = {
 603   TTY_DEVICE,
 604   "tty",
 605   0,
 606   { CD_VARIABLE, DEF_TTYCDDELAY },
 607   tty_AwaitCarrier,
 608   NULL,
 609   tty_Raw,
 610   tty_Offline,
 611   tty_Cooked,
 612   tty_SetAsyncParams,
 613   tty_StopTimer,
 614   tty_Free,
 615   tty_Read,
 616   tty_Write,
 617   tty_device2iov,
 618   tty_Speed,
 619   tty_OpenInfo,
 620   tty_Slot
 621 };
 622
 623 struct device *
 624 tty_iov2device(int type, struct physical *p, struct iovec *iov, int *niov,
 625                int maxiov, int *auxfd, int *nauxfd)
 626 {
 627   if (type == TTY_DEVICE) {
 628     struct ttydevice *dev = (struct ttydevice *)iov[(*niov)++].iov_base;
 629
 630     dev = realloc(dev, sizeof *dev);    /* Reduce to the correct size */
 631     if (dev == NULL) {
 632       log_Printf(LogALERT, "Failed to allocate memory: %d\n",
 633                  (int)(sizeof *dev));
 634       AbortProgram(EX_OSERR);
 635     }
 636
 637 #ifndef NONETGRAPH
 638     if (*nauxfd) {
 639       dev->cs = *auxfd;
 640       (*nauxfd)--;
 641     } else
 642       dev->cs = -1;
 643 #endif
 644
 645     /* Refresh function pointers etc */
 646     memcpy(&dev->dev, &basettydevice, sizeof dev->dev);
 647
 648     physical_SetupStack(p, dev->dev.name, PHYSICAL_NOFORCE);
 649     if (dev->Timer.state != TIMER_STOPPED) {
 650       dev->Timer.state = TIMER_STOPPED;
 651       p->handler = &dev->dev;           /* For the benefit of StartTimer */
 652       tty_StartTimer(p);
 653     }
 654     return &dev->dev;
 655   }
 656
 657   return NULL;
 658 }
 659
 660 struct device *
 661 tty_Create(struct physical *p)
 662 {
 663   struct ttydevice *dev;
 664   struct termios ios;
 665   int oldflag;
 666
 667   if (p->fd < 0 || !isatty(p->fd))
 668     /* Don't want this */
 669     return NULL;
 670
 671   if (*p->name.full == '\0') {
 672     physical_SetDevice(p, ttyname(p->fd));
 673     log_Printf(LogDEBUG, "%s: Input is a tty (%s)\n",
 674                p->link.name, p->name.full);
 675   } else
 676     log_Printf(LogDEBUG, "%s: Opened %s\n", p->link.name, p->name.full);
 677
 678   /* We're gonna return a ttydevice (unless something goes horribly wrong) */
 679
 680   if ((dev = malloc(sizeof *dev)) == NULL) {
 681     /* Complete failure - parent doesn't continue trying to ``create'' */
 682     close(p->fd);
 683     p->fd = -1;
 684     return NULL;
 685   }
 686
 687   memcpy(&dev->dev, &basettydevice, sizeof dev->dev);
 688   memset(&dev->Timer, '\0', sizeof dev->Timer);
 689   dev->mbits = -1;
 690 #ifndef NONETGRAPH
 691   dev->real.speed = 0;
 692   dev->real.fd = -1;
 693   dev->real.disc = -1;
 694   *dev->hook = '\0';
 695 #endif
 696   tcgetattr(p->fd, &ios);
 697   dev->ios = ios;
 698
 699   if (p->cfg.cd.necessity != CD_DEFAULT)
 700     /* Any override is ok for the tty device */
 701     dev->dev.cd = p->cfg.cd;
 702
 703   log_Printf(LogDEBUG, "%s: tty_Create: physical (get): fd = %d,"
 704              " iflag = %lx, oflag = %lx, cflag = %lx\n", p->link.name, p->fd,
 705              (u_long)ios.c_iflag, (u_long)ios.c_oflag, (u_long)ios.c_cflag);
 706
 707   cfmakeraw(&ios);
 708   if (p->cfg.rts_cts)
 709     ios.c_cflag |= CLOCAL | CCTS_OFLOW | CRTS_IFLOW;
 710   else {
 711     ios.c_cflag |= CLOCAL;
 712     ios.c_iflag |= IXOFF;
 713   }
 714   ios.c_iflag |= IXON;
 715   if (p->type != PHYS_DEDICATED)
 716     ios.c_cflag |= HUPCL;
 717
 718   if (p->type != PHYS_DIRECT) {
 719       /* Change tty speed when we're not in -direct mode */
 720       ios.c_cflag &= ~(CSIZE | PARODD | PARENB);
 721       ios.c_cflag |= p->cfg.parity;
 722       if (cfsetspeed(&ios, IntToSpeed(p->cfg.speed)) == -1)
 723         log_Printf(LogWARN, "%s: %s: Unable to set speed to %d\n",
 724                   p->link.name, p->name.full, p->cfg.speed);
 725   }
 726
 727   if (tcsetattr(p->fd, TCSADRAIN, &ios) == -1) {
 728     log_Printf(LogWARN, "%s: tcsetattr: Failed configuring device\n",
 729                p->link.name);
 730     if (p->type != PHYS_DIRECT && p->cfg.speed > 115200)
 731       log_Printf(LogWARN, "%.*s             Perhaps the speed is unsupported\n",
 732                  (int)strlen(p->link.name), "");
 733   }
 734
 735   log_Printf(LogDEBUG, "%s: physical (put): iflag = %lx, oflag = %lx, "
 736             "cflag = %lx\n", p->link.name, (u_long)ios.c_iflag,
 737             (u_long)ios.c_oflag, (u_long)ios.c_cflag);
 738
 739   oldflag = fcntl(p->fd, F_GETFL, 0);
 740   if (oldflag < 0) {
 741     /* Complete failure - parent doesn't continue trying to ``create'' */
 742
 743     log_Printf(LogWARN, "%s: Open: Cannot get physical flags: %s\n",
 744                p->link.name, strerror(errno));
 745     tty_Cooked(p);
 746     close(p->fd);
 747     p->fd = -1;
 748     free(dev);
 749     return NULL;
 750   } else
 751     fcntl(p->fd, F_SETFL, oldflag & ~O_NONBLOCK);
 752
 753   physical_SetupStack(p, dev->dev.name, PHYSICAL_NOFORCE);
 754
 755   return &dev->dev;
 756 }