/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*      Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T     */
/*        All Rights Reserved   */

/*
 * University Copyright- Copyright (c) 1982, 1986, 1988
 * The Regents of the University of California
 * All Rights Reserved
 *
 * University Acknowledgment- Portions of this document are derived from
 * software developed by the University of California, Berkeley, and its
 * contributors.
 */

/*
 * rlogin - remote login
 */
#include <sys/types.h>
#include <sys/param.h>
#include <sys/errno.h>
#include <sys/file.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <sys/stropts.h>
#include <sys/ttold.h>
#include <sys/sockio.h>
#include <sys/tty.h>
#include <sys/ptyvar.h>
#include <sys/resource.h>
#include <sys/select.h>
#include <sys/time.h>

#include <netinet/in.h>
#include <arpa/inet.h>
#include <priv_utils.h>

#include <stdio.h>
#include <errno.h>
#include <pwd.h>
#include <signal.h>
#include <setjmp.h>
#include <netdb.h>
#include <fcntl.h>
#include <locale.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <k5-int.h>
#include <profile/prof_int.h>
#include <com_err.h>
#include <kcmd.h>
#include <krb5.h>

/* signal disposition - signal handler or SIG_IGN, SIG_ERR, etc. */
typedef void (*sigdisp_t)(int);

extern errcode_t        profile_get_options_boolean(profile_t, char **,
    profile_options_boolean *);
extern errcode_t        profile_get_options_string(profile_t, char **,
    profile_option_strings *);

#define RLOGIN_BUFSIZ   (1024 * 50)
static char des_inbuf[2 * RLOGIN_BUFSIZ];
                                        /* needs to be > largest read size */
static char des_outbuf[2 * RLOGIN_BUFSIZ];
                                        /* needs to be > largest write size */
static krb5_data desinbuf, desoutbuf;
static krb5_encrypt_block eblock;       /* eblock for encrypt/decrypt */
static krb5_keyblock *session_key;
static krb5_creds *cred;
static krb5_context bsd_context = NULL;
static krb5_auth_context auth_context;

static char *krb_realm;

static  int krb5auth_flag;      /* Flag set, when KERBEROS is enabled */
static profile_options_boolean autologin_option[] = {
        { "autologin", &krb5auth_flag, 0 },
        { NULL, NULL, 0 }
};

static  int fflag, Fflag;       /* Flag set, when option -f / -F used */
static  int encrypt_flag;       /* Flag set, when the "-x" option is used */

/* Flag set, if -PN / -PO is specified */
static boolean_t rcmdoption_done;

/* Flags set, if corres. cmd line options are turned on */
static boolean_t encrypt_done, fwd_done, fwdable_done;

static profile_options_boolean option[] = {
        { "encrypt", &encrypt_flag, 0 },
        { "forward", &fflag, 0 },
        { "forwardable", &Fflag, 0 },
        { NULL, NULL, 0 }
};

static char *rcmdproto;
static profile_option_strings rcmdversion[] = {
        { "rcmd_protocol", &rcmdproto, 0 },
        { NULL, NULL, 0 }
};

static char rlogin[] = "rlogin";

static char *realmdef[] = { "realms", NULL, rlogin, NULL };
static char *appdef[] = { "appdefaults", rlogin, NULL };

#ifndef TIOCPKT_WINDOW
#define TIOCPKT_WINDOW 0x80
#endif /* TIOCPKT_WINDOW */

#ifndef sigmask
#define sigmask(m)      (1 << ((m)-1))
#endif

#define set2mask(setp)  ((setp)->__sigbits[0])
#define mask2set(mask, setp) \
        ((mask) == -1 ? sigfillset(setp) : (((setp)->__sigbits[0]) = (mask)))

#ifdef DEBUG
#define DEBUGOPTSTRING  "D:"
#else
#define DEBUGOPTSTRING  ""
#endif  /* DEBUG */

static  boolean_t ttcompat;
static  struct termios savetty;

static  char *host;
static  int port_number;
static  int rem = -1;
static  char cmdchar = '~';
static  boolean_t nocmdchar;
static  boolean_t eight;
static  boolean_t litout;
static  boolean_t null_local_username;
/*
 * Note that this list of speeds is shorter than the list of speeds
 * supported by termios.  This is because we can't be sure other rlogind's
 * in the world will correctly cope with values other than what 4.2/4.3BSD
 * supported.
 */
static  char *speeds[] =
        { "0", "50", "75", "110", "134", "150", "200", "300",
            "600", "1200", "1800", "2400", "4800", "9600", "19200",
            "38400" };
static  char term[256] = "network";
static  void lostpeer(void);
static  boolean_t dosigwinch;
static  struct winsize winsize;
static  void sigwinch(int);
static  void oob(void);
static  void doit(int);
static  sigdisp_t sigdisp(int);

#define CRLF "\r\n"

static  pid_t child;
static  void catchild(int);
/* LINTED */
static  void copytochild(int);
static  void writeroob(int);
static  void stop(char), echo(char);

static  int defflags, tabflag;
static  int deflflags;
static  char deferase, defkill;
static  struct tchars deftc;
static  struct ltchars defltc;
static  struct tchars notc = { (char)-1, (char)-1, (char)-1,
                                (char)-1, (char)-1, (char)-1 };
