ncurses 6.2 - patch 20210501
[ncurses.git] / progs / tset.c
1 /****************************************************************************
2  * Copyright 2020,2021 Thomas E. Dickey                                     *
3  * Copyright 1998-2016,2017 Free Software Foundation, Inc.                  *
4  *                                                                          *
5  * Permission is hereby granted, free of charge, to any person obtaining a  *
6  * copy of this software and associated documentation files (the            *
7  * "Software"), to deal in the Software without restriction, including      *
8  * without limitation the rights to use, copy, modify, merge, publish,      *
9  * distribute, distribute with modifications, sublicense, and/or sell       *
10  * copies of the Software, and to permit persons to whom the Software is    *
11  * furnished to do so, subject to the following conditions:                 *
12  *                                                                          *
13  * The above copyright notice and this permission notice shall be included  *
14  * in all copies or substantial portions of the Software.                   *
15  *                                                                          *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
17  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
18  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
19  * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
20  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
21  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
22  * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
23  *                                                                          *
24  * Except as contained in this notice, the name(s) of the above copyright   *
25  * holders shall not be used in advertising or otherwise to promote the     *
26  * sale, use or other dealings in this Software without prior written       *
27  * authorization.                                                           *
28  ****************************************************************************/
29
30 /****************************************************************************
31  *  Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995               *
32  *     and: Eric S. Raymond <esr@snark.thyrsus.com>                         *
33  *     and: Thomas E. Dickey                        1996-on                 *
34  ****************************************************************************/
35
36 /*
37  * Notes:
38  * The initial adaptation from 4.4BSD Lite sources in September 1995 used 686
39  * lines from that version, and made changes/additions for 150 lines.  There
40  * was no reformatting, so with/without ignoring whitespace, the amount of
41  * change is the same.
42  *
43  * Comparing with current (2009) source, excluding this comment:
44  * a) 209 lines match identically to the 4.4BSD Lite sources, with 771 lines
45  *    changed/added.
46  * a) Ignoring whitespace, the current version still uses 516 lines from the
47  *    4.4BSD Lite sources, with 402 lines changed/added.
48  *
49  * Raymond's original comment on this follows...
50  */
51
52 /*
53  * tset.c - terminal initialization utility
54  *
55  * This code was mostly swiped from 4.4BSD tset, with some obsolescent
56  * cruft removed and substantial portions rewritten.  A Regents of the
57  * University of California copyright applies to some portions of the
58  * code, and is reproduced below:
59  */
60 /*-
61  * Copyright (c) 1980, 1991, 1993
62  *      The Regents of the University of California.  All rights reserved.
63  *
64  * Redistribution and use in source and binary forms, with or without
65  * modification, are permitted provided that the following conditions
66  * are met:
67  * 1. Redistributions of source code must retain the above copyright
68  *    notice, this list of conditions and the following disclaimer.
69  * 2. Redistributions in binary form must reproduce the above copyright
70  *    notice, this list of conditions and the following disclaimer in the
71  *    documentation and/or other materials provided with the distribution.
72  * 3. Neither the name of the University nor the names of its contributors
73  *    may be used to endorse or promote products derived from this software
74  *    without specific prior written permission.
75  *
76  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
77  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
78  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
79  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
80  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
81  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
82  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
83  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
84  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
85  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
86  * SUCH DAMAGE.
87  */
88
89 #include <reset_cmd.h>
90 #include <termcap.h>
91 #include <transform.h>
92 #include <tty_settings.h>
93
94 #if HAVE_GETTTYNAM && HAVE_TTYENT_H
95 #include <ttyent.h>
96 #endif
97 #ifdef NeXT
98 char *ttyname(int fd);
99 #endif
100
101 MODULE_ID("$Id: tset.c,v 1.128 2021/04/03 23:03:48 tom Exp $")
102
103 #ifndef environ
104 extern char **environ;
105 #endif
106
107 const char *_nc_progname = "tset";
108
109 #define LOWERCASE(c) ((isalpha(UChar(c)) && isupper(UChar(c))) ? tolower(UChar(c)) : (c))
110
111 static GCC_NORETURN void exit_error(void);
112
113 static int
114 CaselessCmp(const char *a, const char *b)
115 {                               /* strcasecmp isn't portable */
116     while (*a && *b) {
117         int cmp = LOWERCASE(*a) - LOWERCASE(*b);
118         if (cmp != 0)
119             break;
120         a++, b++;
121     }
122     return LOWERCASE(*a) - LOWERCASE(*b);
123 }
124
125 static GCC_NORETURN void
126 exit_error(void)
127 {
128     restore_tty_settings();
129     (void) fprintf(stderr, "\n");
130     fflush(stderr);
131     ExitProgram(EXIT_FAILURE);
132     /* NOTREACHED */
133 }
134
135 static GCC_NORETURN void
136 err(const char *fmt, ...)
137 {
138     va_list ap;
139     va_start(ap, fmt);
140     (void) fprintf(stderr, "%s: ", _nc_progname);
141     (void) vfprintf(stderr, fmt, ap);
142     va_end(ap);
143     exit_error();
144     /* NOTREACHED */
145 }
146
147 static GCC_NORETURN void
148 failed(const char *msg)
149 {
150     char temp[BUFSIZ];
151     size_t len = strlen(_nc_progname) + 2;
152
153     if ((int) len < (int) sizeof(temp) - 12) {
154         _nc_STRCPY(temp, _nc_progname, sizeof(temp));
155         _nc_STRCAT(temp, ": ", sizeof(temp));
156     } else {
157         _nc_STRCPY(temp, "tset: ", sizeof(temp));
158     }
159     _nc_STRNCAT(temp, msg, sizeof(temp), sizeof(temp) - strlen(temp) - 2);
160     perror(temp);
161     exit_error();
162     /* NOTREACHED */
163 }
164
165 /* Prompt the user for a terminal type. */
166 static const char *
167 askuser(const char *dflt)
168 {
169     static char answer[256];
170
171     /* We can get recalled; if so, don't continue uselessly. */
172     clearerr(stdin);
173     if (feof(stdin) || ferror(stdin)) {
174         (void) fprintf(stderr, "\n");
175         exit_error();
176         /* NOTREACHED */
177     }
178
179     for (;;) {
180         char *p;
181
182         if (dflt)
183             (void) fprintf(stderr, "Terminal type? [%s] ", dflt);
184         else
185             (void) fprintf(stderr, "Terminal type? ");
186         (void) fflush(stderr);
187
188         if (fgets(answer, sizeof(answer), stdin) == 0) {
189             if (dflt == 0) {
190                 exit_error();
191                 /* NOTREACHED */
192             }
193             return (dflt);
194         }
195
196         if ((p = strchr(answer, '\n')) != 0)
197             *p = '\0';
198         if (answer[0])
199             return (answer);
200         if (dflt != 0)
201             return (dflt);
202     }
203 }
204
205 /**************************************************************************
206  *
207  * Mapping logic begins here
208  *
209  **************************************************************************/
210
211 /* Baud rate conditionals for mapping. */
212 #define GT              0x01
213 #define EQ              0x02
214 #define LT              0x04
215 #define NOT             0x08
216 #define GE              (GT | EQ)
217 #define LE              (LT | EQ)
218
219 typedef struct map {
220     struct map *next;           /* Linked list of maps. */
221     const char *porttype;       /* Port type, or "" for any. */
222     const char *type;           /* Terminal type to select. */
223     int conditional;            /* Baud rate conditionals bitmask. */
224     int speed;                  /* Baud rate to compare against. */
225 } MAP;
226
227 static MAP *cur, *maplist;
228
229 #define DATA(name,value) { { name }, value }
230
231 typedef struct speeds {
232     const char string[8];
233     int speed;
234 } SPEEDS;
235
236 #if defined(EXP_WIN32_DRIVER)
237 static const SPEEDS speeds[] =
238 {
239     {"0", 0}
240 };
241 #else
242 static const SPEEDS speeds[] =
243 {
244     DATA("0", B0),
245     DATA("50", B50),
246     DATA("75", B75),
247     DATA("110", B110),
248     DATA("134", B134),
249     DATA("134.5", B134),
250     DATA("150", B150),
251     DATA("200", B200),
252     DATA("300", B300),
253     DATA("600", B600),
254     DATA("1200", B1200),
255     DATA("1800", B1800),
256     DATA("2400", B2400),
257     DATA("4800", B4800),
258     DATA("9600", B9600),
259     /* sgttyb may define up to this point */
260 #ifdef B19200
261     DATA("19200", B19200),
262 #endif
263 #ifdef B38400
264     DATA("38400", B38400),
265 #endif
266 #ifdef B19200
267     DATA("19200", B19200),
268 #endif
269 #ifdef B38400
270     DATA("38400", B38400),
271 #endif
272 #ifdef B19200
273     DATA("19200", B19200),
274 #else
275 #ifdef EXTA
276     DATA("19200", EXTA),
277 #endif
278 #endif
279 #ifdef B38400
280     DATA("38400", B38400),
281 #else
282 #ifdef EXTB
283     DATA("38400", EXTB),
284 #endif
285 #endif
286 #ifdef B57600
287     DATA("57600", B57600),
288 #endif
289 #ifdef B76800
290     DATA("76800", B57600),
291 #endif
292 #ifdef B115200
293     DATA("115200", B115200),
294 #endif
295 #ifdef B153600
296     DATA("153600", B153600),
297 #endif
298 #ifdef B230400
299     DATA("230400", B230400),
300 #endif
301 #ifdef B307200
302     DATA("307200", B307200),
303 #endif
304 #ifdef B460800
305     DATA("460800", B460800),
306 #endif
307 #ifdef B500000
308     DATA("500000", B500000),
309 #endif
310 #ifdef B576000
311     DATA("576000", B576000),
312 #endif
313 #ifdef B921600
314     DATA("921600", B921600),
315 #endif
316 #ifdef B1000000
317     DATA("1000000", B1000000),
318 #endif
319 #ifdef B1152000
320     DATA("1152000", B1152000),
321 #endif
322 #ifdef B1500000
323     DATA("1500000", B1500000),
324 #endif
325 #ifdef B2000000
326     DATA("2000000", B2000000),
327 #endif
328 #ifdef B2500000
329     DATA("2500000", B2500000),
330 #endif
331 #ifdef B3000000
332     DATA("3000000", B3000000),
333 #endif
334 #ifdef B3500000
335     DATA("3500000", B3500000),
336 #endif
337 #ifdef B4000000
338     DATA("4000000", B4000000),
339 #endif
340 };
341 #undef DATA
342 #endif
343
344 static int
345 tbaudrate(char *rate)
346 {
347     const SPEEDS *sp = 0;
348     size_t n;
349
350     /* The baudrate number can be preceded by a 'B', which is ignored. */
351     if (*rate == 'B')
352         ++rate;
353
354     for (n = 0; n < SIZEOF(speeds); ++n) {
355         if (n > 0 && (speeds[n].speed <= speeds[n - 1].speed)) {
356             /* if the speeds are not increasing, likely a numeric overflow */
357             break;
358         }
359         if (!CaselessCmp(rate, speeds[n].string)) {
360             sp = speeds + n;
361             break;
362         }
363     }
364     if (sp == 0)
365         err("unknown baud rate %s", rate);
366     return (sp->speed);
367 }
368
369 /*
370  * Syntax for -m:
371  * [port-type][test baudrate]:terminal-type
372  * The baud rate tests are: >, <, @, =, !
373  */
374 static void
375 add_mapping(const char *port, char *arg)
376 {
377     MAP *mapp;
378     char *copy, *p;
379     const char *termp;
380     char *base = 0;
381
382     copy = strdup(arg);
383     mapp = typeMalloc(MAP, 1);
384     if (copy == 0 || mapp == 0)
385         failed("malloc");
386
387     assert(copy != 0);
388     assert(mapp != 0);
389
390     mapp->next = 0;
391     if (maplist == 0)
392         cur = maplist = mapp;
393     else {
394         cur->next = mapp;
395         cur = mapp;
396     }
397
398     mapp->porttype = arg;
399     mapp->conditional = 0;
400
401     arg = strpbrk(arg, "><@=!:");
402
403     if (arg == 0) {             /* [?]term */
404         mapp->type = mapp->porttype;
405         mapp->porttype = 0;
406         goto done;
407     }
408
409     if (arg == mapp->porttype)  /* [><@=! baud]:term */
410         termp = mapp->porttype = 0;
411     else
412         termp = base = arg;
413
414     for (;; ++arg) {            /* Optional conditionals. */
415         switch (*arg) {
416         case '<':
417             if (mapp->conditional & GT)
418                 goto badmopt;
419             mapp->conditional |= LT;
420             break;
421         case '>':
422             if (mapp->conditional & LT)
423                 goto badmopt;
424             mapp->conditional |= GT;
425             break;
426         case '@':
427         case '=':               /* Not documented. */
428             mapp->conditional |= EQ;
429             break;
430         case '!':
431             mapp->conditional |= NOT;
432             break;
433         default:
434             goto next;
435         }
436     }
437
438   next:
439     if (*arg == ':') {
440         if (mapp->conditional)
441             goto badmopt;
442         ++arg;
443     } else {                    /* Optional baudrate. */
444         arg = strchr(p = arg, ':');
445         if (arg == 0)
446             goto badmopt;
447         *arg++ = '\0';
448         mapp->speed = tbaudrate(p);
449     }
450
451     mapp->type = arg;
452
453     /* Terminate porttype, if specified. */
454     if (termp != 0)
455         *base = '\0';
456
457     /* If a NOT conditional, reverse the test. */
458     if (mapp->conditional & NOT)
459         mapp->conditional = ~mapp->conditional & (EQ | GT | LT);
460
461     /* If user specified a port with an option flag, set it. */
462   done:
463     if (port) {
464         if (mapp->porttype) {
465           badmopt:
466             err("illegal -m option format: %s", copy);
467         }
468         mapp->porttype = port;
469     }
470     free(copy);
471 #ifdef MAPDEBUG
472     (void) printf("port: %s\n", mapp->porttype ? mapp->porttype : "ANY");
473     (void) printf("type: %s\n", mapp->type);
474     (void) printf("conditional: ");
475     p = "";
476     if (mapp->conditional & GT) {
477         (void) printf("GT");
478         p = "/";
479     }
480     if (mapp->conditional & EQ) {
481         (void) printf("%sEQ", p);
482         p = "/";
483     }
484     if (mapp->conditional & LT)
485         (void) printf("%sLT", p);
486     (void) printf("\nspeed: %d\n", mapp->speed);
487 #endif
488 }
489
490 /*
491  * Return the type of terminal to use for a port of type 'type', as specified
492  * by the first applicable mapping in 'map'.  If no mappings apply, return
493  * 'type'.
494  */
495 static const char *
496 mapped(const char *type)
497 {
498     MAP *mapp;
499     int match;
500
501     for (mapp = maplist; mapp; mapp = mapp->next)
502         if (mapp->porttype == 0 || !strcmp(mapp->porttype, type)) {
503             switch (mapp->conditional) {
504             case 0:             /* No test specified. */
505                 match = TRUE;
506                 break;
507             case EQ:
508                 match = ((int) ospeed == mapp->speed);
509                 break;
510             case GE:
511                 match = ((int) ospeed >= mapp->speed);
512                 break;
513             case GT:
514                 match = ((int) ospeed > mapp->speed);
515                 break;
516             case LE:
517                 match = ((int) ospeed <= mapp->speed);
518                 break;
519             case LT:
520                 match = ((int) ospeed < mapp->speed);
521                 break;
522             default:
523                 match = FALSE;
524             }
525             if (match)
526                 return (mapp->type);
527         }
528     /* No match found; return given type. */
529     return (type);
530 }
531
532 /**************************************************************************
533  *
534  * Entry fetching
535  *
536  **************************************************************************/
537
538 /*
539  * Figure out what kind of terminal we're dealing with, and then read in
540  * its termcap entry.
541  */
542 static const char *
543 get_termcap_entry(int fd, char *userarg)
544 {
545     int errret;
546     char *p;
547     const char *ttype;
548 #if HAVE_GETTTYNAM
549     struct ttyent *t;
550 #else
551     FILE *fp;
552 #endif
553     char *ttypath;
554
555     (void) fd;
556
557     if (userarg) {
558         ttype = userarg;
559         goto found;
560     }
561
562     /* Try the environment. */
563     if ((ttype = getenv("TERM")) != 0)
564         goto map;
565
566     if ((ttypath = ttyname(fd)) != 0) {
567         p = _nc_basename(ttypath);
568 #if HAVE_GETTTYNAM
569         /*
570          * We have the 4.3BSD library call getttynam(3); that means
571          * there's an /etc/ttys to look up device-to-type mappings in.
572          * Try ttyname(3); check for dialup or other mapping.
573          */
574         if ((t = getttynam(p))) {
575             ttype = t->ty_type;
576             goto map;
577         }
578 #else
579         if ((fp = fopen("/etc/ttytype", "r")) != 0
580             || (fp = fopen("/etc/ttys", "r")) != 0) {
581             char buffer[BUFSIZ];
582             char *s, *t, *d;
583
584             while (fgets(buffer, sizeof(buffer) - 1, fp) != 0) {
585                 for (s = buffer, t = d = 0; *s; s++) {
586                     if (isspace(UChar(*s)))
587                         *s = '\0';
588                     else if (t == 0)
589                         t = s;
590                     else if (d == 0 && s != buffer && s[-1] == '\0')
591                         d = s;
592                 }
593                 if (t != 0 && d != 0 && !strcmp(d, p)) {
594                     ttype = strdup(t);
595                     fclose(fp);
596                     goto map;
597                 }
598             }
599             fclose(fp);
600         }
601 #endif /* HAVE_GETTTYNAM */
602     }
603
604     /* If still undefined, use "unknown". */
605     ttype = "unknown";
606
607   map:ttype = mapped(ttype);
608
609     /*
610      * If not a path, remove TERMCAP from the environment so we get a
611      * real entry from /etc/termcap.  This prevents us from being fooled
612      * by out of date stuff in the environment.
613      */
614   found:
615     if ((p = getenv("TERMCAP")) != 0 && !_nc_is_abs_path(p)) {
616         /* 'unsetenv("TERMCAP")' is not portable.
617          * The 'environ' array is better.
618          */
619         int n;
620         for (n = 0; environ[n] != 0; n++) {
621             if (!strncmp("TERMCAP=", environ[n], (size_t) 8)) {
622                 while ((environ[n] = environ[n + 1]) != 0) {
623                     n++;
624                 }
625                 break;
626             }
627         }
628     }
629
630     /*
631      * ttype now contains a pointer to the type of the terminal.
632      * If the first character is '?', ask the user.
633      */
634     if (ttype[0] == '?') {
635         if (ttype[1] != '\0')
636             ttype = askuser(ttype + 1);
637         else
638             ttype = askuser(0);
639     }
640     /* Find the terminfo entry.  If it doesn't exist, ask the user. */
641     while (setupterm((NCURSES_CONST char *) ttype, fd, &errret)
642            != OK) {
643         if (errret == 0) {
644             (void) fprintf(stderr, "%s: unknown terminal type %s\n",
645                            _nc_progname, ttype);
646             ttype = 0;
647         } else {
648             (void) fprintf(stderr,
649                            "%s: can't initialize terminal type %s (error %d)\n",
650                            _nc_progname, ttype, errret);
651             ttype = 0;
652         }
653         ttype = askuser(ttype);
654     }
655 #if BROKEN_LINKER
656     tgetflag("am");             /* force lib_termcap.o to be linked for 'ospeed' */
657 #endif
658     return (ttype);
659 }
660
661 /**************************************************************************
662  *
663  * Main sequence
664  *
665  **************************************************************************/
666
667 /*
668  * Convert the obsolete argument forms into something that getopt can handle.
669  * This means that -e, -i and -k get default arguments supplied for them.
670  */
671 static void
672 obsolete(char **argv)
673 {
674     for (; *argv; ++argv) {
675         char *parm = argv[0];
676
677         if (parm[0] == '-' && parm[1] == '\0') {
678             argv[0] = strdup("-q");
679             continue;
680         }
681
682         if ((parm[0] != '-')
683             || (argv[1] && argv[1][0] != '-')
684             || (parm[1] != 'e' && parm[1] != 'i' && parm[1] != 'k')
685             || (parm[2] != '\0'))
686             continue;
687         switch (argv[0][1]) {
688         case 'e':
689             argv[0] = strdup("-e^H");
690             break;
691         case 'i':
692             argv[0] = strdup("-i^C");
693             break;
694         case 'k':
695             argv[0] = strdup("-k^U");
696             break;
697         }
698     }
699 }
700
701 static void
702 print_shell_commands(const char *ttype)
703 {
704     const char *p;
705     int len;
706     char *var;
707     char *leaf;
708     /*
709      * Figure out what shell we're using.  A hack, we look for an
710      * environmental variable SHELL ending in "csh".
711      */
712     if ((var = getenv("SHELL")) != 0
713         && ((len = (int) strlen(leaf = _nc_basename(var))) >= 3)
714         && !strcmp(leaf + len - 3, "csh"))
715         p = "set noglob;\nsetenv TERM %s;\nunset noglob;\n";
716     else
717         p = "TERM=%s;\n";
718     (void) printf(p, ttype);
719 }
720
721 static void
722 usage(void)
723 {
724 #define SKIP(s)                 /* nothing */
725 #define KEEP(s) s "\n"
726     static const char msg[] =
727     {
728         KEEP("")
729         KEEP("Options:")
730         SKIP("  -a arpanet  (obsolete)")
731         KEEP("  -c          set control characters")
732         SKIP("  -d dialup   (obsolete)")
733         KEEP("  -e ch       erase character")
734         KEEP("  -I          no initialization strings")
735         KEEP("  -i ch       interrupt character")
736         KEEP("  -k ch       kill character")
737         KEEP("  -m mapping  map identifier to type")
738         SKIP("  -p plugboard (obsolete)")
739         KEEP("  -Q          do not output control key settings")
740         KEEP("  -q          display term only, do no changes")
741         KEEP("  -r          display term on stderr")
742         SKIP("  -S          (obsolete)")
743         KEEP("  -s          output TERM set command")
744         KEEP("  -V          print curses-version")
745         KEEP("  -w          set window-size")
746         KEEP("")
747         KEEP("If neither -c/-w are given, both are assumed.")
748     };
749 #undef KEEP
750 #undef SKIP
751     (void) fprintf(stderr, "Usage: %s [options] [terminal]\n", _nc_progname);
752     fputs(msg, stderr);
753     ExitProgram(EXIT_FAILURE);
754     /* NOTREACHED */
755 }
756
757 static char
758 arg_to_char(void)
759 {
760     return (char) ((optarg[0] == '^' && optarg[1] != '\0')
761                    ? ((optarg[1] == '?') ? '\177' : CTRL(optarg[1]))
762                    : optarg[0]);
763 }
764
765 int
766 main(int argc, char **argv)
767 {
768     int ch, noinit, noset, quiet, Sflag, sflag, showterm;
769     const char *ttype;
770     int terasechar = -1;        /* new erase character */
771     int intrchar = -1;          /* new interrupt character */
772     int tkillchar = -1;         /* new kill character */
773     int my_fd;
774     bool opt_c = FALSE;         /* set control-chars */
775     bool opt_w = FALSE;         /* set window-size */
776     TTY mode, oldmode;
777
778     obsolete(argv);
779     noinit = noset = quiet = Sflag = sflag = showterm = 0;
780     while ((ch = getopt(argc, argv, "a:cd:e:Ii:k:m:p:qQrSsVw")) != -1) {
781         switch (ch) {
782         case 'c':               /* set control-chars */
783             opt_c = TRUE;
784             break;
785         case 'a':               /* OBSOLETE: map identifier to type */
786             add_mapping("arpanet", optarg);
787             break;
788         case 'd':               /* OBSOLETE: map identifier to type */
789             add_mapping("dialup", optarg);
790             break;
791         case 'e':               /* erase character */
792             terasechar = arg_to_char();
793             break;
794         case 'I':               /* no initialization strings */
795             noinit = 1;
796             break;
797         case 'i':               /* interrupt character */
798             intrchar = arg_to_char();
799             break;
800         case 'k':               /* kill character */
801             tkillchar = arg_to_char();
802             break;
803         case 'm':               /* map identifier to type */
804             add_mapping(0, optarg);
805             break;
806         case 'p':               /* OBSOLETE: map identifier to type */
807             add_mapping("plugboard", optarg);
808             break;
809         case 'Q':               /* don't output control key settings */
810             quiet = 1;
811             break;
812         case 'q':               /* display term only */
813             noset = 1;
814             break;
815         case 'r':               /* display term on stderr */
816             showterm = 1;
817             break;
818         case 'S':               /* OBSOLETE: output TERM & TERMCAP */
819             Sflag = 1;
820             break;
821         case 's':               /* output TERM set command */
822             sflag = 1;
823             break;
824         case 'V':               /* print curses-version */
825             puts(curses_version());
826             ExitProgram(EXIT_SUCCESS);
827         case 'w':               /* set window-size */
828             opt_w = TRUE;
829             break;
830         case '?':
831         default:
832             usage();
833         }
834     }
835
836     _nc_progname = _nc_rootname(*argv);
837     argc -= optind;
838     argv += optind;
839
840     if (argc > 1)
841         usage();
842
843     if (!opt_c && !opt_w)
844         opt_c = opt_w = TRUE;
845
846     my_fd = save_tty_settings(&mode, TRUE);
847     oldmode = mode;
848 #ifdef TERMIOS
849     ospeed = (NCURSES_OSPEED) cfgetospeed(&mode);
850 #elif defined(EXP_WIN32_DRIVER)
851     ospeed = 0;
852 #else
853     ospeed = (NCURSES_OSPEED) mode.sg_ospeed;
854 #endif
855
856     if (same_program(_nc_progname, PROG_RESET)) {
857         reset_start(stderr, TRUE, FALSE);
858         reset_tty_settings(my_fd, &mode);
859     } else {
860         reset_start(stderr, FALSE, TRUE);
861     }
862
863     ttype = get_termcap_entry(my_fd, *argv);
864
865     if (!noset) {
866 #if HAVE_SIZECHANGE
867         if (opt_w) {
868             set_window_size(my_fd, &lines, &columns);
869         }
870 #endif
871         if (opt_c) {
872             set_control_chars(&mode, terasechar, intrchar, tkillchar);
873             set_conversions(&mode);
874
875             if (!noinit) {
876                 if (send_init_strings(my_fd, &oldmode)) {
877                     (void) putc('\r', stderr);
878                     (void) fflush(stderr);
879                     (void) napms(1000);         /* Settle the terminal. */
880                 }
881             }
882
883             update_tty_settings(&oldmode, &mode);
884         }
885     }
886
887     if (noset) {
888         (void) printf("%s\n", ttype);
889     } else {
890         if (showterm)
891             (void) fprintf(stderr, "Terminal type is %s.\n", ttype);
892         /*
893          * If erase, kill and interrupt characters could have been
894          * modified and not -Q, display the changes.
895          */
896         if (!quiet) {
897             print_tty_chars(&oldmode, &mode);
898         }
899     }
900
901     if (Sflag)
902         err("The -S option is not supported under terminfo.");
903
904     if (sflag) {
905         print_shell_commands(ttype);
906     }
907
908     ExitProgram(EXIT_SUCCESS);
909 }