progs/tset.c

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