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