static  struct ltchars noltc =  { (char)-1, (char)-1, (char)-1,
                                (char)-1, (char)-1, (char)-1 };

static  void done(int);
static  void mode(int);
static  int reader(int);
static  void writer(void);
static  void prf(const char *, ...);
static  void sendwindow(void);
static  int compat_ioctl(int, int, void *);

static void
sigsetmask(int mask)
{
        sigset_t oset;
        sigset_t nset;

        (void) sigprocmask(0, NULL, &nset);
        mask2set(mask, &nset);
        (void) sigprocmask(SIG_SETMASK, &nset, &oset);
}

static int
sigblock(int mask)
{
        sigset_t oset;
        sigset_t nset;

        (void) sigprocmask(0, NULL, &nset);
        mask2set(mask, &nset);
        (void) sigprocmask(SIG_BLOCK, &nset, &oset);
        return (set2mask(&oset));
}

static void
pop(int status) {
        if (ttcompat) {
                /*
                 * Pop ttcompat module
                 */
                (void) ioctl(STDIN_FILENO, I_POP, 0);
        }
        (void) tcsetattr(STDIN_FILENO, TCSANOW, &savetty);
        exit(status);
}

static void
usage(void) {
        (void) fprintf(stderr, "%s\n%s\n",
            gettext("usage: rlogin [-option] [-option...] "
                "[-k realm] [-l username] host"),
            gettext("       where option is e, 8, E, L, A, a, K, x, "
                "PN / PO, f or F"));
        pop(EXIT_FAILURE);
}

/* PRINTFLIKE(0) */
static void
die(const char *format, ...)
{
        va_list ap;

        va_start(ap, format);
        (void) vfprintf(stderr, format, ap);
        va_end(ap);
        usage();
}

static void
usage_forward(void)
{
        die(gettext("rlogin: Only one of -f and -F allowed.\n"));
}

