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$
  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     unsigned 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 unsigned
 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_PATHSIZ];
 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_NODESIZ];
 260   struct ngm_mkpeer ngm;
 261   struct ngm_connect ngc;
 262   int ldisc, cs, ds, hot;
 263   unsigned speed;
 264
 265   /*
 266    * Don't use the netgraph line discipline for now.  Using it works, but
 267    * carrier cannot be detected via TIOCMGET and the device doesn't become
 268    * selectable with 0 bytes to read when carrier is lost :(
 269    */
 270   return 0;
 271
 272   reply = (struct ng_mesg *)rbuf;
 273   info = (struct nodeinfo *)reply->data;
 274
 275   loadmodules(LOAD_VERBOSLY, "netgraph", "ng_tty", "ng_async", "ng_socket",
 276               NULL);
 277
 278   /* Get the speed before loading the line discipline */
 279   speed = physical_GetSpeed(p);
 280
 281   if (ioctl(p->fd, TIOCGETD, &dev->real.disc) < 0) {
 282     log_Printf(LogDEBUG, "%s: Couldn't get tty line discipline\n",
 283                p->link.name);
 284     return 0;
 285   }
 286   ldisc = NETGRAPHDISC;
 287   if (ID0ioctl(p->fd, TIOCSETD, &ldisc) < 0) {
 288     log_Printf(LogDEBUG, "%s: Couldn't set NETGRAPHDISC line discipline\n",
 289                p->link.name);
 290     return 0;
 291   }
 292
 293   /* Get the name of the tty node */
 294   if (ioctl(p->fd, NGIOCGINFO, info) < 0) {
 295     log_Printf(LogWARN, "%s: ioctl(NGIOCGINFO): %s\n", p->link.name,
 296                strerror(errno));
 297     ID0ioctl(p->fd, TIOCSETD, &dev->real.disc);
 298     return 0;
 299   }
 300   snprintf(ttypath, sizeof ttypath, "%s:", info->name);
 301
 302   /* Create a socket node for our endpoint (and to send messages via) */
 303   if (ID0NgMkSockNode(NULL, &cs, &ds) == -1) {
 304     log_Printf(LogWARN, "%s: NgMkSockNode: %s\n", p->link.name,
 305                strerror(errno));
 306     ID0ioctl(p->fd, TIOCSETD, &dev->real.disc);
 307     return 0;
 308   }
 309
 310   /* Set the ``hot char'' on the TTY node */
 311   hot = HDLC_SYN;
 312   log_Printf(LogDEBUG, "%s: Set tty hotchar to 0x%02x\n", p->link.name, hot);
 313   if (NgSendMsg(cs, ttypath, NGM_TTY_COOKIE,
 314       NGM_TTY_SET_HOTCHAR, &hot, sizeof hot) < 0) {
 315     log_Printf(LogWARN, "%s: Can't set hot char\n", p->link.name);
 316     goto failed;
 317   }
 318
 319   /* Attach an async converter node */
 320   snprintf(ngm.type, sizeof ngm.type, "%s", NG_ASYNC_NODE_TYPE);
 321   snprintf(ngm.ourhook, sizeof ngm.ourhook, "%s", NG_TTY_HOOK);
 322   snprintf(ngm.peerhook, sizeof ngm.peerhook, "%s", NG_ASYNC_HOOK_ASYNC);
 323   log_Printf(LogDEBUG, "%s: Send mkpeer async:%s to %s:%s\n", p->link.name,
 324              ngm.peerhook, ttypath, ngm.ourhook);
 325   if (NgSendMsg(cs, ttypath, NGM_GENERIC_COOKIE,
 326       NGM_MKPEER, &ngm, sizeof ngm) < 0) {
 327     log_Printf(LogWARN, "%s: Can't create %s node\n", p->link.name,
 328                NG_ASYNC_NODE_TYPE);
 329     goto failed;
 330   }
 331
 332   /* Connect the async node to our socket */
 333   snprintf(ngc.path, sizeof ngc.path, "%s%s", ttypath, NG_TTY_HOOK);
 334   snprintf(ngc.peerhook, sizeof ngc.peerhook, "%s", NG_ASYNC_HOOK_SYNC);
 335   memcpy(ngc.ourhook, ngc.peerhook, sizeof ngc.ourhook);
 336   log_Printf(LogDEBUG, "%s: Send connect %s:%s to .:%s\n", p->link.name,
 337              ngc.path, ngc.peerhook, ngc.ourhook);
 338   if (NgSendMsg(cs, ".:", NGM_GENERIC_COOKIE, NGM_CONNECT,
 339       &ngc, sizeof ngc) < 0) {
 340     log_Printf(LogWARN, "%s: Can't connect .:%s -> %s.%s: %s\n",
 341                p->link.name, ngc.ourhook, ngc.path, ngc.peerhook,
 342                strerror(errno));
 343     goto failed;
 344   }
 345
 346   /* Get the async node id */
 347   if (NgSendMsg(cs, ngc.path, NGM_GENERIC_COOKIE, NGM_NODEINFO, NULL, 0) < 0) {
 348     log_Printf(LogWARN, "%s: Can't request async node info at %s: %s\n",
 349                p->link.name, ngc.path, strerror(errno));
 350     goto failed;
 351   }
 352   if (NgRecvMsg(cs, reply, sizeof rbuf, NULL) < 0) {
 353     log_Printf(LogWARN, "%s: Can't obtain async node info at %s: %s\n",
 354                p->link.name, ngc.path, strerror(errno));
 355     goto failed;
 356   }
 357
 358   /* All done, set up our device state */
 359   snprintf(dev->hook, sizeof dev->hook, "%s", ngc.ourhook);
 360   dev->cs = cs;
 361   dev->real.fd = p->fd;
 362   p->fd = ds;
 363   dev->real.speed = speed;
 364   physical_SetSync(p);
 365
 366   tty_SetAsyncParams(p, 0xffffffff, 0xffffffff);
 367   physical_SetupStack(p, dev->dev.name, PHYSICAL_NOFORCE);
 368   log_Printf(LogPHASE, "%s: Loaded netgraph tty line discipline\n",
 369              p->link.name);
 370
 371   return 1;
 372
 373 failed:
 374   ID0ioctl(p->fd, TIOCSETD, &dev->real.disc);
 375   close(ds);
 376   close(cs);
 377
 378   return 0;
 379 }
 380
 381 static void
 382 UnloadLineDiscipline(struct physical *p)
 383 {
 384   struct ttydevice *dev = device2tty(p->handler);
 385
 386   if (isngtty(dev)) {
 387 log_Printf(LogPHASE, "back to speed %d\n", dev->real.speed);
 388     if (!physical_SetSpeed(p, dev->real.speed))
 389       log_Printf(LogWARN, "Couldn't reset tty speed to %d\n", dev->real.speed);
 390     dev->real.speed = 0;
 391     close(p->fd);
 392     p->fd = dev->real.fd;
 393     dev->real.fd = -1;
 394     close(dev->cs);
 395     dev->cs = -1;
 396     *dev->hook = '\0';
 397     if (ID0ioctl(p->fd, TIOCSETD, &dev->real.disc) == 0) {
 398       physical_SetupStack(p, dev->dev.name, PHYSICAL_NOFORCE);
 399       log_Printf(LogPHASE, "%s: Unloaded netgraph tty line discipline\n",
 400                  p->link.name);
 401     } else
 402       log_Printf(LogWARN, "%s: Failed to unload netgraph tty line discipline\n",
 403                  p->link.name);
 404   }
 405 }
 406
 407 static ssize_t
 408 tty_Write(struct physical *p, const void *v, size_t n)
 409 {
 410   struct ttydevice *dev = device2tty(p->handler);
 411
 412   if (isngtty(dev))
 413     return NgSendData(p->fd, dev->hook, v, n) == -1 ? -1 : (ssize_t)n;
 414   else
 415     return write(p->fd, v, n);
 416 }
 417
 418 static ssize_t
 419 tty_Read(struct physical *p, void *v, size_t n)
 420 {
 421   struct ttydevice *dev = device2tty(p->handler);
 422   char hook[sizeof NG_ASYNC_HOOK_SYNC];
 423
 424   if (isngtty(dev))
 425     return NgRecvData(p->fd, v, n, hook);
 426   else
 427     return read(p->fd, v, n);
 428 }
 429
 430 #endif /* NETGRAPH */
 431
 432 static int
 433 tty_Raw(struct physical *p)
 434 {
 435   struct ttydevice *dev = device2tty(p->handler);
 436   struct termios ios;
 437   int oldflag;
 438
 439   log_Printf(LogDEBUG, "%s: Entering tty_Raw\n", p->link.name);
 440
 441   if (p->type != PHYS_DIRECT && p->fd >= 0 && !Online(dev))
 442     log_Printf(LogDEBUG, "%s: Raw: descriptor = %d, mbits = %x\n",
 443               p->link.name, p->fd, dev->mbits);
 444
 445   if (!physical_IsSync(p)) {
 446 #ifndef NONETGRAPH
 447     if (!LoadLineDiscipline(p))
 448 #endif
 449     {
 450       tcgetattr(p->fd, &ios);
 451       cfmakeraw(&ios);
 452       if (p->cfg.rts_cts)
 453         ios.c_cflag |= CLOCAL | CCTS_OFLOW | CRTS_IFLOW;
 454       else
 455         ios.c_cflag |= CLOCAL;
 456
 457       if (p->type != PHYS_DEDICATED)
 458         ios.c_cflag |= HUPCL;
 459
 460       if (tcsetattr(p->fd, TCSANOW, &ios) == -1)
 461         log_Printf(LogWARN, "%s: tcsetattr: Failed configuring device\n",
 462                    p->link.name);
 463     }
 464   }
 465
 466   oldflag = fcntl(p->fd, F_GETFL, 0);
 467   if (oldflag < 0)
 468     return 0;
 469   fcntl(p->fd, F_SETFL, oldflag | O_NONBLOCK);
 470
 471   return 1;
 472 }
 473
 474 static void
 475 tty_Offline(struct physical *p)
 476 {
 477   struct ttydevice *dev = device2tty(p->handler);
 478
 479   if (p->fd >= 0) {
 480     timer_Stop(&dev->Timer);
 481     dev->mbits &= ~TIOCM_DTR;   /* XXX: Hmm, what's this supposed to do ? */
 482     if (Online(dev)) {
 483       struct termios tio;
 484
 485       tcgetattr(p->fd, &tio);
 486       if (cfsetspeed(&tio, B0) == -1 || tcsetattr(p->fd, TCSANOW, &tio) == -1)
 487         log_Printf(LogWARN, "%s: Unable to set physical to speed 0\n",
 488                    p->link.name);
 489     }
 490   }
 491 }
 492
 493 static void
 494 tty_Cooked(struct physical *p)
 495 {
 496   struct ttydevice *dev = device2tty(p->handler);
 497   int oldflag;
 498
 499   tty_Offline(p);       /* In case of emergency close()s */
 500
 501   tcflush(p->fd, TCIOFLUSH);
 502
 503   if (!physical_IsSync(p) && tcsetattr(p->fd, TCSAFLUSH, &dev->ios) == -1)
 504     log_Printf(LogWARN, "%s: tcsetattr: Unable to restore device settings\n",
 505                p->link.name);
 506
 507 #ifndef NONETGRAPH
 508   UnloadLineDiscipline(p);
 509 #endif
 510
 511   if ((oldflag = fcntl(p->fd, F_GETFL, 0)) != -1)
 512     fcntl(p->fd, F_SETFL, oldflag & ~O_NONBLOCK);
 513 }
 514
 515 static void
 516 tty_StopTimer(struct physical *p)
 517 {
 518   struct ttydevice *dev = device2tty(p->handler);
 519
 520   timer_Stop(&dev->Timer);
 521 }
 522
 523 static void
 524 tty_Free(struct physical *p)
 525 {
 526   struct ttydevice *dev = device2tty(p->handler);
 527
 528   tty_Offline(p);       /* In case of emergency close()s */
 529   free(dev);
 530 }
 531
 532 static unsigned
 533 tty_Speed(struct physical *p)
 534 {
 535   struct termios ios;
 536
 537   if (tcgetattr(p->fd, &ios) == -1)
 538     return 0;
 539
 540   return SpeedToUnsigned(cfgetispeed(&ios));
 541 }
 542
 543 static const char *
 544 tty_OpenInfo(struct physical *p)
 545 {
 546   struct ttydevice *dev = device2tty(p->handler);
 547   static char buf[13];
 548
 549   if (Online(dev))
 550     strcpy(buf, "with");
 551   else
 552     strcpy(buf, "no");
 553   strcat(buf, " carrier");
 554
 555   return buf;
 556 }
 557
 558 static int
 559 tty_Slot(struct physical *p)
 560 {
 561   struct ttyent *ttyp;
 562   int slot;
 563
 564   setttyent();
 565   for (slot = 1; (ttyp = getttyent()); ++slot)
 566     if (!strcmp(ttyp->ty_name, p->name.base)) {
 567       endttyent();
 568       return slot;
 569     }
 570
 571   endttyent();
 572   return -1;
 573 }
 574
 575 static void
 576 tty_device2iov(struct device *d, struct iovec *iov, int *niov,
 577                int maxiov __unused,
 578 #ifndef NONETGRAPH
 579                int *auxfd, int *nauxfd
 580 #else
 581                int *auxfd __unused, int *nauxfd __unused
 582 #endif
 583                )
 584 {
 585   struct ttydevice *dev = device2tty(d);
 586   int sz = physical_MaxDeviceSize();
 587
 588   iov[*niov].iov_base = realloc(d, sz);
 589   if (iov[*niov].iov_base == NULL) {
 590     log_Printf(LogALERT, "Failed to allocate memory: %d\n", sz);
 591     AbortProgram(EX_OSERR);
 592   }
 593   iov[*niov].iov_len = sz;
 594   (*niov)++;
 595
 596 #ifndef NONETGRAPH
 597   if (dev->cs >= 0) {
 598     *auxfd = dev->cs;
 599     (*nauxfd)++;
 600   }
 601 #endif
 602
 603   if (dev->Timer.state != TIMER_STOPPED) {
 604     timer_Stop(&dev->Timer);
 605     dev->Timer.state = TIMER_RUNNING;
 606   }
 607 }
 608
 609 static struct device basettydevice = {
 610   TTY_DEVICE,
 611   "tty",
 612   0,
 613   { CD_VARIABLE, DEF_TTYCDDELAY },
 614   tty_AwaitCarrier,
 615   NULL,
 616   tty_Raw,
 617   tty_Offline,
 618   tty_Cooked,
 619   tty_SetAsyncParams,
 620   tty_StopTimer,
 621   tty_Free,
 622   tty_Read,
 623   tty_Write,
 624   tty_device2iov,
 625   tty_Speed,
 626   tty_OpenInfo,
 627   tty_Slot
 628 };
 629
 630 struct device *
 631 tty_iov2device(int type, struct physical *p, struct iovec *iov, int *niov,
 632                int maxiov __unused,
 633 #ifndef NONETGRAPH
 634                int *auxfd, int *nauxfd
 635 #else
 636                int *auxfd __unused, int *nauxfd __unused
 637 #endif
 638                )
 639 {
 640   if (type == TTY_DEVICE) {
 641     struct ttydevice *dev = (struct ttydevice *)iov[(*niov)++].iov_base;
 642
 643     dev = realloc(dev, sizeof *dev);    /* Reduce to the correct size */
 644     if (dev == NULL) {
 645       log_Printf(LogALERT, "Failed to allocate memory: %d\n",
 646                  (int)(sizeof *dev));
 647       AbortProgram(EX_OSERR);
 648     }
 649
 650 #ifndef NONETGRAPH
 651     if (*nauxfd) {
 652       dev->cs = *auxfd;
 653       (*nauxfd)--;
 654     } else
 655       dev->cs = -1;
 656 #endif
 657
 658     /* Refresh function pointers etc */
 659     memcpy(&dev->dev, &basettydevice, sizeof dev->dev);
 660
 661     physical_SetupStack(p, dev->dev.name, PHYSICAL_NOFORCE);
 662     if (dev->Timer.state != TIMER_STOPPED) {
 663       dev->Timer.state = TIMER_STOPPED;
 664       p->handler = &dev->dev;           /* For the benefit of StartTimer */
 665       tty_StartTimer(p);
 666     }
 667     return &dev->dev;
 668   }
 669
 670   return NULL;
 671 }
 672
 673 struct device *
 674 tty_Create(struct physical *p)
 675 {
 676   struct ttydevice *dev;
 677   struct termios ios;
 678   int oldflag;
 679
 680   if (p->fd < 0 || !isatty(p->fd))
 681     /* Don't want this */
 682     return NULL;
 683
 684   if (*p->name.full == '\0') {
 685     physical_SetDevice(p, ttyname(p->fd));
 686     log_Printf(LogDEBUG, "%s: Input is a tty (%s)\n",
 687                p->link.name, p->name.full);
 688   } else
 689     log_Printf(LogDEBUG, "%s: Opened %s\n", p->link.name, p->name.full);
 690
 691   /* We're gonna return a ttydevice (unless something goes horribly wrong) */
 692
 693   if ((dev = malloc(sizeof *dev)) == NULL) {
 694     /* Complete failure - parent doesn't continue trying to ``create'' */
 695     close(p->fd);
 696     p->fd = -1;
 697     return NULL;
 698   }
 699
 700   memcpy(&dev->dev, &basettydevice, sizeof dev->dev);
 701   memset(&dev->Timer, '\0', sizeof dev->Timer);
 702   dev->mbits = -1;
 703 #ifndef NONETGRAPH
 704   dev->real.speed = 0;
 705   dev->real.fd = -1;
 706   dev->real.disc = -1;
 707   *dev->hook = '\0';
 708 #endif
 709   tcgetattr(p->fd, &ios);
 710   dev->ios = ios;
 711
 712   if (p->cfg.cd.necessity != CD_DEFAULT)
 713     /* Any override is ok for the tty device */
 714     dev->dev.cd = p->cfg.cd;
 715
 716   log_Printf(LogDEBUG, "%s: tty_Create: physical (get): fd = %d,"
 717              " iflag = %lx, oflag = %lx, cflag = %lx\n", p->link.name, p->fd,
 718              (u_long)ios.c_iflag, (u_long)ios.c_oflag, (u_long)ios.c_cflag);
 719
 720   cfmakeraw(&ios);
 721   if (p->cfg.rts_cts)
 722     ios.c_cflag |= CLOCAL | CCTS_OFLOW | CRTS_IFLOW;
 723   else {
 724     ios.c_cflag |= CLOCAL;
 725     ios.c_iflag |= IXOFF;
 726   }
 727   ios.c_iflag |= IXON;
 728   if (p->type != PHYS_DEDICATED)
 729     ios.c_cflag |= HUPCL;
 730
 731   if (p->type != PHYS_DIRECT) {
 732       /* Change tty speed when we're not in -direct mode */
 733       ios.c_cflag &= ~(CSIZE | PARODD | PARENB);
 734       ios.c_cflag |= p->cfg.parity;
 735       if (cfsetspeed(&ios, UnsignedToSpeed(p->cfg.speed)) == -1)
 736         log_Printf(LogWARN, "%s: %s: Unable to set speed to %d\n",
 737                   p->link.name, p->name.full, p->cfg.speed);
 738   }
 739
 740   if (tcsetattr(p->fd, TCSADRAIN, &ios) == -1) {
 741     log_Printf(LogWARN, "%s: tcsetattr: Failed configuring device\n",
 742                p->link.name);
 743     if (p->type != PHYS_DIRECT && p->cfg.speed > 115200)
 744       log_Printf(LogWARN, "%.*s             Perhaps the speed is unsupported\n",
 745                  (int)strlen(p->link.name), "");
 746   }
 747
 748   log_Printf(LogDEBUG, "%s: physical (put): iflag = %lx, oflag = %lx, "
 749             "cflag = %lx\n", p->link.name, (u_long)ios.c_iflag,
 750             (u_long)ios.c_oflag, (u_long)ios.c_cflag);
 751
 752   oldflag = fcntl(p->fd, F_GETFL, 0);
 753   if (oldflag < 0) {
 754     /* Complete failure - parent doesn't continue trying to ``create'' */
 755
 756     log_Printf(LogWARN, "%s: Open: Cannot get physical flags: %s\n",
 757                p->link.name, strerror(errno));
 758     tty_Cooked(p);
 759     close(p->fd);
 760     p->fd = -1;
 761     free(dev);
 762     return NULL;
 763   } else
 764     fcntl(p->fd, F_SETFL, oldflag & ~O_NONBLOCK);
 765
 766   physical_SetupStack(p, dev->dev.name, PHYSICAL_NOFORCE);
 767
 768   return &dev->dev;
 769 }