progs/tset.c

   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 */