int
main(int argc, char **argv)
{
        int c;
        char *cp, *cmd, *name = NULL;
        struct passwd *pwd;
        uid_t uid;
        int options = 0, oldmask;
        int on = 1;
        speed_t speed = 0;
        int getattr_ret;
        char *tmp;
        int sock;
        krb5_flags authopts;
        krb5_error_code status;
        enum kcmd_proto kcmd_proto = KCMD_NEW_PROTOCOL;

        (void) setlocale(LC_ALL, "");

#if !defined(TEXT_DOMAIN)
#define TEXT_DOMAIN "SYS_TEST"
#endif
        (void) textdomain(TEXT_DOMAIN);

        if (__init_suid_priv(0, PRIV_NET_PRIVADDR, NULL) == -1) {
                (void) fprintf(stderr,
                    gettext("Insufficient privileges, "
                        "rlogin must be set-uid root\n"));
                exit(1);
        }

        {
                int it;

                if ((getattr_ret = tcgetattr(STDIN_FILENO, &savetty)) < 0)
                        perror("tcgetattr");
                it = ioctl(STDIN_FILENO, I_FIND, "ttcompat");
                if (it < 0) {
                        perror("ioctl I_FIND ttcompat");
                        return (EXIT_FAILURE);
                }
                if (it == 0) {
                        if (ioctl(STDIN_FILENO, I_PUSH, "ttcompat") < 0) {
                                perror("ioctl I_PUSH ttcompat");
                                exit(EXIT_FAILURE);
                        }
                        ttcompat = B_TRUE;
                }
        }

        /*
         * Determine command name used to invoke to rlogin(1). Users can
         * create links named by a host pointing to the binary and type
         * "hostname" to log into that host afterwards.
         */
        cmd = strrchr(argv[0], '/');
        cmd = (cmd != NULL) ? (cmd + 1) : argv[0];

        if (strcmp(cmd, rlogin) == 0) {
                if (argc < 2)
                        usage();
                if (*argv[1] != '-') {
                        host = argv[1];
                        argc--;
                        argv[1] = argv[0];
                        argv++;
                }
        } else {
                host = cmd;
        }

        while ((c = getopt(argc, argv,
            DEBUGOPTSTRING "8AEFLP:aKde:fk:l:x")) != -1) {
                switch (c) {
                case '8':
                        eight = B_TRUE;
                        break;
                case 'A':
                        krb5auth_flag++;
                        break;
#ifdef DEBUG
                case 'D':
                        portnumber = htons(atoi(optarg));
                        krb5auth_flag++;
                        break;
#endif /* DEBUG */
                case 'E':
                        nocmdchar = B_TRUE;
                        break;
                case 'F':
                        if (fflag)
                                usage_forward();
                        Fflag = 1;
                        krb5auth_flag++;
                        fwdable_done = B_TRUE;
                        break;
                case 'f':
                        if (Fflag)
                                usage_forward();
                        fflag = 1;
                        krb5auth_flag++;
                        fwd_done = B_TRUE;
                        break;
                case 'L':
                        litout = B_TRUE;
                        break;
                case 'P':
                        if (strcmp(optarg, "N") == 0)
                                kcmd_proto = KCMD_NEW_PROTOCOL;
                        else if (strcmp(optarg, "O") == 0)
                                kcmd_proto = KCMD_OLD_PROTOCOL;
                        else
                                die(gettext("rlogin: Only -PN or -PO "
                                    "allowed.\n"));
                        if (rcmdoption_done)
                                die(gettext("rlogin: Only one of -PN and -PO "
                                    "allowed.\n"));
                        rcmdoption_done = B_TRUE;
                        krb5auth_flag++;
                        break;
                case 'a':
                case 'K':
                /*
                 * Force the remote host to prompt for a password by sending
                 * a NULL username. These options are mutually exclusive with
                 * the -A, -x, -f, -F, -k <realm> options.
                 */
                        null_local_username = B_TRUE;
                        break;
                case 'd':
                        options |= SO_DEBUG;
                        break;
                case 'e': {
                        int c;

                        cp = optarg;

                        if ((c = *cp) != '\\') {
                                cmdchar = c;
                        } else {
                                c = cp[1];
                                if (c == '\0' || c == '\\') {
                                        cmdchar = '\\';
                                } else if (c >= '0' && c <= '7') {
                                        long lc;

                                        lc = strtol(&cp[1], NULL, 8);
                                        if (lc < 0 || lc > 255)
                                                die(gettext("rlogin: octal "
                                                    "escape character %s too "
                                                    "large.\n"), cp);
                                        cmdchar = (char)lc;
                                } else {
                                        die(gettext("rlogin: unrecognized "
                                            "escape character option %s.\n"),
                                            cp);
                                }
                        }
                        break;
                }
                case 'k':
                        krb_realm = optarg;
                        krb5auth_flag++;
                        break;
                case 'l':
                        name = optarg;
                        break;
                case 'x':
                        encrypt_flag = 1;
                        krb5auth_flag++;
                        encrypt_done = B_TRUE;
                        break;
                default:
                        usage();
                }
        }

        argc -= optind;
        argv += optind;

        if (host == NULL) {
                if (argc == 0)
                        usage();
                argc--;
                host = *argv++;
        }

        if (argc > 0)
                usage();

        pwd = getpwuid(uid = getuid());
        if (pwd == NULL) {
                (void) fprintf(stderr, gettext("getpwuid(): can not find "
                        "password entry for user id %d."), uid);
                return (EXIT_FAILURE);
        }
        if (name == NULL)
                name = pwd->pw_name;

        /*
         * If the `-a or -K' options are issued on the cmd line, we reset
         * all flags associated with other KRB5 specific options, since
         * these options are mutually exclusive with the rest.
         */
        if (null_local_username) {
                krb5auth_flag = 0;
                fflag = Fflag = encrypt_flag = 0;
                (void) fprintf(stderr,
                                gettext("Note: The -a (or -K) option nullifies "
                                        "all other Kerberos-specific\noptions "
                                        "you may have used.\n"));
        } else if (!krb5auth_flag) {
                /* is autologin set in krb5.conf? */
                status = krb5_init_context(&bsd_context);
                /* don't sweat failure here */
                if (!status) {
                        /*
                         * note that the call to profile_get_options_boolean
                         * with autologin_option can affect value of
                         * krb5auth_flag
                         */
                        (void) profile_get_options_boolean(bsd_context->profile,
                            appdef, autologin_option);
                }
        }

        if (krb5auth_flag) {
                if (!bsd_context) {
                        status = krb5_init_context(&bsd_context);
                        if (status) {
                                com_err(rlogin, status,
                                    gettext("while initializing krb5"));
                                return (EXIT_FAILURE);
                        }
                }
                /*
                 * Set up buffers for desread and deswrite.
                 */
                desinbuf.data = des_inbuf;
                desoutbuf.data = des_outbuf;
                desinbuf.length = sizeof (des_inbuf);
                desoutbuf.length = sizeof (des_outbuf);

                /*
                 * Get our local realm to look up local realm options.
                 */
                status = krb5_get_default_realm(bsd_context, &realmdef[1]);
                if (status) {
                        com_err(rlogin, status,
                                gettext("while getting default realm"));
                        return (EXIT_FAILURE);
                }
                /*
                 * Check the realms section in krb5.conf for encryption,
                 * forward & forwardable info
                 */
                (void) profile_get_options_boolean(bsd_context->profile,
                    realmdef, option);
                /*
                 * Check the appdefaults section
                 */
                (void) profile_get_options_boolean(bsd_context->profile,
                    appdef, option);
                (void) profile_get_options_string(bsd_context->profile,
                    appdef, rcmdversion);

                /*
                 * Set the *_flag variables, if the corresponding *_done are
                 * set to 1, because we dont want the config file values
                 * overriding the command line options.
                 */
                if (encrypt_done)
                        encrypt_flag = 1;
                if (fwd_done) {
                        fflag = 1;
                        Fflag = 0;
                } else if (fwdable_done) {
                        Fflag = 1;
                        fflag = 0;
                }
                if (!rcmdoption_done && (rcmdproto != NULL)) {
                        if (strncmp(rcmdproto, "rcmdv2", 6) == 0) {
                                kcmd_proto = KCMD_NEW_PROTOCOL;
                        } else if (strncmp(rcmdproto, "rcmdv1", 6) == 0) {
                                kcmd_proto = KCMD_OLD_PROTOCOL;
                        } else {
                                (void) fprintf(stderr, gettext("Unrecognized "
                                        "KCMD protocol (%s)"), rcmdproto);
                                return (EXIT_FAILURE);
                        }
                }

                if (encrypt_flag && (!krb5_privacy_allowed())) {
                        (void) fprintf(stderr, gettext("rlogin: "
                                        "Encryption not supported.\n"));
                        return (EXIT_FAILURE);
                }
        }

        if (port_number == 0) {
                if (krb5auth_flag) {
                        struct servent *sp;

                        /*
                         * If the krb5auth_flag is set (via -A, -f, -F, -k) &
                         * if there is an entry in /etc/services for Kerberos
                         * login, attempt to login with Kerberos. If we fail
                         * at any step,  use the standard rlogin
                         */
                        sp = getservbyname(encrypt_flag ?
                            "eklogin" : "klogin", "tcp");
                        if (sp == NULL) {
                                port_number = encrypt_flag ?
                                    htons(2105) : htons(543);
                        } else {
                                port_number = sp->s_port;
                        }
                } else {
                        port_number = htons(IPPORT_LOGINSERVER);
                }
        }

        cp = getenv("TERM");
        if (cp) {
                (void) strncpy(term, cp, sizeof (term));
                term[sizeof (term) - 1] = '\0';
        }
        if (getattr_ret == 0) {
                speed = cfgetospeed(&savetty);
                /*
                 * "Be conservative in what we send" -- Only send baud rates
                 * which at least all 4.x BSD derivatives are known to handle
                 * correctly.
                 * NOTE:  This code assumes new termios speed values will
                 * be "higher" speeds.
                 */
                if (speed > B38400)
                        speed = B38400;
        }

        /*
         * Only put the terminal speed info in if we have room
         * so we don't overflow the buffer, and only if we have
         * a speed we recognize.
         */
        if (speed > 0 && speed < sizeof (speeds)/sizeof (char *) &&
            strlen(term) + strlen("/") + strlen(speeds[speed]) + 1 <
            sizeof (term)) {
                (void) strcat(term, "/");
                (void) strcat(term, speeds[speed]);
        }
        (void) sigset(SIGPIPE, (sigdisp_t)lostpeer);
        /* will use SIGUSR1 for window size hack, so hold it off */
        oldmask = sigblock(sigmask(SIGURG) | sigmask(SIGUSR1));

        /*
         * Determine if v4 literal address and if so store it to one
         * side. This is to correct the undesired behaviour of rcmd_af
         * which converts a passed in v4 literal address to a v4 mapped
         * v6 literal address. If it was a v4 literal we then re-assign
         * it to host.
         */
        tmp = NULL;
        if (inet_addr(host) != (in_addr_t)-1)
                tmp = host;

        if (krb5auth_flag) {
                authopts = AP_OPTS_MUTUAL_REQUIRED;

                /* Piggy-back forwarding flags on top of authopts; */
                /* they will be reset in kcmd */
                if (fflag || Fflag)
                        authopts |= OPTS_FORWARD_CREDS;
                if (Fflag)
                        authopts |= OPTS_FORWARDABLE_CREDS;

                status = kcmd(&sock, &host, port_number,
                        null_local_username ? "" : pwd->pw_name,
                        name, term, NULL,
                        "host", krb_realm, bsd_context, &auth_context,
                        &cred,
                        NULL,           /* No need for sequence number */
                        NULL,           /* No need for server seq # */
                        authopts,
                        0,              /* Not any port # */
                        &kcmd_proto);

                if (status != 0) {
                        /*
                         * If new protocol requested, we dont fallback to
                         * less secure ones.
                         */
                        if (kcmd_proto == KCMD_NEW_PROTOCOL) {
                                (void) fprintf(stderr, gettext("rlogin: kcmdv2 "
                                        "to host %s failed - %s\n"
                                        "Fallback to normal rlogin denied."),
                                        host, error_message(status));
                                return (EXIT_FAILURE);
                        }
                        if (status != -1) {
                                (void) fprintf(stderr, gettext("rlogin: kcmd "
                                                "to host %s failed - %s,\n"
                                                "trying normal rlogin...\n\n"),
                                                host, error_message(status));
                        } else {
                                (void) fprintf(stderr,
                                        gettext("trying normal rlogin...\n"));
                        }
                        /*
                         * kcmd() failed, so we have to
                         * fallback to normal rlogin
                         */
                        port_number = htons(IPPORT_LOGINSERVER);
                        krb5auth_flag = 0;
                        fflag = Fflag = encrypt_flag = 0;
                        null_local_username = B_FALSE;
                } else {
                        (void) fprintf(stderr,
                            gettext("connected with Kerberos V5\n"));

                        /*
                         * Setup eblock for desread and deswrite.
                         */
                        session_key = &cred->keyblock;

                        if (kcmd_proto == KCMD_NEW_PROTOCOL) {
                                status = krb5_auth_con_getlocalsubkey(
                                    bsd_context,
                                    auth_context,
                                    &session_key);
                                if (status) {
                                        com_err(rlogin, status,
                                            "determining subkey for session");
                                        return (EXIT_FAILURE);
                                }
                                if (session_key == NULL) {
                                        com_err(rlogin, 0,
                                            "no subkey negotiated for "
                                            "connection");
                                        return (EXIT_FAILURE);
                                }
                        }

                        eblock.crypto_entry = session_key->enctype;
                        eblock.key = (krb5_keyblock *)session_key;

                        init_encrypt(encrypt_flag, bsd_context, kcmd_proto,
                            &desinbuf, &desoutbuf, CLIENT, &eblock);

                        rem = sock;
                        if (rem < 0)
                                pop(EXIT_FAILURE);
                }
        }

        /*
         * Don't merge this with the "if" statement above because
         * "krb5auth_flag" might be set to false inside it.
         */
        if (!krb5auth_flag) {
                rem = rcmd_af(&host, port_number,
                        null_local_username ? "" : pwd->pw_name,
                        name, term, NULL, AF_INET6);
                if (rem < 0)
                        pop(EXIT_FAILURE);
        }

        /* Never need our privilege again */
        __priv_relinquish();

        if (tmp != NULL)
                host = tmp;

        if (options & SO_DEBUG &&
            setsockopt(rem, SOL_SOCKET, SO_DEBUG, (char *)&on,
                            sizeof (on)) < 0)
                perror("rlogin: setsockopt (SO_DEBUG)");

        {
                int bufsize = 8192;

                (void) setsockopt(rem, SOL_SOCKET, SO_RCVBUF, (char *)&bufsize,
                        sizeof (int));
        }

        doit(oldmask);
        return (0);
}

