cmd-inet/usr.sbin/in.rlogind.c

	in.rlogind.c revision e13177896b84fc2d0c344032853bf0277c8182bf
/*
 * Copyright 2008 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   */

/*
 * Copyright (c) 1983 The Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms are permitted
 * provided that the above copyright notice and this paragraph are
 * duplicated in all such forms and that any documentation,
 * advertising materials, and other materials related to such
 * distribution and use acknowledge that the software was developed
 * by the University of California, Berkeley.  The name of the
 * University may not be used to endorse or promote products derived
 * from this software without specific prior written permission.
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 */

/*
 * remote login server:
 *  remuser\0
 *  locuser\0
 *  terminal info\0
 *  data
 */

#include <time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <sys/wait.h>

#include <netinet/in.h>

#include <errno.h>
#include <signal.h>
#include <fcntl.h>
#include <stdio.h>
#include <netdb.h>
#include <syslog.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <alloca.h>
#include <stropts.h>
#include <sac.h>    /* for SC_WILDC */
#include <utmpx.h>
#include <sys/filio.h>
#include <sys/logindmux.h>
#include <sys/rlioctl.h>
#include <sys/termios.h>
#include <sys/tihdr.h>
#include <arpa/inet.h>
#include <security/pam_appl.h>
#include <strings.h>
#include <com_err.h>
#include <k5-int.h>
#include <kcmd.h>
#include <krb5_repository.h>
#include <sys/cryptmod.h>
#include <bsm/adt.h>
#include <addr_match.h>
#include <store_forw_creds.h>

#define KRB5_RECVAUTH_V5 5
#define UT_NAMESIZE sizeof (((struct utmpx *)0)->ut_name)

static char lusername[UT_NAMESIZE+1];
static char rusername[UT_NAMESIZE+1];
static char *krusername = NULL;
static char term[64];

static krb5_ccache ccache = NULL;
static krb5_keyblock *session_key = NULL;
static int chksum_flag = 0;
static int use_auth = 0;
static enum kcmd_proto kcmd_protocol;
#ifdef ALLOW_KCMD_V2
static krb5_data encr_iv = { NULL, 0 };
static krb5_data decr_iv = { NULL, 0 };
#endif /* ALLOW_KCMD_V2 */

#define CHKSUM_REQUIRED 0x01
#define CHKSUM_IGNORED  0x02
#define VALID_CHKSUM(x) ((x) == 0 || (x) == CHKSUM_REQUIRED ||\
            (x) == CHKSUM_IGNORED)

#define PWD_IF_FAIL  0x01
#define PWD_REQUIRED 0x02

#define AUTH_NONE 0x00

#define ARGSTR "k5exEXciM:s:S:D:"
#define DEFAULT_TOS 16

#define KRB5_PROG_NAME "krlogin"

#define SECURE_MSG "This rlogin session is using encryption " \
    "for all data transmissions.\r\n"

#define KRB_V5_SENDAUTH_VERS    "KRB5_SENDAUTH_V1.0"
#define KRB5_RECVAUTH_V5    5

static krb5_error_code krb5_compat_recvauth(krb5_context context,
                        krb5_auth_context *auth_context,
                        krb5_pointer fdp,
                        krb5_principal server,
                        krb5_int32 flags,
                        krb5_keytab keytab,
                        krb5_ticket **ticket,
                        krb5_int32 *auth_sys,
                        krb5_data *version);

static void do_krb_login(int, char *, char *, krb5_context, int, krb5_keytab);
static int configure_stream(int, krb5_keyblock *, int, krb5_data *, uint_t);

extern krb5_error_code krb5_read_message(krb5_context, krb5_pointer,
                    krb5_data *);
extern krb5_error_code krb5_net_read(krb5_context, int, char *, int);

#define LOGIN_PROGRAM "/bin/login"

#define DEFAULT_PROG_NAME   "rlogin"

static const char *pam_prog_name = DEFAULT_PROG_NAME;
static void rmut(void);
static void doit(int,  struct sockaddr_storage *, krb5_context, int,
            krb5_keytab);
static void protocol(int, int, int);

static int  readstream(int, char *, int);
static void fatal(int, const char *);
static void fatalperror(int, const char *);
static int  send_oob(int fd, void *ptr, size_t count);
static int  removemod(int f, char *modname);

static int
issock(int fd)
{
    struct stat stats;

    if (fstat(fd, &stats) == -1)
        return (0);
    return (S_ISSOCK(stats.st_mode));
}

/*
 * audit_rlogin_settid stores the terminal id while it is still
 * available.  Subsequent calls to adt_load_hostname() return
 * the id which is stored here.
 */
static int
audit_rlogin_settid(int fd) {
    adt_session_data_t  *ah;
    adt_termid_t        *termid;
    int         rc;

    if ((rc = adt_start_session(&ah, NULL, 0)) == 0) {
        if ((rc = adt_load_termid(fd, &termid)) == 0) {
            if ((rc = adt_set_user(ah, ADT_NO_AUDIT,
                ADT_NO_AUDIT, 0, ADT_NO_AUDIT,
                termid, ADT_SETTID)) == 0)
                (void) adt_set_proc(ah);
            free(termid);
        }
        (void) adt_end_session(ah);
    }
    return (rc);
}


