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 <stdlib.h> 38 #include <string.h> 39 #include <sysexits.h> 40 #include <sys/uio.h> 41 #include <termios.h> 42 #include <unistd.h> 43 44 #include "layer.h" 45 #include "defs.h" 46 #include "mbuf.h" 47 #include "log.h" 48 #include "timer.h" 49 #include "lqr.h" 50 #include "hdlc.h" 51 #include "throughput.h" 52 #include "fsm.h" 53 #include "lcp.h" 54 #include "ccp.h" 55 #include "link.h" 56 #include "async.h" 57 #include "descriptor.h" 58 #include "physical.h" 59 #include "mp.h" 60 #include "chat.h" 61 #include "auth.h" 62 #include "chap.h" 63 #include "cbcp.h" 64 #include "datalink.h" 65 #include "main.h" 66 #include "tty.h" 67 68 #if defined(__mac68k__) || defined(__macppc__) 69 #undef CRTS_IFLOW 70 #undef CCTS_OFLOW 71 #define CRTS_IFLOW CDTRCTS 72 #define CCTS_OFLOW CDTRCTS 73 #endif 74 75 #define Online(dev) ((dev)->mbits & TIOCM_CD) 76 77 struct ttydevice { 78 struct device dev; /* What struct physical knows about */ 79 struct pppTimer Timer; /* CD checks */ 80 int mbits; /* Current DCD status */ 81 int carrier_seconds; /* seconds before CD is *required* */ 82 struct termios ios; /* To be able to reset from raw mode */ 83 }; 84 85 #define device2tty(d) ((d)->type == TTY_DEVICE ? (struct ttydevice *)d : NULL) 86 87 int 88 tty_DeviceSize(void) 89 { 90 return sizeof(struct ttydevice); 91 } 92 93 /* 94 * tty_Timeout() watches the DCD signal and mentions it if it's status 95 * changes. 96 */ 97 static void 98 tty_Timeout(void *data) 99 { 100 struct physical *p = data; 101 struct ttydevice *dev = device2tty(p->handler); 102 int ombits, change; 103 104 timer_Stop(&dev->Timer); 105 dev->Timer.load = SECTICKS; /* Once a second please */ 106 timer_Start(&dev->Timer); 107 ombits = dev->mbits; 108 109 if (p->fd >= 0) { 110 if (ioctl(p->fd, TIOCMGET, &dev->mbits) < 0) { 111 /* we must be a pty ? */ 112 if (p->cfg.cd.necessity != CD_DEFAULT) 113 log_Printf(LogWARN, "%s: Carrier ioctl not supported, " 114 "using ``set cd off''\n", p->link.name); 115 timer_Stop(&dev->Timer); 116 dev->mbits = TIOCM_CD; 117 return; 118 } 119 } else 120 dev->mbits = 0; 121 122 if (ombits == -1) { 123 /* First time looking for carrier */ 124 if (Online(dev)) 125 log_Printf(LogPHASE, "%s: %s: CD detected\n", p->link.name, p->name.full); 126 else if (++dev->carrier_seconds >= dev->dev.cd.delay) { 127 if (dev->dev.cd.necessity == CD_REQUIRED) 128 log_Printf(LogPHASE, "%s: %s: Required CD not detected\n", 129 p->link.name, p->name.full); 130 else { 131 log_Printf(LogPHASE, "%s: %s doesn't support CD\n", 132 p->link.name, p->name.full); 133 dev->mbits = TIOCM_CD; /* Dodgy null-modem cable ? */ 134 } 135 timer_Stop(&dev->Timer); 136 /* tty_AwaitCarrier() will notice */ 137 } else { 138 /* Keep waiting */ 139 log_Printf(LogDEBUG, "%s: %s: Still no carrier (%d/%d)\n", 140 p->link.name, p->name.full, dev->carrier_seconds, 141 dev->dev.cd.delay); 142 dev->mbits = -1; 143 } 144 } else { 145 change = ombits ^ dev->mbits; 146 if (change & TIOCM_CD) { 147 if (dev->mbits & TIOCM_CD) 148 log_Printf(LogDEBUG, "%s: offline -> online\n", p->link.name); 149 else { 150 log_Printf(LogDEBUG, "%s: online -> offline\n", p->link.name); 151 log_Printf(LogPHASE, "%s: Carrier lost\n", p->link.name); 152 datalink_Down(p->dl, CLOSE_NORMAL); 153 timer_Stop(&dev->Timer); 154 } 155 } else 156 log_Printf(LogDEBUG, "%s: Still %sline\n", p->link.name, 157 Online(dev) ? "on" : "off"); 158 } 159 } 160 161 static void 162 tty_StartTimer(struct physical *p) 163 { 164 struct ttydevice *dev = device2tty(p->handler); 165 166 timer_Stop(&dev->Timer); 167 dev->Timer.load = SECTICKS; 168 dev->Timer.func = tty_Timeout; 169 dev->Timer.name = "tty CD"; 170 dev->Timer.arg = p; 171 log_Printf(LogDEBUG, "%s: Using tty_Timeout [%p]\n", 172 p->link.name, tty_Timeout); 173 timer_Start(&dev->Timer); 174 } 175 176 static int 177 tty_AwaitCarrier(struct physical *p) 178 { 179 struct ttydevice *dev = device2tty(p->handler); 180 181 if (dev->dev.cd.necessity == CD_NOTREQUIRED || physical_IsSync(p)) 182 return CARRIER_OK; 183 184 if (dev->mbits == -1) { 185 if (dev->Timer.state == TIMER_STOPPED) { 186 dev->carrier_seconds = 0; 187 tty_StartTimer(p); 188 } 189 return CARRIER_PENDING; /* Not yet ! */ 190 } 191 192 return Online(dev) ? CARRIER_OK : CARRIER_LOST; 193 } 194 195 static int 196 tty_Raw(struct physical *p) 197 { 198 struct ttydevice *dev = device2tty(p->handler); 199 struct termios ios; 200 int oldflag; 201 202 log_Printf(LogDEBUG, "%s: Entering tty_Raw\n", p->link.name); 203 204 if (p->type != PHYS_DIRECT && p->fd >= 0 && !Online(dev)) 205 log_Printf(LogDEBUG, "%s: Raw: descriptor = %d, mbits = %x\n", 206 p->link.name, p->fd, dev->mbits); 207 208 if (!physical_IsSync(p)) { 209 tcgetattr(p->fd, &ios); 210 cfmakeraw(&ios); 211 if (p->cfg.rts_cts) 212 ios.c_cflag |= CLOCAL | CCTS_OFLOW | CRTS_IFLOW; 213 else 214 ios.c_cflag |= CLOCAL; 215 216 if (p->type != PHYS_DEDICATED) 217 ios.c_cflag |= HUPCL; 218 219 if (tcsetattr(p->fd, TCSANOW, &ios) == -1) 220 log_Printf(LogWARN, "%s: tcsetattr: Failed configuring device\n", 221 p->link.name); 222 } 223 224 oldflag = fcntl(p->fd, F_GETFL, 0); 225 if (oldflag < 0) 226 return 0; 227 fcntl(p->fd, F_SETFL, oldflag | O_NONBLOCK); 228 229 return 1; 230 } 231 232 static void 233 tty_Offline(struct physical *p) 234 { 235 struct ttydevice *dev = device2tty(p->handler); 236 237 if (p->fd >= 0) { 238 timer_Stop(&dev->Timer); 239 dev->mbits &= ~TIOCM_DTR; /* XXX: Hmm, what's this supposed to do ? */ 240 if (Online(dev)) { 241 struct termios tio; 242 243 tcgetattr(p->fd, &tio); 244 if (cfsetspeed(&tio, B0) == -1 || tcsetattr(p->fd, TCSANOW, &tio) == -1) 245 log_Printf(LogWARN, "%s: Unable to set physical to speed 0\n", 246 p->link.name); 247 } 248 } 249 } 250 251 static void 252 tty_Cooked(struct physical *p) 253 { 254 struct ttydevice *dev = device2tty(p->handler); 255 int oldflag; 256 257 tty_Offline(p); /* In case of emergency close()s */ 258 259 tcflush(p->fd, TCIOFLUSH); 260 261 if (!physical_IsSync(p) && tcsetattr(p->fd, TCSAFLUSH, &dev->ios) == -1) 262 log_Printf(LogWARN, "%s: tcsetattr: Unable to restore device settings\n", 263 p->link.name); 264 265 if ((oldflag = fcntl(p->fd, F_GETFL, 0)) != -1) 266 fcntl(p->fd, F_SETFL, oldflag & ~O_NONBLOCK); 267 } 268 269 static void 270 tty_StopTimer(struct physical *p) 271 { 272 struct ttydevice *dev = device2tty(p->handler); 273 274 timer_Stop(&dev->Timer); 275 } 276 277 static void 278 tty_Free(struct physical *p) 279 { 280 struct ttydevice *dev = device2tty(p->handler); 281 282 tty_Offline(p); /* In case of emergency close()s */ 283 free(dev); 284 } 285 286 static int 287 tty_Speed(struct physical *p) 288 { 289 struct termios ios; 290 291 if (tcgetattr(p->fd, &ios) == -1) 292 return 0; 293 294 return SpeedToInt(cfgetispeed(&ios)); 295 } 296 297 static const char * 298 tty_OpenInfo(struct physical *p) 299 { 300 struct ttydevice *dev = device2tty(p->handler); 301 static char buf[13]; 302 303 if (Online(dev)) 304 strcpy(buf, "with"); 305 else 306 strcpy(buf, "no"); 307 strcat(buf, " carrier"); 308 309 return buf; 310 } 311 312 static void 313 tty_device2iov(struct device *d, struct iovec *iov, int *niov, 314 int maxiov, int *auxfd, int *nauxfd) 315 { 316 struct ttydevice *dev = device2tty(d); 317 int sz = physical_MaxDeviceSize(); 318 319 iov[*niov].iov_base = realloc(d, sz); 320 if (iov[*niov].iov_base == NULL) { 321 log_Printf(LogALERT, "Failed to allocate memory: %d\n", sz); 322 AbortProgram(EX_OSERR); 323 } 324 iov[*niov].iov_len = sz; 325 (*niov)++; 326 327 if (dev->Timer.state != TIMER_STOPPED) { 328 timer_Stop(&dev->Timer); 329 dev->Timer.state = TIMER_RUNNING; 330 } 331 } 332 333 static struct device basettydevice = { 334 TTY_DEVICE, 335 "tty", 336 0, 337 { CD_VARIABLE, DEF_TTYCDDELAY }, 338 tty_AwaitCarrier, 339 NULL, 340 tty_Raw, 341 tty_Offline, 342 tty_Cooked, 343 tty_StopTimer, 344 tty_Free, 345 NULL, 346 NULL, 347 tty_device2iov, 348 tty_Speed, 349 tty_OpenInfo 350 }; 351 352 struct device * 353 tty_iov2device(int type, struct physical *p, struct iovec *iov, int *niov, 354 int maxiov, int *auxfd, int *nauxfd) 355 { 356 if (type == TTY_DEVICE) { 357 struct ttydevice *dev = (struct ttydevice *)iov[(*niov)++].iov_base; 358 359 dev = realloc(dev, sizeof *dev); /* Reduce to the correct size */ 360 if (dev == NULL) { 361 log_Printf(LogALERT, "Failed to allocate memory: %d\n", 362 (int)(sizeof *dev)); 363 AbortProgram(EX_OSERR); 364 } 365 366 /* Refresh function pointers etc */ 367 memcpy(&dev->dev, &basettydevice, sizeof dev->dev); 368 369 physical_SetupStack(p, dev->dev.name, PHYSICAL_NOFORCE); 370 if (dev->Timer.state != TIMER_STOPPED) { 371 dev->Timer.state = TIMER_STOPPED; 372 p->handler = &dev->dev; /* For the benefit of StartTimer */ 373 tty_StartTimer(p); 374 } 375 return &dev->dev; 376 } 377 378 return NULL; 379 } 380 381 struct device * 382 tty_Create(struct physical *p) 383 { 384 struct ttydevice *dev; 385 struct termios ios; 386 int oldflag; 387 388 if (p->fd < 0 || !isatty(p->fd)) 389 /* Don't want this */ 390 return NULL; 391 392 if (*p->name.full == '\0') { 393 physical_SetDevice(p, ttyname(p->fd)); 394 log_Printf(LogDEBUG, "%s: Input is a tty (%s)\n", 395 p->link.name, p->name.full); 396 } else 397 log_Printf(LogDEBUG, "%s: Opened %s\n", p->link.name, p->name.full); 398 399 /* We're gonna return a ttydevice (unless something goes horribly wrong) */ 400 401 if ((dev = malloc(sizeof *dev)) == NULL) { 402 /* Complete failure - parent doesn't continue trying to ``create'' */ 403 close(p->fd); 404 p->fd = -1; 405 return NULL; 406 } 407 408 memcpy(&dev->dev, &basettydevice, sizeof dev->dev); 409 memset(&dev->Timer, '\0', sizeof dev->Timer); 410 dev->mbits = -1; 411 tcgetattr(p->fd, &ios); 412 dev->ios = ios; 413 414 if (p->cfg.cd.necessity != CD_DEFAULT) 415 /* Any override is ok for the tty device */ 416 dev->dev.cd = p->cfg.cd; 417 418 log_Printf(LogDEBUG, "%s: tty_Create: physical (get): fd = %d," 419 " iflag = %lx, oflag = %lx, cflag = %lx\n", p->link.name, p->fd, 420 (u_long)ios.c_iflag, (u_long)ios.c_oflag, (u_long)ios.c_cflag); 421 422 cfmakeraw(&ios); 423 if (p->cfg.rts_cts) 424 ios.c_cflag |= CLOCAL | CCTS_OFLOW | CRTS_IFLOW; 425 else { 426 ios.c_cflag |= CLOCAL; 427 ios.c_iflag |= IXOFF; 428 } 429 ios.c_iflag |= IXON; 430 if (p->type != PHYS_DEDICATED) 431 ios.c_cflag |= HUPCL; 432 433 if (p->type != PHYS_DIRECT) { 434 /* Change tty speed when we're not in -direct mode */ 435 ios.c_cflag &= ~(CSIZE | PARODD | PARENB); 436 ios.c_cflag |= p->cfg.parity; 437 if (cfsetspeed(&ios, IntToSpeed(p->cfg.speed)) == -1) 438 log_Printf(LogWARN, "%s: %s: Unable to set speed to %d\n", 439 p->link.name, p->name.full, p->cfg.speed); 440 } 441 442 if (tcsetattr(p->fd, TCSADRAIN, &ios) == -1) { 443 log_Printf(LogWARN, "%s: tcsetattr: Failed configuring device\n", 444 p->link.name); 445 if (p->type != PHYS_DIRECT && p->cfg.speed > 115200) 446 log_Printf(LogWARN, "%.*s Perhaps the speed is unsupported\n", 447 (int)strlen(p->link.name), ""); 448 } 449 450 log_Printf(LogDEBUG, "%s: physical (put): iflag = %lx, oflag = %lx, " 451 "cflag = %lx\n", p->link.name, (u_long)ios.c_iflag, 452 (u_long)ios.c_oflag, (u_long)ios.c_cflag); 453 454 oldflag = fcntl(p->fd, F_GETFL, 0); 455 if (oldflag < 0) { 456 /* Complete failure - parent doesn't continue trying to ``create'' */ 457 458 log_Printf(LogWARN, "%s: Open: Cannot get physical flags: %s\n", 459 p->link.name, strerror(errno)); 460 tty_Cooked(p); 461 close(p->fd); 462 p->fd = -1; 463 free(dev); 464 return NULL; 465 } else 466 fcntl(p->fd, F_SETFL, oldflag & ~O_NONBLOCK); 467 468 physical_SetupStack(p, dev->dev.name, PHYSICAL_NOFORCE); 469 470 return &dev->dev; 471 } 472