static void
doit(int oldmask)
{
        struct sgttyb sb;
        int atmark;

        if (ioctl(STDIN_FILENO, TIOCGETP, (char *)&sb) == -1)
                perror("ioctl TIOCGETP");
        defflags = sb.sg_flags;
        tabflag = defflags & O_TBDELAY;
        defflags &= ECHO | O_CRMOD;
        deferase = sb.sg_erase;
        defkill = sb.sg_kill;
        if (ioctl(STDIN_FILENO, TIOCLGET, (char *)&deflflags) == -1)
                perror("ioctl TIOCLGET");
        if (ioctl(STDIN_FILENO, TIOCGETC, (char *)&deftc) == -1)
                perror("ioctl TIOCGETC");
        notc.t_startc = deftc.t_startc;
        notc.t_stopc = deftc.t_stopc;
        if (ioctl(STDIN_FILENO, TIOCGLTC, (char *)&defltc) == -1)
                perror("ioctl TIOCGLTC");
        (void) sigset(SIGINT, SIG_IGN);
        if (sigdisp(SIGHUP) != SIG_IGN)
                (void) sigset(SIGHUP, exit);
        if (sigdisp(SIGQUIT) != SIG_IGN)
                (void) sigset(SIGQUIT, exit);
        child = fork();
        if (child == (pid_t)-1) {
                perror("rlogin: fork");
                done(EXIT_FAILURE);
        }
        if (child == 0) {
                mode(1);
                if (reader(oldmask) == 0) {
                        prf(gettext("Connection to %.*s closed."),
                            MAXHOSTNAMELEN, host);
                        exit(EXIT_SUCCESS);
                }
                (void) sleep(1);
                prf(gettext("\aConnection to %.*s closed."),
                    MAXHOSTNAMELEN, host);
                exit(EXIT_FAILURE);
        }

        /*
         * We may still own the socket, and may have a pending SIGURG (or might
         * receive one soon) that we really want to send to the reader.  Set a
         * trap that simply copies such signals to the child.
         */
#ifdef F_SETOWN_BUG_FIXED
        (void) sigset(SIGURG, copytochild);
#else
        (void) sigset(SIGURG, SIG_IGN);
#endif /* F_SETOWN_BUG_FIXED */
        (void) sigset(SIGUSR1, writeroob);
        /*
         * Of course, if the urgent byte already arrived, allowing SIGURG
         * won't get us notification.  So, we check to see if we've got
         * an urgent byte.  If so, force a call to writeroob() to pretend
         * we got SIGURG.
         */
        if (ioctl(rem, SIOCATMARK, &atmark) >= 0) {
                if (atmark)
                        writeroob(0);
        }
        sigsetmask(oldmask);
        (void) sigset(SIGCHLD, catchild);
        writer();
        prf(gettext("Closed connection to %.*s."), MAXHOSTNAMELEN, host);
        done(EXIT_SUCCESS);
}