/* ARGSUSED */
int
main(int argc, char *argv[])
{
    int on = 1;
    socklen_t fromlen;
    struct sockaddr_storage from;
    int fd = -1;

    extern char *optarg;
    char c;
    int tos = -1;
    krb5_context krb_context;
    krb5_keytab keytab = NULL;
    krb5_error_code status;
    char *realm = NULL;
    char *keytab_file = NULL;
    int encr_flag = 0;
    struct sockaddr_storage ouraddr;
    socklen_t ourlen;
#ifdef DEBUG
    int debug_port = 0;
#endif /* DEBUG */
    openlog("rlogind", LOG_PID | LOG_ODELAY, LOG_DAEMON);

    while ((c = getopt(argc, argv, ARGSTR)) != -1) {
        switch (c) {
        case 'k':
        case '5':
            use_auth = KRB5_RECVAUTH_V5;
            break;
        case 'e':
        case 'E':
        case 'x':
        case 'X':
            encr_flag = 1;
            break;
        case 'M':
            realm = (char *)strdup(optarg);
            break;
        case 'S':
            keytab_file = (char *)strdup(optarg);
            break;
        case 'c':
            chksum_flag |= CHKSUM_REQUIRED;
            break;
        case 'i':
            chksum_flag |= CHKSUM_IGNORED;
            break;
        case 's':
            if (optarg == NULL || (tos = atoi(optarg)) < 0 ||
                tos > 255) {
                syslog(LOG_ERR, "%s: illegal tos value: "
                    "%s\n", argv[0], optarg);
            } else {
                if (tos < 0)
                    tos = DEFAULT_TOS;
            }
            break;
#ifdef DEBUG
        case 'D':
            debug_port = atoi(optarg);
            break;
#endif /* DEBUG */
        default:
            syslog(LOG_ERR, "Unrecognized command line option "
                "(-%c), exiting", optopt);
            exit(EXIT_FAILURE);
        }
    }
    if (use_auth == KRB5_RECVAUTH_V5) {
        status = krb5_init_context(&krb_context);
        if (status) {
            syslog(LOG_ERR, "Error initializing krb5: %s",
                error_message(status));
            exit(EXIT_FAILURE);
        }
        if (realm != NULL)
            krb5_set_default_realm(krb_context, realm);
        if (keytab_file != NULL) {
            if ((status = krb5_kt_resolve(krb_context,
                            keytab_file,
                            &keytab))) {
                com_err(argv[0],
                    status,
                    "while resolving srvtab file %s",
                    keytab_file);
                exit(EXIT_FAILURE);
            }
        }
    }

#ifdef DEBUG
    if (debug_port) {
        int s;
        struct sockaddr_in sin;

        if ((s = socket(AF_INET, SOCK_STREAM, PF_UNSPEC)) < 0) {
            fatalperror(STDERR_FILENO, "Error in socket");
        }

        (void) memset((char *)&sin, 0, sizeof (sin));
        sin.sin_family = AF_INET;
        sin.sin_port = htons(debug_port);
        sin.sin_addr.s_addr = INADDR_ANY;

        (void) setsockopt(s, SOL_SOCKET, SO_REUSEADDR,
                    (char *)&on, sizeof (on));

        if ((bind(s, (struct sockaddr *)&sin, sizeof (sin))) < 0) {
            fatalperror(STDERR_FILENO, "bind error");
        }

        if ((listen(s, 5)) < 0) {
            fatalperror(STDERR_FILENO, "listen error");
        }

        fromlen = sizeof (from);
        if ((fd = accept(s, (struct sockaddr *)&from, &fromlen)) < 0) {
            fatalperror(STDERR_FILENO, "accept error");
        }

        (void) close(s);
    } else
#endif /* DEBUG */
    {
        if (!issock(STDIN_FILENO))
            fatal(STDIN_FILENO,
                "stdin is not a socket file descriptor");
        fd = STDIN_FILENO;
    }

    fromlen = sizeof (from);
    if (getpeername(fd, (struct sockaddr *)&from, &fromlen) < 0)
        fatalperror(STDERR_FILENO, "getpeername");

    if (audit_rlogin_settid(fd))    /* set terminal ID */
        fatalperror(STDERR_FILENO, "audit");

    if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, (char *)&on,
        sizeof (on)) < 0)
        syslog(LOG_WARNING, "setsockopt(SO_KEEPALIVE): %m");

    if (!VALID_CHKSUM(chksum_flag)) {
        syslog(LOG_ERR, "Configuration error: mutually exclusive "
            "options specified (-c and -i)");
        fatal(fd, "Checksums are required and ignored (-c and -i);"
            "these options are mutually exclusive - check "
            "the documentation.");
    }
    ourlen = sizeof (ouraddr);
    if (getsockname(fd, (struct sockaddr *)&ouraddr, &ourlen) == -1) {
        syslog(LOG_ERR, "getsockname error: %m");
        exit(EXIT_FAILURE);
    }

    if (tos != -1 &&
        ouraddr.ss_family != AF_INET6 &&
        setsockopt(fd, IPPROTO_IP, IP_TOS, (char *)&tos,
                    sizeof (tos)) < 0 &&
                    errno != ENOPROTOOPT) {
        syslog(LOG_ERR, "setsockopt(IP_TOS %d): %m", tos);
    }
    doit(fd, &from, krb_context, encr_flag, keytab);
    return (0);
}

static void cleanup(int);
static int  nsize = 0;  /* bytes read prior to pushing rlmod */
static char *rlbuf;     /* buffer where nbytes are read to */
static char *line;

static struct winsize win = { 0, 0, 0, 0 };
static pid_t pid;
static char hostname[MAXHOSTNAMELEN + 1];

static void
getstr(int f, char *buf, int cnt, char *err)
{
    char c;
    do {
        if (read(f, &c, 1) != 1 || (--cnt < 0)) {
            syslog(LOG_ERR, "Error reading \'%s\' field", err);
            exit(EXIT_FAILURE);
        }
        *buf++ = c;
    } while (c != '\0');
}

