Commit Vladimir's latest version of stty.c. Nice work.

 -Erik

1 files changed, 1392 insertions, 0 deletions

diff --git a/coreutils/stty.c b/coreutils/stty.c
new file mode 100644
index 000000000..0fc0bfbc2
--- /dev/null
+++ b/coreutils/stty.c
@@ -0,0 +1,1392 @@
+/* vi: set sw=4 ts=4: */
+/* stty -- change and print terminal line settings
+   Copyright (C) 1990-1999 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+/* Usage: stty [-ag] [-F device] [setting...]
+
+   Options:
+   -a Write all current settings to stdout in human-readable form.
+   -g Write all current settings to stdout in stty-readable form.
+   -F Open and use the specified device instead of stdin
+
+   If no args are given, write to stdout the baud rate and settings that
+   have been changed from their defaults.  Mode reading and changes
+   are done on the specified device, or stdin if none was specified.
+
+   David MacKenzie <djm@gnu.ai.mit.edu>
+
+   Special for busybox ported by vodz@usa.net 2001
+
+   */
+
+#include "busybox.h"
+
+#include <termios.h>
+#include <sys/ioctl.h>
+#include <getopt.h>
+
+#include <sys/param.h>
+#include <unistd.h>
+
+#ifndef STDIN_FILENO
+# define STDIN_FILENO 0
+#endif
+
+#ifndef STDOUT_FILENO
+# define STDOUT_FILENO 1
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <ctype.h>
+#include <errno.h>
+#include <limits.h>
+#include <memory.h>
+#include <fcntl.h>
+
+#define STREQ(a, b) (strcmp ((a), (b)) == 0)
+
+
+#ifndef _POSIX_VDISABLE
+# define _POSIX_VDISABLE ((unsigned char) 0)
+#endif
+
+#define Control(c) ((c) & 0x1f)
+/* Canonical values for control characters. */
+#ifndef CINTR
+# define CINTR Control ('c')
+#endif
+#ifndef CQUIT
+# define CQUIT 28
+#endif
+#ifndef CERASE
+# define CERASE 127
+#endif
+#ifndef CKILL
+# define CKILL Control ('u')
+#endif
+#ifndef CEOF
+# define CEOF Control ('d')
+#endif
+#ifndef CEOL
+# define CEOL _POSIX_VDISABLE
+#endif
+#ifndef CSTART
+# define CSTART Control ('q')
+#endif
+#ifndef CSTOP
+# define CSTOP Control ('s')
+#endif
+#ifndef CSUSP
+# define CSUSP Control ('z')
+#endif
+#if defined(VEOL2) && !defined(CEOL2)
+# define CEOL2 _POSIX_VDISABLE
+#endif
+/* ISC renamed swtch to susp for termios, but we'll accept either name.  */
+#if defined(VSUSP) && !defined(VSWTCH)
+# define VSWTCH VSUSP
+# define CSWTCH CSUSP
+#endif
+#if defined(VSWTCH) && !defined(CSWTCH)
+# define CSWTCH _POSIX_VDISABLE
+#endif
+
+/* SunOS 5.3 loses (^Z doesn't work) if `swtch' is the same as `susp'.
+   So the default is to disable `swtch.'  */
+#if defined (__sparc__) && defined (__svr4__)
+# undef CSWTCH
+# define CSWTCH _POSIX_VDISABLE
+#endif
+
+#if defined(VWERSE) && !defined (VWERASE)       /* AIX-3.2.5 */
+# define VWERASE VWERSE
+#endif
+#if defined(VDSUSP) && !defined (CDSUSP)
+# define CDSUSP Control ('y')
+#endif
+#if !defined(VREPRINT) && defined(VRPRNT)       /* Irix 4.0.5 */
+# define VREPRINT VRPRNT
+#endif
+#if defined(VREPRINT) && !defined(CRPRNT)
+# define CRPRNT Control ('r')
+#endif
+#if defined(VWERASE) && !defined(CWERASE)
+# define CWERASE Control ('w')
+#endif
+#if defined(VLNEXT) && !defined(CLNEXT)
+# define CLNEXT Control ('v')
+#endif
+#if defined(VDISCARD) && !defined(VFLUSHO)
+# define VFLUSHO VDISCARD
+#endif
+#if defined(VFLUSH) && !defined(VFLUSHO)        /* Ultrix 4.2 */
+# define VFLUSHO VFLUSH
+#endif
+#if defined(CTLECH) && !defined(ECHOCTL)        /* Ultrix 4.3 */
+# define ECHOCTL CTLECH
+#endif
+#if defined(TCTLECH) && !defined(ECHOCTL)       /* Ultrix 4.2 */
+# define ECHOCTL TCTLECH
+#endif
+#if defined(CRTKIL) && !defined(ECHOKE) /* Ultrix 4.2 and 4.3 */
+# define ECHOKE CRTKIL
+#endif
+#if defined(VFLUSHO) && !defined(CFLUSHO)
+# define CFLUSHO Control ('o')
+#endif
+#if defined(VSTATUS) && !defined(CSTATUS)
+# define CSTATUS Control ('t')
+#endif
+
+/* Which speeds to set.  */
+enum speed_setting {
+        input_speed, output_speed, both_speeds
+};
+
+/* What to output and how.  */
+enum output_type {
+        changed, all, recoverable       /* Default, -a, -g.  */
+};
+
+/* Which member(s) of `struct termios' a mode uses.  */
+enum mode_type {
+        control, input, output, local, combination
+};
+
+
+static const char evenp[] = "evenp";
+static const char raw[] = "raw";
+static const char stty_min[] = "min";
+static const char stty_time[] = "time";
+static const char stty_swtch[] = "swtch";
+static const char stty_eol[] = "eol";
+static const char stty_eof[] = "eof";
+static const char parity[] = "parity";
+static const char stty_oddp[] = "oddp";
+static const char stty_nl[] = "nl";
+static const char stty_ek[] = "ek";
+static const char stty_sane[] = "sane";
+static const char cbreak[] = "cbreak";
+static const char stty_pass8[] = "pass8";
+static const char litout[] = "litout";
+static const char cooked[] = "cooked";
+static const char decctlq[] = "decctlq";
+static const char stty_tabs[] = "tabs";
+static const char stty_lcase[] = "lcase";
+static const char stty_LCASE[] = "LCASE";
+static const char stty_crt[] = "crt";
+static const char stty_dec[] = "dec";
+
+
+/* Flags for `struct mode_info'. */
+#define SANE_SET 1                              /* Set in `sane' mode. */
+#define SANE_UNSET 2                    /* Unset in `sane' mode. */
+#define REV 4                                   /* Can be turned off by prepending `-'. */
+#define OMIT 8                                  /* Don't display value. */
+
+/* Each mode.  */
+struct mode_info {
+        const char *name;                       /* Name given on command line.  */
+        enum mode_type type;            /* Which structure element to change. */
+        char flags;                                     /* Setting and display options.  */
+        unsigned long bits;                     /* Bits to set for this mode.  */
+        unsigned long mask;                     /* Other bits to turn off for this mode.  */
+};
+
+static const struct mode_info mode_info[] = {
+        {"parenb", control, REV, PARENB, 0},
+        {"parodd", control, REV, PARODD, 0},
+        {"cs5", control, 0, CS5, CSIZE},
+        {"cs6", control, 0, CS6, CSIZE},
+        {"cs7", control, 0, CS7, CSIZE},
+        {"cs8", control, 0, CS8, CSIZE},
+        {"hupcl", control, REV, HUPCL, 0},
+        {"hup", control, REV | OMIT, HUPCL, 0},
+        {"cstopb", control, REV, CSTOPB, 0},
+        {"cread", control, SANE_SET | REV, CREAD, 0},
+        {"clocal", control, REV, CLOCAL, 0},
+#ifdef CRTSCTS
+        {"crtscts", control, REV, CRTSCTS, 0},
+#endif
+
+        {"ignbrk", input, SANE_UNSET | REV, IGNBRK, 0},
+        {"brkint", input, SANE_SET | REV, BRKINT, 0},
+        {"ignpar", input, REV, IGNPAR, 0},
+        {"parmrk", input, REV, PARMRK, 0},
+        {"inpck", input, REV, INPCK, 0},
+        {"istrip", input, REV, ISTRIP, 0},
+        {"inlcr", input, SANE_UNSET | REV, INLCR, 0},
+        {"igncr", input, SANE_UNSET | REV, IGNCR, 0},
+        {"icrnl", input, SANE_SET | REV, ICRNL, 0},
+        {"ixon", input, REV, IXON, 0},
+        {"ixoff", input, SANE_UNSET | REV, IXOFF, 0},
+        {"tandem", input, REV | OMIT, IXOFF, 0},
+#ifdef IUCLC
+        {"iuclc", input, SANE_UNSET | REV, IUCLC, 0},
+#endif
+#ifdef IXANY
+        {"ixany", input, SANE_UNSET | REV, IXANY, 0},
+#endif
+#ifdef IMAXBEL
+        {"imaxbel", input, SANE_SET | REV, IMAXBEL, 0},
+#endif
+
+        {"opost", output, SANE_SET | REV, OPOST, 0},
+#ifdef OLCUC
+        {"olcuc", output, SANE_UNSET | REV, OLCUC, 0},
+#endif
+#ifdef OCRNL
+        {"ocrnl", output, SANE_UNSET | REV, OCRNL, 0},
+#endif
+#ifdef ONLCR
+        {"onlcr", output, SANE_SET | REV, ONLCR, 0},
+#endif
+#ifdef ONOCR
+        {"onocr", output, SANE_UNSET | REV, ONOCR, 0},
+#endif
+#ifdef ONLRET
+        {"onlret", output, SANE_UNSET | REV, ONLRET, 0},
+#endif
+#ifdef OFILL
+        {"ofill", output, SANE_UNSET | REV, OFILL, 0},
+#endif
+#ifdef OFDEL
+        {"ofdel", output, SANE_UNSET | REV, OFDEL, 0},
+#endif
+#ifdef NLDLY
+        {"nl1", output, SANE_UNSET, NL1, NLDLY},
+        {"nl0", output, SANE_SET, NL0, NLDLY},
+#endif
+#ifdef CRDLY
+        {"cr3", output, SANE_UNSET, CR3, CRDLY},
+        {"cr2", output, SANE_UNSET, CR2, CRDLY},
+        {"cr1", output, SANE_UNSET, CR1, CRDLY},
+        {"cr0", output, SANE_SET, CR0, CRDLY},
+#endif
+#ifdef TABDLY
+        {"tab3", output, SANE_UNSET, TAB3, TABDLY},
+        {"tab2", output, SANE_UNSET, TAB2, TABDLY},
+        {"tab1", output, SANE_UNSET, TAB1, TABDLY},
+        {"tab0", output, SANE_SET, TAB0, TABDLY},
+#else
+# ifdef OXTABS
+        {"tab3", output, SANE_UNSET, OXTABS, 0},
+# endif
+#endif
+#ifdef BSDLY
+        {"bs1", output, SANE_UNSET, BS1, BSDLY},
+        {"bs0", output, SANE_SET, BS0, BSDLY},
+#endif
+#ifdef VTDLY
+        {"vt1", output, SANE_UNSET, VT1, VTDLY},
+        {"vt0", output, SANE_SET, VT0, VTDLY},
+#endif
+#ifdef FFDLY
+        {"ff1", output, SANE_UNSET, FF1, FFDLY},
+        {"ff0", output, SANE_SET, FF0, FFDLY},
+#endif
+
+        {"isig", local, SANE_SET | REV, ISIG, 0},
+        {"icanon", local, SANE_SET | REV, ICANON, 0},
+#ifdef IEXTEN
+        {"iexten", local, SANE_SET | REV, IEXTEN, 0},
+#endif
+        {"echo", local, SANE_SET | REV, ECHO, 0},
+        {"echoe", local, SANE_SET | REV, ECHOE, 0},
+        {"crterase", local, REV | OMIT, ECHOE, 0},
+        {"echok", local, SANE_SET | REV, ECHOK, 0},
+        {"echonl", local, SANE_UNSET | REV, ECHONL, 0},
+        {"noflsh", local, SANE_UNSET | REV, NOFLSH, 0},
+#ifdef XCASE
+        {"xcase", local, SANE_UNSET | REV, XCASE, 0},
+#endif
+#ifdef TOSTOP
+        {"tostop", local, SANE_UNSET | REV, TOSTOP, 0},
+#endif
+#ifdef ECHOPRT
+        {"echoprt", local, SANE_UNSET | REV, ECHOPRT, 0},
+        {"prterase", local, REV | OMIT, ECHOPRT, 0},
+#endif
+#ifdef ECHOCTL
+        {"echoctl", local, SANE_SET | REV, ECHOCTL, 0},
+        {"ctlecho", local, REV | OMIT, ECHOCTL, 0},
+#endif
+#ifdef ECHOKE
+        {"echoke", local, SANE_SET | REV, ECHOKE, 0},
+        {"crtkill", local, REV | OMIT, ECHOKE, 0},
+#endif
+
+        {evenp, combination, REV | OMIT, 0, 0},
+        {parity, combination, REV | OMIT, 0, 0},
+        {stty_oddp, combination, REV | OMIT, 0, 0},
+        {stty_nl, combination, REV | OMIT, 0, 0},
+        {stty_ek, combination, OMIT, 0, 0},
+        {stty_sane, combination, OMIT, 0, 0},
+        {cooked, combination, REV | OMIT, 0, 0},
+        {raw, combination, REV | OMIT, 0, 0},
+        {stty_pass8, combination, REV | OMIT, 0, 0},
+        {litout, combination, REV | OMIT, 0, 0},
+        {cbreak, combination, REV | OMIT, 0, 0},
+#ifdef IXANY
+        {decctlq, combination, REV | OMIT, 0, 0},
+#endif
+#if defined (TABDLY) || defined (OXTABS)
+        {stty_tabs, combination, REV | OMIT, 0, 0},
+#endif
+#if defined(XCASE) && defined(IUCLC) && defined(OLCUC)
+        {stty_lcase, combination, REV | OMIT, 0, 0},
+        {stty_LCASE, combination, REV | OMIT, 0, 0},
+#endif
+        {stty_crt, combination, OMIT, 0, 0},
+        {stty_dec, combination, OMIT, 0, 0},
+};
+
+static const int NUM_mode_info =
+
+        (sizeof(mode_info) / sizeof(struct mode_info));
+
+/* Control character settings.  */
+struct control_info {
+        const char *name;                       /* Name given on command line.  */
+        unsigned char saneval;          /* Value to set for `stty sane'.  */
+        int offset;                                     /* Offset in c_cc.  */
+};
+
+/* Control characters. */
+
+static const struct control_info control_info[] = {
+        {"intr", CINTR, VINTR},
+        {"quit", CQUIT, VQUIT},
+        {"erase", CERASE, VERASE},
+        {"kill", CKILL, VKILL},
+        {stty_eof, CEOF, VEOF},
+        {stty_eol, CEOL, VEOL},
+#ifdef VEOL2
+        {"eol2", CEOL2, VEOL2},
+#endif
+#ifdef VSWTCH
+        {stty_swtch, CSWTCH, VSWTCH},
+#endif
+        {"start", CSTART, VSTART},
+        {"stop", CSTOP, VSTOP},
+        {"susp", CSUSP, VSUSP},
+#ifdef VDSUSP
+        {"dsusp", CDSUSP, VDSUSP},
+#endif
+#ifdef VREPRINT
+        {"rprnt", CRPRNT, VREPRINT},
+#endif
+#ifdef VWERASE
+        {"werase", CWERASE, VWERASE},
+#endif
+#ifdef VLNEXT
+        {"lnext", CLNEXT, VLNEXT},
+#endif
+#ifdef VFLUSHO
+        {"flush", CFLUSHO, VFLUSHO},
+#endif
+#ifdef VSTATUS
+        {"status", CSTATUS, VSTATUS},
+#endif
+
+        /* These must be last because of the display routines. */
+        {stty_min, 1, VMIN},
+        {stty_time, 0, VTIME},
+};
+
+static const int NUM_control_info =
+        (sizeof(control_info) / sizeof(struct control_info));
+
+
+static const char *visible(unsigned int ch);
+static unsigned long baud_to_value(speed_t speed);
+static int recover_mode(char *arg, struct termios *mode);
+static int screen_columns(void);
+static int set_mode(const struct mode_info *info,
+                int reversed, struct termios *mode);
+static speed_t string_to_baud(const char *arg);
+static tcflag_t *mode_type_flag(enum mode_type type, struct termios *mode);
+static void display_all(struct termios *mode, int fd,
+                const char *device_name);
+static void display_changed(struct termios *mode);
+static void display_recoverable(struct termios *mode);
+static void display_settings(enum output_type output_type, 
+                struct termios *mode, int fd,
+                const char *device_name);
+static void display_speed(struct termios *mode, int fancy);
+static void display_window_size(int fancy, int fd,
+                const char *device_name);
+static void sane_mode(struct termios *mode);
+static void set_control_char(const struct control_info *info,
+                const char *arg, struct termios *mode);
+static void set_speed(enum speed_setting type,
+                const char *arg, struct termios *mode);
+static void set_window_size(int rows, int cols, int fd,
+
+                                                        const char *device_name);
+
+/* The width of the screen, for output wrapping. */
+static int max_col;
+
+/* Current position, to know when to wrap. */
+static int current_col;
+
+/* Print format string MESSAGE and optional args.
+   Wrap to next line first if it won't fit.
+   Print a space first unless MESSAGE will start a new line. */
+
+static void wrapf(const char *message, ...)
+{
+        va_list args;
+        char buf[1024];                         /* Plenty long for our needs. */
+        int buflen;
+
+        va_start(args, message);
+        vsprintf(buf, message, args);
+        va_end(args);
+        buflen = strlen(buf);
+        if (current_col + (current_col > 0) + buflen >= max_col) {
+                putchar('\n');
+                current_col = 0;
+        }
+        if (current_col > 0) {
+                putchar(' ');
+                current_col++;
+        }
+        fputs(buf, stdout);
+        current_col += buflen;
+}
+
+static const struct suffix_mult stty_suffixes[] = {
+        {"b", 512},
+        {"k", 1024},
+        {"B", 1024},
+        {NULL, 0}
+};
+
+extern int stty_main(int argc, char **argv)
+{
+        struct termios mode;
+        enum output_type output_type;
+        int optc;
+        int require_set_attr;
+        int speed_was_set;
+        int verbose_output;
+        int recoverable_output;
+        int k;
+        int noargs = 1;
+        char *file_name = NULL;
+        int fd;
+        const char *device_name;
+
+        output_type = changed;
+        verbose_output = 0;
+        recoverable_output = 0;
+
+        /* Don't print error messages for unrecognized options.  */
+        opterr = 0;
+
+        while ((optc = getopt(argc, argv, "agF:")) != -1) {
+                switch (optc) {
+                case 'a':
+                        verbose_output = 1;
+                        output_type = all;
+                        break;
+
+                case 'g':
+                        recoverable_output = 1;
+                        output_type = recoverable;
+                        break;
+
+                case 'F':
+                        if (file_name)
+                                error_msg_and_die("only one device may be specified");
+                        file_name = optarg;
+                        break;
+
+                default:                                /* unrecognized option */
+                        noargs = 0;
+                        break;
+                }
+
+                if (noargs == 0)
+                        break;
+        }
+
+        if (optind < argc)
+                noargs = 0;
+
+        /* Specifying both -a and -g gets an error.  */
+        if (verbose_output && recoverable_output)
+                error_msg_and_die ("verbose and stty-readable output styles are mutually exclusive");
+
+        /* Specifying any other arguments with -a or -g gets an error.  */
+        if (!noargs && (verbose_output || recoverable_output))
+                error_msg_and_die ("modes may not be set when specifying an output style");
+
+        /* FIXME: it'd be better not to open the file until we've verified
+           that all arguments are valid.  Otherwise, we could end up doing
+           only some of the requested operations and then failing, probably
+           leaving things in an undesirable state.  */
+
+        if (file_name) {
+                int fdflags;
+
+                device_name = file_name;
+                fd = open(device_name, O_RDONLY | O_NONBLOCK);
+                if (fd < 0)
+                        perror_msg_and_die("%s", device_name);
+                if ((fdflags = fcntl(fd, F_GETFL)) == -1
+                        || fcntl(fd, F_SETFL, fdflags & ~O_NONBLOCK) < 0)
+                        perror_msg_and_die("%s: couldn't reset non-blocking mode",
+                                                           device_name);
+        } else {
+                fd = 0;
+                device_name = "standard input";
+        }
+
+        /* Initialize to all zeroes so there is no risk memcmp will report a
+           spurious difference in an uninitialized portion of the structure.  */
+        memset(&mode, 0, sizeof(mode));
+        if (tcgetattr(fd, &mode))
+                perror_msg_and_die("%s", device_name);
+
+        if (verbose_output || recoverable_output || noargs) {
+                max_col = screen_columns();
+                current_col = 0;
+                display_settings(output_type, &mode, fd, device_name);
+                return EXIT_SUCCESS;
+        }
+
+        speed_was_set = 0;
+        require_set_attr = 0;
+        k = optind;
+        while (k < argc) {
+                int match_found = 0;
+                int reversed = 0;
+                int i;
+
+                if (argv[k][0] == '-') {
+                        ++argv[k];
+                        reversed = 1;
+                }
+                for (i = 0; i < NUM_mode_info; ++i) {
+                        if (STREQ(argv[k], mode_info[i].name)) {
+                                match_found = set_mode(&mode_info[i], reversed, &mode);
+                                require_set_attr = 1;
+                                break;
+                        }
+                }
+                if (match_found == 0 && reversed) {
+                        error_msg_and_die("invalid argument `%s'", --argv[k]);
+                }
+                if (match_found == 0) {
+                        for (i = 0; i < NUM_control_info; ++i) {
+                                if (STREQ(argv[k], control_info[i].name)) {
+                                        if (k == argc - 1) {
+                                                error_msg_and_die("missing argument to `%s'", argv[k]);
+                                        }
+                                        match_found = 1;
+                                        ++k;
+                                        set_control_char(&control_info[i], argv[k], &mode);
+                                        require_set_attr = 1;
+                                        break;
+                                }
+                        }
+                }
+                if (match_found == 0) {
+                        if (STREQ(argv[k], "ispeed")) {
+                                if (k == argc - 1) {
+                                        error_msg_and_die("missing argument to `%s'", argv[k]);
+                                }
+                                ++k;
+                                set_speed(input_speed, argv[k], &mode);
+                                speed_was_set = 1;
+                                require_set_attr = 1;
+                        } else if (STREQ(argv[k], "ospeed")) {
+                                if (k == argc - 1) {
+                                        error_msg_and_die("missing argument to `%s'", argv[k]);
+                                }
+                                ++k;
+                                set_speed(output_speed, argv[k], &mode);
+                                speed_was_set = 1;
+                                require_set_attr = 1;
+                        }
+#ifdef TIOCGWINSZ
+                        else if (STREQ(argv[k], "rows")) {
+                                if (k == argc - 1) {
+                                        error_msg_and_die("missing argument to `%s'", argv[k]);
+                                }
+                                ++k;
+                                set_window_size((int) parse_number(argv[k], stty_suffixes),
+                                                                -1, fd, device_name);
+                        } else if (STREQ(argv[k], "cols") || STREQ(argv[k], "columns")) {
+                                if (k == argc - 1) {
+                                        error_msg_and_die("missing argument to `%s'", argv[k]);
+                                }
+                                ++k;
+                                set_window_size(-1,
+                                                                (int) parse_number(argv[k], stty_suffixes),
+                                                                fd, device_name);
+                        } else if (STREQ(argv[k], "size")) {
+                                max_col = screen_columns();
+                                current_col = 0;
+                                display_window_size(0, fd, device_name);
+                        }
+#endif
+#ifdef HAVE_C_LINE
+                        else if (STREQ(argv[k], "line")) {
+                                if (k == argc - 1) {
+                                        error_msg_and_die("missing argument to `%s'", argv[k]);
+                                }
+                                ++k;
+                                mode.c_line = parse_number(argv[k], stty_suffixes);
+                                require_set_attr = 1;
+                        }
+#endif
+                        else if (STREQ(argv[k], "speed")) {
+                                max_col = screen_columns();
+                                display_speed(&mode, 0);
+                        } else if (string_to_baud(argv[k]) != (speed_t) - 1) {
+                                set_speed(both_speeds, argv[k], &mode);
+                                speed_was_set = 1;
+                                require_set_attr = 1;
+                        } else {
+                                if (recover_mode(argv[k], &mode) == 0) {
+                                        error_msg_and_die("invalid argument `%s'", argv[k]);
+                                }
+                                require_set_attr = 1;
+                        }
+                }
+                k++;
+        }
+
+        if (require_set_attr) {
+                struct termios new_mode;
+
+                if (tcsetattr(fd, TCSADRAIN, &mode))
+                        perror_msg_and_die("%s", device_name);
+
+                /* POSIX (according to Zlotnick's book) tcsetattr returns zero if
+                   it performs *any* of the requested operations.  This means it
+                   can report `success' when it has actually failed to perform
+                   some proper subset of the requested operations.  To detect
+                   this partial failure, get the current terminal attributes and
+                   compare them to the requested ones.  */
+
+                /* Initialize to all zeroes so there is no risk memcmp will report a
+                   spurious difference in an uninitialized portion of the structure.  */
+                memset(&new_mode, 0, sizeof(new_mode));
+                if (tcgetattr(fd, &new_mode))
+                        perror_msg_and_die("%s", device_name);
+
+                /* Normally, one shouldn't use memcmp to compare structures that
+                   may have `holes' containing uninitialized data, but we have been
+                   careful to initialize the storage of these two variables to all
+                   zeroes.  One might think it more efficient simply to compare the
+                   modified fields, but that would require enumerating those fields --
+                   and not all systems have the same fields in this structure.  */
+
+                if (memcmp(&mode, &new_mode, sizeof(mode)) != 0) {
+#ifdef CIBAUD
+                        /* SunOS 4.1.3 (at least) has the problem that after this sequence,
+                           tcgetattr (&m1); tcsetattr (&m1); tcgetattr (&m2);
+                           sometimes (m1 != m2).  The only difference is in the four bits
+                           of the c_cflag field corresponding to the baud rate.  To save
+                           Sun users a little confusion, don't report an error if this
+                           happens.  But suppress the error only if we haven't tried to
+                           set the baud rate explicitly -- otherwise we'd never give an
+                           error for a true failure to set the baud rate.  */
+
+                        new_mode.c_cflag &= (~CIBAUD);
+                        if (speed_was_set || memcmp(&mode, &new_mode, sizeof(mode)) != 0)
+#endif
+                        {
+                                error_msg_and_die ("%s: unable to perform all requested operations",
+                                         device_name);
+#ifdef TESTING
+                                {
+                                        size_t i;
+
+                                        printf("new_mode: mode\n");
+                                        for (i = 0; i < sizeof(new_mode); i++)
+                                                printf("0x%02x: 0x%02x\n",
+                                                           *(((unsigned char *) &new_mode) + i),
+                                                           *(((unsigned char *) &mode) + i));
+                                }
+#endif
+                        }
+                }
+        }
+
+        return EXIT_SUCCESS;
+}
+
+/* Return 0 if not applied because not reversible; otherwise return 1.  */
+
+static int
+set_mode(const struct mode_info *info, int reversed, struct termios *mode)
+{
+        tcflag_t *bitsp;
+
+        if (reversed && (info->flags & REV) == 0)
+                return 0;
+
+        bitsp = mode_type_flag(info->type, mode);
+
+        if (bitsp == NULL) {
+                /* Combination mode. */
+                if (info->name == evenp || info->name == parity) {
+                        if (reversed)
+                                mode->c_cflag = (mode->c_cflag & ~PARENB & ~CSIZE) | CS8;
+                        else
+                                mode->c_cflag =
+                                        (mode->c_cflag & ~PARODD & ~CSIZE) | PARENB | CS7;
+                } else if (info->name == stty_oddp) {
+                        if (reversed)
+                                mode->c_cflag = (mode->c_cflag & ~PARENB & ~CSIZE) | CS8;
+                        else
+                                mode->c_cflag =
+                                        (mode->c_cflag & ~CSIZE) | CS7 | PARODD | PARENB;
+                } else if (info->name == stty_nl) {
+                        if (reversed) {
+                                mode->c_iflag = (mode->c_iflag | ICRNL) & ~INLCR & ~IGNCR;
+                                mode->c_oflag = (mode->c_oflag
+#ifdef ONLCR
+                                                                 | ONLCR
+#endif
+                                        )
+#ifdef OCRNL
+                                        & ~OCRNL
+#endif
+#ifdef ONLRET
+                                        & ~ONLRET
+#endif
+                                        ;
+                        } else {
+                                mode->c_iflag = mode->c_iflag & ~ICRNL;
+#ifdef ONLCR
+                                mode->c_oflag = mode->c_oflag & ~ONLCR;
+#endif
+                        }
+                } else if (info->name == stty_ek) {
+                        mode->c_cc[VERASE] = CERASE;
+                        mode->c_cc[VKILL] = CKILL;
+                } else if (info->name == stty_sane)
+                        sane_mode(mode);
+                else if (info->name == cbreak) {
+                        if (reversed)
+                                mode->c_lflag |= ICANON;
+                        else
+                                mode->c_lflag &= ~ICANON;
+                } else if (info->name == stty_pass8) {
+                        if (reversed) {
+                                mode->c_cflag = (mode->c_cflag & ~CSIZE) | CS7 | PARENB;
+                                mode->c_iflag |= ISTRIP;
+                        } else {
+                                mode->c_cflag = (mode->c_cflag & ~PARENB & ~CSIZE) | CS8;
+                                mode->c_iflag &= ~ISTRIP;
+                        }
+                } else if (info->name == litout) {
+                        if (reversed) {
+                                mode->c_cflag = (mode->c_cflag & ~CSIZE) | CS7 | PARENB;
+                                mode->c_iflag |= ISTRIP;
+                                mode->c_oflag |= OPOST;
+                        } else {
+                                mode->c_cflag = (mode->c_cflag & ~PARENB & ~CSIZE) | CS8;
+                                mode->c_iflag &= ~ISTRIP;
+                                mode->c_oflag &= ~OPOST;
+                        }
+                } else if (info->name == raw || info->name == cooked) {
+                        if ((info->name[0] == 'r' && reversed)
+                                || (info->name[0] == 'c' && !reversed)) {
+                                /* Cooked mode. */
+                                mode->c_iflag |= BRKINT | IGNPAR | ISTRIP | ICRNL | IXON;
+                                mode->c_oflag |= OPOST;
+                                mode->c_lflag |= ISIG | ICANON;
+#if VMIN == VEOF
+                                mode->c_cc[VEOF] = CEOF;
+#endif
+#if VTIME == VEOL
+                                mode->c_cc[VEOL] = CEOL;
+#endif
+                        } else {
+                                /* Raw mode. */
+                                mode->c_iflag = 0;
+                                mode->c_oflag &= ~OPOST;
+                                mode->c_lflag &= ~(ISIG | ICANON
+#ifdef XCASE
+                                                                   | XCASE
+#endif
+                                        );
+                                mode->c_cc[VMIN] = 1;
+                                mode->c_cc[VTIME] = 0;
+                        }
+                }
+#ifdef IXANY
+                else if (info->name == decctlq) {
+                        if (reversed)
+                                mode->c_iflag |= IXANY;
+                        else
+                                mode->c_iflag &= ~IXANY;
+                }
+#endif
+#ifdef TABDLY
+                else if (info->name == stty_tabs) {
+                        if (reversed)
+                                mode->c_oflag = (mode->c_oflag & ~TABDLY) | TAB3;
+                        else
+                                mode->c_oflag = (mode->c_oflag & ~TABDLY) | TAB0;
+                }
+#else
+# ifdef OXTABS
+                else if (info->name == stty_tabs) {
+                        if (reversed)
+                                mode->c_oflag = mode->c_oflag | OXTABS;
+                        else
+                                mode->c_oflag = mode->c_oflag & ~OXTABS;
+                }
+# endif
+#endif
+#if defined(XCASE) && defined(IUCLC) && defined(OLCUC)
+                else if (info->name == stty_lcase || info->name == stty_LCASE) {
+                        if (reversed) {
+                                mode->c_lflag &= ~XCASE;
+                                mode->c_iflag &= ~IUCLC;
+                                mode->c_oflag &= ~OLCUC;
+                        } else {
+                                mode->c_lflag |= XCASE;
+                                mode->c_iflag |= IUCLC;
+                                mode->c_oflag |= OLCUC;
+                        }
+                }
+#endif
+                else if (info->name == stty_crt)
+                        mode->c_lflag |= ECHOE
+#ifdef ECHOCTL
+                                | ECHOCTL
+#endif
+#ifdef ECHOKE
+                                | ECHOKE
+#endif
+                                ;
+                else if (info->name == stty_dec) {
+                        mode->c_cc[VINTR] = 3;  /* ^C */
+                        mode->c_cc[VERASE] = 127;       /* DEL */
+                        mode->c_cc[VKILL] = 21; /* ^U */
+                        mode->c_lflag |= ECHOE
+#ifdef ECHOCTL
+                                | ECHOCTL
+#endif
+#ifdef ECHOKE
+                                | ECHOKE
+#endif
+                                ;
+#ifdef IXANY
+                        mode->c_iflag &= ~IXANY;
+#endif
+                }
+        } else if (reversed)
+                *bitsp = *bitsp & ~info->mask & ~info->bits;
+        else
+                *bitsp = (*bitsp & ~info->mask) | info->bits;
+
+        return 1;
+}
+
+static void
+set_control_char(const struct control_info *info, const char *arg,
+                                 struct termios *mode)
+{
+        unsigned char value;
+
+        if (info->name == stty_min || info->name == stty_time)
+                value = parse_number(arg, stty_suffixes);
+        else if (arg[0] == '\0' || arg[1] == '\0')
+                value = arg[0];
+        else if (STREQ(arg, "^-") || STREQ(arg, "undef"))
+                value = _POSIX_VDISABLE;
+        else if (arg[0] == '^' && arg[1] != '\0') {     /* Ignore any trailing junk. */
+                if (arg[1] == '?')
+                        value = 127;
+                else
+                        value = arg[1] & ~0140; /* Non-letters get weird results. */
+        } else
+                value = parse_number(arg, stty_suffixes);
+        mode->c_cc[info->offset] = value;
+}
+
+static void
+set_speed(enum speed_setting type, const char *arg, struct termios *mode)
+{
+        speed_t baud;
+
+        baud = string_to_baud(arg);
+        if (type == input_speed || type == both_speeds)
+                cfsetispeed(mode, baud);
+        if (type == output_speed || type == both_speeds)
+                cfsetospeed(mode, baud);
+}
+
+#ifdef TIOCGWINSZ
+
+static int get_win_size(int fd, struct winsize *win)
+{
+        int err = ioctl(fd, TIOCGWINSZ, (char *) win);
+
+        return err;
+}
+
+static void
+set_window_size(int rows, int cols, int fd, const char *device_name)
+{
+        struct winsize win;
+
+        if (get_win_size(fd, &win)) {
+                if (errno != EINVAL)
+                        perror_msg_and_die("%s", device_name);
+                memset(&win, 0, sizeof(win));
+        }
+
+        if (rows >= 0)
+                win.ws_row = rows;
+        if (cols >= 0)
+                win.ws_col = cols;
+
+# ifdef TIOCSSIZE
+        /* Alexander Dupuy <dupuy@cs.columbia.edu> wrote:
+           The following code deals with a bug in the SunOS 4.x (and 3.x?) kernel.
+           This comment from sys/ttold.h describes Sun's twisted logic - a better
+           test would have been (ts_lines > 64k || ts_cols > 64k || ts_cols == 0).
+           At any rate, the problem is gone in Solaris 2.x. */
+
+        if (win.ws_row == 0 || win.ws_col == 0) {
+                struct ttysize ttysz;
+
+                ttysz.ts_lines = win.ws_row;
+                ttysz.ts_cols = win.ws_col;
+
+                win.ws_row = 1;
+                win.ws_col = 1;
+
+                if (ioctl(fd, TIOCSWINSZ, (char *) &win))
+                        perror_msg_and_die("%s", device_name);
+
+                if (ioctl(fd, TIOCSSIZE, (char *) &ttysz))
+                        perror_msg_and_die("%s", device_name);
+                return;
+        }
+# endif
+
+        if (ioctl(fd, TIOCSWINSZ, (char *) &win))
+                perror_msg_and_die("%s", device_name);
+}
+
+static void display_window_size(int fancy, int fd, const char *device_name)
+{
+        struct winsize win;
+
+        if (get_win_size(fd, &win)) {
+                if (errno != EINVAL)
+                        perror_msg_and_die("%s", device_name);
+                if (!fancy)
+                        perror_msg_and_die("%s: no size information for this device",
+                                                           device_name);
+        } else {
+                wrapf(fancy ? "rows %d; columns %d;" : "%d %d\n",
+                          win.ws_row, win.ws_col);
+                if (!fancy)
+                        current_col = 0;
+        }
+}
+#endif
+
+static int screen_columns(void)
+{
+#ifdef TIOCGWINSZ
+        struct winsize win;
+
+        /* With Solaris 2.[123], this ioctl fails and errno is set to
+           EINVAL for telnet (but not rlogin) sessions.
+           On ISC 3.0, it fails for the console and the serial port
+           (but it works for ptys).
+           It can also fail on any system when stdout isn't a tty.
+           In case of any failure, just use the default.  */
+        if (get_win_size(STDOUT_FILENO, &win) == 0 && win.ws_col > 0)
+                return win.ws_col;
+#endif
+
+        if (getenv("COLUMNS"))
+                return atoi(getenv("COLUMNS"));
+        return 80;
+}
+
+static tcflag_t *mode_type_flag(enum mode_type type, struct termios *mode)
+{
+        switch (type) {
+        case control:
+                return &mode->c_cflag;
+
+        case input:
+                return &mode->c_iflag;
+
+        case output:
+                return &mode->c_oflag;
+
+        case local:
+                return &mode->c_lflag;
+
+        default:                                        /* combination: */
+                return NULL;
+        }
+}
+
+static void
+display_settings(enum output_type output_type, struct termios *mode,
+                                 int fd, const char *device_name)
+{
+        switch (output_type) {
+        case changed:
+                display_changed(mode);
+                break;
+
+        case all:
+                display_all(mode, fd, device_name);
+                break;
+
+        case recoverable:
+                display_recoverable(mode);
+                break;
+        }
+}
+
+static void display_changed(struct termios *mode)
+{
+        int i;
+        int empty_line;
+        tcflag_t *bitsp;
+        unsigned long mask;
+        enum mode_type prev_type = control;
+
+        display_speed(mode, 1);
+#ifdef HAVE_C_LINE
+        wrapf("line = %d;", mode->c_line);
+#endif
+        putchar('\n');
+        current_col = 0;
+
+        empty_line = 1;
+        for (i = 0; control_info[i].name != stty_min; ++i) {
+                if (mode->c_cc[control_info[i].offset] == control_info[i].saneval)
+                        continue;
+                /* If swtch is the same as susp, don't print both.  */
+#if VSWTCH == VSUSP
+                if (control_info[i].name == stty_swtch)
+                        continue;
+#endif
+                /* If eof uses the same slot as min, only print whichever applies.  */
+#if VEOF == VMIN
+                if ((mode->c_lflag & ICANON) == 0
+                        && (control_info[i].name == stty_eof
+                                || control_info[i].name == stty_eol)) continue;
+#endif
+
+                empty_line = 0;
+                wrapf("%s = %s;", control_info[i].name,
+                          visible(mode->c_cc[control_info[i].offset]));
+        }
+        if ((mode->c_lflag & ICANON) == 0) {
+                wrapf("min = %d; time = %d;\n", (int) mode->c_cc[VMIN],
+                          (int) mode->c_cc[VTIME]);
+        } else if (empty_line == 0)
+                putchar('\n');
+        current_col = 0;
+
+        empty_line = 1;
+        for (i = 0; i < NUM_mode_info; ++i) {
+                if (mode_info[i].flags & OMIT)
+                        continue;
+                if (mode_info[i].type != prev_type) {
+                        if (empty_line == 0) {
+                                putchar('\n');
+                                current_col = 0;
+                                empty_line = 1;
+                        }
+                        prev_type = mode_info[i].type;
+                }
+
+                bitsp = mode_type_flag(mode_info[i].type, mode);
+                mask = mode_info[i].mask ? mode_info[i].mask : mode_info[i].bits;
+                if ((*bitsp & mask) == mode_info[i].bits) {
+                        if (mode_info[i].flags & SANE_UNSET) {
+                                wrapf("%s", mode_info[i].name);
+                                empty_line = 0;
+                        }
+                }
+                        else if ((mode_info[i].flags & (SANE_SET | REV)) ==
+                                         (SANE_SET | REV)) {
+                        wrapf("-%s", mode_info[i].name);
+                        empty_line = 0;
+                }
+        }
+        if (empty_line == 0)
+                putchar('\n');
+        current_col = 0;
+}
+
+static void
+display_all(struct termios *mode, int fd, const char *device_name)
+{
+        int i;
+        tcflag_t *bitsp;
+        unsigned long mask;
+        enum mode_type prev_type = control;
+
+        display_speed(mode, 1);
+#ifdef TIOCGWINSZ
+        display_window_size(1, fd, device_name);
+#endif
+#ifdef HAVE_C_LINE
+        wrapf("line = %d;", mode->c_line);
+#endif
+        putchar('\n');
+        current_col = 0;
+
+        for (i = 0; control_info[i].name != stty_min; ++i) {
+                /* If swtch is the same as susp, don't print both.  */
+#if VSWTCH == VSUSP
+                if (control_info[i].name == stty_swtch)
+                        continue;
+#endif
+                /* If eof uses the same slot as min, only print whichever applies.  */
+#if VEOF == VMIN
+                if ((mode->c_lflag & ICANON) == 0
+                        && (control_info[i].name == stty_eof
+                                || control_info[i].name == stty_eol)) continue;
+#endif
+                wrapf("%s = %s;", control_info[i].name,
+                          visible(mode->c_cc[control_info[i].offset]));
+        }
+#if VEOF == VMIN
+        if ((mode->c_lflag & ICANON) == 0)
+#endif
+                wrapf("min = %d; time = %d;", mode->c_cc[VMIN], mode->c_cc[VTIME]);
+        if (current_col != 0)
+                putchar('\n');
+        current_col = 0;
+
+        for (i = 0; i < NUM_mode_info; ++i) {
+                if (mode_info[i].flags & OMIT)
+                        continue;
+                if (mode_info[i].type != prev_type) {
+                        putchar('\n');
+                        current_col = 0;
+                        prev_type = mode_info[i].type;
+                }
+
+                bitsp = mode_type_flag(mode_info[i].type, mode);
+                mask = mode_info[i].mask ? mode_info[i].mask : mode_info[i].bits;
+                if ((*bitsp & mask) == mode_info[i].bits)
+                        wrapf("%s", mode_info[i].name);
+                else if (mode_info[i].flags & REV)
+                        wrapf("-%s", mode_info[i].name);
+        }
+        putchar('\n');
+        current_col = 0;
+}
+
+static void display_speed(struct termios *mode, int fancy)
+{
+        if (cfgetispeed(mode) == 0 || cfgetispeed(mode) == cfgetospeed(mode))
+                wrapf(fancy ? "speed %lu baud;" : "%lu\n",
+                          baud_to_value(cfgetospeed(mode)));
+        else
+                wrapf(fancy ? "ispeed %lu baud; ospeed %lu baud;" : "%lu %lu\n",
+                          baud_to_value(cfgetispeed(mode)),
+                          baud_to_value(cfgetospeed(mode)));
+        if (!fancy)
+                current_col = 0;
+}
+
+static void display_recoverable(struct termios *mode)
+{
+        int i;
+
+        printf("%lx:%lx:%lx:%lx",
+                   (unsigned long) mode->c_iflag, (unsigned long) mode->c_oflag,
+                   (unsigned long) mode->c_cflag, (unsigned long) mode->c_lflag);
+        for (i = 0; i < NCCS; ++i)
+                printf(":%x", (unsigned int) mode->c_cc[i]);
+        putchar('\n');
+}
+
+static int recover_mode(char *arg, struct termios *mode)
+{
+        int i, n;
+        unsigned int chr;
+        unsigned long iflag, oflag, cflag, lflag;
+
+        /* Scan into temporaries since it is too much trouble to figure out
+           the right format for `tcflag_t'.  */
+        if (sscanf(arg, "%lx:%lx:%lx:%lx%n",
+                           &iflag, &oflag, &cflag, &lflag, &n) != 4)
+                return 0;
+        mode->c_iflag = iflag;
+        mode->c_oflag = oflag;
+        mode->c_cflag = cflag;
+        mode->c_lflag = lflag;
+        arg += n;
+        for (i = 0; i < NCCS; ++i) {
+                if (sscanf(arg, ":%x%n", &chr, &n) != 1)
+                        return 0;
+                mode->c_cc[i] = chr;
+                arg += n;
+        }
+
+        /* Fail if there are too many fields.  */
+        if (*arg != '\0')
+                return 0;
+
+        return 1;
+}
+
+struct speed_map {
+        speed_t speed;                          /* Internal form. */
+        unsigned long value;            /* Numeric value. */
+};
+
+static const struct speed_map speeds[] = {
+        {B0, 0},
+        {B50, 50},
+        {B75, 75},
+        {B110, 110},
+        {B134, 134},
+        {B150, 150},
+        {B200, 200},
+        {B300, 300},
+        {B600, 600},
+        {B1200, 1200},
+        {B1800, 1800},
+        {B2400, 2400},
+        {B4800, 4800},
+        {B9600, 9600},
+        {B19200, 19200},
+        {B38400, 38400},
+#ifdef B57600
+        {B57600, 57600},
+#endif
+#ifdef B115200
+        {B115200, 115200},
+#endif
+#ifdef B230400
+        {B230400, 230400},
+#endif
+#ifdef B460800
+        {B460800, 460800},
+#endif
+};
+
+static const int NUM_SPEEDS = (sizeof(speeds) / sizeof(struct speed_map));
+
+static speed_t string_to_baud(const char *arg)
+{
+        int i;
+        static const struct suffix_mult stty_zerosuff = { NULL, 0 };
+
+        for (i = 0; i < NUM_SPEEDS; ++i)
+                if (parse_number(arg, &stty_zerosuff) == speeds[i].value)
+                        return speeds[i].speed;
+        return (speed_t) - 1;
+}
+
+static unsigned long baud_to_value(speed_t speed)
+{
+        int i;
+
+        for (i = 0; i < NUM_SPEEDS; ++i)
+                if (speed == speeds[i].speed)
+                        return speeds[i].value;
+        return 0;
+}
+
+static void sane_mode(struct termios *mode)
+{
+        int i;
+        tcflag_t *bitsp;
+
+        for (i = 0; i < NUM_control_info; ++i) {
+#if VMIN == VEOF
+                if (control_info[i].name == stty_min)
+                        break;
+#endif
+                mode->c_cc[control_info[i].offset] = control_info[i].saneval;
+        }
+
+        for (i = 0; i < NUM_mode_info; ++i) {
+                if (mode_info[i].flags & SANE_SET) {
+                        bitsp = mode_type_flag(mode_info[i].type, mode);
+                        *bitsp = (*bitsp & ~mode_info[i].mask) | mode_info[i].bits;
+                } else if (mode_info[i].flags & SANE_UNSET) {
+                        bitsp = mode_type_flag(mode_info[i].type, mode);
+                        *bitsp = *bitsp & ~mode_info[i].mask & ~mode_info[i].bits;
+                }
+        }
+}
+
+/* Return a string that is the printable representation of character CH.  */
+/* Adapted from `cat' by Torbjorn Granlund.  */
+
+static const char *visible(unsigned int ch)
+{
+        static char buf[10];
+        char *bpout = buf;
+
+        if (ch == _POSIX_VDISABLE)
+                return "<undef>";
+
+        if (ch >= 32) {
+                if (ch < 127)
+                        *bpout++ = ch;
+                else if (ch == 127) {
+                        *bpout++ = '^';
+                        *bpout++ = '?';
+                } else {
+                        *bpout++ = 'M', *bpout++ = '-';
+                        if (ch >= 128 + 32) {
+                                if (ch < 128 + 127)
+                                        *bpout++ = ch - 128;
+                                else {
+                                        *bpout++ = '^';
+                                        *bpout++ = '?';
+                                }
+                        } else {
+                                *bpout++ = '^';
+                                *bpout++ = ch - 128 + 64;
+                        }
+                }
+        } else {
+                *bpout++ = '^';
+                *bpout++ = ch + 64;
+        }
+        *bpout = '\0';
+        return (const char *) buf;
+}
+
+/*
+Local Variables:
+c-file-style: "linux"
+c-basic-offset: 4
+tab-width: 4
+End:
+*/