/*
 * Get signal disposition (or signal handler) for a given signal
 */
static sigdisp_t
sigdisp(int sig)
{
        struct sigaction act;

        act.sa_handler = NULL;
        act.sa_flags = 0;
        (void) sigemptyset(&act.sa_mask);
        (void) sigaction(sig, NULL, &act);
        return (act.sa_handler);
}

static void
done(int status)
{
        pid_t w;

        mode(0);
        if (child > 0) {
                /* make sure catchild does not snap it up */
                (void) sigset(SIGCHLD, SIG_DFL);
                if (kill(child, SIGKILL) >= 0)
                        while ((w = wait(0)) > (pid_t)0 && w != child)
                                /* void */;
        }
        pop(status);
}

/*
 * Copy SIGURGs to the child process.
 */

/* ARGSUSED */
static void
copytochild(int signum)
{

        (void) kill(child, SIGURG);
}

/*
 * This is called when the reader process gets the out-of-band (urgent)
 * request to turn on the window-changing protocol.
 */

/* ARGSUSED */
static void
writeroob(int signum)
{
        int mask;

        if (!dosigwinch) {
                /*
                 * Start tracking window size.  It doesn't matter which
                 * order the next two are in, because we'll be unconditionally
                 * sending a size notification in a moment.
                 */
                (void) sigset(SIGWINCH, sigwinch);
                dosigwinch = B_TRUE;

                /*
                 * It would be bad if a SIGWINCH came in between the ioctl
                 * and sending the data.  It could result in the SIGWINCH
                 * handler sending a good message, and then us sending an
                 * outdated or inconsistent message.
                 *
                 * Instead, if the change is made before the
                 * ioctl, the sigwinch handler will send a size message
                 * and we'll send another, identical, one.  If the change
                 * is made after the ioctl, we'll send a message with the
                 * old value, and then the sigwinch handler will send
                 * a revised, correct one.
                 */
                mask = sigblock(sigmask(SIGWINCH));
                if (ioctl(STDIN_FILENO, TIOCGWINSZ, &winsize) == 0)
                        sendwindow();
                sigsetmask(mask);
        }
}