static krb5_error_code
recvauth(int f,
    krb5_context krb_context,
    unsigned int *valid_checksum,
    krb5_ticket **ticket,
    int *auth_type,
    krb5_principal *client,
    int encr_flag,
    krb5_keytab keytab)
{
    krb5_error_code status = 0;
    krb5_auth_context auth_context = NULL;
    krb5_rcache rcache;
    krb5_authenticator *authenticator;
    krb5_data inbuf;
    krb5_data auth_version;

    *valid_checksum = 0;

    if ((status = krb5_auth_con_init(krb_context, &auth_context)))
        return (status);

    /* Only need remote address for rd_cred() to verify client */
    if ((status = krb5_auth_con_genaddrs(krb_context, auth_context, f,
            KRB5_AUTH_CONTEXT_GENERATE_REMOTE_FULL_ADDR)))
        return (status);

    status = krb5_auth_con_getrcache(krb_context, auth_context, &rcache);
    if (status)
        return (status);

    if (!rcache) {
        krb5_principal server;

        status = krb5_sname_to_principal(krb_context, 0, 0,
                        KRB5_NT_SRV_HST, &server);
        if (status)
            return (status);

        status = krb5_get_server_rcache(krb_context,
                krb5_princ_component(krb_context, server, 0),
                &rcache);
        krb5_free_principal(krb_context, server);
        if (status)
            return (status);

        status = krb5_auth_con_setrcache(krb_context, auth_context,
                        rcache);
        if (status)
            return (status);
    }
    if ((status = krb5_compat_recvauth(krb_context,
                    &auth_context,
                    &f,
                    NULL,   /* Specify daemon principal */
                    0,  /* no flags */
                    keytab, /* NULL to use v5srvtab */
                    ticket, /* return ticket */
                    auth_type, /* authentication system */
                    &auth_version))) {
        if (*auth_type == KRB5_RECVAUTH_V5) {
            /*
             * clean up before exiting
             */
            getstr(f, rusername, sizeof (rusername), "remuser");
            getstr(f, lusername, sizeof (lusername), "locuser");
            getstr(f, term, sizeof (term), "Terminal type");
        }
        return (status);
    }

    getstr(f, lusername, sizeof (lusername), "locuser");
    getstr(f, term, sizeof (term), "Terminal type");

    kcmd_protocol = KCMD_UNKNOWN_PROTOCOL;
    if (auth_version.length != 9 || auth_version.data == NULL) {
        syslog(LOG_ERR, "Bad application protocol version length in "
            "KRB5 exchange, exiting");
        fatal(f, "Bad application version length, exiting.");
    }
    /*
     * Determine which Kerberos CMD protocol was used.
     */
    if (strncmp(auth_version.data, "KCMDV0.1", 9) == 0) {
        kcmd_protocol = KCMD_OLD_PROTOCOL;
    } else if (strncmp(auth_version.data, "KCMDV0.2", 9) == 0) {
        kcmd_protocol = KCMD_NEW_PROTOCOL;
    } else {
        syslog(LOG_ERR, "Unrecognized KCMD protocol (%s), exiting",
            (char *)auth_version.data);
        fatal(f, "Unrecognized KCMD protocol, exiting");
    }

    if ((*auth_type == KRB5_RECVAUTH_V5) && chksum_flag &&
        kcmd_protocol == KCMD_OLD_PROTOCOL) {
        if ((status = krb5_auth_con_getauthenticator(krb_context,
                                auth_context,
                                &authenticator)))
            return (status);
        if (authenticator->checksum) {
            struct sockaddr_storage adr;
            int adr_length = sizeof (adr);
            int buflen;
            krb5_data input;
            krb5_keyblock key;
            char *chksumbuf;

            /*
             * Define the lenght of the chksum buffer.
             * chksum string = "[portnum]:termstr:username"
             * The extra 32 is to hold a integer string for
             * the portnumber.
             */
            buflen = strlen(term) + strlen(lusername) + 32;
            chksumbuf = (char *)malloc(buflen);
            if (chksumbuf == 0) {
                krb5_free_authenticator(krb_context,
                            authenticator);
                fatal(f, "Out of memory error");
            }

            if (getsockname(f, (struct sockaddr *)&adr,
                            &adr_length) != 0) {
                krb5_free_authenticator(krb_context,
                            authenticator);
                fatal(f, "getsockname error");
            }

            (void) snprintf(chksumbuf, buflen,
                    "%u:%s%s",
                    ntohs(SOCK_PORT(adr)),
                    term, lusername);

            input.data = chksumbuf;
            input.length = strlen(chksumbuf);
            key.contents = (*ticket)->enc_part2->session->contents;
            key.length = (*ticket)->enc_part2->session->length;
            status = krb5_c_verify_checksum(krb_context,
                        &key, 0,
                        &input,
                        authenticator->checksum,
                        valid_checksum);

            if (status == 0 && *valid_checksum == 0)
                status = KRB5KRB_AP_ERR_BAD_INTEGRITY;

            if (chksumbuf)
                krb5_xfree(chksumbuf);
            if (status) {
                krb5_free_authenticator(krb_context,
                            authenticator);
                return (status);
            }
        }
        krb5_free_authenticator(krb_context, authenticator);
    }

    if ((status = krb5_copy_principal(krb_context,
                    (*ticket)->enc_part2->client,
                    client)))
        return (status);

    /* Get the Unix username of the remote user */
    getstr(f, rusername, sizeof (rusername), "remuser");

    /* Get the Kerberos principal name string of the remote user */
    if ((status = krb5_unparse_name(krb_context, *client, &krusername)))
        return (status);

#ifdef DEBUG
    syslog(LOG_DEBUG | LOG_AUTH, "rlogind: got krb5 credentials for %s",
        (krusername != NULL ? krusername : "<unknown>"));
#endif

    if (encr_flag) {
        status = krb5_auth_con_getremotesubkey(krb_context,
                            auth_context,
                            &session_key);
        if (status) {
            syslog(LOG_ERR, "Error getting KRB5 session "
                "subkey, exiting");
            fatal(f, "Error getting KRB5 session subkey, exiting");
        }
        /*
         * The "new" protocol requires that a subkey be sent.
         */
        if (session_key == NULL &&
            kcmd_protocol == KCMD_NEW_PROTOCOL) {
            syslog(LOG_ERR, "No KRB5 session subkey sent, exiting");
            fatal(f, "No KRB5 session subkey sent, exiting");
        }
        /*
         * The "old" protocol does not permit an authenticator subkey.
         * The key is taken from the ticket instead (see below).
         */
        if (session_key != NULL &&
            kcmd_protocol == KCMD_OLD_PROTOCOL) {
            syslog(LOG_ERR, "KRB5 session subkey not permitted "
                "with old KCMD protocol, exiting");

            fatal(f, "KRB5 session subkey not permitted "
                "with old KCMD protocol, exiting");
        }
        /*
         * If no key at this point, use the session key from
         * the ticket.
         */
        if (session_key == NULL) {
            /*
             * Save the session key so we can configure the crypto
             * module later.
             */
            status = krb5_copy_keyblock(krb_context,
                        (*ticket)->enc_part2->session,
                        &session_key);
            if (status) {
                syslog(LOG_ERR, "krb5_copy_keyblock failed");
                fatal(f, "krb5_copy_keyblock failed");
            }
        }
        /*
         * If session key still cannot be found, we must
         * exit because encryption is required here
         * when encr_flag (-x) is set.
         */
        if (session_key == NULL) {
            syslog(LOG_ERR, "Could not find an encryption key,"
                    "exiting");
            fatal(f, "Encryption required but key not found, "
                "exiting");
        }
    }
    /*
     * Use krb5_read_message to read the principal stuff.
     */
    if ((status = krb5_read_message(krb_context, (krb5_pointer)&f,
                    &inbuf)))
        fatal(f, "Error reading krb5 message");

    if (inbuf.length) { /* Forwarding being done, read creds */
        krb5_creds **creds = NULL;

        if (status = krb5_rd_cred(krb_context, auth_context, &inbuf,
                        &creds, NULL)) {
            if (rcache)
                (void) krb5_rc_close(krb_context, rcache);
            krb5_free_creds(krb_context, *creds);
            fatal(f, "Can't get forwarded credentials");
        }

        /* Store the forwarded creds in the ccache */
        if (status = store_forw_creds(krb_context,
                        creds, *ticket, lusername,
                        &ccache)) {
            if (rcache)
                (void) krb5_rc_close(krb_context, rcache);
            krb5_free_creds(krb_context, *creds);
            fatal(f, "Can't store forwarded credentials");
        }
        krb5_free_creds(krb_context, *creds);
    }

    if (rcache)
        (void) krb5_rc_close(krb_context, rcache);

    return (status);
}

