1 /**************************************************************************** 2 * Copyright (c) 1998,1999,2000 Free Software Foundation, Inc. * 3 * * 4 * Permission is hereby granted, free of charge, to any person obtaining a * 5 * copy of this software and associated documentation files (the * 6 * "Software"), to deal in the Software without restriction, including * 7 * without limitation the rights to use, copy, modify, merge, publish, * 8 * distribute, distribute with modifications, sublicense, and/or sell * 9 * copies of the Software, and to permit persons to whom the Software is * 10 * furnished to do so, subject to the following conditions: * 11 * * 12 * The above copyright notice and this permission notice shall be included * 13 * in all copies or substantial portions of the Software. * 14 * * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * 16 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * 17 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * 18 * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, * 19 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR * 20 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR * 21 * THE USE OR OTHER DEALINGS IN THE SOFTWARE. * 22 * * 23 * Except as contained in this notice, the name(s) of the above copyright * 24 * holders shall not be used in advertising or otherwise to promote the * 25 * sale, use or other dealings in this Software without prior written * 26 * authorization. * 27 ****************************************************************************/ 28 29 /**************************************************************************** 30 * Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995 * 31 * and: Eric S. Raymond <esr@snark.thyrsus.com> * 32 ****************************************************************************/ 33 34 /* 35 * tset.c - terminal initialization utility 36 * 37 * This code was mostly swiped from 4.4BSD tset, with some obsolescent 38 * cruft removed and substantial portions rewritten. A Regents of the 39 * University of California copyright applies to some portions of the 40 * code, and is reproduced below: 41 */ 42 /*- 43 * Copyright (c) 1980, 1991, 1993 44 * The Regents of the University of California. All rights reserved. 45 * 46 * Redistribution and use in source and binary forms, with or without 47 * modification, are permitted provided that the following conditions 48 * are met: 49 * 1. Redistributions of source code must retain the above copyright 50 * notice, this list of conditions and the following disclaimer. 51 * 2. Redistributions in binary form must reproduce the above copyright 52 * notice, this list of conditions and the following disclaimer in the 53 * documentation and/or other materials provided with the distribution. 54 * 3. All advertising materials mentioning features or use of this software 55 * must display the following acknowledgement: 56 * This product includes software developed by the University of 57 * California, Berkeley and its contributors. 58 * 4. Neither the name of the University nor the names of its contributors 59 * may be used to endorse or promote products derived from this software 60 * without specific prior written permission. 61 * 62 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 63 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 64 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 65 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 66 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 67 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 68 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 69 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 70 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 71 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 72 * SUCH DAMAGE. 73 */ 74 75 #define __INTERNAL_CAPS_VISIBLE /* we need to see has_hardware_tabs */ 76 #include <progs.priv.h> 77 78 #include <errno.h> 79 #include <stdio.h> 80 #include <termcap.h> 81 #include <fcntl.h> 82 83 #if HAVE_GETTTYNAM && HAVE_TTYENT_H 84 #include <ttyent.h> 85 #endif 86 #ifdef NeXT 87 char *ttyname(int fd); 88 #endif 89 90 /* this is just to stifle a missing-prototype warning */ 91 #ifdef linux 92 # include <sys/ioctl.h> 93 #endif 94 95 #if NEED_PTEM_H 96 /* they neglected to define struct winsize in termios.h -- it's only 97 in termio.h */ 98 #include <sys/stream.h> 99 #include <sys/ptem.h> 100 #endif 101 102 #include <curses.h> /* for bool typedef */ 103 #include <dump_entry.h> 104 #include <transform.h> 105 106 MODULE_ID("$Id: tset.c,v 0.47 2000/10/08 01:01:08 tom Exp $") 107 108 extern char **environ; 109 110 #undef CTRL 111 #define CTRL(x) ((x) & 0x1f) 112 113 const char *_nc_progname = "tset"; 114 115 static TTY mode, oldmode; 116 117 static bool isreset = FALSE; /* invoked as reset */ 118 static int terasechar = -1; /* new erase character */ 119 static int intrchar = -1; /* new interrupt character */ 120 static int tkillchar = -1; /* new kill character */ 121 static int tlines, tcolumns; /* window size */ 122 123 #define LOWERCASE(c) ((isalpha(c) && isupper(c)) ? tolower(c) : (c)) 124 125 static int 126 CaselessCmp(const char *a, const char *b) 127 { /* strcasecmp isn't portable */ 128 while (*a && *b) { 129 int cmp = LOWERCASE(*a) - LOWERCASE(*b); 130 if (cmp != 0) 131 break; 132 a++, b++; 133 } 134 return LOWERCASE(*a) - LOWERCASE(*b); 135 } 136 137 static void 138 err(const char *fmt,...) 139 { 140 va_list ap; 141 va_start(ap, fmt); 142 (void) fprintf(stderr, "tset: "); 143 (void) vfprintf(stderr, fmt, ap); 144 va_end(ap); 145 (void) fprintf(stderr, "\n"); 146 exit(EXIT_FAILURE); 147 /* NOTREACHED */ 148 } 149 150 static void 151 failed(const char *msg) 152 { 153 char temp[BUFSIZ]; 154 perror(strncat(strcpy(temp, "tset: "), msg, sizeof(temp) - 10)); 155 exit(EXIT_FAILURE); 156 /* NOTREACHED */ 157 } 158 159 static void 160 cat(char *file) 161 { 162 register int fd, nr, nw; 163 char buf[BUFSIZ]; 164 165 if ((fd = open(file, O_RDONLY, 0)) < 0) 166 failed(file); 167 168 while ((nr = read(fd, buf, sizeof(buf))) > 0) 169 if ((nw = write(STDERR_FILENO, buf, (size_t) nr)) == -1) 170 failed("write to stderr"); 171 if (nr != 0) 172 failed(file); 173 (void) close(fd); 174 } 175 176 static int 177 outc(int c) 178 { 179 return putc(c, stderr); 180 } 181 182 /* Prompt the user for a terminal type. */ 183 static const char * 184 askuser(const char *dflt) 185 { 186 static char answer[256]; 187 char *p; 188 189 /* We can get recalled; if so, don't continue uselessly. */ 190 if (feof(stdin) || ferror(stdin)) { 191 (void) fprintf(stderr, "\n"); 192 exit(EXIT_FAILURE); 193 } 194 for (;;) { 195 if (dflt) 196 (void) fprintf(stderr, "Terminal type? [%s] ", dflt); 197 else 198 (void) fprintf(stderr, "Terminal type? "); 199 (void) fflush(stderr); 200 201 if (fgets(answer, sizeof(answer), stdin) == 0) { 202 if (dflt == 0) { 203 (void) fprintf(stderr, "\n"); 204 exit(EXIT_FAILURE); 205 } 206 return (dflt); 207 } 208 209 if ((p = strchr(answer, '\n')) != 0) 210 *p = '\0'; 211 if (answer[0]) 212 return (answer); 213 if (dflt != 0) 214 return (dflt); 215 } 216 } 217 218 /************************************************************************** 219 * 220 * Mapping logic begins here 221 * 222 **************************************************************************/ 223 224 /* Baud rate conditionals for mapping. */ 225 #define GT 0x01 226 #define EQ 0x02 227 #define LT 0x04 228 #define NOT 0x08 229 #define GE (GT | EQ) 230 #define LE (LT | EQ) 231 232 typedef struct map { 233 struct map *next; /* Linked list of maps. */ 234 const char *porttype; /* Port type, or "" for any. */ 235 const char *type; /* Terminal type to select. */ 236 int conditional; /* Baud rate conditionals bitmask. */ 237 int speed; /* Baud rate to compare against. */ 238 } MAP; 239 240 static MAP *cur, *maplist; 241 242 typedef struct speeds { 243 const char *string; 244 int speed; 245 } SPEEDS; 246 247 static const SPEEDS speeds[] = 248 { 249 {"0", B0}, 250 {"50", B50}, 251 {"75", B75}, 252 {"110", B110}, 253 {"134", B134}, 254 {"134.5", B134}, 255 {"150", B150}, 256 {"200", B200}, 257 {"300", B300}, 258 {"600", B600}, 259 {"1200", B1200}, 260 {"1800", B1800}, 261 {"2400", B2400}, 262 {"4800", B4800}, 263 {"9600", B9600}, 264 /* sgttyb may define up to this point */ 265 #ifdef B19200 266 {"19200", B19200}, 267 #endif 268 #ifdef B38400 269 {"38400", B38400}, 270 #endif 271 #ifdef B19200 272 {"19200", B19200}, 273 #endif 274 #ifdef B38400 275 {"38400", B38400}, 276 #endif 277 #ifdef B19200 278 {"19200", B19200}, 279 #else 280 #ifdef EXTA 281 {"19200", EXTA}, 282 #endif 283 #endif 284 #ifdef B38400 285 {"38400", B38400}, 286 #else 287 #ifdef EXTB 288 {"38400", EXTB}, 289 #endif 290 #endif 291 #ifdef B57600 292 {"57600", B57600}, 293 #endif 294 #ifdef B115200 295 {"115200", B115200}, 296 #endif 297 #ifdef B230400 298 {"230400", B230400}, 299 #endif 300 #ifdef B460800 301 {"460800", B460800}, 302 #endif 303 {(char *) 0, 0} 304 }; 305 306 static int 307 tbaudrate(char *rate) 308 { 309 const SPEEDS *sp; 310 int found = FALSE; 311 312 /* The baudrate number can be preceded by a 'B', which is ignored. */ 313 if (*rate == 'B') 314 ++rate; 315 316 for (sp = speeds; sp->string; ++sp) { 317 if (!CaselessCmp(rate, sp->string)) { 318 found = TRUE; 319 break; 320 } 321 } 322 if (!found) 323 err("unknown baud rate %s", rate); 324 return (sp->speed); 325 } 326 327 /* 328 * Syntax for -m: 329 * [port-type][test baudrate]:terminal-type 330 * The baud rate tests are: >, <, @, =, ! 331 */ 332 static void 333 add_mapping(const char *port, char *arg) 334 { 335 MAP *mapp; 336 char *copy, *p; 337 const char *termp; 338 char *base = 0; 339 340 copy = strdup(arg); 341 mapp = malloc(sizeof(MAP)); 342 if (copy == 0 || mapp == 0) 343 failed("malloc"); 344 mapp->next = 0; 345 if (maplist == 0) 346 cur = maplist = mapp; 347 else { 348 cur->next = mapp; 349 cur = mapp; 350 } 351 352 mapp->porttype = arg; 353 mapp->conditional = 0; 354 355 arg = strpbrk(arg, "><@=!:"); 356 357 if (arg == 0) { /* [?]term */ 358 mapp->type = mapp->porttype; 359 mapp->porttype = 0; 360 goto done; 361 } 362 363 if (arg == mapp->porttype) /* [><@=! baud]:term */ 364 termp = mapp->porttype = 0; 365 else 366 termp = base = arg; 367 368 for (;; ++arg) { /* Optional conditionals. */ 369 switch (*arg) { 370 case '<': 371 if (mapp->conditional & GT) 372 goto badmopt; 373 mapp->conditional |= LT; 374 break; 375 case '>': 376 if (mapp->conditional & LT) 377 goto badmopt; 378 mapp->conditional |= GT; 379 break; 380 case '@': 381 case '=': /* Not documented. */ 382 mapp->conditional |= EQ; 383 break; 384 case '!': 385 mapp->conditional |= NOT; 386 break; 387 default: 388 goto next; 389 } 390 } 391 392 next: 393 if (*arg == ':') { 394 if (mapp->conditional) 395 goto badmopt; 396 ++arg; 397 } else { /* Optional baudrate. */ 398 arg = strchr(p = arg, ':'); 399 if (arg == 0) 400 goto badmopt; 401 *arg++ = '\0'; 402 mapp->speed = tbaudrate(p); 403 } 404 405 if (arg == (char *) 0) /* Non-optional type. */ 406 goto badmopt; 407 408 mapp->type = arg; 409 410 /* Terminate porttype, if specified. */ 411 if (termp != 0) 412 *base = '\0'; 413 414 /* If a NOT conditional, reverse the test. */ 415 if (mapp->conditional & NOT) 416 mapp->conditional = ~mapp->conditional & (EQ | GT | LT); 417 418 /* If user specified a port with an option flag, set it. */ 419 done:if (port) { 420 if (mapp->porttype) 421 badmopt:err("illegal -m option format: %s", copy); 422 mapp->porttype = port; 423 } 424 #ifdef MAPDEBUG 425 (void) printf("port: %s\n", mapp->porttype ? mapp->porttype : "ANY"); 426 (void) printf("type: %s\n", mapp->type); 427 (void) printf("conditional: "); 428 p = ""; 429 if (mapp->conditional & GT) { 430 (void) printf("GT"); 431 p = "/"; 432 } 433 if (mapp->conditional & EQ) { 434 (void) printf("%sEQ", p); 435 p = "/"; 436 } 437 if (mapp->conditional & LT) 438 (void) printf("%sLT", p); 439 (void) printf("\nspeed: %d\n", mapp->speed); 440 #endif 441 } 442 443 /* 444 * Return the type of terminal to use for a port of type 'type', as specified 445 * by the first applicable mapping in 'map'. If no mappings apply, return 446 * 'type'. 447 */ 448 static const char * 449 mapped(const char *type) 450 { 451 MAP *mapp; 452 int match; 453 454 for (mapp = maplist; mapp; mapp = mapp->next) 455 if (mapp->porttype == 0 || !strcmp(mapp->porttype, type)) { 456 switch (mapp->conditional) { 457 case 0: /* No test specified. */ 458 match = TRUE; 459 break; 460 case EQ: 461 match = (ospeed == mapp->speed); 462 break; 463 case GE: 464 match = (ospeed >= mapp->speed); 465 break; 466 case GT: 467 match = (ospeed > mapp->speed); 468 break; 469 case LE: 470 match = (ospeed <= mapp->speed); 471 break; 472 case LT: 473 match = (ospeed < mapp->speed); 474 break; 475 default: 476 match = FALSE; 477 } 478 if (match) 479 return (mapp->type); 480 } 481 /* No match found; return given type. */ 482 return (type); 483 } 484 485 /************************************************************************** 486 * 487 * Entry fetching 488 * 489 **************************************************************************/ 490 491 /* 492 * Figure out what kind of terminal we're dealing with, and then read in 493 * its termcap entry. 494 */ 495 static const char * 496 get_termcap_entry(char *userarg) 497 { 498 int rval, errret; 499 char *p; 500 const char *ttype; 501 #if HAVE_GETTTYNAM 502 struct ttyent *t; 503 #else 504 FILE *fp; 505 #endif 506 char *ttypath; 507 508 if (userarg) { 509 ttype = userarg; 510 goto found; 511 } 512 513 /* Try the environment. */ 514 if ((ttype = getenv("TERM")) != 0) 515 goto map; 516 517 if ((ttypath = ttyname(STDERR_FILENO)) != 0) { 518 p = _nc_basename(ttypath); 519 #if HAVE_GETTTYNAM 520 /* 521 * We have the 4.3BSD library call getttynam(3); that means 522 * there's an /etc/ttys to look up device-to-type mappings in. 523 * Try ttyname(3); check for dialup or other mapping. 524 */ 525 if ((t = getttynam(p))) { 526 ttype = t->ty_type; 527 goto map; 528 } 529 #else 530 if ((fp = fopen("/etc/ttytype", "r")) != 0 531 || (fp = fopen("/etc/ttys", "r")) != 0) { 532 char buffer[BUFSIZ]; 533 char *s, *t, *d; 534 535 while (fgets(buffer, sizeof(buffer) - 1, fp) != 0) { 536 for (s = buffer, t = d = 0; *s; s++) { 537 if (isspace(*s)) 538 *s = '\0'; 539 else if (t == 0) 540 t = s; 541 else if (d == 0 && s != buffer && s[-1] == '\0') 542 d = s; 543 } 544 if (t != 0 && d != 0 && !strcmp(d, p)) { 545 ttype = strdup(t); 546 fclose(fp); 547 goto map; 548 } 549 } 550 fclose(fp); 551 } 552 #endif /* HAVE_GETTTYNAM */ 553 } 554 555 /* If still undefined, use "unknown". */ 556 ttype = "unknown"; 557 558 map:ttype = mapped(ttype); 559 560 /* 561 * If not a path, remove TERMCAP from the environment so we get a 562 * real entry from /etc/termcap. This prevents us from being fooled 563 * by out of date stuff in the environment. 564 */ 565 found:if ((p = getenv("TERMCAP")) != 0 && *p != '/') { 566 /* 'unsetenv("TERMCAP")' is not portable. 567 * The 'environ' array is better. 568 */ 569 int n; 570 for (n = 0; environ[n] != 0; n++) { 571 if (!strncmp("TERMCAP=", environ[n], 8)) { 572 while ((environ[n] = environ[n + 1]) != 0) { 573 n++; 574 } 575 break; 576 } 577 } 578 } 579 580 /* 581 * ttype now contains a pointer to the type of the terminal. 582 * If the first character is '?', ask the user. 583 */ 584 if (ttype[0] == '?') { 585 if (ttype[1] != '\0') 586 ttype = askuser(ttype + 1); 587 else 588 ttype = askuser(0); 589 } 590 /* Find the terminfo entry. If it doesn't exist, ask the user. */ 591 while ((rval = setupterm((NCURSES_CONST char *) ttype, STDOUT_FILENO, 592 &errret)) != OK) { 593 if (errret == 0) { 594 (void) fprintf(stderr, "tset: unknown terminal type %s\n", 595 ttype); 596 ttype = 0; 597 } else { 598 (void) fprintf(stderr, 599 "tset: can't initialize terminal type %s (error %d)\n", 600 ttype, errret); 601 ttype = 0; 602 } 603 ttype = askuser(ttype); 604 } 605 #if BROKEN_LINKER 606 tgetflag("am"); /* force lib_termcap.o to be linked for 'ospeed' */ 607 #endif 608 return (ttype); 609 } 610 611 /************************************************************************** 612 * 613 * Mode-setting logic 614 * 615 **************************************************************************/ 616 617 /* some BSD systems have these built in, some systems are missing 618 * one or more definitions. The safest solution is to override. 619 */ 620 #undef CEOF 621 #undef CERASE 622 #undef CINTR 623 #undef CKILL 624 #undef CLNEXT 625 #undef CRPRNT 626 #undef CQUIT 627 #undef CSTART 628 #undef CSTOP 629 #undef CSUSP 630 631 /* control-character defaults */ 632 #define CEOF CTRL('D') 633 #define CERASE CTRL('H') 634 #define CINTR 127 /* ^? */ 635 #define CKILL CTRL('U') 636 #define CLNEXT CTRL('v') 637 #define CRPRNT CTRL('r') 638 #define CQUIT CTRL('\\') 639 #define CSTART CTRL('Q') 640 #define CSTOP CTRL('S') 641 #define CSUSP CTRL('Z') 642 643 #define CHK(val, dft) ((int)val <= 0 ? dft : val) 644 645 static bool set_tabs(void); 646 647 /* 648 * Reset the terminal mode bits to a sensible state. Very useful after 649 * a child program dies in raw mode. 650 */ 651 static void 652 reset_mode(void) 653 { 654 #ifdef TERMIOS 655 tcgetattr(STDERR_FILENO, &mode); 656 #else 657 stty(STDERR_FILENO, &mode); 658 #endif 659 660 #ifdef TERMIOS 661 #if defined(VDISCARD) && defined(CDISCARD) 662 mode.c_cc[VDISCARD] = CHK(mode.c_cc[VDISCARD], CDISCARD); 663 #endif 664 mode.c_cc[VEOF] = CHK(mode.c_cc[VEOF], CEOF); 665 mode.c_cc[VERASE] = CHK(mode.c_cc[VERASE], CERASE); 666 #if defined(VFLUSH) && defined(CFLUSH) 667 mode.c_cc[VFLUSH] = CHK(mode.c_cc[VFLUSH], CFLUSH); 668 #endif 669 mode.c_cc[VINTR] = CHK(mode.c_cc[VINTR], CINTR); 670 mode.c_cc[VKILL] = CHK(mode.c_cc[VKILL], CKILL); 671 #if defined(VLNEXT) && defined(CLNEXT) 672 mode.c_cc[VLNEXT] = CHK(mode.c_cc[VLNEXT], CLNEXT); 673 #endif 674 mode.c_cc[VQUIT] = CHK(mode.c_cc[VQUIT], CQUIT); 675 #if defined(VREPRINT) && defined(CRPRNT) 676 mode.c_cc[VREPRINT] = CHK(mode.c_cc[VREPRINT], CRPRNT); 677 #endif 678 #if defined(VSTART) && defined(CSTART) 679 mode.c_cc[VSTART] = CHK(mode.c_cc[VSTART], CSTART); 680 #endif 681 #if defined(VSTOP) && defined(CSTOP) 682 mode.c_cc[VSTOP] = CHK(mode.c_cc[VSTOP], CSTOP); 683 #endif 684 #if defined(VSUSP) && defined(CSUSP) 685 mode.c_cc[VSUSP] = CHK(mode.c_cc[VSUSP], CSUSP); 686 #endif 687 #if defined(VWERASE) && defined(CWERASE) 688 mode.c_cc[VWERASE] = CHK(mode.c_cc[VWERASE], CWERASE); 689 #endif 690 691 mode.c_iflag &= ~(IGNBRK | PARMRK | INPCK | ISTRIP | INLCR | IGNCR 692 #ifdef IUCLC 693 | IUCLC 694 #endif 695 #ifdef IXANY 696 | IXANY 697 #endif 698 | IXOFF); 699 700 mode.c_iflag |= (BRKINT | IGNPAR | ICRNL | IXON 701 #ifdef IMAXBEL 702 | IMAXBEL 703 #endif 704 ); 705 706 mode.c_oflag &= ~(0 707 #ifdef OLCUC 708 | OLCUC 709 #endif 710 #ifdef OCRNL 711 | OCRNL 712 #endif 713 #ifdef ONOCR 714 | ONOCR 715 #endif 716 #ifdef ONLRET 717 | ONLRET 718 #endif 719 #ifdef OFILL 720 | OFILL 721 #endif 722 #ifdef OFDEL 723 | OFDEL 724 #endif 725 #ifdef NLDLY 726 | NLDLY | CRDLY | TABDLY | BSDLY | VTDLY | FFDLY 727 #endif 728 ); 729 730 mode.c_oflag |= (OPOST 731 #ifdef ONLCR 732 | ONLCR 733 #endif 734 ); 735 736 mode.c_cflag &= ~(CSIZE | CSTOPB | PARENB | PARODD | CLOCAL); 737 mode.c_cflag |= (CS8 | CREAD); 738 mode.c_lflag &= ~(ECHONL | NOFLSH 739 #ifdef TOSTOP 740 | TOSTOP 741 #endif 742 #ifdef ECHOPTR 743 | ECHOPRT 744 #endif 745 #ifdef XCASE 746 | XCASE 747 #endif 748 ); 749 750 mode.c_lflag |= (ISIG | ICANON | ECHO | ECHOE | ECHOK 751 #ifdef ECHOCTL 752 | ECHOCTL 753 #endif 754 #ifdef ECHOKE 755 | ECHOKE 756 #endif 757 ); 758 #endif 759 760 #ifdef TERMIOS 761 tcsetattr(STDERR_FILENO, TCSADRAIN, &mode); 762 #else 763 stty(STDERR_FILENO, &mode); 764 #endif 765 } 766 767 /* 768 * Returns a "good" value for the erase character. This is loosely based on 769 * the BSD4.4 logic. 770 */ 771 #ifdef TERMIOS 772 static int 773 default_erase(void) 774 { 775 int result; 776 777 if (over_strike 778 && key_backspace != 0 779 && strlen(key_backspace) == 1) 780 result = key_backspace[0]; 781 else 782 result = CERASE; 783 784 return result; 785 } 786 #endif 787 788 /* 789 * Update the values of the erase, interrupt, and kill characters in 'mode'. 790 * 791 * SVr4 tset (e.g., Solaris 2.5) only modifies the intr, quit or erase 792 * characters if they're unset, or if we specify them as options. This differs 793 * from BSD 4.4 tset, which always sets erase. 794 */ 795 static void 796 set_control_chars(void) 797 { 798 #ifdef TERMIOS 799 if (mode.c_cc[VERASE] == 0 || terasechar >= 0) 800 mode.c_cc[VERASE] = terasechar >= 0 ? terasechar : default_erase(); 801 802 if (mode.c_cc[VINTR] == 0 || intrchar >= 0) 803 mode.c_cc[VINTR] = intrchar >= 0 ? intrchar : CINTR; 804 805 if (mode.c_cc[VKILL] == 0 || tkillchar >= 0) 806 mode.c_cc[VKILL] = tkillchar >= 0 ? tkillchar : CKILL; 807 #endif 808 } 809 810 /* 811 * Set up various conversions in 'mode', including parity, tabs, returns, 812 * echo, and case, according to the termcap entry. If the program we're 813 * running was named with a leading upper-case character, map external 814 * uppercase to internal lowercase. 815 */ 816 static void 817 set_conversions(void) 818 { 819 #ifdef __OBSOLETE__ 820 /* 821 * Conversion logic for some *really* ancient terminal glitches, 822 * not supported in terminfo. Left here for succeeding generations 823 * to marvel at. 824 */ 825 if (tgetflag("UC")) { 826 #ifdef IUCLC 827 mode.c_iflag |= IUCLC; 828 mode.c_oflag |= OLCUC; 829 #endif 830 } else if (tgetflag("LC")) { 831 #ifdef IUCLC 832 mode.c_iflag &= ~IUCLC; 833 mode.c_oflag &= ~OLCUC; 834 #endif 835 } 836 mode.c_iflag &= ~(PARMRK | INPCK); 837 mode.c_lflag |= ICANON; 838 if (tgetflag("EP")) { 839 mode.c_cflag |= PARENB; 840 mode.c_cflag &= ~PARODD; 841 } 842 if (tgetflag("OP")) { 843 mode.c_cflag |= PARENB; 844 mode.c_cflag |= PARODD; 845 } 846 #endif /* __OBSOLETE__ */ 847 848 #ifdef TERMIOS 849 #ifdef ONLCR 850 mode.c_oflag |= ONLCR; 851 #endif 852 mode.c_iflag |= ICRNL; 853 mode.c_lflag |= ECHO; 854 #ifdef OXTABS 855 mode.c_oflag |= OXTABS; 856 #endif /* OXTABS */ 857 858 /* test used to be tgetflag("NL") */ 859 if (newline != (char *) 0 && newline[0] == '\n' && !newline[1]) { 860 /* Newline, not linefeed. */ 861 #ifdef ONLCR 862 mode.c_oflag &= ~ONLCR; 863 #endif 864 mode.c_iflag &= ~ICRNL; 865 } 866 #ifdef __OBSOLETE__ 867 if (tgetflag("HD")) /* Half duplex. */ 868 mode.c_lflag &= ~ECHO; 869 #endif /* __OBSOLETE__ */ 870 #ifdef OXTABS 871 /* test used to be tgetflag("pt") */ 872 if (has_hardware_tabs) /* Print tabs. */ 873 mode.c_oflag &= ~OXTABS; 874 #endif /* OXTABS */ 875 mode.c_lflag |= (ECHOE | ECHOK); 876 #endif 877 } 878 879 /* Output startup string. */ 880 static void 881 set_init(void) 882 { 883 char *p; 884 bool settle; 885 886 #ifdef __OBSOLETE__ 887 if (pad_char != (char *) 0) /* Get/set pad character. */ 888 PC = pad_char[0]; 889 #endif /* OBSOLETE */ 890 891 #ifdef TAB3 892 if (oldmode.c_oflag & (TAB3 | ONLCR | OCRNL | ONLRET)) { 893 oldmode.c_oflag &= (TAB3 | ONLCR | OCRNL | ONLRET); 894 tcsetattr(STDERR_FILENO, TCSADRAIN, &oldmode); 895 } 896 #endif 897 settle = set_tabs(); 898 899 if (isreset) { 900 if ((p = reset_1string) != 0) { 901 tputs(p, 0, outc); 902 settle = TRUE; 903 } 904 if ((p = reset_2string) != 0) { 905 tputs(p, 0, outc); 906 settle = TRUE; 907 } 908 /* What about rf, rs3, as per terminfo man page? */ 909 /* also might be nice to send rmacs, rmul, rmm */ 910 if ((p = reset_file) != 0 911 || (p = init_file) != 0) { 912 cat(p); 913 settle = TRUE; 914 } 915 } 916 917 if (settle) { 918 (void) putc('\r', stderr); 919 (void) fflush(stderr); 920 (void) napms(1000); /* Settle the terminal. */ 921 } 922 } 923 924 /* 925 * Set the hardware tabs on the terminal, using the ct (clear all tabs), 926 * st (set one tab) and ch (horizontal cursor addressing) capabilities. 927 * This is done before if and is, so they can patch in case we blow this. 928 * Return TRUE if we set any tab stops, FALSE if not. 929 */ 930 static bool 931 set_tabs() 932 { 933 if (set_tab && clear_all_tabs) { 934 int c; 935 936 (void) putc('\r', stderr); /* Force to left margin. */ 937 tputs(clear_all_tabs, 0, outc); 938 939 for (c = 8; c < tcolumns; c += 8) { 940 /* Get to the right column. In BSD tset, this 941 * used to try a bunch of half-clever things 942 * with cup and hpa, for an average saving of 943 * somewhat less than two character times per 944 * tab stop, less that .01 sec at 2400cps. We 945 * lost all this cruft because it seemed to be 946 * introducing some odd bugs. 947 * ----------12345678----------- */ 948 (void) fputs(" ", stderr); 949 tputs(set_tab, 0, outc); 950 } 951 putc('\r', stderr); 952 return (TRUE); 953 } 954 return (FALSE); 955 } 956 957 /************************************************************************** 958 * 959 * Main sequence 960 * 961 **************************************************************************/ 962 963 /* 964 * Tell the user if a control key has been changed from the default value. 965 */ 966 #ifdef TERMIOS 967 static void 968 report(const char *name, int which, unsigned def) 969 { 970 unsigned older, newer; 971 char *p; 972 973 newer = mode.c_cc[which]; 974 older = oldmode.c_cc[which]; 975 976 if (older == newer && older == def) 977 return; 978 979 (void) fprintf(stderr, "%s %s ", name, older == newer ? "is" : "set to"); 980 981 /* 982 * Check 'delete' before 'backspace', since the key_backspace value 983 * is ambiguous. 984 */ 985 if (newer == 0177) 986 (void) fprintf(stderr, "delete.\n"); 987 else if ((p = key_backspace) != 0 988 && newer == (unsigned char) p[0] 989 && p[1] == '\0') 990 (void) fprintf(stderr, "backspace.\n"); 991 else if (newer < 040) { 992 newer ^= 0100; 993 (void) fprintf(stderr, "control-%c (^%c).\n", newer, newer); 994 } else 995 (void) fprintf(stderr, "%c.\n", newer); 996 } 997 #endif 998 999 /* 1000 * Convert the obsolete argument forms into something that getopt can handle. 1001 * This means that -e, -i and -k get default arguments supplied for them. 1002 */ 1003 static void 1004 obsolete(char **argv) 1005 { 1006 for (; *argv; ++argv) { 1007 char *parm = argv[0]; 1008 1009 if (parm[0] == '-' && parm[1] == '\0') { 1010 argv[0] = strdup("-q"); 1011 continue; 1012 } 1013 1014 if ((parm[0] != '-') 1015 || (argv[1] && argv[1][0] != '-') 1016 || (parm[1] != 'e' && parm[1] != 'i' && parm[1] != 'k') 1017 || (parm[2] != '\0')) 1018 continue; 1019 switch (argv[0][1]) { 1020 case 'e': 1021 argv[0] = strdup("-e^H"); 1022 break; 1023 case 'i': 1024 argv[0] = strdup("-i^C"); 1025 break; 1026 case 'k': 1027 argv[0] = strdup("-k^U"); 1028 break; 1029 } 1030 } 1031 } 1032 1033 static void 1034 usage(const char *pname) 1035 { 1036 (void) fprintf(stderr, 1037 "usage: %s [-IQVrs] [-] [-e ch] [-i ch] [-k ch] [-m mapping] [terminal]\n", pname); 1038 exit(EXIT_FAILURE); 1039 } 1040 1041 static char 1042 arg_to_char(void) 1043 { 1044 return (optarg[0] == '^' && optarg[1] != '\0') 1045 ? ((optarg[1] == '?') ? '\177' : CTRL(optarg[1])) 1046 : optarg[0]; 1047 } 1048 1049 int 1050 main(int argc, char **argv) 1051 { 1052 #if defined(TIOCGWINSZ) && defined(TIOCSWINSZ) 1053 struct winsize win; 1054 #endif 1055 int ch, noinit, noset, quiet, Sflag, sflag, showterm; 1056 const char *p; 1057 const char *ttype; 1058 1059 if (GET_TTY(STDERR_FILENO, &mode) < 0) 1060 failed("standard error"); 1061 oldmode = mode; 1062 #ifdef TERMIOS 1063 ospeed = cfgetospeed(&mode); 1064 #else 1065 ospeed = mode.sg_ospeed; 1066 #endif 1067 1068 p = _nc_basename(*argv); 1069 if (!strcmp(p, PROG_RESET)) { 1070 isreset = TRUE; 1071 reset_mode(); 1072 } 1073 1074 obsolete(argv); 1075 noinit = noset = quiet = Sflag = sflag = showterm = 0; 1076 while ((ch = getopt(argc, argv, "a:d:e:Ii:k:m:np:qQSrsV")) != EOF) { 1077 switch (ch) { 1078 case 'q': /* display term only */ 1079 noset = 1; 1080 break; 1081 case 'a': /* OBSOLETE: map identifier to type */ 1082 add_mapping("arpanet", optarg); 1083 break; 1084 case 'd': /* OBSOLETE: map identifier to type */ 1085 add_mapping("dialup", optarg); 1086 break; 1087 case 'e': /* erase character */ 1088 terasechar = arg_to_char(); 1089 break; 1090 case 'I': /* no initialization strings */ 1091 noinit = 1; 1092 break; 1093 case 'i': /* interrupt character */ 1094 intrchar = arg_to_char(); 1095 break; 1096 case 'k': /* kill character */ 1097 tkillchar = arg_to_char(); 1098 break; 1099 case 'm': /* map identifier to type */ 1100 add_mapping(0, optarg); 1101 break; 1102 case 'n': /* OBSOLETE: set new tty driver */ 1103 break; 1104 case 'p': /* OBSOLETE: map identifier to type */ 1105 add_mapping("plugboard", optarg); 1106 break; 1107 case 'Q': /* don't output control key settings */ 1108 quiet = 1; 1109 break; 1110 case 'S': /* OBSOLETE: output TERM & TERMCAP */ 1111 Sflag = 1; 1112 break; 1113 case 'r': /* display term on stderr */ 1114 showterm = 1; 1115 break; 1116 case 's': /* output TERM set command */ 1117 sflag = 1; 1118 break; 1119 case 'V': 1120 puts(curses_version()); 1121 return EXIT_SUCCESS; 1122 case '?': 1123 default: 1124 usage(*argv); 1125 } 1126 } 1127 argc -= optind; 1128 argv += optind; 1129 1130 if (argc > 1) 1131 usage(*argv); 1132 1133 ttype = get_termcap_entry(*argv); 1134 1135 if (!noset) { 1136 tcolumns = columns; 1137 tlines = lines; 1138 1139 #if defined(TIOCGWINSZ) && defined(TIOCSWINSZ) 1140 /* Set window size */ 1141 (void) ioctl(STDERR_FILENO, TIOCGWINSZ, &win); 1142 if (win.ws_row == 0 && win.ws_col == 0 && 1143 tlines > 0 && tcolumns > 0) { 1144 win.ws_row = tlines; 1145 win.ws_col = tcolumns; 1146 (void) ioctl(STDERR_FILENO, TIOCSWINSZ, &win); 1147 } 1148 #endif 1149 set_control_chars(); 1150 set_conversions(); 1151 1152 if (!noinit) 1153 set_init(); 1154 1155 /* Set the modes if they've changed. */ 1156 if (memcmp(&mode, &oldmode, sizeof(mode))) { 1157 #ifdef TERMIOS 1158 tcsetattr(STDERR_FILENO, TCSADRAIN, &mode); 1159 #else 1160 stty(STDERR_FILENO, &mode); 1161 #endif 1162 } 1163 } 1164 1165 /* Get the terminal name from the entry. */ 1166 ttype = _nc_first_name(cur_term->type.term_names); 1167 1168 if (noset) 1169 (void) printf("%s\n", ttype); 1170 else { 1171 if (showterm) 1172 (void) fprintf(stderr, "Terminal type is %s.\n", ttype); 1173 /* 1174 * If erase, kill and interrupt characters could have been 1175 * modified and not -Q, display the changes. 1176 */ 1177 #ifdef TERMIOS 1178 if (!quiet) { 1179 report("Erase", VERASE, CERASE); 1180 report("Kill", VKILL, CINTR); 1181 report("Interrupt", VINTR, CKILL); 1182 } 1183 #endif 1184 } 1185 1186 if (Sflag) 1187 err("The -S option is not supported under terminfo."); 1188 1189 if (sflag) { 1190 /* 1191 * Figure out what shell we're using. A hack, we look for an 1192 * environmental variable SHELL ending in "csh". 1193 */ 1194 if ((p = getenv("SHELL")) != 0 1195 && !strcmp(p + strlen(p) - 3, "csh")) 1196 p = "set noglob;\nsetenv TERM %s;\nunset noglob;\n"; 1197 else 1198 p = "TERM=%s;\n"; 1199 (void) printf(p, ttype); 1200 } 1201 1202 return EXIT_SUCCESS; 1203 } 1204 1205 /* tset.c ends here */ 1206