/* ARGSUSED */
static void
catchild(int signum)
{
        int options;
        siginfo_t       info;
        int error;

        for (;;) {
                options = WNOHANG | WEXITED;
                error = waitid(P_ALL, 0, &info, options);
                if (error != 0)
                        return;
                if (info.si_pid == 0)
                        return;
                if (info.si_code == CLD_TRAPPED)
                        continue;
                if (info.si_code == CLD_STOPPED)
                        continue;
                done(info.si_status);
        }
}

/*
 * writer: write to remote: 0 -> line.
 * ~.   terminate
 * ~^Z  suspend rlogin process.
 * ~^Y  suspend rlogin process, but leave reader alone.
 */
static void
writer(void)
{
        char c;
        int n;
        boolean_t bol = B_TRUE;         /* beginning of line */
        boolean_t local = B_FALSE;

        for (;;) {
                n = read(STDIN_FILENO, &c, 1);
                if (n <= 0) {
                        if (n == 0)
                                break;
                        if (errno == EINTR)
                                continue;
                        else {
                                prf(gettext("Read error from terminal: %s"),
                                    strerror(errno));
                                break;
                        }
                }
                /*
                 * If we're at the beginning of the line
                 * and recognize a command character, then
                 * we echo locally.  Otherwise, characters
                 * are echo'd remotely.  If the command
                 * character is doubled, this acts as a
                 * force and local echo is suppressed.
                 */
                if (bol && !nocmdchar) {
                        bol = B_FALSE;
                        if (c == cmdchar) {
                                local = B_TRUE;
                                continue;
                        }
                } else if (local) {
                        local = B_FALSE;
                        if (c == '.' || c == deftc.t_eofc) {
                                echo(c);
                                break;
                        }
                        if (c == defltc.t_suspc || c == defltc.t_dsuspc) {
                                bol = B_TRUE;
                                echo(c);
                                stop(c);
                                continue;
                        }
                        if (c != cmdchar) {
                                if (deswrite(rem, &cmdchar, 1, 0) < 0) {
                                        prf(gettext(
                                            "Write error to network: %s"),
                                            strerror(errno));
                                        break;
                                }
                        }
                }
                if ((n = deswrite(rem, &c, 1, 0)) <= 0) {
                        if (n == 0)
                                prf(gettext("line gone"));
                        else
                                prf(gettext("Write error to network: %s"),
                                    strerror(errno));
                        break;
                }
                bol = c == defkill || c == deftc.t_eofc ||
                    c == deftc.t_intrc || c == defltc.t_suspc ||
                    c == '\r' || c == '\n';
        }
}

static void
echo(char c)
{
        char buf[8];
        char *p = buf;

        c &= 0177;
        *p++ = cmdchar;
        if (c < ' ') {
                *p++ = '^';
                *p++ = c + '@';
        } else if (c == 0177) {
                *p++ = '^';
                *p++ = '?';
        } else
                *p++ = c;
        *p++ = '\r';
        *p++ = '\n';
        if (write(STDOUT_FILENO, buf, p - buf) < 0)
                prf(gettext("Write error to terminal: %s"), strerror(errno));
}

static void
stop(char cmdc)
{
        mode(0);
        (void) sigset(SIGCHLD, SIG_IGN);
        (void) kill(cmdc == defltc.t_suspc ? 0 : getpid(), SIGTSTP);
        (void) sigset(SIGCHLD, catchild);
        mode(1);
        sigwinch(0);                    /* check for size changes */
}

/* ARGSUSED */
static void
sigwinch(int signum)
{
        struct winsize ws;

        if (dosigwinch && ioctl(STDIN_FILENO, TIOCGWINSZ, &ws) == 0 &&
            memcmp(&winsize, &ws, sizeof (ws)) != 0) {
                winsize = ws;
                sendwindow();
        }
}

/*
 * Send the window size to the server via the magic escape.
 * Note:  SIGWINCH should be blocked when this is called, lest
 * winsize change underneath us and chaos result.
 */