static void
do_krb_login(int f, char *host_addr, char *hostname,
        krb5_context krb_context, int encr_flag,
        krb5_keytab keytab)
{
    krb5_error_code status;
    uint_t valid_checksum;
    krb5_ticket *ticket = NULL;
    int auth_sys = 0;
    int auth_sent = 0;
    krb5_principal client = NULL;

    if (getuid())
        fatal(f, "Error authorizing KRB5 connection, "
            "server lacks privilege");

    status = recvauth(f, krb_context, &valid_checksum, &ticket,
            &auth_sys, &client, encr_flag, keytab);
    if (status) {
        if (ticket)
            krb5_free_ticket(krb_context, ticket);
        if (status != 255)
            syslog(LOG_ERR,
                "Authentication failed from %s(%s): %s\n",
                host_addr, hostname, error_message(status));
        fatal(f, "Kerberos authentication failed, exiting");
    }

    if (auth_sys != KRB5_RECVAUTH_V5) {
        fatal(f, "This server only supports Kerberos V5");
    } else {
        /*
         * Authenticated OK, now check authorization.
         */
        if (client && krb5_kuserok(krb_context, client, lusername))
            auth_sent = KRB5_RECVAUTH_V5;
    }

    if (auth_sent == KRB5_RECVAUTH_V5 &&
        kcmd_protocol == KCMD_OLD_PROTOCOL &&
        chksum_flag == CHKSUM_REQUIRED && !valid_checksum) {
        syslog(LOG_ERR, "Client did not supply required checksum, "
            "connection rejected.");
        fatal(f, "Client did not supply required checksum, "
            "connection rejected.");
    }

    if (auth_sys != auth_sent) {
        char *msg_fail = NULL;
        int msgsize = 0;

        if (ticket)
            krb5_free_ticket(krb_context, ticket);

        if (krusername != NULL) {
            /*
             * msgsize must be enough to hold
             * krusername, lusername and a brief
             * message describing the failure.
             */
            msgsize = strlen(krusername) +
                strlen(lusername) + 80;
            msg_fail = (char *)malloc(msgsize);
        }
        if (msg_fail == NULL) {
            syslog(LOG_ERR, "User is not authorized to login to "
                "specified account");

            fatal(f, "User is not authorized to login to "
                "specified account");
        }
        if (auth_sent != 0)
            (void) snprintf(msg_fail, msgsize,
                    "Access denied because of improper "
                    "KRB5 credentials");
        else
            (void) snprintf(msg_fail, msgsize,
                    "User %s is not authorized to login "
                    "to account %s",
                    krusername, lusername);
        syslog(LOG_ERR, "%s", msg_fail);
        fatal(f, msg_fail);
    }
}

/*
 * stop_stream
 *
 * Utility routine to send a CRYPTIOCSTOP ioctl to the
 * crypto module(cryptmod).
 */
static void
stop_stream(int fd, int dir)
{
    struct strioctl  crioc;
    uint32_t stopdir = dir;

    crioc.ic_cmd = CRYPTIOCSTOP;
    crioc.ic_timout = -1;
    crioc.ic_len = sizeof (stopdir);
    crioc.ic_dp = (char *)&stopdir;

    if (ioctl(fd, I_STR, &crioc))
        syslog(LOG_ERR, "Error sending CRYPTIOCSTOP ioctl: %m");
}

/*
 * start_stream
 *
 * Utility routine to send a CRYPTIOCSTART ioctl to the
 * crypto module(cryptmod).  This routine may contain optional
 * payload data that the cryptmod will interpret as bytes that
 * need to be decrypted and sent back up to the application
 * via the data stream.
 */
static void
start_stream(int fd, int dir)
{
    struct strioctl crioc;
    uint32_t iocval;
    size_t datalen = 0;
    char *data = NULL;

    if (dir == CRYPT_DECRYPT) {
        iocval = CRYPTIOCSTARTDEC;

        /* Look for data not yet processed */
        if (ioctl(fd, I_NREAD, &datalen) < 0) {
            syslog(LOG_ERR, "I_NREAD returned error %m");
            datalen = 0;
        } else {
            if (datalen > 0) {
                data = malloc(datalen);
                if (data != NULL) {
                    int nbytes = read(fd, data, datalen);
                    datalen = nbytes;
                } else {
                    syslog(LOG_ERR,
                        "malloc error (%d bytes)",
                        datalen);
                    datalen = 0;
                }
            } else {
                datalen = 0;
            }
        }
    } else {
        iocval = CRYPTIOCSTARTENC;
    }

    crioc.ic_cmd = iocval;
    crioc.ic_timout = -1;
    crioc.ic_len = datalen;
    crioc.ic_dp = data;

    if (ioctl(fd, I_STR, &crioc))
        syslog(LOG_ERR, "Error sending CRYPTIOCSTART ioctl: %m");

    if (data != NULL)
        free(data);
}

static int
configure_stream(int fd, krb5_keyblock *skey, int dir, krb5_data *ivec,
        uint_t iv_usage)
{
    struct cr_info_t setup_info;
    struct strioctl crioc;
    int retval = 0;

    switch (skey->enctype) {
    case ENCTYPE_DES_CBC_CRC:
        setup_info.crypto_method = CRYPT_METHOD_DES_CBC_CRC;
        break;
    case ENCTYPE_DES_CBC_MD5:
        setup_info.crypto_method = CRYPT_METHOD_DES_CBC_MD5;
        break;
    case ENCTYPE_DES_CBC_RAW:
        setup_info.crypto_method = CRYPT_METHOD_DES_CBC_NULL;
        break;
    case ENCTYPE_DES3_CBC_SHA1:
        setup_info.crypto_method = CRYPT_METHOD_DES3_CBC_SHA1;
        break;
    case ENCTYPE_ARCFOUR_HMAC:
        setup_info.crypto_method = CRYPT_METHOD_ARCFOUR_HMAC_MD5;
        break;
    case ENCTYPE_ARCFOUR_HMAC_EXP:
        setup_info.crypto_method = CRYPT_METHOD_ARCFOUR_HMAC_MD5_EXP;
        break;
    case ENCTYPE_AES128_CTS_HMAC_SHA1_96:
        setup_info.crypto_method = CRYPT_METHOD_AES128;
        break;
    case ENCTYPE_AES256_CTS_HMAC_SHA1_96:
        setup_info.crypto_method = CRYPT_METHOD_AES256;
        break;
    default:
        syslog(LOG_ERR, "Enctype in kerberos session key "
            "is not supported by crypto module(%d)",
            skey->enctype);
        return (-1);
    }
    if (ivec == NULL || ivec->length == 0) {
        (void) memset(&setup_info.ivec, 0, sizeof (setup_info.ivec));

        if (skey->enctype != ENCTYPE_ARCFOUR_HMAC &&
            skey->enctype != ENCTYPE_ARCFOUR_HMAC_EXP)
            /* Kerberos IVs are 8 bytes long for DES keys */
            setup_info.iveclen = KRB5_MIT_DES_KEYSIZE;
        else
            setup_info.iveclen = 0;
    } else {
        (void) memcpy(&setup_info.ivec, ivec->data, ivec->length);
        setup_info.iveclen = ivec->length;
    }

    setup_info.ivec_usage = iv_usage;
    (void) memcpy(&setup_info.key, skey->contents, skey->length);

    setup_info.keylen = skey->length;
    setup_info.direction_mask = dir;
    /*
     * R* commands get special handling by crypto module -
     * 4 byte length field is used before each encrypted block
     * of data.
     */
    setup_info.option_mask = (kcmd_protocol == KCMD_OLD_PROTOCOL ?
                CRYPTOPT_RCMD_MODE_V1 :
                CRYPTOPT_RCMD_MODE_V2);

    crioc.ic_cmd = CRYPTIOCSETUP;
    crioc.ic_timout = -1;
    crioc.ic_len = sizeof (setup_info);
    crioc.ic_dp = (char *)&setup_info;

    if (ioctl(fd, I_STR, &crioc)) {
        syslog(LOG_ERR, "Error sending CRYPTIOCSETUP ioctl: %m");
        retval = -1;
    }
    return (retval);
}

