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