static void
sendwindow(void)
{
        char obuf[4 + sizeof (struct winsize)];
        struct winsize *wp = (struct winsize *)(void *)(obuf+4);

        obuf[0] = -1;
        obuf[1] = -1;
        obuf[2] = 's';
        obuf[3] = 's';
        wp->ws_row = htons(winsize.ws_row);
        wp->ws_col = htons(winsize.ws_col);
        wp->ws_xpixel = htons(winsize.ws_xpixel);
        wp->ws_ypixel = htons(winsize.ws_ypixel);
        if (deswrite(rem, obuf, sizeof (obuf), 0) < 0)
                prf(gettext("Write error to network: %s"), strerror(errno));
}


/*
 * reader: read from remote: remote -> stdout
 */
#define READING 1
#define WRITING 2

static  char rcvbuf[8 * 1024];
static  int rcvcnt;
static  int rcvstate;
static  pid_t ppid;
static  jmp_buf rcvtop;

static void
oob(void)
{
        int out = FWRITE, atmark, n;
        int rcvd = 0;
        char waste[4*BUFSIZ], mark;
        struct sgttyb sb;
        fd_set exceptfds;
        struct timeval tv;
        int ret;

        FD_ZERO(&exceptfds);
        FD_SET(rem, &exceptfds);
        timerclear(&tv);
        ret = select(rem+1, NULL, NULL, &exceptfds, &tv);
        /*
         * We may get an extra signal at start up time since we are trying
         * to take all precautions not to miss the urgent byte. This
         * means we may get here without any urgent data to process, in which
         * case we do nothing and just return.
         */
        if (ret <= 0)
                return;

        do {
                if (ioctl(rem, SIOCATMARK, &atmark) < 0) {
                        break;
                }
                if (!atmark) {
                        /*
                         * Urgent data not here yet.
                         * It may not be possible to send it yet
                         * if we are blocked for output
                         * and our input buffer is full.
                         */
                        if (rcvcnt < sizeof (rcvbuf)) {
                                n = desread(rem, rcvbuf + rcvcnt,
                                        sizeof (rcvbuf) - rcvcnt, 0);
                                if (n <= 0)
                                        return;
                                rcvd += n;
                                rcvcnt += n;
                        } else {
                                /*
                                 * We still haven't gotten to the urgent mark
                                 * and we're out of buffer space.  Since we
                                 * must clear our receive window to allow it
                                 * to arrive, we will have to throw away
                                 * these bytes.
                                 */
                                n = desread(rem, waste, sizeof (waste), 0);
                                if (n <= 0)
                                        return;
                        }
                }
        } while (atmark == 0);
        while (recv(rem, &mark, 1, MSG_OOB) < 0) {
                switch (errno) {

                case EWOULDBLOCK:
                        /*
                         * We've reached the urgent mark, so the next
                         * data to arrive will be the urgent, but it must
                         * not have arrived yet.
                         */
                        (void) sleep(1);
                        continue;

                default:
                        return;
                }
        }
        if (mark & TIOCPKT_WINDOW) {
                /*
                 * Let server know about window size changes
                 */
                (void) kill(ppid, SIGUSR1);
        }
        if (!eight && (mark & TIOCPKT_NOSTOP)) {
                if (ioctl(STDIN_FILENO, TIOCGETP, (char *)&sb) == -1)
                        perror("ioctl TIOCGETP");
                sb.sg_flags &= ~O_CBREAK;
                sb.sg_flags |= O_RAW;
                if (compat_ioctl(STDIN_FILENO, TIOCSETP, &sb) == -1)
                        perror("ioctl TIOCSETP 1");
                notc.t_stopc = -1;
                notc.t_startc = -1;
                if (compat_ioctl(STDIN_FILENO, TIOCSETC, &notc) == -1)
                        perror("ioctl TIOCSETC");
        }
        if (!eight && (mark & TIOCPKT_DOSTOP)) {
                if (ioctl(STDIN_FILENO, TIOCGETP, (char *)&sb) == -1)
                        perror("ioctl TIOCGETP");
                sb.sg_flags &= ~O_RAW;
                sb.sg_flags |= O_CBREAK;
                if (compat_ioctl(STDIN_FILENO, TIOCSETP, &sb) == -1)
                        perror("ioctl TIOCSETP 2");
                notc.t_stopc = deftc.t_stopc;
                notc.t_startc = deftc.t_startc;
                if (compat_ioctl(STDIN_FILENO, TIOCSETC, &notc) == -1)
                        perror("ioctl TIOCSETC");
        }
        if (mark & TIOCPKT_FLUSHWRITE) {
                if (ioctl(STDOUT_FILENO, TIOCFLUSH, (char *)&out) == -1)
                        perror("ioctl TIOCFLUSH");
                for (;;) {
                        if (ioctl(rem, SIOCATMARK, &atmark) < 0) {
                                perror("ioctl SIOCATMARK");
                                break;
                        }
                        if (atmark)
                                break;
                        n = desread(rem, waste, sizeof (waste), 0);
                        if (n <= 0) {
                                if (n < 0)
                                        prf(gettext(
                                            "Read error from network: %s"),
                                            strerror(errno));
                                break;
                        }
                }
                /*
                 * Don't want any pending data to be output,
                 * so clear the recv buffer.
                 * If we were hanging on a write when interrupted,
                 * don't want it to restart.  If we were reading,
                 * restart anyway.
                 */
                rcvcnt = 0;
                longjmp(rcvtop, 1);
        }
        /*
         * If we filled the receive buffer while a read was pending,
         * longjmp to the top to restart appropriately.  Don't abort
         * a pending write, however, or we won't know how much was written.
         */
        if (rcvd && rcvstate == READING)
                longjmp(rcvtop, 1);
}