static krb5_error_code
krb5_compat_recvauth(krb5_context context,
            krb5_auth_context *auth_context,
            krb5_pointer fdp,   /* IN */
            krb5_principal server,  /* IN */
            krb5_int32 flags,   /* IN */
            krb5_keytab keytab, /* IN */
            krb5_ticket **ticket, /* OUT */
            krb5_int32 *auth_sys, /* OUT */
            krb5_data *version)   /* OUT */
{
    krb5_int32 vlen;
    char    *buf;
    int len, length;
    krb5_int32  retval;
    int     fd = *((int *)fdp);

    if ((retval = krb5_net_read(context, fd, (char *)&vlen, 4)) != 4)
        return ((retval < 0) ? errno : ECONNABORTED);

    /*
     * Assume that we're talking to a V5 recvauth; read in the
     * the version string, and make sure it matches.
     */
    len = (int)ntohl(vlen);

    if (len < 0 || len > 255)
        return (KRB5_SENDAUTH_BADAUTHVERS);

    buf = malloc(len);
    if (buf == NULL)
        return (ENOMEM);

    length = krb5_net_read(context, fd, buf, len);
    if (len != length) {
        krb5_xfree(buf);
        return ((len < 0) ? errno : ECONNABORTED);
    }

    if (strcmp(buf, KRB_V5_SENDAUTH_VERS) != 0) {
        krb5_xfree(buf);
        return (KRB5_SENDAUTH_BADAUTHVERS);
    }
    krb5_xfree(buf);

    *auth_sys = KRB5_RECVAUTH_V5;

    retval = krb5_recvauth_version(context, auth_context, fdp,
                    server, flags | KRB5_RECVAUTH_SKIP_VERSION,
                    keytab, ticket, version);

    return (retval);
}


