ncurses 6.2 - patch 20201024
[ncurses.git] / progs / tset.c
1 /****************************************************************************
2  * Copyright 2020 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.125 2020/09/05 22:54:47 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 void exit_error(void) GCC_NORETURN;
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 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 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 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     char *p;
171
172     /* We can get recalled; if so, don't continue uselessly. */
173     clearerr(stdin);
174     if (feof(stdin) || ferror(stdin)) {
175         (void) fprintf(stderr, "\n");
176         exit_error();
177         /* NOTREACHED */
178     }
179     for (;;) {
180         if (dflt)
181             (void) fprintf(stderr, "Terminal type? [%s] ", dflt);
182         else
183             (void) fprintf(stderr, "Terminal type? ");
184         (void) fflush(stderr);
185
186         if (fgets(answer, sizeof(answer), stdin) == 0) {
187             if (dflt == 0) {
188                 exit_error();
189                 /* NOTREACHED */
190             }
191             return (dflt);
192         }
193
194         if ((p = strchr(answer, '\n')) != 0)
195             *p = '\0';
196         if (answer[0])
197             return (answer);
198         if (dflt != 0)
199             return (dflt);
200     }
201 }
202
203 /**************************************************************************
204  *
205  * Mapping logic begins here
206  *
207  **************************************************************************/
208
209 /* Baud rate conditionals for mapping. */
210 #define GT              0x01
211 #define EQ              0x02
212 #define LT              0x04
213 #define NOT             0x08
214 #define GE              (GT | EQ)
215 #define LE              (LT | EQ)
216
217 typedef struct map {
218     struct map *next;           /* Linked list of maps. */
219     const char *porttype;       /* Port type, or "" for any. */
220     const char *type;           /* Terminal type to select. */
221     int conditional;            /* Baud rate conditionals bitmask. */
222     int speed;                  /* Baud rate to compare against. */
223 } MAP;
224
225 static MAP *cur, *maplist;
226
227 #define DATA(name,value) { { name }, value }
228
229 typedef struct speeds {
230     const char string[8];
231     int speed;
232 } SPEEDS;
233
234 #if defined(EXP_WIN32_DRIVER)
235 static const SPEEDS speeds[] =
236 {
237     {"0", 0}
238 };
239 #else
240 static const SPEEDS speeds[] =
241 {
242     DATA("0", B0),
243     DATA("50", B50),
244     DATA("75", B75),
245     DATA("110", B110),
246     DATA("134", B134),
247     DATA("134.5", B134),
248     DATA("150", B150),
249     DATA("200", B200),
250     DATA("300", B300),
251     DATA("600", B600),
252     DATA("1200", B1200),
253     DATA("1800", B1800),
254     DATA("2400", B2400),
255     DATA("4800", B4800),
256     DATA("9600", B9600),
257     /* sgttyb may define up to this point */
258 #ifdef B19200
259     DATA("19200", B19200),
260 #endif
261 #ifdef B38400
262     DATA("38400", B38400),
263 #endif
264 #ifdef B19200
265     DATA("19200", B19200),
266 #endif
267 #ifdef B38400
268     DATA("38400", B38400),
269 #endif
270 #ifdef B19200
271     DATA("19200", B19200),
272 #else
273 #ifdef EXTA
274     DATA("19200", EXTA),
275 #endif
276 #endif
277 #ifdef B38400
278     DATA("38400", B38400),
279 #else
280 #ifdef EXTB
281     DATA("38400", EXTB),
282 #endif
283 #endif
284 #ifdef B57600
285     DATA("57600", B57600),
286 #endif
287 #ifdef B76800
288     DATA("76800", B57600),
289 #endif
290 #ifdef B115200
291     DATA("115200", B115200),
292 #endif
293 #ifdef B153600
294     DATA("153600", B153600),
295 #endif
296 #ifdef B230400
297     DATA("230400", B230400),
298 #endif
299 #ifdef B307200
300     DATA("307200", B307200),
301 #endif
302 #ifdef B460800
303     DATA("460800", B460800),
304 #endif
305 #ifdef B500000
306     DATA("500000", B500000),
307 #endif
308 #ifdef B576000
309     DATA("576000", B576000),
310 #endif
311 #ifdef B921600
312     DATA("921600", B921600),
313 #endif
314 #ifdef B1000000
315     DATA("1000000", B1000000),
316 #endif
317 #ifdef B1152000
318     DATA("1152000", B1152000),
319 #endif
320 #ifdef B1500000
321     DATA("1500000", B1500000),
322 #endif
323 #ifdef B2000000
324     DATA("2000000", B2000000),
325 #endif
326 #ifdef B2500000
327     DATA("2500000", B2500000),
328 #endif
329 #ifdef B3000000
330     DATA("3000000", B3000000),
331 #endif
332 #ifdef B3500000
333     DATA("3500000", B3500000),
334 #endif
335 #ifdef B4000000
336     DATA("4000000", B4000000),
337 #endif
338 };
339 #undef DATA
340 #endif
341
342 static int
343 tbaudrate(char *rate)
344 {
345     const SPEEDS *sp = 0;
346     size_t n;
347
348     /* The baudrate number can be preceded by a 'B', which is ignored. */
349     if (*rate == 'B')
350         ++rate;
351
352     for (n = 0; n < SIZEOF(speeds); ++n) {
353         if (n > 0 && (speeds[n].speed <= speeds[n - 1].speed)) {
354             /* if the speeds are not increasing, likely a numeric overflow */
355             break;
356         }
357         if (!CaselessCmp(rate, speeds[n].string)) {
358             sp = speeds + n;
359             break;
360         }
361     }
362     if (sp == 0)
363         err("unknown baud rate %s", rate);
364     return (sp->speed);
365 }
366
367 /*
368  * Syntax for -m:
369  * [port-type][test baudrate]:terminal-type
370  * The baud rate tests are: >, <, @, =, !
371  */
372 static void
373 add_mapping(const char *port, char *arg)
374 {
375     MAP *mapp;
376     char *copy, *p;
377     const char *termp;
378     char *base = 0;
379
380     copy = strdup(arg);
381     mapp = typeMalloc(MAP, 1);
382     if (copy == 0 || mapp == 0)
383         failed("malloc");
384
385     assert(copy != 0);
386     assert(mapp != 0);
387
388     mapp->next = 0;
389     if (maplist == 0)
390         cur = maplist = mapp;
391     else {
392         cur->next = mapp;
393         cur = mapp;
394     }
395
396     mapp->porttype = arg;
397     mapp->conditional = 0;
398
399     arg = strpbrk(arg, "><@=!:");
400
401     if (arg == 0) {             /* [?]term */
402         mapp->type = mapp->porttype;
403         mapp->porttype = 0;
404         goto done;
405     }
406
407     if (arg == mapp->porttype)  /* [><@=! baud]:term */
408         termp = mapp->porttype = 0;
409     else
410         termp = base = arg;
411
412     for (;; ++arg) {            /* Optional conditionals. */
413         switch (*arg) {
414         case '<':
415             if (mapp->conditional & GT)
416                 goto badmopt;
417             mapp->conditional |= LT;
418             break;
419         case '>':
420             if (mapp->conditional & LT)
421                 goto badmopt;
422             mapp->conditional |= GT;
423             break;
424         case '@':
425         case '=':               /* Not documented. */
426             mapp->conditional |= EQ;
427             break;
428         case '!':
429             mapp->conditional |= NOT;
430             break;
431         default:
432             goto next;
433         }
434     }
435
436   next:
437     if (*arg == ':') {
438         if (mapp->conditional)
439             goto badmopt;
440         ++arg;
441     } else {                    /* Optional baudrate. */
442         arg = strchr(p = arg, ':');
443         if (arg == 0)
444             goto badmopt;
445         *arg++ = '\0';
446         mapp->speed = tbaudrate(p);
447     }
448
449     mapp->type = arg;
450
451     /* Terminate porttype, if specified. */
452     if (termp != 0)
453         *base = '\0';
454
455     /* If a NOT conditional, reverse the test. */
456     if (mapp->conditional & NOT)
457         mapp->conditional = ~mapp->conditional & (EQ | GT | LT);
458
459     /* If user specified a port with an option flag, set it. */
460   done:
461     if (port) {
462         if (mapp->porttype) {
463           badmopt:
464             err("illegal -m option format: %s", copy);
465         }
466         mapp->porttype = port;
467     }
468     free(copy);
469 #ifdef MAPDEBUG
470     (void) printf("port: %s\n", mapp->porttype ? mapp->porttype : "ANY");
471     (void) printf("type: %s\n", mapp->type);
472     (void) printf("conditional: ");
473     p = "";
474     if (mapp->conditional & GT) {
475         (void) printf("GT");
476         p = "/";
477     }
478     if (mapp->conditional & EQ) {
479         (void) printf("%sEQ", p);
480         p = "/";
481     }
482     if (mapp->conditional & LT)
483         (void) printf("%sLT", p);
484     (void) printf("\nspeed: %d\n", mapp->speed);
485 #endif
486 }
487
488 /*
489  * Return the type of terminal to use for a port of type 'type', as specified
490  * by the first applicable mapping in 'map'.  If no mappings apply, return
491  * 'type'.
492  */
493 static const char *
494 mapped(const char *type)
495 {
496     MAP *mapp;
497     int match;
498
499     for (mapp = maplist; mapp; mapp = mapp->next)
500         if (mapp->porttype == 0 || !strcmp(mapp->porttype, type)) {
501             switch (mapp->conditional) {
502             case 0:             /* No test specified. */
503                 match = TRUE;
504                 break;
505             case EQ:
506                 match = ((int) ospeed == mapp->speed);
507                 break;
508             case GE:
509                 match = ((int) ospeed >= mapp->speed);
510                 break;
511             case GT:
512                 match = ((int) ospeed > mapp->speed);
513                 break;
514             case LE:
515                 match = ((int) ospeed <= mapp->speed);
516                 break;
517             case LT:
518                 match = ((int) ospeed < mapp->speed);
519                 break;
520             default:
521                 match = FALSE;
522             }
523             if (match)
524                 return (mapp->type);
525         }
526     /* No match found; return given type. */
527     return (type);
528 }
529
530 /**************************************************************************
531  *
532  * Entry fetching
533  *
534  **************************************************************************/
535
536 /*
537  * Figure out what kind of terminal we're dealing with, and then read in
538  * its termcap entry.
539  */
540 static const char *
541 get_termcap_entry(int fd, char *userarg)
542 {
543     int errret;
544     char *p;
545     const char *ttype;
546 #if HAVE_GETTTYNAM
547     struct ttyent *t;
548 #else
549     FILE *fp;
550 #endif
551     char *ttypath;
552
553     (void) fd;
554
555     if (userarg) {
556         ttype = userarg;
557         goto found;
558     }
559
560     /* Try the environment. */
561     if ((ttype = getenv("TERM")) != 0)
562         goto map;
563
564     if ((ttypath = ttyname(fd)) != 0) {
565         p = _nc_basename(ttypath);
566 #if HAVE_GETTTYNAM
567         /*
568          * We have the 4.3BSD library call getttynam(3); that means
569          * there's an /etc/ttys to look up device-to-type mappings in.
570          * Try ttyname(3); check for dialup or other mapping.
571          */
572         if ((t = getttynam(p))) {
573             ttype = t->ty_type;
574             goto map;
575         }
576 #else
577         if ((fp = fopen("/etc/ttytype", "r")) != 0
578             || (fp = fopen("/etc/ttys", "r")) != 0) {
579             char buffer[BUFSIZ];
580             char *s, *t, *d;
581
582             while (fgets(buffer, sizeof(buffer) - 1, fp) != 0) {
583                 for (s = buffer, t = d = 0; *s; s++) {
584                     if (isspace(UChar(*s)))
585                         *s = '\0';
586                     else if (t == 0)
587                         t = s;
588                     else if (d == 0 && s != buffer && s[-1] == '\0')
589                         d = s;
590                 }
591                 if (t != 0 && d != 0 && !strcmp(d, p)) {
592                     ttype = strdup(t);
593                     fclose(fp);
594                     goto map;
595                 }
596             }
597             fclose(fp);
598         }
599 #endif /* HAVE_GETTTYNAM */
600     }
601
602     /* If still undefined, use "unknown". */
603     ttype = "unknown";
604
605   map:ttype = mapped(ttype);
606
607     /*
608      * If not a path, remove TERMCAP from the environment so we get a
609      * real entry from /etc/termcap.  This prevents us from being fooled
610      * by out of date stuff in the environment.
611      */
612   found:
613     if ((p = getenv("TERMCAP")) != 0 && !_nc_is_abs_path(p)) {
614         /* 'unsetenv("TERMCAP")' is not portable.
615          * The 'environ' array is better.
616          */
617         int n;
618         for (n = 0; environ[n] != 0; n++) {
619             if (!strncmp("TERMCAP=", environ[n], (size_t) 8)) {
620                 while ((environ[n] = environ[n + 1]) != 0) {
621                     n++;
622                 }
623                 break;
624             }
625         }
626     }
627
628     /*
629      * ttype now contains a pointer to the type of the terminal.
630      * If the first character is '?', ask the user.
631      */
632     if (ttype[0] == '?') {
633         if (ttype[1] != '\0')
634             ttype = askuser(ttype + 1);
635         else
636             ttype = askuser(0);
637     }
638     /* Find the terminfo entry.  If it doesn't exist, ask the user. */
639     while (setupterm((NCURSES_CONST char *) ttype, fd, &errret)
640            != OK) {
641         if (errret == 0) {
642             (void) fprintf(stderr, "%s: unknown terminal type %s\n",
643                            _nc_progname, ttype);
644             ttype = 0;
645         } else {
646             (void) fprintf(stderr,
647                            "%s: can't initialize terminal type %s (error %d)\n",
648                            _nc_progname, ttype, errret);
649             ttype = 0;
650         }
651         ttype = askuser(ttype);
652     }
653 #if BROKEN_LINKER
654     tgetflag("am");             /* force lib_termcap.o to be linked for 'ospeed' */
655 #endif
656     return (ttype);
657 }
658
659 /**************************************************************************
660  *
661  * Main sequence
662  *
663  **************************************************************************/
664
665 /*
666  * Convert the obsolete argument forms into something that getopt can handle.
667  * This means that -e, -i and -k get default arguments supplied for them.
668  */
669 static void
670 obsolete(char **argv)
671 {
672     for (; *argv; ++argv) {
673         char *parm = argv[0];
674
675         if (parm[0] == '-' && parm[1] == '\0') {
676             argv[0] = strdup("-q");
677             continue;
678         }
679
680         if ((parm[0] != '-')
681             || (argv[1] && argv[1][0] != '-')
682             || (parm[1] != 'e' && parm[1] != 'i' && parm[1] != 'k')
683             || (parm[2] != '\0'))
684             continue;
685         switch (argv[0][1]) {
686         case 'e':
687             argv[0] = strdup("-e^H");
688             break;
689         case 'i':
690             argv[0] = strdup("-i^C");
691             break;
692         case 'k':
693             argv[0] = strdup("-k^U");
694             break;
695         }
696     }
697 }
698
699 static void
700 print_shell_commands(const char *ttype)
701 {
702     const char *p;
703     int len;
704     char *var;
705     char *leaf;
706     /*
707      * Figure out what shell we're using.  A hack, we look for an
708      * environmental variable SHELL ending in "csh".
709      */
710     if ((var = getenv("SHELL")) != 0
711         && ((len = (int) strlen(leaf = _nc_basename(var))) >= 3)
712         && !strcmp(leaf + len - 3, "csh"))
713         p = "set noglob;\nsetenv TERM %s;\nunset noglob;\n";
714     else
715         p = "TERM=%s;\n";
716     (void) printf(p, ttype);
717 }
718
719 static void
720 usage(void)
721 {
722 #define SKIP(s)                 /* nothing */
723 #define KEEP(s) s "\n"
724     static const char msg[] =
725     {
726         KEEP("")
727         KEEP("Options:")
728         SKIP("  -a arpanet  (obsolete)")
729         KEEP("  -c          set control characters")
730         SKIP("  -d dialup   (obsolete)")
731         KEEP("  -e ch       erase character")
732         KEEP("  -I          no initialization strings")
733         KEEP("  -i ch       interrupt character")
734         KEEP("  -k ch       kill character")
735         KEEP("  -m mapping  map identifier to type")
736         SKIP("  -p plugboard (obsolete)")
737         KEEP("  -Q          do not output control key settings")
738         KEEP("  -q          display term only, do no changes")
739         KEEP("  -r          display term on stderr")
740         SKIP("  -S          (obsolete)")
741         KEEP("  -s          output TERM set command")
742         KEEP("  -V          print curses-version")
743         KEEP("  -w          set window-size")
744         KEEP("")
745         KEEP("If neither -c/-w are given, both are assumed.")
746     };
747 #undef KEEP
748 #undef SKIP
749     (void) fprintf(stderr, "Usage: %s [options] [terminal]\n", _nc_progname);
750     fputs(msg, stderr);
751     ExitProgram(EXIT_FAILURE);
752     /* NOTREACHED */
753 }
754
755 static char
756 arg_to_char(void)
757 {
758     return (char) ((optarg[0] == '^' && optarg[1] != '\0')
759                    ? ((optarg[1] == '?') ? '\177' : CTRL(optarg[1]))
760                    : optarg[0]);
761 }
762
763 int
764 main(int argc, char **argv)
765 {
766     int ch, noinit, noset, quiet, Sflag, sflag, showterm;
767     const char *ttype;
768     int terasechar = -1;        /* new erase character */
769     int intrchar = -1;          /* new interrupt character */
770     int tkillchar = -1;         /* new kill character */
771     int my_fd;
772     bool opt_c = FALSE;         /* set control-chars */
773     bool opt_w = FALSE;         /* set window-size */
774     TTY mode, oldmode;
775
776     my_fd = STDERR_FILENO;
777     obsolete(argv);
778     noinit = noset = quiet = Sflag = sflag = showterm = 0;
779     while ((ch = getopt(argc, argv, "a:cd:e:Ii:k:m:p:qQrSsVw")) != -1) {
780         switch (ch) {
781         case 'c':               /* set control-chars */
782             opt_c = TRUE;
783             break;
784         case 'a':               /* OBSOLETE: map identifier to type */
785             add_mapping("arpanet", optarg);
786             break;
787         case 'd':               /* OBSOLETE: map identifier to type */
788             add_mapping("dialup", optarg);
789             break;
790         case 'e':               /* erase character */
791             terasechar = arg_to_char();
792             break;
793         case 'I':               /* no initialization strings */
794             noinit = 1;
795             break;
796         case 'i':               /* interrupt character */
797             intrchar = arg_to_char();
798             break;
799         case 'k':               /* kill character */
800             tkillchar = arg_to_char();
801             break;
802         case 'm':               /* map identifier to type */
803             add_mapping(0, optarg);
804             break;
805         case 'p':               /* OBSOLETE: map identifier to type */
806             add_mapping("plugboard", optarg);
807             break;
808         case 'Q':               /* don't output control key settings */
809             quiet = 1;
810             break;
811         case 'q':               /* display term only */
812             noset = 1;
813             break;
814         case 'r':               /* display term on stderr */
815             showterm = 1;
816             break;
817         case 'S':               /* OBSOLETE: output TERM & TERMCAP */
818             Sflag = 1;
819             break;
820         case 's':               /* output TERM set command */
821             sflag = 1;
822             break;
823         case 'V':               /* print curses-version */
824             puts(curses_version());
825             ExitProgram(EXIT_SUCCESS);
826         case 'w':               /* set window-size */
827             opt_w = TRUE;
828             break;
829         case '?':
830         default:
831             usage();
832         }
833     }
834
835     _nc_progname = _nc_rootname(*argv);
836     argc -= optind;
837     argv += optind;
838
839     if (argc > 1)
840         usage();
841
842     if (!opt_c && !opt_w)
843         opt_c = opt_w = TRUE;
844
845     my_fd = save_tty_settings(&mode, TRUE);
846     oldmode = mode;
847 #ifdef TERMIOS
848     ospeed = (NCURSES_OSPEED) cfgetospeed(&mode);
849 #elif defined(EXP_WIN32_DRIVER)
850     ospeed = 0;
851 #else
852     ospeed = (NCURSES_OSPEED) mode.sg_ospeed;
853 #endif
854
855     if (same_program(_nc_progname, PROG_RESET)) {
856         reset_start(stderr, TRUE, FALSE);
857         reset_tty_settings(my_fd, &mode);
858     } else {
859         reset_start(stderr, FALSE, TRUE);
860     }
861
862     ttype = get_termcap_entry(my_fd, *argv);
863
864     if (!noset) {
865 #if HAVE_SIZECHANGE
866         if (opt_w) {
867             set_window_size(my_fd, &lines, &columns);
868         }
869 #endif
870         if (opt_c) {
871             set_control_chars(&mode, terasechar, intrchar, tkillchar);
872             set_conversions(&mode);
873
874             if (!noinit) {
875                 if (send_init_strings(my_fd, &oldmode)) {
876                     (void) putc('\r', stderr);
877                     (void) fflush(stderr);
878                     (void) napms(1000);         /* Settle the terminal. */
879                 }
880             }
881
882             update_tty_settings(&oldmode, &mode);
883         }
884     }
885
886     if (noset) {
887         (void) printf("%s\n", ttype);
888     } else {
889         if (showterm)
890             (void) fprintf(stderr, "Terminal type is %s.\n", ttype);
891         /*
892          * If erase, kill and interrupt characters could have been
893          * modified and not -Q, display the changes.
894          */
895         if (!quiet) {
896             print_tty_chars(&oldmode, &mode);
897         }
898     }
899
900     if (Sflag)
901         err("The -S option is not supported under terminfo.");
902
903     if (sflag) {
904         print_shell_commands(ttype);
905     }
906
907     ExitProgram(EXIT_SUCCESS);
908 }