/*
 * reader: read from remote: line -> 1
 */
static int
reader(int oldmask)
{
        /*
         * 4.3bsd or later and SunOS 4.0 or later use the posiitive
         * pid; otherwise use the negative.
         */
        pid_t pid = getpid();
        int n, remaining;
        char *bufp = rcvbuf;

        (void) sigset(SIGTTOU, SIG_IGN);
        (void) sigset(SIGURG, (void (*)())oob);
        ppid = getppid();
        if (fcntl(rem, F_SETOWN, pid) == -1)
                perror("fcntl F_SETOWN");
        /*
         * A SIGURG may have been posted before we were completely forked,
         * which means we may not have received it. To insure we do not miss
         * any urgent data, we force the signal. The signal hander will be
         * able to determine if in fact there is urgent data or not.
         */
        (void) kill(pid, SIGURG);
        (void) setjmp(rcvtop);
        sigsetmask(oldmask);
        for (;;) {
                while ((remaining = rcvcnt - (bufp - rcvbuf)) > 0) {
                        rcvstate = WRITING;
                        n = write(STDOUT_FILENO, bufp, remaining);
                        if (n < 0) {
                                if (errno != EINTR) {
                                        prf(gettext(
                                            "Write error to terminal: %s"),
                                            strerror(errno));
                                        return (-1);
                                }
                                continue;
                        }
                        bufp += n;
                }
                bufp = rcvbuf;
                rcvcnt = 0;
                rcvstate = READING;
                rcvcnt = desread(rem, rcvbuf, sizeof (rcvbuf), 0);
                if (rcvcnt == 0)
                        return (0);
                if (rcvcnt < 0) {
                        if (errno == EINTR)
                                continue;
                        prf(gettext("Read error from network: %s"),
                            strerror(errno));
                        return (-1);
                }
        }
}

static void
mode(int f)
{
        struct tchars *tc;
        struct ltchars *ltc;
        struct sgttyb sb;
        int     lflags;

        if (ioctl(STDIN_FILENO, TIOCGETP, (char *)&sb) == -1)
                perror("ioctl TIOCGETP");
        if (ioctl(STDIN_FILENO, TIOCLGET, (char *)&lflags) == -1)
                perror("ioctl TIOCLGET");
        switch (f) {

        case 0:
                sb.sg_flags &= ~(O_CBREAK|O_RAW|O_TBDELAY);
                sb.sg_flags |= defflags|tabflag;
                tc = &deftc;
                ltc = &defltc;
                sb.sg_kill = defkill;
                sb.sg_erase = deferase;
                lflags = deflflags;
                break;

        case 1:
                sb.sg_flags |= (eight ? O_RAW : O_CBREAK);
                sb.sg_flags &= ~defflags;
                /* preserve tab delays, but turn off XTABS */
                if ((sb.sg_flags & O_TBDELAY) == O_XTABS)
                        sb.sg_flags &= ~O_TBDELAY;
                tc = &notc;
                ltc = &noltc;
                sb.sg_kill = sb.sg_erase = -1;
                if (litout)
                        lflags |= LLITOUT;
                break;

        default:
                /*NOTREACHED*/
                return;
        }
        if (compat_ioctl(STDIN_FILENO, TIOCSLTC, ltc) == -1)
                perror("ioctl TIOCSLTC");
        if (compat_ioctl(STDIN_FILENO, TIOCSETC, tc) == -1)
                perror("ioctl TIOCSETC");
        if (compat_ioctl(STDIN_FILENO, TIOCSETP, &sb) == -1)
                perror("ioctl TIOCSETP 3");
        if (compat_ioctl(STDIN_FILENO, TIOCLSET, &lflags) == -1)
                perror("ioctl TIOCLSET");
}

/* PRINTFLIKE(0) */
static void
prf(const char *format, ...)
{
        va_list ap;

        va_start(ap, format);
        (void) vfprintf(stderr, format, ap);
        va_end(ap);
        (void) fputs(CRLF, stderr);
}

static void
lostpeer(void)
{
        (void) sigset(SIGPIPE, SIG_IGN);
        prf(gettext("\aConnection to %.*s closed."), MAXHOSTNAMELEN, host);
        done(EXIT_FAILURE);
}

static int
compat_ioctl(int des, int request, void *arg)
{
        struct termios  tb;
        boolean_t       flag = B_FALSE;

        if (ioctl(des, request, arg) < 0)
                return (-1);

        if (tcgetattr(des, &tb) < 0)
                return (-1);

        if (cfgetispeed(&tb) != cfgetispeed(&savetty)) {
                (void) cfsetispeed(&tb, cfgetispeed(&savetty));
                flag = B_TRUE;
        }
        if (cfgetospeed(&tb) != cfgetospeed(&savetty)) {
                (void) cfsetospeed(&tb, cfgetospeed(&savetty));
                flag = B_TRUE;
        }

        return (flag ? tcsetattr(des, TCSANOW, &tb) : 0);
}