static void
doit(int f,
    struct sockaddr_storage *fromp,
    krb5_context krb_context,
    int encr_flag,
    krb5_keytab keytab)
{
    int p, t, on = 1;
    char c;
    char abuf[INET6_ADDRSTRLEN];
    struct sockaddr_in *sin;
    struct sockaddr_in6 *sin6;
    int fromplen;
    in_port_t port;
    struct termios tp;
    boolean_t bad_port;
    boolean_t no_name;
    char rhost_addra[INET6_ADDRSTRLEN];

    if (!(rlbuf = malloc(BUFSIZ))) {
        syslog(LOG_ERR, "rlbuf malloc failed\n");
        exit(EXIT_FAILURE);
    }
    (void) alarm(60);
    if (read(f, &c, 1) != 1 || c != 0) {
        syslog(LOG_ERR, "failed to receive protocol zero byte\n");
        exit(EXIT_FAILURE);
    }
    (void) alarm(0);
    if (fromp->ss_family == AF_INET) {
        sin = (struct sockaddr_in *)fromp;
        port = sin->sin_port = ntohs((ushort_t)sin->sin_port);
        fromplen = sizeof (struct sockaddr_in);

        if (!inet_ntop(AF_INET, &sin->sin_addr,
                rhost_addra, sizeof (rhost_addra)))
            goto badconversion;
    } else if (fromp->ss_family == AF_INET6) {
        sin6 = (struct sockaddr_in6 *)fromp;
        port = sin6->sin6_port = ntohs((ushort_t)sin6->sin6_port);
        fromplen = sizeof (struct sockaddr_in6);

        if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
            struct in_addr ipv4_addr;

            IN6_V4MAPPED_TO_INADDR(&sin6->sin6_addr,
                        &ipv4_addr);
            if (!inet_ntop(AF_INET, &ipv4_addr, rhost_addra,
                    sizeof (rhost_addra)))
                goto badconversion;
        } else {
            if (!inet_ntop(AF_INET6, &sin6->sin6_addr,
                    rhost_addra, sizeof (rhost_addra)))
                goto badconversion;
        }
    } else {
        syslog(LOG_ERR, "unknown address family %d\n",
            fromp->ss_family);
        fatal(f, "Permission denied");
    }

    /*
     * Allow connections only from the "ephemeral" reserved
     * ports(ports 512 - 1023) by checking the remote port
     * because other utilities(e.g. in.ftpd) can be used to
     * allow a unprivileged user to originate a connection
     * from a privileged port and provide untrustworthy
     * authentication.
     */
    bad_port = (use_auth != KRB5_RECVAUTH_V5 &&
            (port >= (in_port_t)IPPORT_RESERVED) ||
            (port < (in_port_t)(IPPORT_RESERVED/2)));
    no_name = getnameinfo((const struct sockaddr *) fromp,
                fromplen, hostname, sizeof (hostname),
                NULL, 0, 0) != 0;

    if (no_name || bad_port) {
        (void) strlcpy(abuf, rhost_addra, sizeof (abuf));
        /* If no host name, use IP address for name later on. */
        if (no_name)
            (void) strlcpy(hostname, abuf, sizeof (hostname));
    }

    if (!no_name) {
        /*
         * Even if getnameinfo() succeeded, we still have to check
         * for spoofing.
         */
        check_address("rlogind", fromp, sin, sin6, rhost_addra,
            hostname, sizeof (hostname));
    }

    if (bad_port) {
        if (no_name)
            syslog(LOG_NOTICE,
                "connection from %s - bad port\n",
                abuf);
        else
            syslog(LOG_NOTICE,
                "connection from %s(%s) - bad port\n",
                hostname, abuf);
        fatal(f, "Permission denied");
    }

    if (use_auth == KRB5_RECVAUTH_V5) {
        do_krb_login(f, rhost_addra, hostname,
                krb_context, encr_flag, keytab);
        if (krusername != NULL && strlen(krusername)) {
            /*
             * Kerberos Authentication succeeded,
             * so set the proper program name to use
             * with pam (important during 'cleanup'
             * routine later).
             */
            pam_prog_name = KRB5_PROG_NAME;
        }
    }

    if (write(f, "", 1) != 1) {
        syslog(LOG_NOTICE,
            "send of the zero byte(to %s) failed:"
            " cannot start data transfer mode\n",
            (no_name ? abuf : hostname));
        exit(EXIT_FAILURE);
    }
    if ((p = open("/dev/ptmx", O_RDWR)) == -1)
        fatalperror(f, "cannot open /dev/ptmx");
    if (grantpt(p) == -1)
        fatal(f, "could not grant slave pty");
    if (unlockpt(p) == -1)
        fatal(f, "could not unlock slave pty");
    if ((line = ptsname(p)) == NULL)
        fatal(f, "could not enable slave pty");
    if ((t = open(line, O_RDWR)) == -1)
        fatal(f, "could not open slave pty");
    if (ioctl(t, I_PUSH, "ptem") == -1)
        fatalperror(f, "ioctl I_PUSH ptem");
    if (ioctl(t, I_PUSH, "ldterm") == -1)
        fatalperror(f, "ioctl I_PUSH ldterm");
    if (ioctl(t, I_PUSH, "ttcompat") == -1)
        fatalperror(f, "ioctl I_PUSH ttcompat");
    /*
     * POP the sockmod and push the rlmod module.
     *
     * Note that sockmod has to be removed since readstream assumes
     * a "raw" TPI endpoint(e.g. it uses getmsg).
     */
    if (removemod(f, "sockmod") < 0)
        fatalperror(f, "couldn't remove sockmod");

    if (encr_flag) {
        if (ioctl(f, I_PUSH, "cryptmod") < 0)
            fatalperror(f, "ioctl I_PUSH rlmod");

    }

    if (ioctl(f, I_PUSH, "rlmod") < 0)
        fatalperror(f, "ioctl I_PUSH rlmod");

    if (encr_flag) {
        /*
         * Make sure rlmod will pass unrecognized IOCTLs to cryptmod
         */
        uchar_t passthru = 1;
        struct strioctl rlmodctl;

        rlmodctl.ic_cmd = CRYPTPASSTHRU;
        rlmodctl.ic_timout = -1;
        rlmodctl.ic_len = sizeof (uchar_t);
        rlmodctl.ic_dp = (char *)&passthru;

        if (ioctl(f, I_STR, &rlmodctl) < 0)
            fatal(f, "ioctl CRYPTPASSTHRU failed\n");
    }

    /*
     * readstream will do a getmsg till it receives
     * M_PROTO type T_DATA_REQ from rloginmodopen()
     * indicating all data on the stream prior to pushing rlmod has
     * been drained at the stream head.
     */
    if ((nsize = readstream(f, rlbuf, BUFSIZ)) < 0)
        fatalperror(f, "readstream failed");
    /*
     * Make sure the pty doesn't modify the strings passed
     * to login as part of the "rlogin protocol."  The login
     * program should set these flags to apropriate values
     * after it has read the strings.
     */
    if (ioctl(t, TCGETS, &tp) == -1)
        fatalperror(f, "ioctl TCGETS");
    tp.c_lflag &= ~(ECHO|ICANON);
    tp.c_oflag &= ~(XTABS|OCRNL);
    tp.c_iflag &= ~(IGNPAR|ICRNL);
    if (ioctl(t, TCSETS, &tp) == -1)
        fatalperror(f, "ioctl TCSETS");

    /*
     * System V ptys allow the TIOC{SG}WINSZ ioctl to be
     * issued on the master side of the pty.  Luckily, that's
     * the only tty ioctl we need to do do, so we can close the
     * slave side in the parent process after the fork.
     */
    (void) ioctl(p, TIOCSWINSZ, &win);

    pid = fork();
    if (pid < 0)
        fatalperror(f, "fork");
    if (pid == 0) {
        int tt;
        struct utmpx ut;

        /* System V login expects a utmp entry to already be there */
        (void) memset(&ut, 0, sizeof (ut));
        (void) strncpy(ut.ut_user, ".rlogin", sizeof (ut.ut_user));
        (void) strncpy(ut.ut_line, line, sizeof (ut.ut_line));
        ut.ut_pid = getpid();
        ut.ut_id[0] = 'r';
        ut.ut_id[1] = (char)SC_WILDC;
        ut.ut_id[2] = (char)SC_WILDC;
        ut.ut_id[3] = (char)SC_WILDC;
        ut.ut_type = LOGIN_PROCESS;
        ut.ut_exit.e_termination = 0;
        ut.ut_exit.e_exit = 0;
        (void) time(&ut.ut_tv.tv_sec);
        if (makeutx(&ut) == NULL)
            syslog(LOG_INFO, "in.rlogind:\tmakeutx failed");

        /* controlling tty */
        if (setsid() == -1)
            fatalperror(f, "setsid");
        if ((tt = open(line, O_RDWR)) == -1)
            fatalperror(f, "could not re-open slave pty");

        if (close(p) == -1)
            fatalperror(f, "error closing pty master");
        if (close(t) == -1)
            fatalperror(f, "error closing pty slave"
                    " opened before session established");
        /*
         * If this fails we may or may not be able to output an
         * error message.
         */
        if (close(f) == -1)
            fatalperror(f, "error closing deamon stdout");
        if (dup2(tt, STDIN_FILENO) == -1 ||
            dup2(tt, STDOUT_FILENO) == -1 ||
            dup2(tt, STDERR_FILENO) == -1)
            exit(EXIT_FAILURE); /* Disaster! No stderr! */

        (void) close(tt);

        if (use_auth == KRB5_RECVAUTH_V5 &&
            krusername != NULL && strlen(krusername)) {
            (void) execl(LOGIN_PROGRAM, "login",
                    "-d", line,
                    "-r", hostname,
                    "-u", krusername, /* KRB5 principal name */
                    "-s", pam_prog_name,
                    "-t", term, /* Remote Terminal */
                    "-U", rusername,    /* Remote User */
                    "-R", KRB5_REPOSITORY_NAME,
                    lusername,  /* local user */
                    NULL);
        } else {
            (void) execl(LOGIN_PROGRAM, "login",
                "-d", line,
                "-r", hostname,
                NULL);
        }

        fatalperror(STDERR_FILENO, "/bin/login");
        /*NOTREACHED*/
    }
    (void) close(t);
    (void) ioctl(f, FIONBIO, &on);
    (void) ioctl(p, FIONBIO, &on);

    /*
     * Must ignore SIGTTOU, otherwise we'll stop
     * when we try and set slave pty's window shape
     * (our controlling tty is the master pty).
     * Likewise, we don't want any of the tty-generated
     * signals from chars passing through.
     */
    (void) sigset(SIGTSTP, SIG_IGN);
    (void) sigset(SIGINT, SIG_IGN);
    (void) sigset(SIGQUIT, SIG_IGN);
    (void) sigset(SIGTTOU, SIG_IGN);
    (void) sigset(SIGTTIN, SIG_IGN);
    (void) sigset(SIGCHLD, cleanup);
    (void) setpgrp();

    if (encr_flag) {
        krb5_data ivec, *ivptr;
        uint_t ivec_usage;
        stop_stream(f, CRYPT_ENCRYPT|CRYPT_DECRYPT);

        /*
         * Configure the STREAMS crypto module.  For now,
         * don't use any IV parameter.  KCMDV0.2 support
         * will require the use of Initialization Vectors
         * for both encrypt and decrypt modes.
         */
        if (kcmd_protocol == KCMD_OLD_PROTOCOL) {
            if (session_key->enctype == ENCTYPE_DES_CBC_CRC) {
                /*
                 * This is gross but necessary for MIT compat.
                 */
                ivec.length = session_key->length;
                ivec.data = (char *)session_key->contents;
                ivec_usage = IVEC_REUSE;
                ivptr = &ivec;
            } else {
                ivptr = NULL; /* defaults to all 0's */
                ivec_usage = IVEC_NEVER;
            }
            /*
             * configure both sides of stream together
             * since they share the same IV.
             * This is what makes the OLD KCMD protocol
             * less secure than the newer one - Bad ivecs.
             */
            if (configure_stream(f, session_key,
                CRYPT_ENCRYPT|CRYPT_DECRYPT,
                ivptr, ivec_usage) != 0)
                fatal(f, "Cannot initialize encryption -"
                    " exiting.\n");
        } else {
            size_t blocksize;
            if (session_key->enctype == ENCTYPE_ARCFOUR_HMAC ||
                session_key->enctype == ENCTYPE_ARCFOUR_HMAC_EXP) {
                if (configure_stream(f, session_key,
                    CRYPT_ENCRYPT|CRYPT_DECRYPT,
                    NULL, IVEC_NEVER) != 0)
                    fatal(f,
                    "Cannot initialize encryption -"
                    " exiting.\n");
                goto startcrypto;
            }
            if (krb5_c_block_size(krb_context,
                        session_key->enctype,
                        &blocksize)) {
                syslog(LOG_ERR, "Cannot determine blocksize "
                    "for encryption type %d",
                    session_key->enctype);
                fatal(f, "Cannot determine blocksize "
                    "for encryption - exiting.\n");
            }
            ivec.data = (char *)malloc(blocksize);
            ivec.length = blocksize;
            if (ivec.data == NULL)
                fatal(f, "memory error - exiting\n");
            /*
             * Following MIT convention -
             *   encrypt IV = 0x01 x blocksize
             *   decrypt IV = 0x00 x blocksize
             *   ivec_usage = IVEC_ONETIME
             *
             * configure_stream separately for encrypt and
             * decrypt because there are 2 different IVs.
             *
             * AES uses 0's for IV.
             */
            if (session_key->enctype ==
                ENCTYPE_AES128_CTS_HMAC_SHA1_96 ||
                session_key->enctype ==
                ENCTYPE_AES256_CTS_HMAC_SHA1_96)
                (void) memset(ivec.data, 0x00, blocksize);
            else
                (void) memset(ivec.data, 0x01, blocksize);
            if (configure_stream(f, session_key, CRYPT_ENCRYPT,
                &ivec, IVEC_ONETIME) != 0)
                fatal(f, "Cannot initialize encryption -"
                    " exiting.\n");
            (void) memset(ivec.data, 0x00, blocksize);
            if (configure_stream(f, session_key, CRYPT_DECRYPT,
                &ivec, IVEC_ONETIME) != 0)
                fatal(f, "Cannot initialize encryption -"
                    " exiting.\n");

            (void) free(ivec.data);
        }
startcrypto:
        start_stream(f, CRYPT_ENCRYPT);
        start_stream(f, CRYPT_DECRYPT);
    }
    protocol(f, p, encr_flag);
    cleanup(0);
    /*NOTREACHED*/

badconversion:
    fatalperror(f, "address conversion");
    /*NOTREACHED*/
}

/*
 * rlogin "protocol" machine.
 */
static void
protocol(int f, int p, int encr_flag)
{
    struct  stat    buf;
    struct  protocol_arg    rloginp;
    struct  strioctl    rloginmod;
    int ptmfd;  /* fd of logindmux coneected to ptmx */
    int netfd;  /* fd of logindmux connected to netf */
    static uchar_t  oobdata[] = {TIOCPKT_WINDOW};

    /* indicate new rlogin */
    if (send_oob(f, oobdata, 1) < 0)
        fatalperror(f, "send_oob");
    /*
     * We cannot send the SECURE_MSG until after the
     * client has been signaled with the oobdata (above).
     */
    if (encr_flag) {
        if (write(f, SECURE_MSG, strlen(SECURE_MSG)) < 0)
            fatalperror(f, "Error writing SECURE message");
    }

    /*
     * Open logindmux driver and link netf and ptmx
     * underneath logindmux.
     */
    if ((ptmfd = open("/dev/logindmux", O_RDWR)) == -1)
        fatalperror(f, "open /dev/logindmux");

    if ((netfd = open("/dev/logindmux", O_RDWR)) == -1)
        fatalperror(f, "open /dev/logindmux");

    if (ioctl(ptmfd, I_LINK, p) < 0)
        fatal(f, "ioctl I_LINK of /dev/ptmx failed\n");

    if (ioctl(netfd, I_LINK, f) < 0)
        fatal(f, "ioctl I_LINK of tcp connection failed\n");

    /*
     * Figure out the device number of the ptm's mux fd, and pass that
     * to the net's mux.
     */
    if (fstat(ptmfd, &buf) < 0)
        fatalperror(f, "cannot determine device number"
            " of pty side of /dev/logindmux");
    rloginp.dev = buf.st_rdev;
    rloginp.flag = 0;

    rloginmod.ic_cmd = LOGDMX_IOC_QEXCHANGE;
    rloginmod.ic_timout = -1;
    rloginmod.ic_len = sizeof (struct protocol_arg);
    rloginmod.ic_dp = (char *)&rloginp;

    if (ioctl(netfd, I_STR, &rloginmod) < 0)
        fatal(netfd, "ioctl LOGDMX_IOC_QEXCHANGE of netfd failed\n");

    /*
     * Figure out the device number of the net's mux fd, and pass that
     * to the ptm's mux.
     */
    if (fstat(netfd, &buf))
        fatalperror(f, "cannot determine device number"
            " of network side of /dev/logindmux");
    rloginp.dev = buf.st_rdev;
    rloginp.flag = 1;

    rloginmod.ic_cmd = LOGDMX_IOC_QEXCHANGE;
    rloginmod.ic_timout = -1;
    rloginmod.ic_len = sizeof (struct protocol_arg);
    rloginmod.ic_dp = (char *)&rloginp;

    if (ioctl(ptmfd, I_STR, &rloginmod) < 0)
        fatal(netfd, "ioctl LOGDMXZ_IOC_QEXCHANGE of ptmfd failed\n");
    /*
     * Send an ioctl type RL_IOC_ENABLE to reenable the
     * message queue and reinsert the data read from streamhead
     * at the time of pushing rloginmod module.
     * We need to send this ioctl even if no data was read earlier
     * since we need to reenable the message queue of rloginmod module.
     */
    rloginmod.ic_cmd = RL_IOC_ENABLE;
    rloginmod.ic_timout = -1;
    if (nsize) {
        rloginmod.ic_len = nsize;
        rloginmod.ic_dp = rlbuf;
    } else {
        rloginmod.ic_len = 0;
        rloginmod.ic_dp = NULL;
    }

    if (ioctl(netfd, I_STR, &rloginmod) < 0)
        fatal(netfd, "ioctl RL_IOC_ENABLE of netfd failed\n");

    /*
     * User level daemon now pauses till the shell exits.
     */
    (void) pause();
}

/* This is a signal handler, hence the dummy argument */
/*ARGSUSED*/
static void
cleanup(int dummy)
{
    rmut();
    exit(EXIT_FAILURE);
    /*NOTREACHED*/
}

/*
 * TPI style replacement for socket send() primitive, so we don't require
 * sockmod to be on the stream.
 */
static int
send_oob(int fd, void *ptr, size_t count)
{
    struct T_exdata_req exd_req;
    struct strbuf hdr, dat;
    int ret;

    exd_req.PRIM_type = T_EXDATA_REQ;
    exd_req.MORE_flag = 0;

    hdr.buf = (char *)&exd_req;
    hdr.len = sizeof (exd_req);

    dat.buf = ptr;
    dat.len = count;

    ret = putmsg(fd, &hdr, &dat, 0);
    if (ret == 0)
        ret = count;
    return (ret);
}

static void
fatal(int fd, const char *msg)
{
    char *bufp;
    size_t len = strlen(msg) + 16;      /* enough for our wrapper */

    bufp = alloca(len);
    /* ASCII 001 is the error indicator */
    len = snprintf(bufp, len, "\01rlogind: %s.\r\n", msg);
    (void) write(fd, bufp, len);
    exit(EXIT_FAILURE);
    /*NOTREACHED*/
}

/*PRINTFLIKE2*/
static void
fatalperror(int fd, const char *msg)
{
    char *bufp;
    const char *errstr;
    int save_errno = errno;
    size_t len = strlen(msg);

    if ((errstr = strerror(save_errno))) {
        len += strlen(errstr) + 3;  /* 3 for ": " and \0 below */
        bufp = alloca(len);
        (void) snprintf(bufp, len, "%s: %s", msg, errstr);
    } else {
        const char fmt[] = "%s: Error %d";

        /* -4 for %s & %d. "*8/3" is bytes->decimal, pessimistically */
        len += sizeof (fmt) -4 + (sizeof (save_errno) *8 /3);
        bufp = alloca(len);
        (void) snprintf(bufp, len, fmt, msg, save_errno);
    }
    fatal(fd, bufp);
    /*NOTREACHED*/
}

static void
rmut(void)
{
    pam_handle_t *pamh;
    struct utmpx *up;
    char user[sizeof (up->ut_user) + 1];
    char ttyn[sizeof (up->ut_line) + 1];
    char rhost[sizeof (up->ut_host) + 1];

    /* while cleaning up dont allow disruption */
    (void) sigset(SIGCHLD, SIG_IGN);

    setutxent();
    while (up = getutxent()) {
        if (up->ut_pid == pid) {
            if (up->ut_type == DEAD_PROCESS)
                break;      /* Cleaned up elsewhere. */

            /*
             * call pam_close_session if login changed
             * the utmpx user entry from type LOGIN_PROCESS
             * to type USER_PROCESS, which happens
             * after pam_open_session is called.
             */
            if (up->ut_type == USER_PROCESS) {
                (void) strlcpy(user, up->ut_user,
                        sizeof (user));
                (void) strlcpy(ttyn, up->ut_line,
                        sizeof (ttyn));
                (void) strlcpy(rhost, up->ut_host,
                        sizeof (rhost));

                /*
                 * Use the same pam_prog_name that
                 * 'login' used.
                 */
                if ((pam_start(pam_prog_name, user,  NULL,
                        &pamh))
                    == PAM_SUCCESS) {
                    (void) pam_set_item(pamh, PAM_TTY,
                                ttyn);
                    (void) pam_set_item(pamh, PAM_RHOST,
                                rhost);
                    (void) pam_close_session(pamh, 0);
                    (void) pam_end(pamh, PAM_SUCCESS);
                }
            }

            up->ut_type = DEAD_PROCESS;
            up->ut_exit.e_termination = WTERMSIG(0);
            up->ut_exit.e_exit = WEXITSTATUS(0);
            (void) time(&up->ut_tv.tv_sec);

            if (modutx(up) == NULL) {
                /*
                 * Since modutx failed we'll
                 * write out the new entry
                 * ourselves.
                 */
                (void) pututxline(up);
                updwtmpx("wtmpx", up);
            }
            break;
        }
    }

    endutxent();

    (void) sigset(SIGCHLD, cleanup);
}

static int
readstream(int fd, char *buf, int size)
{
    struct strbuf ctlbuf, datbuf;
    union T_primitives tpi;
    int nbytes = 0;
    int ret = 0;
    int flags = 0;
    int bufsize = size;
    int nread;

    (void) memset(&ctlbuf, 0, sizeof (ctlbuf));
    (void) memset(&datbuf, 0, sizeof (datbuf));

    ctlbuf.buf = (char *)&tpi;
    ctlbuf.maxlen = sizeof (tpi);
    datbuf.buf = buf;
    datbuf.maxlen = size;

    for (;;) {
        if (ioctl(fd, I_NREAD, &nread) < 0) {
            syslog(LOG_ERR, "I_NREAD returned error %m");
            return (-1);
        }
        if (nread + nbytes > bufsize) {
            buf = (char *)realloc(buf, (unsigned)(bufsize + nread));
            if (buf == NULL) {
                syslog(LOG_WARNING,
                    "buffer allocation failed\n");
                return (-1);
            }
            bufsize += nread;
            rlbuf = buf;
            datbuf.buf = buf + nbytes;
        }
        datbuf.maxlen = bufsize - nbytes;
        ret = getmsg(fd, &ctlbuf, &datbuf, &flags);
        if (ret < 0) {
            syslog(LOG_ERR, "getmsg failed error %m");
            return (-1);
        }
        if ((ctlbuf.len == 0) && (datbuf.len == 0)) {
            /*
             * getmsg() returned no data - this indicates
             * that the connection is closing down.
             */
            cleanup(0);
        }
        if (ctlbuf.len <= 0) {
            nbytes += datbuf.len;
            datbuf.buf += datbuf.len;
            continue;
        }
        if (tpi.type == T_DATA_REQ) {
            return (nbytes);
        }
        if ((tpi.type == T_ORDREL_IND) || (tpi.type == T_DISCON_IND))
            cleanup(0);
    }
}

/*
 * Verify that the named module is at the top of the stream
 * and then pop it off.
 */
static int
removemod(int f, char *modname)
{
    char topmodname[BUFSIZ];

    if (ioctl(f, I_LOOK, topmodname) < 0)
        return (-1);
    if (strcmp(modname, topmodname) != 0) {
        errno = ENXIO;
        return (-1);
    }
    if (ioctl(f, I_POP, 0) < 0)
        return (-1);
    return (0);
}