Merge remote-tracking branch 'origin/master'

[unleashed/lotheac.git] / usr / src / uts / common / io / ldterm.c

/*
 * 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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 * Copyright (c) 2014, Joyent, Inc.  All rights reserved.
 * Copyright 2018 OmniOS Community Edition (OmniOSce) Association.
 */

/* Copyright (c) 1984, 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.
 */

/*
 * Standard Streams Terminal Line Discipline module.
 */

#include <sys/param.h>
#include <sys/types.h>
#include <sys/termio.h>
#include <sys/stream.h>
#include <sys/conf.h>
#include <sys/stropts.h>
#include <sys/strsubr.h>
#include <sys/strsun.h>
#include <sys/strtty.h>
#include <sys/signal.h>
#include <sys/file.h>
#include <sys/errno.h>
#include <sys/debug.h>
#include <sys/cmn_err.h>
#include <sys/euc.h>
#include <sys/eucioctl.h>
#include <sys/csiioctl.h>
#include <sys/ptms.h>
#include <sys/ldterm.h>
#include <sys/cred.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/kmem.h>
#include <sys/modctl.h>

/* Time limit when draining during a close(9E) invoked by exit(2) */
/* Can be set to zero to emulate the old, broken behavior */
int ldterm_drain_limit = 15000000;

/*
 * Character types.
 */
#define ORDINARY        0
#define CONTROL         1
#define BACKSPACE       2
#define NEWLINE         3
#define TAB             4
#define VTAB            5
#define RETURN          6

/*
 * The following for EUC handling:
 */
#define T_SS2           7
#define T_SS3           8

/*
 * Table indicating character classes to tty driver.  In particular,
 * if the class is ORDINARY, then the character needs no special
 * processing on output.
 *
 * Characters in the C1 set are all considered CONTROL; this will
 * work with terminals that properly use the ANSI/ISO extensions,
 * but might cause distress with terminals that put graphics in
 * the range 0200-0237.  On the other hand, characters in that
 * range cause even greater distress to other UNIX terminal drivers....
 */

static char typetab[256] = {
/* 000 */       CONTROL,        CONTROL,        CONTROL,        CONTROL,
/* 004 */       CONTROL,        CONTROL,        CONTROL,        CONTROL,
/* 010 */       BACKSPACE,      TAB,            NEWLINE,        CONTROL,
/* 014 */       VTAB,           RETURN,         CONTROL,        CONTROL,
/* 020 */       CONTROL,        CONTROL,        CONTROL,        CONTROL,
/* 024 */       CONTROL,        CONTROL,        CONTROL,        CONTROL,
/* 030 */       CONTROL,        CONTROL,        CONTROL,        CONTROL,
/* 034 */       CONTROL,        CONTROL,        CONTROL,        CONTROL,
/* 040 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 044 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 050 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 054 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 060 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 064 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 070 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 074 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 100 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 104 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 110 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 114 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 120 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 124 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 130 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 134 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 140 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 144 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 150 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 154 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 160 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 164 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 170 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 174 */       ORDINARY,       ORDINARY,       ORDINARY,       CONTROL,
/* 200 */       CONTROL,        CONTROL,        CONTROL,        CONTROL,
/* 204 */       CONTROL,        CONTROL,        T_SS2,          T_SS3,
/* 210 */       CONTROL,        CONTROL,        CONTROL,        CONTROL,
/* 214 */       CONTROL,        CONTROL,        CONTROL,        CONTROL,
/* 220 */       CONTROL,        CONTROL,        CONTROL,        CONTROL,
/* 224 */       CONTROL,        CONTROL,        CONTROL,        CONTROL,
/* 230 */       CONTROL,        CONTROL,        CONTROL,        CONTROL,
/* 234 */       CONTROL,        CONTROL,        CONTROL,        CONTROL,
/* 240 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 244 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 250 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 254 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 260 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 264 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 270 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 274 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 300 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 304 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 310 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 314 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 320 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 324 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 330 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 334 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 340 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 344 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 350 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 354 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 360 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 364 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/* 370 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
/*
 * WARNING:  For EUC, 0xFF must be an ordinary character.  It is used with
 * single-byte EUC in some of the "ISO Latin Alphabet" codesets, and occupies
 * a screen position; in those ISO sets where that position isn't used, it
 * shouldn't make any difference.
 */
/* 374 */       ORDINARY,       ORDINARY,       ORDINARY,       ORDINARY,
};

/*
 * Translation table for output without OLCUC.  All ORDINARY-class characters
 * translate to themselves.  All other characters have a zero in the table,
 * which stops the copying.
 */
static unsigned char notrantab[256] = {
/* 000 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 010 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 020 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 030 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 040 */       ' ',    '!',    '"',    '#',    '$',    '%',    '&',    '\'',
/* 050 */       '(',    ')',    '*',    '+',    ',',    '-',    '.',    '/',
/* 060 */       '0',    '1',    '2',    '3',    '4',    '5',    '6',    '7',
/* 070 */       '8',    '9',    ':',    ';',    '<',    '=',    '>',    '?',
/* 100 */       '@',    'A',    'B',    'C',    'D',    'E',    'F',    'G',
/* 110 */       'H',    'I',    'J',    'K',    'L',    'M',    'N',    'O',
/* 120 */       'P',    'Q',    'R',    'S',    'T',    'U',    'V',    'W',
/* 130 */       'X',    'Y',    'Z',    '[',    '\\',   ']',    '^',    '_',
/* 140 */       '`',    'a',    'b',    'c',    'd',    'e',    'f',    'g',
/* 150 */       'h',    'i',    'j',    'k',    'l',    'm',    'n',    'o',
/* 160 */       'p',    'q',    'r',    's',    't',    'u',    'v',    'w',
/* 170 */       'x',    'y',    'z',    '{',    '|',    '}',    '~',    0,
/* 200 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 210 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 220 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 230 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 240 */       0240,   0241,   0242,   0243,   0244,   0245,   0246,   0247,
/* 250 */       0250,   0251,   0252,   0253,   0254,   0255,   0256,   0257,
/* 260 */       0260,   0261,   0262,   0263,   0264,   0265,   0266,   0267,
/* 270 */       0270,   0271,   0272,   0273,   0274,   0275,   0276,   0277,
/* 300 */       0300,   0301,   0302,   0303,   0304,   0305,   0306,   0307,
/* 310 */       0310,   0311,   0312,   0313,   0314,   0315,   0316,   0317,
/* 320 */       0320,   0321,   0322,   0323,   0324,   0325,   0326,   0327,
/* 330 */       0330,   0331,   0332,   0333,   0334,   0335,   0336,   0337,
/* 340 */       0340,   0341,   0342,   0343,   0344,   0345,   0346,   0347,
/* 350 */       0350,   0351,   0352,   0353,   0354,   0355,   0356,   0357,
/* 360 */       0360,   0361,   0362,   0363,   0364,   0365,   0366,   0367,
/*
 * WARNING: as for above ISO sets, \377 may be used.  Translate it to
 * itself.
 */
/* 370 */       0370,   0371,   0372,   0373,   0374,   0375,   0376,   0377,
};

/*
 * Translation table for output with OLCUC.  All ORDINARY-class characters
 * translate to themselves, except for lower-case letters which translate
 * to their upper-case equivalents.  All other characters have a zero in
 * the table, which stops the copying.
 */
static unsigned char lcuctab[256] = {
/* 000 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 010 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 020 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 030 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 040 */       ' ',    '!',    '"',    '#',    '$',    '%',    '&',    '\'',
/* 050 */       '(',    ')',    '*',    '+',    ',',    '-',    '.',    '/',
/* 060 */       '0',    '1',    '2',    '3',    '4',    '5',    '6',    '7',
/* 070 */       '8',    '9',    ':',    ';',    '<',    '=',    '>',    '?',
/* 100 */       '@',    'A',    'B',    'C',    'D',    'E',    'F',    'G',
/* 110 */       'H',    'I',    'J',    'K',    'L',    'M',    'N',    'O',
/* 120 */       'P',    'Q',    'R',    'S',    'T',    'U',    'V',    'W',
/* 130 */       'X',    'Y',    'Z',    '[',    '\\',   ']',    '^',    '_',
/* 140 */       '`',    'A',    'B',    'C',    'D',    'E',    'F',    'G',
/* 150 */       'H',    'I',    'J',    'K',    'L',    'M',    'N',    'O',
/* 160 */       'P',    'Q',    'R',    'S',    'T',    'U',    'V',    'W',
/* 170 */       'X',    'Y',    'Z',    '{',    '|',    '}',    '~',    0,
/* 200 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 210 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 220 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 230 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 240 */       0240,   0241,   0242,   0243,   0244,   0245,   0246,   0247,
/* 250 */       0250,   0251,   0252,   0253,   0254,   0255,   0256,   0257,
/* 260 */       0260,   0261,   0262,   0263,   0264,   0265,   0266,   0267,
/* 270 */       0270,   0271,   0272,   0273,   0274,   0275,   0276,   0277,
/* 300 */       0300,   0301,   0302,   0303,   0304,   0305,   0306,   0307,
/* 310 */       0310,   0311,   0312,   0313,   0314,   0315,   0316,   0317,
/* 320 */       0320,   0321,   0322,   0323,   0324,   0325,   0326,   0327,
/* 330 */       0330,   0331,   0332,   0333,   0334,   0335,   0336,   0337,
/* 340 */       0340,   0341,   0342,   0343,   0344,   0345,   0346,   0347,
/* 350 */       0350,   0351,   0352,   0353,   0354,   0355,   0356,   0357,
/* 360 */       0360,   0361,   0362,   0363,   0364,   0365,   0366,   0367,
/*
 * WARNING: as for above ISO sets, \377 may be used.  Translate it to
 * itself.
 */
/* 370 */       0370,   0371,   0372,   0373,   0374,   0375,   0376,   0377,
};

/*
 * Input mapping table -- if an entry is non-zero, and XCASE is set,
 * when the corresponding character is typed preceded by "\" the escape
 * sequence is replaced by the table value.  Mostly used for
 * upper-case only terminals.
 */
static char     imaptab[256] = {
/* 000 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 010 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 020 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 030 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 040 */       0,      '|',    0,      0,      0,      0,      0,      '`',
/* 050 */       '{',    '}',    0,      0,      0,      0,      0,      0,
/* 060 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 070 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 100 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 110 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 120 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 130 */       0,      0,      0,      0,      '\\',   0,      '~',    0,
/* 140 */       0,      'A',    'B',    'C',    'D',    'E',    'F',    'G',
/* 150 */       'H',    'I',    'J',    'K',    'L',    'M',    'N',    'O',
/* 160 */       'P',    'Q',    'R',    'S',    'T',    'U',    'V',    'W',
/* 170 */       'X',    'Y',    'Z',    0,      0,      0,      0,      0,
/* 200-377 aren't mapped */
};

/*
 * Output mapping table -- if an entry is non-zero, and XCASE is set,
 * the corresponding character is printed as "\" followed by the table
 * value.  Mostly used for upper-case only terminals.
 */
static char     omaptab[256] = {
/* 000 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 010 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 020 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 030 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 040 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 050 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 060 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 070 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 100 */       0,      'A',    'B',    'C',    'D',    'E',    'F',    'G',
/* 110 */       'H',    'I',    'J',    'K',    'L',    'M',    'N',    'O',
/* 120 */       'P',    'Q',    'R',    'S',    'T',    'U',    'V',    'W',
/* 130 */       'X',    'Y',    'Z',    0,      0,      0,      0,      0,
/* 140 */       '\'',   0,      0,      0,      0,      0,      0,      0,
/* 150 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 160 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 170 */       0,      0,      0,      '(',    '!',    ')',    '^',    0,
/* 200-377 aren't mapped */
};

/*
 * Translation table for TS_MEUC output without OLCUC.  All printing ASCII
 * characters translate to themselves.  All other _bytes_ have a zero in
 * the table, which stops the copying.  This and the following table exist
 * only so we can use the existing movtuc processing with or without OLCUC.
 * Maybe it speeds up something...because we can copy a block of characters
 * by only looking for zeros in the table.
 *
 * If we took the simple expedient of DISALLOWING "olcuc" with multi-byte
 * processing, we could rid ourselves of both these tables and save 512 bytes;
 * seriously, it doesn't make much sense to use olcuc with multi-byte, and
 * it will probably never be used.  Consideration should be given to disallowing
 * the combination TS_MEUC & OLCUC.
 */
static unsigned char enotrantab[256] = {
/* 000 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 010 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 020 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 030 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 040 */       ' ',    '!',    '"',    '#',    '$',    '%',    '&',    '\'',
/* 050 */       '(',    ')',    '*',    '+',    ',',    '-',    '.',    '/',
/* 060 */       '0',    '1',    '2',    '3',    '4',    '5',    '6',    '7',
/* 070 */       '8',    '9',    ':',    ';',    '<',    '=',    '>',    '?',
/* 100 */       '@',    'A',    'B',    'C',    'D',    'E',    'F',    'G',
/* 110 */       'H',    'I',    'J',    'K',    'L',    'M',    'N',    'O',
/* 120 */       'P',    'Q',    'R',    'S',    'T',    'U',    'V',    'W',
/* 130 */       'X',    'Y',    'Z',    '[',    '\\',   ']',    '^',    '_',
/* 140 */       '`',    'a',    'b',    'c',    'd',    'e',    'f',    'g',
/* 150 */       'h',    'i',    'j',    'k',    'l',    'm',    'n',    'o',
/* 160 */       'p',    'q',    'r',    's',    't',    'u',    'v',    'w',
/* 170 */       'x',    'y',    'z',    '{',    '|',    '}',    '~',    0,
/* 200 - 377 aren't mapped (they're stoppers). */
};

/*
 * Translation table for TS_MEUC output with OLCUC.  All printing ASCII
 * translate to themselves, except for lower-case letters which translate
 * to their upper-case equivalents.  All other bytes have a zero in
 * the table, which stops the copying.  Useless for ISO Latin Alphabet
 * translations, but *sigh* OLCUC is really only defined for ASCII anyway.
 * We only have this table so we can use the existing OLCUC processing with
 * TS_MEUC set (multi-byte mode).  Nobody would ever think of actually
 * _using_ it...would they?
 */
static unsigned char elcuctab[256] = {
/* 000 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 010 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 020 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 030 */       0,      0,      0,      0,      0,      0,      0,      0,
/* 040 */       ' ',    '!',    '"',    '#',    '$',    '%',    '&',    '\'',
/* 050 */       '(',    ')',    '*',    '+',    ',',    '-',    '.',    '/',
/* 060 */       '0',    '1',    '2',    '3',    '4',    '5',    '6',    '7',
/* 070 */       '8',    '9',    ':',    ';',    '<',    '=',    '>',    '?',
/* 100 */       '@',    'A',    'B',    'C',    'D',    'E',    'F',    'G',
/* 110 */       'H',    'I',    'J',    'K',    'L',    'M',    'N',    'O',
/* 120 */       'P',    'Q',    'R',    'S',    'T',    'U',    'V',    'W',
/* 130 */       'X',    'Y',    'Z',    '[',    '\\',   ']',    '^',    '_',
/* 140 */       '`',    'A',    'B',    'C',    'D',    'E',    'F',    'G',
/* 150 */       'H',    'I',    'J',    'K',    'L',    'M',    'N',    'O',
/* 160 */       'P',    'Q',    'R',    'S',    'T',    'U',    'V',    'W',
/* 170 */       'X',    'Y',    'Z',    '{',    '|',    '}',    '~',    0,
/* 200 - 377 aren't mapped (they're stoppers). */
};

static struct streamtab ldtrinfo;

static struct fmodsw fsw = {
        "ldterm",
        &ldtrinfo,
        D_MTQPAIR | D_MP | _D_SINGLE_INSTANCE
};

static struct modlstrmod modlstrmod = {
        &mod_strmodops, "terminal line discipline", &fsw
};


static struct modlinkage modlinkage = {
        MODREV_1, &modlstrmod, NULL
};


int
_init(void)
{
        return (mod_install(&modlinkage));
}

int
_fini(void)
{
        return (mod_remove(&modlinkage));
}

int
_info(struct modinfo *modinfop)
{
        return (mod_info(&modlinkage, modinfop));
}


static int      ldtermopen(queue_t *, dev_t *, int, int, cred_t *);
static int      ldtermclose(queue_t *, int, cred_t *);
static void     ldtermrput(queue_t *, mblk_t *);
static void     ldtermrsrv(queue_t *);
static int      ldtermrmsg(queue_t *, mblk_t *);
static void     ldtermwput(queue_t *, mblk_t *);
static void     ldtermwsrv(queue_t *);
static int      ldtermwmsg(queue_t *, mblk_t *);
static mblk_t   *ldterm_docanon(unsigned char, mblk_t *, size_t, queue_t *,
                                ldtermstd_state_t *, int *);
static int      ldterm_unget(ldtermstd_state_t *);
static void     ldterm_trim(ldtermstd_state_t *);
static void     ldterm_rubout(unsigned char, queue_t *, size_t,
                                ldtermstd_state_t *);
static int      ldterm_tabcols(ldtermstd_state_t *);
static void     ldterm_erase(queue_t *, size_t, ldtermstd_state_t *);
static void     ldterm_werase(queue_t *, size_t, ldtermstd_state_t *);
static void     ldterm_kill(queue_t *, size_t, ldtermstd_state_t *);
static void     ldterm_reprint(queue_t *, size_t, ldtermstd_state_t *);
static mblk_t   *ldterm_dononcanon(mblk_t *, mblk_t *, size_t, queue_t *,
                                        ldtermstd_state_t *);
static int      ldterm_echo(unsigned char, queue_t *, size_t,
                                ldtermstd_state_t *);
static void     ldterm_outchar(unsigned char, queue_t *, size_t,
                                ldtermstd_state_t *);
static void     ldterm_outstring(unsigned char *, int, queue_t *, size_t,
                                        ldtermstd_state_t *tp);
static mblk_t   *newmsg(ldtermstd_state_t *);
static void     ldterm_msg_upstream(queue_t *, ldtermstd_state_t *);
static void     ldterm_wenable(void *);
static mblk_t   *ldterm_output_msg(queue_t *, mblk_t *, mblk_t **,
                                ldtermstd_state_t *, size_t, int);
static void     ldterm_flush_output(unsigned char, queue_t *,
                                        ldtermstd_state_t *);
static void     ldterm_dosig(queue_t *, int, unsigned char, int, int);
static void     ldterm_do_ioctl(queue_t *, mblk_t *);
static int      chgstropts(struct termios *, ldtermstd_state_t *, queue_t *);
static void     ldterm_ioctl_reply(queue_t *, mblk_t *);
static void     vmin_satisfied(queue_t *, ldtermstd_state_t *, int);
static void     vmin_settimer(queue_t *);
static void     vmin_timed_out(void *);
static void     ldterm_adjust_modes(ldtermstd_state_t *);
static void     ldterm_eucwarn(ldtermstd_state_t *);
static void     cp_eucwioc(eucioc_t *, eucioc_t *, int);
static int      ldterm_codeset(uchar_t, uchar_t);

static void     ldterm_csi_erase(queue_t *, size_t, ldtermstd_state_t *);
static void     ldterm_csi_werase(queue_t *, size_t, ldtermstd_state_t *);

static uchar_t  ldterm_utf8_width(uchar_t *, int);

/* Codeset type specific methods for EUC, PCCS, and, UTF-8 codeset types. */
static int      __ldterm_dispwidth_euc(uchar_t, void *, int);
static int      __ldterm_memwidth_euc(uchar_t, void *);

static int      __ldterm_dispwidth_pccs(uchar_t, void *, int);
static int      __ldterm_memwidth_pccs(uchar_t, void *);

static int      __ldterm_dispwidth_utf8(uchar_t, void *, int);
static int      __ldterm_memwidth_utf8(uchar_t, void *);

static const ldterm_cs_methods_t cs_methods[LDTERM_CS_TYPE_MAX + 1] = {
        {
                NULL,
                NULL
        },
        {
                __ldterm_dispwidth_euc,
                __ldterm_memwidth_euc
        },
        {
                __ldterm_dispwidth_pccs,
                __ldterm_memwidth_pccs
        },
        {
                __ldterm_dispwidth_utf8,
                __ldterm_memwidth_utf8
        }
};

/*
 * The default codeset is presumably C locale's ISO 646 in EUC but
 * the data structure at below defined as the default codeset data also
 * support any single byte (EUC) locales.
 */
static const ldterm_cs_data_t default_cs_data = {
        LDTERM_DATA_VERSION,
        LDTERM_CS_TYPE_EUC,
        (uchar_t)0,
        (uchar_t)0,
        NULL,
        {
                '\0', '\0', '\0', '\0',
                '\0', '\0', '\0', '\0',
                '\0', '\0', '\0', '\0',
                '\0', '\0', '\0', '\0',
                '\0', '\0', '\0', '\0',
                '\0', '\0', '\0', '\0',
                '\0', '\0', '\0', '\0',
                '\0', '\0', '\0', '\0',
                '\0', '\0', '\0', '\0',
                '\0', '\0', '\0', '\0'
        }
};

/*
 * The following tables are from either u8_textprep.c or uconv.c at
 * usr/src/common/unicode/. The tables are used to figure out corresponding
 * UTF-8 character byte lengths and also the validity of given character bytes.
 */
extern const int8_t u8_number_of_bytes[];
extern const uchar_t u8_masks_tbl[];
extern const uint8_t u8_valid_min_2nd_byte[];
extern const uint8_t u8_valid_max_2nd_byte[];

/*
 * Unicode character width definition tables from uwidth.c:
 */
extern const ldterm_unicode_data_cell_t ldterm_ucode[][16384];

#ifdef LDDEBUG
int     ldterm_debug = 0;
#define DEBUG1(a)       if (ldterm_debug == 1) printf a
#define DEBUG2(a)       if (ldterm_debug >= 2) printf a /* allocations */
#define DEBUG3(a)       if (ldterm_debug >= 3) printf a /* M_CTL Stuff */
#define DEBUG4(a)       if (ldterm_debug >= 4) printf a /* M_READ Stuff */
#define DEBUG5(a)       if (ldterm_debug >= 5) printf a
#define DEBUG6(a)       if (ldterm_debug >= 6) printf a
#define DEBUG7(a)       if (ldterm_debug >= 7) printf a
#else
#define DEBUG1(a)
#define DEBUG2(a)
#define DEBUG3(a)
#define DEBUG4(a)
#define DEBUG5(a)
#define DEBUG6(a)
#define DEBUG7(a)
#endif          /* LDDEBUG */


/*
 * Since most of the buffering occurs either at the stream head or in
 * the "message currently being assembled" buffer, we have a
 * relatively small input queue, so that blockages above us get
 * reflected fairly quickly to the module below us.  We also have a
 * small maximum packet size, since you can put a message of that
 * size on an empty queue no matter how much bigger than the high
 * water mark it is.
 */
static struct module_info ldtermmiinfo = {
        0x0bad,
        "ldterm",
        0,
        _TTY_BUFSIZ,
        _TTY_BUFSIZ,
        LOWAT
};


static struct qinit ldtermrinit = {
        (int (*)())ldtermrput,
        (int (*)())ldtermrsrv,
        ldtermopen,
        ldtermclose,
        NULL,
        &ldtermmiinfo
};


static struct module_info ldtermmoinfo = {
        0x0bad,
        "ldterm",
        0,
        INFPSZ,
        1,
        0
};


static struct qinit ldtermwinit = {
        (int (*)())ldtermwput,
        (int (*)())ldtermwsrv,
        ldtermopen,
        ldtermclose,
        NULL,
        &ldtermmoinfo
};


static struct streamtab ldtrinfo = {
        &ldtermrinit,
        &ldtermwinit,
        NULL,
        NULL
};

/*
 * Dummy qbufcall callback routine used by open and close.
 * The framework will wake up qwait_sig when we return from
 * this routine (as part of leaving the perimeters.)
 * (The framework enters the perimeters before calling the qbufcall() callback
 * and leaves the perimeters after the callback routine has executed. The
 * framework performs an implicit wakeup of any thread in qwait/qwait_sig
 * when it leaves the perimeter. See qwait(9E).)
 */
/* ARGSUSED */
static void
dummy_callback(void *arg)
{}


static mblk_t *
open_ioctl(queue_t *q, uint_t cmd)
{
        mblk_t *mp;
        bufcall_id_t id;
        int retv;

        while ((mp = mkiocb(cmd)) == NULL) {
                id = qbufcall(q, sizeof (struct iocblk), BPRI_MED,
                    dummy_callback, NULL);
                retv = qwait_sig(q);
                qunbufcall(q, id);
                if (retv == 0)
                        break;
        }
        return (mp);
}

static mblk_t *
open_mblk(queue_t *q, size_t len)
{
        mblk_t *mp;
        bufcall_id_t id;
        int retv;

        while ((mp = allocb(len, BPRI_MED)) == NULL) {
                id = qbufcall(q, len, BPRI_MED, dummy_callback, NULL);
                retv = qwait_sig(q);
                qunbufcall(q, id);
                if (retv == 0)
                        break;
        }
        return (mp);
}

/*
 * Line discipline open.
 */
/* ARGSUSED1 */
static int
ldtermopen(queue_t *q, dev_t *devp, int oflag, int sflag, cred_t *crp)
{
        ldtermstd_state_t *tp;
        mblk_t *bp, *qryp;
        int len;
        struct stroptions *strop;
        struct termios *termiosp;
        queue_t *wq;

        if (q->q_ptr != NULL) {
                return (0);     /* already attached */
        }

        tp = (ldtermstd_state_t *)kmem_zalloc(sizeof (ldtermstd_state_t),
            KM_SLEEP);

        /*
         * Get termios defaults.  These are stored as
         * a property in the "options" node.
         */
        if (ddi_getlongprop(DDI_DEV_T_ANY, ddi_root_node(), DDI_PROP_NOTPROM,
            "ttymodes", (caddr_t)&termiosp, &len) == DDI_PROP_SUCCESS &&
            len == sizeof (struct termios)) {
                tp->t_modes = *termiosp;
                tp->t_amodes = *termiosp;
                kmem_free(termiosp, len);
        } else {
                /*
                 * Gack!  Whine about it.
                 */
                cmn_err(CE_WARN, "ldterm: Couldn't get ttymodes property!");
        }
        bzero(&tp->t_dmodes, sizeof (struct termios));

        tp->t_state = 0;

        tp->t_line = 0;
        tp->t_col = 0;

        tp->t_rocount = 0;
        tp->t_rocol = 0;

        tp->t_message = NULL;
        tp->t_endmsg = NULL;
        tp->t_msglen = 0;
        tp->t_rd_request = 0;

        tp->t_echomp = NULL;
        tp->t_iocid = 0;
        tp->t_wbufcid = 0;
        tp->t_vtid = 0;

        q->q_ptr = (caddr_t)tp;
        WR(q)->q_ptr = (caddr_t)tp;
        /*
         * The following for EUC and also non-EUC codesets:
         */
        tp->t_codeset = tp->t_eucleft = tp->t_eucign = tp->t_scratch_len = 0;
        bzero(&tp->eucwioc, EUCSIZE);
        tp->eucwioc.eucw[0] = 1;        /* ASCII mem & screen width */
        tp->eucwioc.scrw[0] = 1;
        tp->t_maxeuc = 1;       /* the max len in bytes of an EUC char */
        tp->t_eucp = NULL;
        tp->t_csmethods = cs_methods[LDTERM_CS_TYPE_EUC];
        tp->t_csdata = default_cs_data;

        /*
         * Try to switch to UTF-8 mode by allocating buffer for multibyte
         * chars, keep EUC if allocation fails.
         */
        if ((tp->t_eucp_mp = allocb(_TTY_BUFSIZ, BPRI_HI)) != NULL) {
                tp->t_eucp = tp->t_eucp_mp->b_rptr;
                tp->t_state = TS_MEUC;  /* Multibyte mode. */
                tp->t_maxeuc = 4; /* the max len in bytes of an UTF-8 char */
                tp->t_csdata.codeset_type = LDTERM_CS_TYPE_UTF8;
                tp->t_csdata.csinfo_num = 4;
                /* locale_name needs string length with terminating NUL */
                tp->t_csdata.locale_name = (char *)kmem_alloc(6, KM_SLEEP);
                (void) strcpy(tp->t_csdata.locale_name, "UTF-8");
                tp->t_csmethods = cs_methods[LDTERM_CS_TYPE_UTF8];
        }
        tp->t_eucwarn = 0;      /* no bad chars seen yet */

        qprocson(q);

        /*
         * Find out if the module below us does canonicalization; if
         * so, we won't do it ourselves.
         */

        if ((qryp = open_ioctl(q, MC_CANONQUERY)) == NULL)
                goto open_abort;

        /*
         * Reformulate as an M_CTL message. The actual data will
         * be in the b_cont field.
         */
        qryp->b_datap->db_type = M_CTL;
        wq = OTHERQ(q);
        putnext(wq, qryp);

        /* allocate a TCSBRK ioctl in case we'll need it on close */
        if ((qryp = open_ioctl(q, TCSBRK)) == NULL)
                goto open_abort;
        tp->t_drainmsg = qryp;
        if ((bp = open_mblk(q, sizeof (int))) == NULL)
                goto open_abort;
        qryp->b_cont = bp;

        /*
         * Find out if the underlying driver supports proper POSIX close
         * semantics.  If not, we'll have to approximate it using TCSBRK.  If
         * it does, it will respond with MC_HAS_POSIX, and we'll catch that in
         * the ldtermrput routine.
         *
         * When the ldterm_drain_limit tunable is set to zero, we behave the
         * same as old ldterm: don't send this new message, and always use
         * TCSBRK during close.
         */
        if (ldterm_drain_limit != 0) {
                if ((qryp = open_ioctl(q, MC_POSIXQUERY)) == NULL)
                        goto open_abort;
                qryp->b_datap->db_type = M_CTL;
                putnext(wq, qryp);
        }

        /* prepare to clear the water marks on close */
        if ((bp = open_mblk(q, sizeof (struct stroptions))) == NULL)
                goto open_abort;
        tp->t_closeopts = bp;

        /*
         * Set the high-water and low-water marks on the stream head
         * to values appropriate for a terminal.  Also set the "vmin"
         * and "vtime" values to 1 and 0, turn on message-nondiscard
         * mode (as we're in ICANON mode), and turn on "old-style
         * NODELAY" mode.
         */
        if ((bp = open_mblk(q, sizeof (struct stroptions))) == NULL)
                goto open_abort;
        strop = (struct stroptions *)bp->b_wptr;
        strop->so_flags = SO_READOPT|SO_HIWAT|SO_LOWAT|SO_NDELON|SO_ISTTY;
        strop->so_readopt = RMSGN;
        strop->so_hiwat = _TTY_BUFSIZ;
        strop->so_lowat = LOWAT;
        bp->b_wptr += sizeof (struct stroptions);
        bp->b_datap->db_type = M_SETOPTS;
        putnext(q, bp);

        return (0);             /* this can become a controlling TTY */

open_abort:
        qprocsoff(q);
        q->q_ptr = NULL;
        WR(q)->q_ptr = NULL;
        freemsg(tp->t_closeopts);
        freemsg(tp->t_drainmsg);
        /* Dump the state structure */
        kmem_free(tp, sizeof (ldtermstd_state_t));
        return (EINTR);
}

struct close_timer {
        timeout_id_t id;
        ldtermstd_state_t *tp;
};

static void
drain_timed_out(void *arg)
{
        struct close_timer *ctp = arg;

        ctp->id = 0;
        ctp->tp->t_state &= ~TS_IOCWAIT;
}

/* ARGSUSED2 */
static int
ldtermclose(queue_t *q, int cflag, cred_t *crp)
{
        ldtermstd_state_t *tp = (ldtermstd_state_t *)q->q_ptr;
        struct stroptions *strop;
        mblk_t *bp;
        struct close_timer cltimer;

        /*
         * If we have an outstanding vmin timeout, cancel it.
         */
        tp->t_state |= TS_CLOSE;
        if (tp->t_vtid != 0)
                (void) quntimeout(q, tp->t_vtid);
        tp->t_vtid = 0;

        /*
         * Cancel outstanding qbufcall request.
         */
        if (tp->t_wbufcid != 0)
                qunbufcall(q, tp->t_wbufcid);

        /*
         * Reset the high-water and low-water marks on the stream
         * head (?), turn on byte-stream mode, and turn off
         * "old-style NODELAY" mode.
         */
        bp = tp->t_closeopts;
        strop = (struct stroptions *)bp->b_wptr;
        strop->so_flags = SO_READOPT|SO_NDELOFF;
        strop->so_readopt = RNORM;
        bp->b_wptr += sizeof (struct stroptions);
        bp->b_datap->db_type = M_SETOPTS;
        putnext(q, bp);

        if (cflag & (FNDELAY|FNONBLOCK)) {
                freemsg(tp->t_drainmsg);
        } else if ((bp = tp->t_drainmsg) != NULL) {
                struct iocblk *iocb;

                /*
                 * If the driver isn't known to have POSIX close semantics,
                 * then we have to emulate this the old way.  This is done by
                 * sending down TCSBRK,1 to drain the output and waiting for
                 * the reply.
                 */
                iocb = (struct iocblk *)bp->b_rptr;
                iocb->ioc_count = sizeof (int);
                *(int *)bp->b_cont->b_rptr = 1;
                bp->b_cont->b_wptr += sizeof (int);
                tp->t_state |= TS_IOCWAIT;
                tp->t_iocid = iocb->ioc_id;
                if (!putq(WR(q), bp))
                        putnext(WR(q), bp);

                /*
                 * If we're not able to receive signals at this point, then
                 * launch a timer.  This timer will prevent us from waiting
                 * forever for a signal that won't arrive.
                 */
                cltimer.id = 0;
                if (!ddi_can_receive_sig() && ldterm_drain_limit != 0) {
                        cltimer.tp = tp;
                        cltimer.id = qtimeout(q, drain_timed_out, &cltimer,
                            drv_usectohz(ldterm_drain_limit));
                }

                /*
                 * Note that the read side of ldterm and the qtimeout are
                 * protected by D_MTQPAIR, so no additional locking is needed
                 * here.
                 */
                while (tp->t_state & TS_IOCWAIT) {
                        if (qwait_sig(q) == 0)
                                break;
                }
                if (cltimer.id != 0)
                        (void) quntimeout(q, cltimer.id);
        }

        /*
         * From here to the end, the routine does not sleep and does not
         * reference STREAMS, so it's guaranteed to run to completion.
         */

        qprocsoff(q);

        freemsg(tp->t_message);
        freemsg(tp->t_eucp_mp);

        /* Dump the state structure, then unlink it */
        if (tp->t_csdata.locale_name != NULL)
                kmem_free(tp->t_csdata.locale_name,
                    strlen(tp->t_csdata.locale_name) + 1);
        kmem_free(tp, sizeof (ldtermstd_state_t));
        q->q_ptr = NULL;
        return (0);
}


/*
 * Put procedure for input from driver end of stream (read queue).
 */
static void
ldtermrput(queue_t *q, mblk_t *mp)
{
        ldtermstd_state_t *tp;
        unsigned char c;
        queue_t *wrq = WR(q);           /* write queue of ldterm mod */
        queue_t *nextq = q->q_next;     /* queue below us */
        mblk_t *bp;
        struct iocblk *qryp;
        unsigned char *readp;
        unsigned char *writep;
        struct termios *emodes;         /* effective modes set by driver */
        int dbtype;

        tp = (ldtermstd_state_t *)q->q_ptr;
        /*
         * We received our ack from the driver saying there is nothing left to
         * shovel out, so wake up the close routine.
         */
        dbtype = DB_TYPE(mp);
        if ((dbtype == M_IOCACK || dbtype == M_IOCNAK) &&
            (tp->t_state & (TS_CLOSE|TS_IOCWAIT)) == (TS_CLOSE|TS_IOCWAIT)) {
                struct iocblk *iocp = (struct iocblk *)mp->b_rptr;

                if (iocp->ioc_id == tp->t_iocid) {
                        tp->t_state &= ~TS_IOCWAIT;
                        freemsg(mp);
                        return;
                }
        }

        switch (dbtype) {

        default:
                (void) putq(q, mp);
                return;

                /*
                 * Send these up unmolested
                 *
                 */
        case M_PCSIG:
        case M_SIG:
        case M_IOCNAK:

                putnext(q, mp);
                return;

        case M_IOCACK:

                ldterm_ioctl_reply(q, mp);
                return;

        case M_BREAK:

                /*
                 * Parity errors are sent up as M_BREAKS with single
                 * character data (formerly handled in the driver)
                 */
                if (mp->b_wptr - mp->b_rptr == 1) {
                        /*
                         * IGNPAR       PARMRK          RESULT
                         * off          off             0
                         * off          on              3 byte sequence
                         * on           either          ignored
                         */
                        if (!(tp->t_amodes.c_iflag & IGNPAR)) {
                                mp->b_wptr = mp->b_rptr;
                                if (tp->t_amodes.c_iflag & PARMRK) {
                                        unsigned char c;

                                        c = *mp->b_rptr;
                                        freemsg(mp);
                                        if ((mp = allocb(3, BPRI_HI)) == NULL) {
                                                cmn_err(CE_WARN,
                                                    "ldtermrput: no blocks");
                                                return;
                                        }
                                        mp->b_datap->db_type = M_DATA;
                                        *mp->b_wptr++ = (uchar_t)'\377';
                                        *mp->b_wptr++ = '\0';
                                        *mp->b_wptr++ = c;
                                        putnext(q, mp);
                                } else {
                                        mp->b_datap->db_type = M_DATA;
                                        *mp->b_wptr++ = '\0';
                                        putnext(q, mp);
                                }
                        } else {
                                freemsg(mp);
                        }
                        return;
                }
                /*
                 * We look at the apparent modes here instead of the
                 * effective modes. Effective modes cannot be used if
                 * IGNBRK, BRINT and PARMRK have been negotiated to
                 * be handled by the driver. Since M_BREAK should be
                 * sent upstream only if break processing was not
                 * already done, it should be ok to use the apparent
                 * modes.
                 */

                if (!(tp->t_amodes.c_iflag & IGNBRK)) {
                        if (tp->t_amodes.c_iflag & BRKINT) {
                                ldterm_dosig(q, SIGINT, '\0', M_PCSIG, FLUSHRW);
                                freemsg(mp);
                        } else if (tp->t_amodes.c_iflag & PARMRK) {
                                /*
                                 * Send '\377','\0', '\0'.
                                 */
                                freemsg(mp);
                                if ((mp = allocb(3, BPRI_HI)) == NULL) {
                                        cmn_err(CE_WARN,
                                            "ldtermrput: no blocks");
                                        return;
                                }
                                mp->b_datap->db_type = M_DATA;
                                *mp->b_wptr++ = (uchar_t)'\377';
                                *mp->b_wptr++ = '\0';
                                *mp->b_wptr++ = '\0';
                                putnext(q, mp);
                        } else {
                                /*
                                 * Act as if a '\0' came in.
                                 */
                                freemsg(mp);
                                if ((mp = allocb(1, BPRI_HI)) == NULL) {
                                        cmn_err(CE_WARN,
                                            "ldtermrput: no blocks");
                                        return;
                                }
                                mp->b_datap->db_type = M_DATA;
                                *mp->b_wptr++ = '\0';
                                putnext(q, mp);
                        }
                } else {
                        freemsg(mp);
                }
                return;

        case M_CTL:
                DEBUG3(("ldtermrput: M_CTL received\n"));
                /*
                 * The M_CTL has been standardized to look like an
                 * M_IOCTL message.
                 */

                if ((mp->b_wptr - mp->b_rptr) != sizeof (struct iocblk)) {
                        DEBUG3((
                            "Non standard M_CTL received by ldterm module\n"));
                        /* May be for someone else; pass it on */
                        putnext(q, mp);
                        return;
                }
                qryp = (struct iocblk *)mp->b_rptr;

                switch (qryp->ioc_cmd) {

                case MC_PART_CANON:

                        DEBUG3(("ldtermrput: M_CTL Query Reply\n"));
                        if (!mp->b_cont) {
                                DEBUG3(("No information in Query Message\n"));
                                break;
                        }
                        if ((mp->b_cont->b_wptr - mp->b_cont->b_rptr) ==
                            sizeof (struct termios)) {
                                DEBUG3(("ldtermrput: M_CTL GrandScheme\n"));
                                /* elaborate turning off scheme */
                                emodes = (struct termios *)mp->b_cont->b_rptr;
                                bcopy(emodes, &tp->t_dmodes,
                                        sizeof (struct termios));
                                ldterm_adjust_modes(tp);
                                break;
                        } else {
                                DEBUG3(("Incorrect query replysize\n"));
                                break;
                        }

                case MC_NO_CANON:
                        tp->t_state |= TS_NOCANON;
                        /*
                         * Note: this is very nasty.  It's not clear
                         * what the right thing to do with a partial
                         * message is; We throw it out
                         */
                        if (tp->t_message != NULL) {
                                freemsg(tp->t_message);
                                tp->t_message = NULL;
                                tp->t_endmsg = NULL;
                                tp->t_msglen = 0;
                                tp->t_rocount = 0;
                                tp->t_rocol = 0;
                                if (tp->t_state & TS_MEUC) {
                                        ASSERT(tp->t_eucp_mp);
                                        tp->t_eucp = tp->t_eucp_mp->b_rptr;
                                        tp->t_codeset = 0;
                                        tp->t_eucleft = 0;
                                }
                        }
                        break;

                case MC_DO_CANON:
                        tp->t_state &= ~TS_NOCANON;
                        break;

                case MC_HAS_POSIX:
                        /* no longer any reason to drain from ldterm */
                        if (ldterm_drain_limit != 0) {
                                freemsg(tp->t_drainmsg);
                                tp->t_drainmsg = NULL;
                        }
                        break;

                default:
                        DEBUG3(("Unknown M_CTL Message\n"));
                        break;
                }
                putnext(q, mp); /* In case anyone else has to see it */
                return;

        case M_FLUSH:
                /*
                 * Flush everything we haven't looked at yet.
                 */

                if ((tp->t_state & TS_ISPTSTTY) && (*mp->b_rptr & FLUSHBAND))
                        flushband(q, *(mp->b_rptr + 1), FLUSHDATA);
                else
                        flushq(q, FLUSHDATA);

                /*
                 * Flush everything we have looked at.
                 */
                freemsg(tp->t_message);
                tp->t_message = NULL;
                tp->t_endmsg = NULL;
                tp->t_msglen = 0;
                tp->t_rocount = 0;
                tp->t_rocol = 0;
                if (tp->t_state & TS_MEUC) {    /* EUC multi-byte */
                        ASSERT(tp->t_eucp_mp);
                        tp->t_eucp = tp->t_eucp_mp->b_rptr;
                }
                putnext(q, mp); /* pass it on */

                /*
                 * Relieve input flow control
                 */
                if ((tp->t_modes.c_iflag & IXOFF) &&
                    (tp->t_state & TS_TBLOCK) &&
                    !(tp->t_state & TS_IFBLOCK) && q->q_count <= TTXOLO) {
                        tp->t_state &= ~TS_TBLOCK;
                        (void) putnextctl(wrq, M_STARTI);
                        DEBUG1(("M_STARTI down\n"));
                }
                return;

        case M_DATA:
                break;
        }
        (void) drv_setparm(SYSRAWC, msgdsize(mp));

        /*
         * Flow control: send "start input" message if blocked and
         * our queue is below its low water mark.
         */
        if ((tp->t_modes.c_iflag & IXOFF) && (tp->t_state & TS_TBLOCK) &&
            !(tp->t_state & TS_IFBLOCK) && q->q_count <= TTXOLO) {
                tp->t_state &= ~TS_TBLOCK;
                (void) putnextctl(wrq, M_STARTI);
                DEBUG1(("M_STARTI down\n"));
        }
        /*
         * If somebody below us ("intelligent" communications
         * board, pseudo-tty controlled by an editor) is doing
         * canonicalization, don't scan it for special characters.
         */
        if (tp->t_state & TS_NOCANON) {
                (void) putq(q, mp);
                return;
        }
        bp = mp;

        do {
                readp = bp->b_rptr;
                writep = readp;
                if (tp->t_modes.c_iflag & (INLCR|IGNCR|ICRNL|IUCLC|IXON) ||
                    tp->t_modes.c_lflag & (ISIG|ICANON)) {
                        /*
                         * We're doing some sort of non-trivial
                         * processing of input; look at every
                         * character.
                         */
                        while (readp < bp->b_wptr) {
                                c = *readp++;

                                if (tp->t_modes.c_iflag & ISTRIP)
                                        c &= 0177;

                                /*
                                 * First, check that this hasn't been
                                 * escaped with the "literal next"
                                 * character.
                                 */
                                if (tp->t_state & TS_PLNCH) {
                                        tp->t_state &= ~TS_PLNCH;
                                        tp->t_modes.c_lflag &= ~FLUSHO;
                                        *writep++ = c;
                                        continue;
                                }
                                /*
                                 * Setting a special character to NUL
                                 * disables it, so if this character
                                 * is NUL, it should not be compared
                                 * with any of the special characters.
                                 * It should, however, restart frozen
                                 * output if IXON and IXANY are set.
                                 */
                                if (c == _POSIX_VDISABLE) {
                                        if (tp->t_modes.c_iflag & IXON &&
                                            tp->t_state & TS_TTSTOP &&
                                            tp->t_modes.c_lflag & IEXTEN &&
                                            tp->t_modes.c_iflag & IXANY) {
                                                tp->t_state &=
                                                    ~(TS_TTSTOP|TS_OFBLOCK);
                                                (void) putnextctl(wrq, M_START);
                                        }
                                        tp->t_modes.c_lflag &= ~FLUSHO;
                                        *writep++ = c;
                                        continue;
                                }
                                /*
                                 * If stopped, start if you can; if
                                 * running, stop if you must.
                                 */
                                if (tp->t_modes.c_iflag & IXON) {
                                        if (tp->t_state & TS_TTSTOP) {
                                                if (c ==
                                                    tp->t_modes.c_cc[VSTART] ||
                                                    (tp->t_modes.c_lflag &
                                                    IEXTEN &&
                                                    tp->t_modes.c_iflag &
                                                    IXANY)) {
                                                        tp->t_state &=
                                                            ~(TS_TTSTOP |
                                                            TS_OFBLOCK);
                                                        (void) putnextctl(wrq,
                                                            M_START);
                                                }
                                        } else {
                                                if (c ==
                                                    tp->t_modes.c_cc[VSTOP]) {
                                                        tp->t_state |=
                                                            TS_TTSTOP;
                                                        (void) putnextctl(wrq,
                                                            M_STOP);
                                                }
                                        }
                                        if (c == tp->t_modes.c_cc[VSTOP] ||
                                            c == tp->t_modes.c_cc[VSTART])
                                                continue;
                                }
                                /*
                                 * Check for "literal next" character
                                 * and "flush output" character.
                                 * Note that we omit checks for ISIG
                                 * and ICANON, since the IEXTEN
                                 * setting subsumes them.
                                 */
                                if (tp->t_modes.c_lflag & IEXTEN) {
                                        if (c == tp->t_modes.c_cc[VLNEXT]) {
                                                /*
                                                 * Remember that we saw a
                                                 * "literal next" while
                                                 * scanning input, but leave
                                                 * leave it in the message so
                                                 * that the service routine
                                                 * can see it too.
                                                 */
                                                tp->t_state |= TS_PLNCH;
                                                tp->t_modes.c_lflag &= ~FLUSHO;
                                                *writep++ = c;
                                                continue;
                                        }
                                        if (c == tp->t_modes.c_cc[VDISCARD]) {
                                                ldterm_flush_output(c, wrq, tp);
                                                continue;
                                        }
                                }
                                tp->t_modes.c_lflag &= ~FLUSHO;

                                /*
                                 * Check for signal-generating
                                 * characters.
                                 */
                                if (tp->t_modes.c_lflag & ISIG) {
                                        if (c == tp->t_modes.c_cc[VINTR]) {
                                                ldterm_dosig(q, SIGINT, c,
                                                    M_PCSIG, FLUSHRW);
                                                continue;
                                        }
                                        if (c == tp->t_modes.c_cc[VQUIT]) {
                                                ldterm_dosig(q, SIGQUIT, c,
                                                    M_PCSIG, FLUSHRW);
                                                continue;
                                        }
                                        if (c == tp->t_modes.c_cc[VSWTCH]) {
                                                /*
                                                 * Ancient SXT support; discard
                                                 * character without action.
                                                 */
                                                continue;
                                        }
                                        if (c == tp->t_modes.c_cc[VSUSP]) {
                                                ldterm_dosig(q, SIGTSTP, c,
                                                    M_PCSIG, FLUSHRW);
                                                continue;
                                        }
                                        if ((tp->t_modes.c_lflag & IEXTEN) &&
                                            (c == tp->t_modes.c_cc[VDSUSP])) {
                                                ldterm_dosig(q, SIGTSTP, c,
                                                    M_SIG, 0);
                                                continue;
                                        }

                                        /*
                                         * Consumers do not expect the ^T to be
                                         * echoed out when we generate a
                                         * VSTATUS.
                                         */
                                        if (c == tp->t_modes.c_cc[VSTATUS]) {
                                                ldterm_dosig(q, SIGINFO, '\0',
                                                    M_PCSIG, FLUSHRW);
                                                continue;
                                        }
                                }
                                /*
                                 * Throw away CR if IGNCR set, or
                                 * turn it into NL if ICRNL set.
                                 */
                                if (c == '\r') {
                                        if (tp->t_modes.c_iflag & IGNCR)
                                                continue;
                                        if (tp->t_modes.c_iflag & ICRNL)
                                                c = '\n';
                                } else {
                                        /*
                                         * Turn NL into CR if INLCR
                                         * set.
                                         */
                                        if (c == '\n' &&
                                            tp->t_modes.c_iflag & INLCR)
                                                c = '\r';
                                }

                                /*
                                 * Map upper case input to lower case
                                 * if IUCLC flag set.
                                 */
                                if (tp->t_modes.c_iflag & IUCLC &&
                                    c >= 'A' && c <= 'Z')
                                        c += 'a' - 'A';

                                /*
                                 * Put the possibly-transformed
                                 * character back in the message.
                                 */
                                *writep++ = c;
                        }

                        /*
                         * If we didn't copy some characters because
                         * we were ignoring them, fix the size of the
                         * data block by adjusting the write pointer.
                         * XXX This may result in a zero-length
                         * block; will this cause anybody gastric
                         * distress?
                         */
                        bp->b_wptr -= (readp - writep);
                } else {
                        /*
                         * We won't be doing anything other than
                         * possibly stripping the input.
                         */
                        if (tp->t_modes.c_iflag & ISTRIP) {
                                while (readp < bp->b_wptr)
                                        *writep++ = *readp++ & 0177;
                        }
                        tp->t_modes.c_lflag &= ~FLUSHO;
                }

        } while ((bp = bp->b_cont) != NULL);    /* next block, if any */

        /*
         * Queue the message for service procedure if the
         * queue is not empty or canputnext() fails or
         * tp->t_state & TS_RESCAN is true.
         */

        if (q->q_first != NULL || !bcanputnext(q, mp->b_band) ||
            (tp->t_state & TS_RESCAN))
                (void) putq(q, mp);
        else
                (void) ldtermrmsg(q, mp);

        /*
         * Flow control: send "stop input" message if our queue is
         * approaching its high-water mark. The message will be
         * dropped on the floor in the service procedure, if we
         * cannot ship it up and we have had it upto our neck!
         *
         * Set QWANTW to ensure that the read queue service procedure
         * gets run when nextq empties up again, so that it can
         * unstop the input.
         */
        if ((tp->t_modes.c_iflag & IXOFF) && !(tp->t_state & TS_TBLOCK) &&
            q->q_count >= TTXOHI) {
                mutex_enter(QLOCK(nextq));
                nextq->q_flag |= QWANTW;
                mutex_exit(QLOCK(nextq));
                tp->t_state |= TS_TBLOCK;
                (void) putnextctl(wrq, M_STOPI);
                DEBUG1(("M_STOPI down\n"));
        }
}


/*
 * Line discipline input server processing.  Erase/kill and escape
 * ('\') processing, gathering into messages, upper/lower case input
 * mapping.
 */
static void
ldtermrsrv(queue_t *q)
{
        ldtermstd_state_t *tp;
        mblk_t *mp;

        tp = (ldtermstd_state_t *)q->q_ptr;

        if (tp->t_state & TS_RESCAN) {
                /*
                 * Canonicalization was turned on or off. Put the
                 * message being assembled back in the input queue,
                 * so that we rescan it.
                 */
                if (tp->t_message != NULL) {
                        DEBUG5(("RESCAN WAS SET; put back in q\n"));
                        if (tp->t_msglen != 0)
                                (void) putbq(q, tp->t_message);
                        else
                                freemsg(tp->t_message);
                        tp->t_message = NULL;
                        tp->t_endmsg = NULL;
                        tp->t_msglen = 0;
                }
                if (tp->t_state & TS_MEUC) {
                        ASSERT(tp->t_eucp_mp);
                        tp->t_eucp = tp->t_eucp_mp->b_rptr;
                        tp->t_codeset = 0;
                        tp->t_eucleft = 0;
                }
                tp->t_state &= ~TS_RESCAN;
        }

        while ((mp = getq(q)) != NULL) {
                if (!ldtermrmsg(q, mp))
                        break;
        }

        /*
         * Flow control: send start message if blocked and our queue
         * is below its low water mark.
         */
        if ((tp->t_modes.c_iflag & IXOFF) && (tp->t_state & TS_TBLOCK) &&
            !(tp->t_state & TS_IFBLOCK) && q->q_count <= TTXOLO) {
                tp->t_state &= ~TS_TBLOCK;
                (void) putctl(WR(q), M_STARTI);
        }
}

/*
 * This routine is called from both ldtermrput and ldtermrsrv to
 * do the actual work of dealing with mp. Return 1 on sucesss and
 * 0 on failure.
 */
static int
ldtermrmsg(queue_t *q, mblk_t *mp)
{
        unsigned char c;
        int dofree;
        int status = 1;
        size_t   ebsize;
        mblk_t *bp;
        mblk_t *bpt;
        ldtermstd_state_t *tp;

        bpt = NULL;

        tp = (ldtermstd_state_t *)q->q_ptr;

        if (mp->b_datap->db_type <= QPCTL && !bcanputnext(q, mp->b_band)) {
                /*
                 * Stream head is flow controlled. If echo is
                 * turned on, flush the read side or send a
                 * bell down the line to stop input and
                 * process the current message.
                 * Otherwise(putbq) the user will not see any
                 * response to to the typed input. Typically
                 * happens if there is no reader process.
                 * Note that you will loose the data in this
                 * case if the data is coming too fast. There
                 * is an assumption here that if ECHO is
                 * turned on its some user typing the data on
                 * a terminal and its not network.
                 */
                if (tp->t_modes.c_lflag & ECHO) {
                        if ((tp->t_modes.c_iflag & IMAXBEL) &&
                            (tp->t_modes.c_lflag & ICANON)) {
                                freemsg(mp);
                                if (canputnext(WR(q)))
                                        ldterm_outchar(CTRL('g'), WR(q), 4, tp);
                                status = 0;
                                goto echo;
                        } else {
                                (void) putctl1(q, M_FLUSH, FLUSHR);
                        }
                } else {
                        (void) putbq(q, mp);
                        status = 0;
                        goto out;       /* read side is blocked */
                }
        }
        switch (mp->b_datap->db_type) {

        default:
                putnext(q, mp); /* pass it on */
                goto out;

        case M_HANGUP:
                /*
                 * Flush everything we haven't looked at yet.
                 */
                flushq(q, FLUSHDATA);

                /*
                 * Flush everything we have looked at.
                 */
                freemsg(tp->t_message);
                tp->t_message = NULL;
                tp->t_endmsg = NULL;
                tp->t_msglen = 0;
                /*
                 * XXX  should we set read request
                 * tp->t_rd_request to NULL?
                 */
                tp->t_rocount = 0;      /* if it hasn't been typed */
                tp->t_rocol = 0;        /* it hasn't been echoed :-) */
                if (tp->t_state & TS_MEUC) {
                        ASSERT(tp->t_eucp_mp);
                        tp->t_eucp = tp->t_eucp_mp->b_rptr;
                }
                /*
                 * Restart output, since it's probably got
                 * nowhere to go anyway, and we're probably
                 * not going to see another ^Q for a while.
                 */
                if (tp->t_state & TS_TTSTOP) {
                        tp->t_state &= ~(TS_TTSTOP|TS_OFBLOCK);
                        (void) putnextctl(WR(q), M_START);
                }
                /*
                 * This message will travel up the read
                 * queue, flushing as it goes, get turned
                 * around at the stream head, and travel back
                 * down the write queue, flushing as it goes.
                 */
                (void) putnextctl1(q, M_FLUSH, FLUSHW);

                /*
                 * This message will travel down the write
                 * queue, flushing as it goes, get turned
                 * around at the driver, and travel back up
                 * the read queue, flushing as it goes.
                 */
                (void) putctl1(WR(q), M_FLUSH, FLUSHR);

                /*
                 * Now that that's done, we send a SIGCONT
                 * upstream, followed by the M_HANGUP.
                 */
                /* (void) putnextctl1(q, M_PCSIG, SIGCONT); */
                putnext(q, mp);
                goto out;

        case M_IOCACK:

                /*
                 * Augment whatever information the driver is
                 * returning  with the information we supply.
                 */
                ldterm_ioctl_reply(q, mp);
                goto out;

        case M_DATA:
                break;
        }

        /*
         * This is an M_DATA message.
         */

        /*
         * If somebody below us ("intelligent" communications
         * board, pseudo-tty controlled by an editor) is
         * doing canonicalization, don't scan it for special
         * characters.
         */
        if (tp->t_state & TS_NOCANON) {
                putnext(q, mp);
                goto out;
        }
        bp = mp;

        if ((bpt = newmsg(tp)) != NULL) {
                mblk_t *bcont;

                do {
                        ASSERT(bp->b_wptr >= bp->b_rptr);
                        ebsize = bp->b_wptr - bp->b_rptr;
                        if (ebsize > EBSIZE)
                                ebsize = EBSIZE;
                        bcont = bp->b_cont;
                        if (CANON_MODE) {
                                /*
                                 * By default, free the message once processed
                                 */
                                dofree = 1;

                                /*
                                 * update sysinfo canch
                                 * character. The value of
                                 * canch may vary as compared
                                 * to character tty
                                 * implementation.
                                 */
                                while (bp->b_rptr < bp->b_wptr) {
                                        c = *bp->b_rptr++;
                                        if ((bpt = ldterm_docanon(c,
                                            bpt, ebsize, q, tp, &dofree)) ==
                                            NULL)
                                                break;
                                }
                                /*
                                 * Release this block or put back on queue.
                                 */
                                if (dofree)
                                        freeb(bp);
                                else {
                                        (void) putbq(q, bp);
                                        break;
                                }
                        } else
                                bpt = ldterm_dononcanon(bp, bpt, ebsize, q, tp);
                        if (bpt == NULL) {
                                cmn_err(CE_WARN,
                                    "ldtermrsrv: out of blocks");
                                freemsg(bcont);
                                break;
                        }
                } while ((bp = bcont) != NULL);
        }
echo:
        /*
         * Send whatever we echoed downstream.
         */
        if (tp->t_echomp != NULL) {
                if (canputnext(WR(q)))
                        putnext(WR(q), tp->t_echomp);
                else
                        freemsg(tp->t_echomp);
                tp->t_echomp = NULL;
        }

out:
        return (status);
}


/*
 * Do canonical mode input; check whether this character is to be
 * treated as a special character - if so, check whether it's equal
 * to any of the special characters and handle it accordingly.
 * Otherwise, just add it to the current line.
 */
static mblk_t *
ldterm_docanon(uchar_t c, mblk_t *bpt, size_t ebsize, queue_t *q,
    ldtermstd_state_t *tp, int *dofreep)
{
        queue_t *wrq = WR(q);
        int i;

        /*
         * If the previous character was the "literal next"
         * character, treat this character as regular input.
         */
        if (tp->t_state & TS_SLNCH)
                goto escaped;

        /*
         * Setting a special character to NUL disables it, so if this
         * character is NUL, it should not be compared with any of
         * the special characters.
         */
        if (c == _POSIX_VDISABLE) {
                tp->t_state &= ~TS_QUOT;
                goto escaped;
        }
        /*
         * If this character is the literal next character, echo it
         * as '^', backspace over it, and record that fact.
         */
        if ((tp->t_modes.c_lflag & IEXTEN) && c == tp->t_modes.c_cc[VLNEXT]) {
                if (tp->t_modes.c_lflag & ECHO)
                        ldterm_outstring((unsigned char *)"^\b", 2, wrq,
                            ebsize, tp);
                tp->t_state |= TS_SLNCH;
                goto out;
        }
        /*
         * Check for the editing character. If the display width of
         * the last byte at the canonical buffer is not one and also
         * smaller than or equal to UNKNOWN_WIDTH, the character at
         * the end of the buffer is a multi-byte and/or multi-column
         * character.
         */
        if (c == tp->t_modes.c_cc[VERASE] || c == tp->t_modes.c_cc[VERASE2]) {
                if (tp->t_state & TS_QUOT) {
                        /*
                         * Get rid of the backslash, and put the
                         * erase character in its place.
                         */
                        ldterm_erase(wrq, ebsize, tp);
                        bpt = tp->t_endmsg;
                        goto escaped;
                } else {
                        if ((tp->t_state & TS_MEUC) && tp->t_msglen &&
                            (*(tp->t_eucp - 1) != 1 &&
                            *(tp->t_eucp - 1) <= UNKNOWN_WIDTH))
                                ldterm_csi_erase(wrq, ebsize, tp);
                        else
                                ldterm_erase(wrq, ebsize, tp);
                        bpt = tp->t_endmsg;
                        goto out;
                }
        }
        if ((tp->t_modes.c_lflag & IEXTEN) && c == tp->t_modes.c_cc[VWERASE]) {
                /*
                 * Do "ASCII word" or "multibyte character token/chunk" erase.
                 */
                if (tp->t_state & TS_MEUC)
                        ldterm_csi_werase(wrq, ebsize, tp);
                else
                        ldterm_werase(wrq, ebsize, tp);
                bpt = tp->t_endmsg;
                goto out;
        }
        if (c == tp->t_modes.c_cc[VKILL]) {
                if (tp->t_state & TS_QUOT) {
                        /*
                         * Get rid of the backslash, and put the kill
                         * character in its place.
                         */
                        ldterm_erase(wrq, ebsize, tp);
                        bpt = tp->t_endmsg;
                        goto escaped;
                } else {
                        ldterm_kill(wrq, ebsize, tp);
                        bpt = tp->t_endmsg;
                        goto out;
                }
        }
        if ((tp->t_modes.c_lflag & IEXTEN) && c == tp->t_modes.c_cc[VREPRINT]) {
                ldterm_reprint(wrq, ebsize, tp);
                goto out;
        }
        /*
         * If the preceding character was a backslash: if the current
         * character is an EOF, get rid of the backslash and treat
         * the EOF as data; if we're in XCASE mode and the current
         * character is part of a backslash-X escape sequence,
         * process it; otherwise, just treat the current character
         * normally.
         */
        if (tp->t_state & TS_QUOT) {
                tp->t_state &= ~TS_QUOT;
                if (c == tp->t_modes.c_cc[VEOF]) {
                        /*
                         * EOF character. Since it's escaped, get rid
                         * of the backslash and put the EOF character
                         * in its place.
                         */
                        ldterm_erase(wrq, ebsize, tp);
                        bpt = tp->t_endmsg;
                } else {
                        /*
                         * If we're in XCASE mode, and the current
                         * character is part of a backslash-X
                         * sequence, get rid of the backslash and
                         * replace the current character with what
                         * that sequence maps to.
                         */
                        if ((tp->t_modes.c_lflag & XCASE) &&
                            imaptab[c] != '\0') {
                                ldterm_erase(wrq, ebsize, tp);
                                bpt = tp->t_endmsg;
                                c = imaptab[c];
                        }
                }
        } else {
                /*
                 * Previous character wasn't backslash; check whether
                 * this was the EOF character.
                 */
                if (c == tp->t_modes.c_cc[VEOF]) {
                        /*
                         * EOF character. Don't echo it unless
                         * ECHOCTL is set, don't stuff it in the
                         * current line, but send the line up the
                         * stream.
                         */
                        if ((tp->t_modes.c_lflag & ECHOCTL) &&
                            (tp->t_modes.c_lflag & IEXTEN) &&
                            (tp->t_modes.c_lflag & ECHO)) {
                                i = ldterm_echo(c, wrq, ebsize, tp);
                                while (i > 0) {
                                        ldterm_outchar('\b', wrq, ebsize, tp);
                                        i--;
                                }
                        }
                        bpt->b_datap->db_type = M_DATA;
                        ldterm_msg_upstream(q, tp);
                        if (!canputnext(q)) {
                                bpt = NULL;
                                *dofreep = 0;
                        } else {
                                bpt = newmsg(tp);
                                *dofreep = 1;
                        }
                        goto out;
                }
        }

escaped:
        /*
         * First, make sure we can fit one WHOLE multi-byte char in the
         * buffer.  This is one place where we have overhead even if
         * not in multi-byte mode; the overhead is subtracting
         * tp->t_maxeuc from MAX_CANON before checking.
         *
         * Allows MAX_CANON bytes in the buffer before throwing awaying
         * the the overflow of characters.
         */
        if ((tp->t_msglen > ((_TTY_BUFSIZ + 1) - (int)tp->t_maxeuc)) &&
            !((tp->t_state & TS_MEUC) && tp->t_eucleft)) {

                /*
                 * Byte will cause line to overflow, or the next EUC
                 * won't fit: Ring the bell or discard all input, and
                 * don't save the byte away.
                 */
                if (tp->t_modes.c_iflag & IMAXBEL) {
                        if (canputnext(wrq))
                                ldterm_outchar(CTRL('g'), wrq, ebsize, tp);
                        goto out;
                } else {
                        /*
                         * MAX_CANON processing. free everything in
                         * the current line and start with the
                         * current character as the first character.
                         */
                        DEBUG7(("ldterm_docanon: MAX_CANON processing\n"));
                        freemsg(tp->t_message);
                        tp->t_message = NULL;
                        tp->t_endmsg = NULL;
                        tp->t_msglen = 0;
                        tp->t_rocount = 0;      /* if it hasn't been type */
                        tp->t_rocol = 0;        /* it hasn't been echoed :-) */
                        if (tp->t_state & TS_MEUC) {
                                ASSERT(tp->t_eucp_mp);
                                tp->t_eucp = tp->t_eucp_mp->b_rptr;
                        }
                        tp->t_state &= ~TS_SLNCH;
                        bpt = newmsg(tp);
                }
        }
        /*
         * Add the character to the current line.
         */
        if (bpt->b_wptr >= bpt->b_datap->db_lim) {
                /*
                 * No more room in this mblk; save this one away, and
                 * allocate a new one.
                 */
                bpt->b_datap->db_type = M_DATA;
                if ((bpt = allocb(IBSIZE, BPRI_MED)) == NULL)
                        goto out;

                /*
                 * Chain the new one to the end of the old one, and
                 * mark it as the last block in the current line.
                 */
                tp->t_endmsg->b_cont = bpt;
                tp->t_endmsg = bpt;
        }
        *bpt->b_wptr++ = c;
        tp->t_msglen++;         /* message length in BYTES */

        /*
         * In multi-byte mode, we have to keep track of where we are.
         * The first bytes of multi-byte chars get the full count for the
         * whole character.  We don't do any column calculations
         * here, but we need the information for when we do. We could
         * come across cases where we are getting garbage on the
         * line, but we're in multi-byte mode.  In that case, we may
         * see ASCII controls come in the middle of what should have been a
         * multi-byte character.  Call ldterm_eucwarn...eventually, a
         * warning message will be printed about it.
         */
        if (tp->t_state & TS_MEUC) {
                if (tp->t_eucleft) {    /* if in a multi-byte char already */
                        --tp->t_eucleft;
                        *tp->t_eucp++ = 0;      /* is a subsequent byte */
                        if (c < (uchar_t)0x20)
                                ldterm_eucwarn(tp);
                } else { /* is the first byte of a multi-byte, or is ASCII */
                        if (ISASCII(c)) {
                                *tp->t_eucp++ =
                                    tp->t_csmethods.ldterm_dispwidth(c,
                                    (void *)tp, tp->t_modes.c_lflag & ECHOCTL);
                                tp->t_codeset = 0;
                        } else {
                                *tp->t_eucp++ =
                                    tp->t_csmethods.ldterm_dispwidth(c,
                                    (void *)tp, tp->t_modes.c_lflag & ECHOCTL);
                                tp->t_eucleft =
                                    tp->t_csmethods.ldterm_memwidth(c,
                                    (void *)tp) - 1;
                                tp->t_codeset = ldterm_codeset(
                                    tp->t_csdata.codeset_type, c);
                        }
                }
        }
        /*
         * AT&T is concerned about the following but we aren't since
         * we have already shipped code that works.
         *
         * EOL2/XCASE should be conditioned with IEXTEN to be truly
         * POSIX conformant. This is going to cause problems for
         * pre-SVR4.0 programs that don't know about IEXTEN. Hence
         * EOL2/IEXTEN is not conditioned with IEXTEN.
         */
        if (!(tp->t_state & TS_SLNCH) &&
            (c == '\n' || (c != '\0' && (c == tp->t_modes.c_cc[VEOL] ||
            (c == tp->t_modes.c_cc[VEOL2]))))) {
                /*
                 * || ((tp->t_modes.c_lflag & IEXTEN) && c ==
                 * tp->t_modes.c_cc[VEOL2]))))) {
                 */
                /*
                 * It's a line-termination character; send the line
                 * up the stream.
                 */
                bpt->b_datap->db_type = M_DATA;
                ldterm_msg_upstream(q, tp);
                if (tp->t_state & TS_MEUC) {
                        ASSERT(tp->t_eucp_mp);
                        tp->t_eucp = tp->t_eucp_mp->b_rptr;
                }
                if ((bpt = newmsg(tp)) == NULL)
                        goto out;
        } else {
                /*
                 * Character was escaped with LNEXT.
                 */
                if (tp->t_rocount++ == 0)
                        tp->t_rocol = tp->t_col;
                tp->t_state &= ~(TS_SLNCH|TS_QUOT);
                /*
                 * If the current character is a single byte and single
                 * column character and it is the backslash character and
                 * IEXTEN, then the state will have TS_QUOT.
                 */
                if ((c == '\\') && (tp->t_modes.c_lflag & IEXTEN) &&
                    (!(tp->t_state & TS_MEUC) ||
                    ((tp->t_state & TS_MEUC) && (!tp->t_eucleft))))
                        tp->t_state |= TS_QUOT;
        }

        /*
         * Echo it.
         */
        if (tp->t_state & TS_ERASE) {
                tp->t_state &= ~TS_ERASE;
                if (tp->t_modes.c_lflag & ECHO)
                        ldterm_outchar('/', wrq, ebsize, tp);
        }
        if (tp->t_modes.c_lflag & ECHO)
                (void) ldterm_echo(c, wrq, ebsize, tp);
        else {
                /*
                 * Echo NL when ECHO turned off, if ECHONL flag is
                 * set.
                 */
                if (c == '\n' && (tp->t_modes.c_lflag & ECHONL))
                        ldterm_outchar(c, wrq, ebsize, tp);
        }

out:

        return (bpt);
}


static int
ldterm_unget(ldtermstd_state_t *tp)
{
        mblk_t *bpt;

        if ((bpt = tp->t_endmsg) == NULL)
                return (-1);    /* no buffers */
        if (bpt->b_rptr == bpt->b_wptr)
                return (-1);    /* zero-length record */
        tp->t_msglen--;         /* one fewer character */
        return (*--bpt->b_wptr);
}


static void
ldterm_trim(ldtermstd_state_t *tp)
{
        mblk_t *bpt;
        mblk_t *bp;

        ASSERT(tp->t_endmsg);
        bpt = tp->t_endmsg;

        if (bpt->b_rptr == bpt->b_wptr) {
                /*
                 * This mblk is now empty. Find the previous mblk;
                 * throw this one away, unless it's the first one.
                 */
                bp = tp->t_message;
                if (bp != bpt) {
                        while (bp->b_cont != bpt) {
                                ASSERT(bp->b_cont);
                                bp = bp->b_cont;
                        }
                        bp->b_cont = NULL;
                        freeb(bpt);
                        tp->t_endmsg = bp;      /* point to that mblk */
                }
        }
}


/*
 * Rubout one character from the current line being built for tp as
 * cleanly as possible.  q is the write queue for tp. Most of this
 * can't be applied to multi-byte processing.  We do our own thing
 * for that... See the "ldterm_eucerase" routine.  We never call
 * ldterm_rubout on a multi-byte or multi-column character.
 */
static void
ldterm_rubout(uchar_t c, queue_t *q, size_t ebsize, ldtermstd_state_t *tp)
{
        int tabcols;
        static unsigned char crtrubout[] = "\b \b\b \b";
#define RUBOUT1 &crtrubout[3]   /* rub out one position */
#define RUBOUT2 &crtrubout[0]   /* rub out two positions */

        if (!(tp->t_modes.c_lflag & ECHO))
                return;
        if (tp->t_modes.c_lflag & ECHOE) {
                /*
                 * "CRT rubout"; try erasing it from the screen.
                 */
                if (tp->t_rocount == 0) {
                        /*
                         * After the character being erased was
                         * echoed, some data was written to the
                         * terminal; we can't erase it cleanly, so we
                         * just reprint the whole line as if the user
                         * had typed the reprint character.
                         */
                        ldterm_reprint(q, ebsize, tp);
                        return;
                } else {
                        /*
                         * XXX what about escaped characters?
                         */
                        switch (typetab[c]) {

                        case ORDINARY:
                                if ((tp->t_modes.c_lflag & XCASE) &&
                                    omaptab[c])
                                        ldterm_outstring(RUBOUT1, 3, q, ebsize,
                                            tp);
                                ldterm_outstring(RUBOUT1, 3, q, ebsize, tp);
                                break;

                        case VTAB:
                        case BACKSPACE:
                        case CONTROL:
                        case RETURN:
                        case NEWLINE:
                                if ((tp->t_modes.c_lflag & ECHOCTL) &&
                                    (tp->t_modes.c_lflag & IEXTEN))
                                        ldterm_outstring(RUBOUT2, 6, q, ebsize,
                                            tp);
                                break;

                        case TAB:
                                if (tp->t_rocount < tp->t_msglen) {
                                        /*
                                         * While the tab being erased was
                                         * expanded, some data was written
                                         * to the terminal; we can't erase
                                         * it cleanly, so we just reprint
                                         * the whole line as if the user
                                         * had typed the reprint character.
                                         */
                                        ldterm_reprint(q, ebsize, tp);
                                        return;
                                }
                                tabcols = ldterm_tabcols(tp);
                                while (--tabcols >= 0)
                                        ldterm_outchar('\b', q, ebsize, tp);
                                break;
                        }
                }
        } else if ((tp->t_modes.c_lflag & ECHOPRT) &&
            (tp->t_modes.c_lflag & IEXTEN)) {
                /*
                 * "Printing rubout"; echo it between \ and /.
                 */
                if (!(tp->t_state & TS_ERASE)) {
                        ldterm_outchar('\\', q, ebsize, tp);
                        tp->t_state |= TS_ERASE;
                }
                (void) ldterm_echo(c, q, ebsize, tp);
        } else
                (void) ldterm_echo(tp->t_modes.c_cc[VERASE], q, ebsize, tp);
        tp->t_rocount--;        /* we "unechoed" this character */
}


/*
 * Find the number of characters the tab we just deleted took up by
 * zipping through the current line and recomputing the column
 * number.
 */
static int
ldterm_tabcols(ldtermstd_state_t *tp)
{
        int col;
        int i;
        mblk_t *bp;
        unsigned char *readp, *endp;
        unsigned char c;
        uchar_t *startp;
        char errflg;
        uchar_t u8[LDTERM_CS_MAX_BYTE_LENGTH];

        col = tp->t_rocol;
        /*
         * If we're doing multi-byte stuff, zip through the list of
         * widths to figure out where we are (we've kept track in most
         * cases).
         */
        if (tp->t_state & TS_MEUC) {
                ASSERT(tp->t_eucp_mp);
                bp = tp->t_message;
                startp = bp->b_datap->db_base;
                readp = tp->t_eucp_mp->b_rptr;
                endp = tp->t_eucp;
                errflg = '\0';
                while (readp < endp) {
                        switch (*readp) {
                        case EUC_TWIDTH:        /* it's a tab */
                                col |= 07;      /* bump up */
                                col++;
                                break;
                        case EUC_BSWIDTH:       /* backspace */
                                if (col)
                                        col--;
                                break;
                        case EUC_NLWIDTH:       /* newline */
                                if (tp->t_modes.c_oflag & ONLRET)
                                        col = 0;
                                break;
                        case EUC_CRWIDTH:       /* return */
                                col = 0;
                                break;
                        case UNKNOWN_WIDTH:     /* UTF-8 unknown width */
                                if (tp->t_csdata.codeset_type !=
                                    LDTERM_CS_TYPE_UTF8 || errflg) {
                                        *readp = 1;
                                        col++;
                                        break;
                                }
                                /*
                                 * Collect the current UTF-8 character bytes
                                 * from (possibly multiple) data buffers so
                                 * that we can figure out the display width.
                                 */
                                u8[0] = *startp;
                                for (i = 1; (i < LDTERM_CS_MAX_BYTE_LENGTH) &&
                                    (*(readp + i) == 0); i++) {
                                        startp++;
                                        if (startp >= bp->b_datap->db_lim) {
                                                if (bp->b_cont) {
                                                        bp = bp->b_cont;
                                                        startp =
                                                            bp->b_datap->
                                                            db_base;
                                                } else {
                                                        *readp = 1;
                                                        col++;
                                                        break;
                                                }
                                        }
                                        u8[i] = *startp;
                                }

                                /* tp->t_eucp_mp contains wrong info?? */
                                if (*readp == 1)
                                        break;

                                *readp = ldterm_utf8_width(u8, i);

                                col += *readp;
                                readp += (i - 1);
                                break;
                        default:
                                col += *readp;
                                break;
                        }
                        ++readp;
                        ++startp;
                        if (startp >= bp->b_datap->db_lim) {
                                if (bp->b_cont) {
                                        bp = bp->b_cont;
                                        startp = bp->b_datap->db_base;
                                } else {
                                        /*
                                         * This will happen only if
                                         * tp->t_eucp_mp contains wrong
                                         * display width info.
                                         */
                                        errflg = (char)1;
                                        startp--;
                                }
                        }
                }
                goto eucout;    /* finished! */
        }
        bp = tp->t_message;
        do {
                readp = bp->b_rptr;
                while (readp < bp->b_wptr) {
                        c = *readp++;
                        if ((tp->t_modes.c_lflag & ECHOCTL) &&
                            (tp->t_modes.c_lflag & IEXTEN)) {
                                if (c <= 037 && c != '\t' && c != '\n' ||
                                    c == 0177) {
                                        col += 2;
                                        continue;
                                }
                        }
                        /*
                         * Column position calculated here.
                         */
                        switch (typetab[c]) {

                                /*
                                 * Ordinary characters; advance by
                                 * one.
                                 */
                        case ORDINARY:
                                col++;
                                break;

                                /*
                                 * Non-printing characters; nothing
                                 * happens.
                                 */
                        case CONTROL:
                                break;

                                /* Backspace */
                        case BACKSPACE:
                                if (col != 0)
                                        col--;
                                break;

                                /* Newline; column depends on flags. */
                        case NEWLINE:
                                if (tp->t_modes.c_oflag & ONLRET)
                                        col = 0;
                                break;

                                /* tab */
                        case TAB:
                                col |= 07;
                                col++;
                                break;

                                /* vertical motion */
                        case VTAB:
                                break;

                                /* carriage return */
                        case RETURN:
                                col = 0;
                                break;
                        }
                }
        } while ((bp = bp->b_cont) != NULL);    /* next block, if any */

        /*
         * "col" is now the column number before the tab. "tp->t_col"
         * is still the column number after the tab, since we haven't
         * erased the tab yet. Thus "tp->t_col - col" is the number
         * of positions the tab moved.
         */
eucout:
        col = tp->t_col - col;
        if (col > 8)
                col = 8;        /* overflow screw */
        return (col);
}


/*
 * Erase a single character; We ONLY ONLY deal with ASCII or
 * single-column single-byte codeset character.  For multi-byte characters,
 * see "ldterm_csi_erase".
 */
static void
ldterm_erase(queue_t *q, size_t ebsize, ldtermstd_state_t *tp)
{
        int c;

        if ((c = ldterm_unget(tp)) != -1) {
                ldterm_rubout((unsigned char) c, q, ebsize, tp);
                ldterm_trim(tp);
                if (tp->t_state & TS_MEUC)
                        --tp->t_eucp;
        }
}


/*
 * Erase an entire word, single-byte EUC only please.
 */
static void
ldterm_werase(queue_t *q, size_t ebsize, ldtermstd_state_t *tp)
{
        int c;

        /*
         * Erase trailing white space, if any.
         */
        while ((c = ldterm_unget(tp)) == ' ' || c == '\t') {
                ldterm_rubout((unsigned char) c, q, ebsize, tp);
                ldterm_trim(tp);
        }

        /*
         * Erase non-white-space characters, if any.
         */
        while (c != -1 && c != ' ' && c != '\t') {
                ldterm_rubout((unsigned char) c, q, ebsize, tp);
                ldterm_trim(tp);
                c = ldterm_unget(tp);
        }
        if (c != -1) {
                /*
                 * We removed one too many characters; put the last
                 * one back.
                 */
                tp->t_endmsg->b_wptr++; /* put 'c' back */
                tp->t_msglen++;
        }
}


/*
 * ldterm_csi_werase - This is multi-byte equivalent of "word erase".
 * "Word erase" only makes sense in languages which space between words,
 * and it's presumptuous for us to attempt "word erase" when we don't
 * know anything about what's really going on.  It makes no sense for
 * many languages, as the criteria for defining words and tokens may
 * be completely different.
 *
 * In the TS_MEUC case (which is how we got here), we define a token to
 * be space- or tab-delimited, and erase one of them.  It helps to
 * have this for command lines, but it's otherwise useless for text
 * editing applications; you need more sophistication than we can
 * provide here.
 */
static void
ldterm_csi_werase(queue_t *q, size_t ebsize, ldtermstd_state_t *tp)
{
        int c, i;
        int len;
        uchar_t *ip;
        uchar_t u8[LDTERM_CS_MAX_BYTE_LENGTH];
        uchar_t u8_2[LDTERM_CS_MAX_BYTE_LENGTH];

        /*
         * ip points to the width of the actual bytes.  t_eucp points
         * one byte beyond, where the next thing will be inserted.
         */
        ip = tp->t_eucp - 1;
        /*
         * Erase trailing white space, if any.
         */
        while ((c = ldterm_unget(tp)) == ' ' || c == '\t') {
                tp->t_eucp--;
                ldterm_rubout((unsigned char) c, q, ebsize, tp);
                ldterm_trim(tp);
                --ip;
        }

        /*
         * Erase non-white-space characters, if any.  The outer loop
         * bops through each byte in the buffer. Multi-byte is removed, as
         * is ASCII, one byte at a time. The inner loop (for) is only
         * executed for first bytes of multi-byte.  The inner loop erases
         * the number of columns required for the multi-byte char.  We check
         * for ASCII first, and ldterm_rubout knows about ASCII.
         */
        len = 0;
        while (c != -1 && c != ' ' && c != '\t') {
                tp->t_eucp--;
                if (len < LDTERM_CS_MAX_BYTE_LENGTH) {
                        u8[len++] = (uchar_t)c;
                }
                /*
                 * Unlike EUC, except the leading byte, some bytes of
                 * a non-EUC multi-byte characters are in the ASCII code
                 * range, esp., 0x41 ~ 0x7a. Thus, we cannot simply check
                 * ISASCII().
                 * Checking the (*ip == 1 || *ip == 2 || *ip > UNKNOWN_WIDTH)
                 * will ensure that it is a single byte character (even though
                 * it is on display width not byte length) and can be further
                 * checked whether it is an ASCII character or not.
                 *
                 * When ECHOCTL is on and 'c' is an ASCII control character,
                 * *ip == 2 happens.
                 */
                if ((*ip == 1 || *ip == 2 || *ip > UNKNOWN_WIDTH) &&
                    ISASCII(c)) {
                        ldterm_rubout((unsigned char) c, q, ebsize, tp);
                        len = 0;
                } else if (*ip) {
                        if (*ip == UNKNOWN_WIDTH) {
                                if (tp->t_csdata.codeset_type ==
                                    LDTERM_CS_TYPE_UTF8) {
                                        for (i = 0; i < len; i++)
                                                u8_2[i] = u8[len - i - 1];
                                        *ip = ldterm_utf8_width(u8_2, len);
                                } else {
                                        *ip = 1;
                                }
                        }
                        /*
                         * erase for number of columns required for
                         * this multi-byte character. Hopefully, matches
                         * ldterm_dispwidth!
                         */
                        for (i = 0; i < (int)*ip; i++)
                                ldterm_rubout(' ', q, ebsize, tp);
                        len = 0;
                }
                ldterm_trim(tp);
                --ip;
                c = ldterm_unget(tp);
        }
        if (c != -1) {
                /*
                 * We removed one too many characters; put the last
                 * one back.
                 */
                tp->t_endmsg->b_wptr++; /* put 'c' back */
                tp->t_msglen++;
        }
}


/*
 * Kill an entire line, erasing each character one-by-one (if ECHOKE
 * is set) or just echoing the kill character, followed by a newline
 * (if ECHOK is set).  Multi-byte processing is included here.
 */

static void
ldterm_kill(queue_t *q, size_t ebsize, ldtermstd_state_t *tp)
{
        int c, i;
        int len;
        uchar_t *ip;
        uchar_t u8[LDTERM_CS_MAX_BYTE_LENGTH];
        uchar_t u8_2[LDTERM_CS_MAX_BYTE_LENGTH];

        if ((tp->t_modes.c_lflag & ECHOKE) &&
            (tp->t_modes.c_lflag & IEXTEN) &&
            (tp->t_msglen == tp->t_rocount)) {
                if (tp->t_state & TS_MEUC) {
                        ip = tp->t_eucp - 1;
                        /*
                         * This loop similar to "ldterm_csi_werase" above.
                         */
                        len = 0;
                        while ((c = ldterm_unget(tp)) != (-1)) {
                                tp->t_eucp--;
                                if (len < LDTERM_CS_MAX_BYTE_LENGTH) {
                                        u8[len++] = (uchar_t)c;
                                }
                                if ((*ip == 1 || *ip == 2 ||
                                    *ip > UNKNOWN_WIDTH) && ISASCII(c)) {
                                        ldterm_rubout((unsigned char) c, q,
                                            ebsize, tp);
                                        len = 0;
                                } else if (*ip) {
                                        if (*ip == UNKNOWN_WIDTH) {
                                                if (tp->t_csdata.codeset_type
                                                    == LDTERM_CS_TYPE_UTF8) {
                                                        for (i = 0; i < len;
                                                            i++)
                                                                u8_2[i] =
                                                                    u8[len-i-1];
                                                        *ip = ldterm_utf8_width(
                                                            u8_2, len);
                                                } else {
                                                        *ip = 1;
                                                }
                                        }
                                        for (i = 0; i < (int)*ip; i++)
                                                ldterm_rubout(' ', q, ebsize,
                                                    tp);
                                        len = 0;
                                }
                                ldterm_trim(tp);
                                --ip;
                        }
                } else {
                        while ((c = ldterm_unget(tp)) != -1) {
                                ldterm_rubout((unsigned char) c, q, ebsize, tp);
                                ldterm_trim(tp);
                        }
                }
        } else {
                (void) ldterm_echo(tp->t_modes.c_cc[VKILL], q, ebsize, tp);
                if (tp->t_modes.c_lflag & ECHOK)
                        (void) ldterm_echo('\n', q, ebsize, tp);
                while (ldterm_unget(tp) != -1) {
                        if (tp->t_state & TS_MEUC)
                                --tp->t_eucp;
                        ldterm_trim(tp);
                }
                tp->t_rocount = 0;
                if (tp->t_state & TS_MEUC)
                        tp->t_eucp = tp->t_eucp_mp->b_rptr;
        }
        tp->t_state &= ~(TS_QUOT|TS_ERASE|TS_SLNCH);
}


/*
 * Reprint the current input line. We assume c_cc has already been
 * checked. XXX just the current line, not the whole queue? What
 * about DEFECHO mode?
 */
static void
ldterm_reprint(queue_t *q, size_t ebsize, ldtermstd_state_t *tp)
{
        mblk_t *bp;
        unsigned char *readp;

        if (tp->t_modes.c_cc[VREPRINT] != (unsigned char) 0)
                (void) ldterm_echo(tp->t_modes.c_cc[VREPRINT], q, ebsize, tp);
        ldterm_outchar('\n', q, ebsize, tp);

        bp = tp->t_message;
        do {
                readp = bp->b_rptr;
                while (readp < bp->b_wptr)
                        (void) ldterm_echo(*readp++, q, ebsize, tp);
        } while ((bp = bp->b_cont) != NULL);    /* next block, if any */

        tp->t_state &= ~TS_ERASE;
        tp->t_rocount = tp->t_msglen;   /* we reechoed the entire line */
        tp->t_rocol = 0;
}


/*
 * Non canonical processing. Called with q locked from  ldtermrsrv.
 *
 */
static mblk_t *
ldterm_dononcanon(mblk_t *bp, mblk_t *bpt, size_t ebsize, queue_t *q,
    ldtermstd_state_t *tp)
{
        queue_t *wrq = WR(q);
        unsigned char *rptr;
        size_t bytes_in_bp;
        size_t roomleft;
        size_t bytes_to_move;
        int free_flag = 0;

        if (tp->t_modes.c_lflag & (ECHO|ECHONL|IEXTEN)) {
                unsigned char *wptr;
                unsigned char c;

                /*
                 * Either we must echo the characters, or we must
                 * echo NL, or we must check for VLNEXT. Process
                 * characters one at a time.
                 */
                rptr = bp->b_rptr;
                wptr = bp->b_rptr;
                while (rptr < bp->b_wptr) {
                        c = *rptr++;
                        /*
                         * If this character is the literal next
                         * character, echo it as '^' and backspace
                         * over it if echoing is enabled, indicate
                         * that the next character is to be treated
                         * literally, and remove the LNEXT from the
                         * input stream.
                         *
                         * If the *previous* character was the literal
                         * next character, don't check whether this
                         * is a literal next or not.
                         */
                        if ((tp->t_modes.c_lflag & IEXTEN) &&
                            !(tp->t_state & TS_SLNCH) &&
                            c != _POSIX_VDISABLE &&
                            c == tp->t_modes.c_cc[VLNEXT]) {
                                if (tp->t_modes.c_lflag & ECHO)
                                        ldterm_outstring(
                                            (unsigned char *)"^\b",
                                            2, wrq, ebsize, tp);
                                tp->t_state |= TS_SLNCH;
                                continue;       /* and ignore it */
                        }
                        /*
                         * Not a "literal next" character, so it
                         * should show up as input. If it was
                         * literal-nexted, turn off the literal-next
                         * flag.
                         */
                        tp->t_state &= ~TS_SLNCH;
                        *wptr++ = c;
                        if (tp->t_modes.c_lflag & ECHO) {
                                /*
                                 * Echo the character.
                                 */
                                (void) ldterm_echo(c, wrq, ebsize, tp);
                        } else if (tp->t_modes.c_lflag & ECHONL) {
                                /*
                                 * Echo NL, even though ECHO is not
                                 * set.
                                 */
                                if (c == '\n')
                                        ldterm_outchar('\n', wrq, 1, tp);
                        }
                }
                bp->b_wptr = wptr;
        } else {
                /*
                 * If there are any characters in this buffer, and
                 * the first of them was literal-nexted, turn off the
                 * literal-next flag.
                 */
                if (bp->b_rptr != bp->b_wptr)
                        tp->t_state &= ~TS_SLNCH;
        }

        ASSERT(bp->b_wptr >= bp->b_rptr);
        bytes_in_bp = bp->b_wptr - bp->b_rptr;
        rptr = bp->b_rptr;
        while (bytes_in_bp != 0) {
                roomleft = bpt->b_datap->db_lim - bpt->b_wptr;
                if (roomleft == 0) {
                        /*
                         * No more room in this mblk; save this one
                         * away, and allocate a new one.
                         */
                        if ((bpt = allocb(IBSIZE, BPRI_MED)) == NULL) {
                                freeb(bp);
                                DEBUG4(("ldterm_do_noncanon: allcob failed\n"));
                                return (bpt);
                        }
                        /*
                         * Chain the new one to the end of the old
                         * one, and mark it as the last block in the
                         * current lump.
                         */
                        tp->t_endmsg->b_cont = bpt;
                        tp->t_endmsg = bpt;
                        roomleft = IBSIZE;
                }
                DEBUG5(("roomleft=%d, bytes_in_bp=%d, tp->t_rd_request=%d\n",
                    roomleft, bytes_in_bp, tp->t_rd_request));
                /*
                 * if there is a read pending before this data got
                 * here move bytes according to the minimum of room
                 * left in this buffer, bytes in the message and byte
                 * count requested in the read. If there is no read
                 * pending, move the minimum of the first two
                 */
                if (tp->t_rd_request == 0)
                        bytes_to_move = MIN(roomleft, bytes_in_bp);
                else
                        bytes_to_move =
                            MIN(MIN(roomleft, bytes_in_bp), tp->t_rd_request);
                DEBUG5(("Bytes to move = %lu\n", bytes_to_move));
                if (bytes_to_move == 0)
                        break;
                bcopy(rptr, bpt->b_wptr, bytes_to_move);
                bpt->b_wptr += bytes_to_move;
                rptr += bytes_to_move;
                tp->t_msglen += bytes_to_move;
                bytes_in_bp -= bytes_to_move;
        }
        if (bytes_in_bp == 0) {
                DEBUG4(("bytes_in_bp is zero\n"));
                freeb(bp);
        } else
                free_flag = 1;  /* for debugging olny */

        DEBUG4(("ldterm_do_noncanon: VMIN = %d, VTIME = %d, msglen = %d, \
                tid = %d\n", V_MIN, V_TIME, tp->t_msglen, tp->t_vtid));
        /*
         * If there is a pending read request at the stream head we
         * need to do VMIN/VTIME processing. The four possible cases
         * are:
         *      MIN = 0, TIME > 0
         *      MIN = >, TIME = 0
         *      MIN > 0, TIME > 0
         *      MIN = 0, TIME = 0
         * If we can satisfy VMIN, send it up, and start a new
         * timer if necessary.  These four cases of VMIN/VTIME
         * are also dealt with in the write side put routine
         * when the M_READ is first seen.
         */

        DEBUG4(("Incoming data while M_READ'ing\n"));
        /*
         * Case 1:  Any data will satisfy the read, so send
         * it upstream.
         */
        if (V_MIN == 0 && V_TIME > 0) {
                if (tp->t_msglen)
                        vmin_satisfied(q, tp, 1);
                else {
                        /* EMPTY */
                        DEBUG4(("ldterm_do_noncanon called, but no data!\n"));
                }
                /*
                 * Case 2:  This should never time out, so
                 * until there's enough data, do nothing.
                 */
        } else if (V_MIN > 0 && V_TIME == 0) {
                if (tp->t_msglen >= (int)V_MIN)
                        vmin_satisfied(q, tp, 1);

                /*
                 * Case 3:  If MIN is satisfied, send it up.
                 * Also, remember to start a new timer *every*
                 * time we see something if MIN isn't
                 * safisfied
                 */
        } else if (V_MIN > 0 && V_TIME > 0) {
                if (tp->t_msglen >= (int)V_MIN)
                        vmin_satisfied(q, tp, 1);
                else
                        vmin_settimer(q);
                /*
                 * Case 4:  Not possible.  This request
                 * should always be satisfied from the write
                 * side, left here for debugging.
                 */
        } else {        /* V_MIN == 0 && V_TIME == 0 */
                        vmin_satisfied(q, tp, 1);
        }

        if (free_flag) {
                /* EMPTY */
                DEBUG4(("CAUTION message block not freed\n"));
        }
        return (newmsg(tp));
}


/*
 * Echo a typed byte to the terminal.  Returns the number of bytes
 * printed. Bytes of EUC characters drop through the ECHOCTL stuff
 * and are just output as themselves.
 */
static int
ldterm_echo(uchar_t c, queue_t *q, size_t ebsize, ldtermstd_state_t *tp)
{
        int i;

        if (!(tp->t_modes.c_lflag & ECHO))
                return (0);
        i = 0;

        /*
         * Echo control characters (c <= 37) only if the ECHOCTRL
         * flag is set as ^X.
         */

        if ((tp->t_modes.c_lflag & ECHOCTL) &&
            (tp->t_modes.c_lflag & IEXTEN)) {
                if (c <= 037 && c != '\t' && c != '\n') {
                        ldterm_outchar('^', q, ebsize, tp);
                        i++;
                        if (tp->t_modes.c_oflag & OLCUC)
                                c += 'a' - 1;
                        else
                                c += 'A' - 1;
                } else if (c == 0177) {
                        ldterm_outchar('^', q, ebsize, tp);
                        i++;
                        c = '?';
                }
                ldterm_outchar(c, q, ebsize, tp);
                return (i + 1);
                /* echo only special control character and the Bell */
        } else if ((c > 037 && c != 0177) || c == '\t' || c == '\n' ||
            c == '\r' || c == '\b' || c == 007 ||
            c == tp->t_modes.c_cc[VKILL]) {
                ldterm_outchar(c, q, ebsize, tp);
                return (i + 1);
        }
        return (i);
}


/*
 * Put a character on the output queue.
 */
static void
ldterm_outchar(uchar_t c, queue_t *q, size_t bsize, ldtermstd_state_t *tp)
{
        mblk_t *curbp;

        /*
         * Don't even look at the characters unless we have something
         * useful to do with them.
         */
        if ((tp->t_modes.c_oflag & OPOST) ||
            ((tp->t_modes.c_lflag & XCASE) &&
            (tp->t_modes.c_lflag & ICANON))) {
                mblk_t *mp;

                if ((mp = allocb(4, BPRI_HI)) == NULL) {
                        cmn_err(CE_WARN,
                            "ldterm: (ldterm_outchar) out of blocks");
                        return;
                }
                *mp->b_wptr++ = c;
                mp = ldterm_output_msg(q, mp, &tp->t_echomp, tp, bsize, 1);
                if (mp != NULL)
                        freemsg(mp);

        } else {
                if ((curbp = tp->t_echomp) != NULL) {
                        while (curbp->b_cont != NULL)
                                curbp = curbp->b_cont;
                        if (curbp->b_datap->db_lim == curbp->b_wptr) {
                                mblk_t *newbp;

                                if ((newbp = allocb(bsize, BPRI_HI)) == NULL) {
                                        cmn_err(CE_WARN,
                                            "ldterm_outchar: out of blocks");
                                        return;
                                }
                                curbp->b_cont = newbp;
                                curbp = newbp;
                        }
                } else {
                        if ((curbp = allocb(bsize, BPRI_HI)) == NULL) {
                                cmn_err(CE_WARN,
                                    "ldterm_outchar: out of blocks");
                                return;
                        }
                        tp->t_echomp = curbp;
                }
                *curbp->b_wptr++ = c;
        }
}


/*
 * Copy a string, of length len, to the output queue.
 */
static void
ldterm_outstring(uchar_t *cp, int len, queue_t *q, size_t bsize,
    ldtermstd_state_t *tp)
{
        while (len > 0) {
                ldterm_outchar(*cp++, q, bsize, tp);
                len--;
        }
}


static mblk_t *
newmsg(ldtermstd_state_t *tp)
{
        mblk_t *bp;

        /*
         * If no current message, allocate a block for it.
         */
        if ((bp = tp->t_endmsg) == NULL) {
                if ((bp = allocb(IBSIZE, BPRI_MED)) == NULL) {
                        cmn_err(CE_WARN,
                            "ldterm: (ldtermrsrv/newmsg) out of blocks");
                        return (bp);
                }
                tp->t_message = bp;
                tp->t_endmsg = bp;
        }
        return (bp);
}


static void
ldterm_msg_upstream(queue_t *q, ldtermstd_state_t *tp)
{
        ssize_t s;
        mblk_t *bp;

        bp = tp->t_message;
        s = msgdsize(bp);
        if (bp)
                putnext(q, tp->t_message);

        /*
         * update sysinfo canch character.
         */
        if (CANON_MODE)
                (void) drv_setparm(SYSCANC, s);
        tp->t_message = NULL;
        tp->t_endmsg = NULL;
        tp->t_msglen = 0;
        tp->t_rocount = 0;
        tp->t_rd_request = 0;
        if (tp->t_state & TS_MEUC) {
                ASSERT(tp->t_eucp_mp);
                tp->t_eucp = tp->t_eucp_mp->b_rptr;
                /* can't reset everything, as we may have other input */
        }
}


/*
 * Re-enable the write-side service procedure.  When an allocation
 * failure causes write-side processing to stall, we disable the
 * write side and arrange to call this function when allocation once
 * again becomes possible.
 */
static void
ldterm_wenable(void *addr)
{
        queue_t *q = addr;
        ldtermstd_state_t *tp;

        tp = (ldtermstd_state_t *)q->q_ptr;
        /*
         * The bufcall is no longer pending.
         */
        tp->t_wbufcid = 0;
        enableok(q);
        qenable(q);
}


/*
 * Line discipline output queue put procedure.  Attempts to process
 * the message directly and send it on downstream, queueing it only
 * if there's already something pending or if its downstream neighbor
 * is clogged.
 */
static void
ldtermwput(queue_t *q, mblk_t *mp)
{
        ldtermstd_state_t *tp;
        unsigned char type = mp->b_datap->db_type;

        tp = (ldtermstd_state_t *)q->q_ptr;

        /*
         * Always process priority messages, regardless of whether or
         * not our queue is nonempty.
         */
        if (type >= QPCTL) {
                switch (type) {

                case M_FLUSH:
                        /*
                         * Get rid of it, see comment in
                         * ldterm_dosig().
                         */
                        if ((tp->t_state & TS_FLUSHWAIT) &&
                            (*mp->b_rptr == FLUSHW)) {
                                tp->t_state &= ~TS_FLUSHWAIT;
                                freemsg(mp);
                                return;
                        }
                        /*
                         * This is coming from above, so we only
                         * handle the write queue here.  If FLUSHR is
                         * set, it will get turned around at the
                         * driver, and the read procedure will see it
                         * eventually.
                         */
                        if (*mp->b_rptr & FLUSHW) {
                                if ((tp->t_state & TS_ISPTSTTY) &&
                                    (*mp->b_rptr & FLUSHBAND))
                                        flushband(q, *(mp->b_rptr + 1),
                                            FLUSHDATA);
                                else
                                        flushq(q, FLUSHDATA);
                        }

                        putnext(q, mp);
                        /*
                         * If a timed read is interrupted, there is
                         * no way to cancel an existing M_READ
                         * request.  We kludge by allowing a flush to
                         * do so.
                         */
                        if (tp->t_state & TS_MREAD)
                                vmin_satisfied(RD(q), tp, 0);
                        break;

                case M_READ:
                        DEBUG1(("ldtermwmsg:M_READ RECEIVED\n"));
                        /*
                         * Stream head needs data to satisfy timed
                         * read. Has meaning only if ICANON flag is
                         * off indicating raw mode
                         */

                        DEBUG4((
                            "M_READ: RAW_MODE=%d, CNT=%d, VMIN=%d, VTIME=%d\n",
                            RAW_MODE, *(unsigned int *)mp->b_rptr, V_MIN,
                            V_TIME));

                        tp->t_rd_request = *(unsigned int *)mp->b_rptr;

                        if (RAW_MODE) {
                                if (newmsg(tp) != NULL) {
                                        /*
                                         * VMIN/VTIME processing...
                                         * The four possible cases are:
                                         *      MIN = 0, TIME > 0
                                         *      MIN = >, TIME = 0
                                         *      MIN > 0, TIME > 0
                                         *      MIN = 0, TIME = 0
                                         * These four conditions must be dealt
                                         * with on the read side as well in
                                         * ldterm_do_noncanon(). Set TS_MREAD
                                         * so that the read side will know
                                         * there is a pending read request
                                         * waiting at the stream head.  If we
                                         * can satisfy MIN do it here, rather
                                         * than on the read side.  If we can't,
                                         * start timers if necessary and let
                                         * the other side deal with it.
                                         *
                                         * We got another M_READ before the
                                         * pending one completed, cancel any
                                         * existing timeout.
                                         */
                                        if (tp->t_state & TS_MREAD) {
                                                vmin_satisfied(RD(q),
                                                    tp, 0);
                                        }
                                        tp->t_state |= TS_MREAD;
                                        /*
                                         * Case 1:  Any data will
                                         * satisfy read, otherwise
                                         * start timer
                                         */
                                        if (V_MIN == 0 && V_TIME > 0) {
                                                if (tp->t_msglen)
                                                        vmin_satisfied(RD(q),
                                                            tp, 1);
                                                else
                                                        vmin_settimer(RD(q));

                                                /*
                                                 * Case 2:  If we have enough
                                                 * data, send up now.
                                                 * Otherwise, the read side
                                                 * should wait forever until MIN
                                                 * is satisified.
                                                 */
                                        } else if (V_MIN > 0 && V_TIME == 0) {
                                                if (tp->t_msglen >= (int)V_MIN)
                                                        vmin_satisfied(RD(q),
                                                            tp, 1);

                                                /*
                                                 * Case 3:  If we can satisfy
                                                 * the read, send it up. If we
                                                 * don't have enough data, but
                                                 * there is at least one char,
                                                 * start a timer.  Otherwise,
                                                 * let the read side start
                                                 * the timer.
                                                 */
                                        } else if (V_MIN > 0 && V_TIME > 0) {
                                                if (tp->t_msglen >= (int)V_MIN)
                                                        vmin_satisfied(RD(q),
                                                            tp, 1);
                                                else if (tp->t_msglen)
                                                        vmin_settimer(RD(q));
                                                /*
                                                 * Case 4:  Read returns
                                                 * whatever data is available
                                                 * or zero if none.
                                                 */
                                        } else { /* V_MIN == 0 && V_TIME == 0 */
                                                vmin_satisfied(RD(q), tp, 1);
                                        }

                                } else  /* should do bufcall, really! */
                                        cmn_err(CE_WARN,
                                            "ldtermwmsg: out of blocks");
                        }
                        /*
                         * pass M_READ down
                         */
                        putnext(q, mp);
                        break;

                default:
                        /* Pass it through unmolested. */
                        putnext(q, mp);
                        break;
                }
                return;
        }
        /*
         * If our queue is nonempty or there's a traffic jam
         * downstream, this message must get in line.
         */
        if (q->q_first != NULL || !bcanputnext(q, mp->b_band)) {
                /*
                 * Exception: ioctls, except for those defined to
                 * take effect after output has drained, should be
                 * processed immediately.
                 */
                if (type == M_IOCTL) {
                        struct iocblk *iocp;

                        iocp = (struct iocblk *)mp->b_rptr;
                        switch (iocp->ioc_cmd) {

                                /*
                                 * Queue these.
                                 */
                        case TCSETSW:
                        case TCSETSF:
                        case TCSETAW:
                        case TCSETAF:
                        case TCSBRK:
                                break;

                                /*
                                 * Handle all others immediately.
                                 */
                        default:
                                (void) ldtermwmsg(q, mp);
                                return;
                        }
                }
                (void) putq(q, mp);
                return;
        }
        /*
         * We can take the fast path through, by simply calling
         * ldtermwmsg to dispose of mp.
         */
        (void) ldtermwmsg(q, mp);
}


/*
 * Line discipline output queue service procedure.
 */
static void
ldtermwsrv(queue_t *q)
{
        mblk_t *mp;

        /*
         * We expect this loop to iterate at most once, but must be
         * prepared for more in case our upstream neighbor isn't
         * paying strict attention to what canput tells it.
         */
        while ((mp = getq(q)) != NULL) {
                /*
                 * N.B.: ldtermwput has already handled high-priority
                 * messages, so we don't have to worry about them
                 * here. Hence, the putbq call is safe.
                 */
                if (!bcanputnext(q, mp->b_band)) {
                        (void) putbq(q, mp);
                        break;
                }
                if (!ldtermwmsg(q, mp)) {
                        /*
                         * Couldn't handle the whole thing; give up
                         * for now and wait to be rescheduled.
                         */
                        break;
                }
        }
}


/*
 * Process the write-side message denoted by mp.  If mp can't be
 * processed completely (due to allocation failures), put the
 * residual unprocessed part on the front of the write queue, disable
 * the queue, and schedule a qbufcall to arrange to complete its
 * processing later.
 *
 * Return 1 if the message was processed completely and 0 if not.
 *
 * This routine is called from both ldtermwput and ldtermwsrv to do the
 * actual work of dealing with mp.  ldtermwput will have already
 * dealt with high priority messages.
 */
static int
ldtermwmsg(queue_t *q, mblk_t *mp)
{
        ldtermstd_state_t *tp;
        mblk_t *residmp = NULL;
        size_t size;

        tp = (ldtermstd_state_t *)q->q_ptr;

        switch (mp->b_datap->db_type) {

        case M_IOCTL:
                ldterm_do_ioctl(q, mp);
                break;

        case M_DATA:
                {
                        mblk_t *omp = NULL;

                        if ((tp->t_modes.c_lflag & FLUSHO) &&
                            (tp->t_modes.c_lflag & IEXTEN)) {
                                freemsg(mp);    /* drop on floor */
                                break;
                        }
                        tp->t_rocount = 0;
                        /*
                         * Don't even look at the characters unless
                         * we have something useful to do with them.
                         */
                        if (((tp->t_modes.c_oflag & OPOST) ||
                            ((tp->t_modes.c_lflag & XCASE) &&
                            (tp->t_modes.c_lflag & ICANON))) &&
                            (msgdsize(mp) || !(tp->t_state & TS_ISPTSTTY))) {
                                unsigned char band = mp->b_band;
                                short flag = mp->b_flag;

                                residmp = ldterm_output_msg(q, mp, &omp,
                                    tp, OBSIZE, 0);
                                if ((mp = omp) == NULL)
                                        break;
                                mp->b_band |= band;
                                mp->b_flag |= flag;
                        }
                        /* Update sysinfo outch */
                        (void) drv_setparm(SYSOUTC, msgdsize(mp));
                        putnext(q, mp);
                        break;
                }

        default:
                putnext(q, mp); /* pass it through unmolested */
                break;
        }

        if (residmp == NULL)
                return (1);

        /*
         * An allocation failure occurred that prevented the message
         * from being completely processed.  First, disable our
         * queue, since it's pointless to attempt further processing
         * until the allocation situation is resolved.  (This must
         * precede the putbq call below, which would otherwise mark
         * the queue to be serviced.)
         */
        noenable(q);
        /*
         * Stuff the remnant on our write queue so that we can
         * complete it later when times become less lean.  Note that
         * this sets QFULL, so that our upstream neighbor will be
         * blocked by flow control.
         */
        (void) putbq(q, residmp);
        /*
         * Schedule a qbufcall to re-enable the queue.  The failure
         * won't have been for an allocation of more than OBSIZE
         * bytes, so don't ask for more than that from bufcall.
         */
        size = msgdsize(residmp);
        if (size > OBSIZE)
                size = OBSIZE;
        if (tp->t_wbufcid)
                qunbufcall(q, tp->t_wbufcid);
        tp->t_wbufcid = qbufcall(q, size, BPRI_MED, ldterm_wenable, q);

        return (0);
}


/*
 * Perform output processing on a message, accumulating the output
 * characters in a new message.
 */
static mblk_t *
ldterm_output_msg(queue_t *q, mblk_t *imp, mblk_t **omp,
    ldtermstd_state_t *tp, size_t bsize, int echoing)
{
        mblk_t *ibp;            /* block we're examining from input message */
        mblk_t *obp;            /* block we're filling in output message */
        mblk_t *cbp;            /* continuation block */
        mblk_t *oobp;           /* old value of obp; valid if NEW_BLOCK fails */
        mblk_t **contpp;        /* where to stuff ptr to newly-allocated blk */
        unsigned char c, n;
        int count, ctype;
        ssize_t bytes_left;

        mblk_t *bp;             /* block to stuff an M_DELAY message in */


        /*
         * Allocate a new block into which to put bytes. If we can't,
         * we just drop the rest of the message on the floor. If x is
         * non-zero, just fall thru; failure requires cleanup before
         * going out
         */

#define NEW_BLOCK(x) \
        { \
                oobp = obp; \
                if ((obp = allocb(bsize, BPRI_MED)) == NULL) { \
                        if (x == 0) \
                                goto outofbufs; \
                } else { \
                        *contpp = obp; \
                        contpp = &obp->b_cont; \
                        bytes_left = obp->b_datap->db_lim - obp->b_wptr; \
                } \
        }

        ibp = imp;

        /*
         * When we allocate the first block of a message, we should
         * stuff the pointer to it in "*omp".  All subsequent blocks
         * should have the pointer to them stuffed into the "b_cont"
         * field of the previous block.  "contpp" points to the place
         * where we should stuff the pointer.
         *
         * If we already have a message we're filling in, continue doing
         * so.
         */
        if ((obp = *omp) != NULL) {
                while (obp->b_cont != NULL)
                        obp = obp->b_cont;
                contpp = &obp->b_cont;
                bytes_left = obp->b_datap->db_lim - obp->b_wptr;
        } else {
                contpp = omp;
                bytes_left = 0;
        }

        do {
                while (ibp->b_rptr < ibp->b_wptr) {
                        /*
                         * Make sure there's room for one more
                         * character.  At most, we'll need "t_maxeuc"
                         * bytes.
                         */
                        if ((bytes_left < (int)tp->t_maxeuc)) {
                                /* LINTED */
                                NEW_BLOCK(0);
                        }
                        /*
                         * If doing XCASE processing (not very
                         * likely, in this day and age), look at each
                         * character individually.
                         */
                        if ((tp->t_modes.c_lflag & XCASE) &&
                            (tp->t_modes.c_lflag & ICANON)) {
                                c = *ibp->b_rptr++;

                                /*
                                 * We need to make sure that this is not
                                 * a following byte of a multibyte character
                                 * before applying an XCASE processing.
                                 *
                                 * tp->t_eucign will be 0 if and only
                                 * if the current 'c' is an ASCII character
                                 * and also a byte. Otherwise, it will have
                                 * the byte length of a multibyte character.
                                 */
                                if ((tp->t_state & TS_MEUC) &&
                                    tp->t_eucign == 0 && NOTASCII(c)) {
                                        tp->t_eucign =
                                            tp->t_csmethods.ldterm_memwidth(
                                            c, (void *)tp);
                                        tp->t_scratch_len = tp->t_eucign;

                                        if (tp->t_csdata.codeset_type !=
                                            LDTERM_CS_TYPE_UTF8) {
                                                tp->t_col +=
                                                    tp->
                                                    t_csmethods.
                                                    ldterm_dispwidth(c,
                                                    (void *)tp,
                                                    tp->t_modes.c_lflag &
                                                    ECHOCTL);
                                        }
                                }

                                /*
                                 * If character is mapped on output,
                                 * put out a backslash followed by
                                 * what it is mapped to.
                                 */
                                if (tp->t_eucign == 0 && omaptab[c] != 0 &&
                                    (!echoing || c != '\\')) {
                                        /* backslash is an ordinary character */
                                        tp->t_col++;
                                        *obp->b_wptr++ = '\\';
                                        bytes_left--;
                                        if (bytes_left == 0) {
                                                /* LINTED */
                                                NEW_BLOCK(1);
                                        }
                                        /*
                                         * Allocation failed, make
                                         * state consistent before
                                         * returning
                                         */
                                        if (obp == NULL) {
                                                ibp->b_rptr--;
                                                tp->t_col--;
                                                oobp->b_wptr--;
                                                goto outofbufs;
                                        }
                                        c = omaptab[c];
                                }
                                /*
                                 * If no other output processing is
                                 * required, push the character into
                                 * the block and get another.
                                 */
                                if (!(tp->t_modes.c_oflag & OPOST)) {
                                        if (tp->t_eucign > 0) {
                                                --tp->t_eucign;
                                        } else {
                                                tp->t_col++;
                                        }
                                        *obp->b_wptr++ = c;
                                        bytes_left--;
                                        continue;
                                }
                                /*
                                 * OPOST output flag is set. Map
                                 * lower case to upper case if OLCUC
                                 * flag is set and the 'c' is a lowercase
                                 * ASCII character.
                                 */
                                if (tp->t_eucign == 0 &&
                                    (tp->t_modes.c_oflag & OLCUC) &&
                                    c >= 'a' && c <= 'z')
                                        c -= 'a' - 'A';
                        } else {
                                /*
                                 * Copy all the ORDINARY characters,
                                 * possibly mapping upper case to
                                 * lower case.  We use "movtuc",
                                 * STOPPING when we can't move some
                                 * character. For multi-byte or
                                 * multi-column EUC, we can't depend
                                 * on the regular tables. Rather than
                                 * just drop through to the "big
                                 * switch" for all characters, it
                                 * _might_ be faster to let "movtuc"
                                 * move a bunch of characters.
                                 * Chances are, even in multi-byte
                                 * mode we'll have lots of ASCII
                                 * going through. We check the flag
                                 * once, and call movtuc with the
                                 * appropriate table as an argument.
                                 *
                                 * "movtuc will work for all codeset
                                 * types since it stops at the beginning
                                 * byte of a multibyte character.
                                 */
                                size_t bytes_to_move;
                                size_t bytes_moved;

                                ASSERT(ibp->b_wptr >= ibp->b_rptr);
                                bytes_to_move = ibp->b_wptr - ibp->b_rptr;
                                if (bytes_to_move > bytes_left)
                                        bytes_to_move = bytes_left;
                                if (tp->t_state & TS_MEUC) {
                                        bytes_moved = movtuc(bytes_to_move,
                                            ibp->b_rptr, obp->b_wptr,
                                            (tp->t_modes.c_oflag & OLCUC ?
                                            elcuctab : enotrantab));
                                } else {
                                        bytes_moved = movtuc(bytes_to_move,
                                            ibp->b_rptr, obp->b_wptr,
                                            (tp->t_modes.c_oflag & OLCUC ?
                                            lcuctab : notrantab));
                                }
                                /*
                                 * We're save to just do this column
                                 * calculation, because if TS_MEUC is
                                 * set, we used the proper EUC
                                 * tables, and won't have copied any
                                 * EUC bytes.
                                 */
                                tp->t_col += bytes_moved;
                                ibp->b_rptr += bytes_moved;
                                obp->b_wptr += bytes_moved;
                                bytes_left -= bytes_moved;
                                if (ibp->b_rptr >= ibp->b_wptr)
                                        continue;       /* moved all of block */
                                if (bytes_left == 0) {
                                        /* LINTED */
                                        NEW_BLOCK(0);
                                }
                                c = *ibp->b_rptr++;     /* stopper */
                        }

                        /*
                         * Again, we need to make sure that this is not
                         * a following byte of a multibyte character at
                         * here.
                         *
                         * 'tp->t_eucign' will be 0 iff the current 'c' is
                         * an ASCII character. Otherwise, it will have
                         * the byte length of a multibyte character.
                         * We also add the display width to 'tp->t_col' if
                         * the current codeset is not UTF-8 since this is
                         * a leading byte of a multibyte character.
                         * For UTF-8 codeset type, we add the display width
                         * when we get the last byte of a character.
                         */
                        if ((tp->t_state & TS_MEUC) && tp->t_eucign == 0 &&
                            NOTASCII(c)) {
                                tp->t_eucign = tp->t_csmethods.ldterm_memwidth(
                                    c, (void *)tp);
                                tp->t_scratch_len = tp->t_eucign;

                                if (tp->t_csdata.codeset_type !=
                                    LDTERM_CS_TYPE_UTF8) {
                                        tp->t_col +=
                                            tp->t_csmethods.ldterm_dispwidth(c,
                                            (void *)tp,
                                            tp->t_modes.c_lflag & ECHOCTL);
                                }
                        }

                        /*
                         * If the driver has requested, don't process
                         * output flags.  However, if we're in
                         * multi-byte mode, we HAVE to look at
                         * EVERYTHING going out to maintain column
                         * position properly. Therefore IF the driver
                         * says don't AND we're not doing multi-byte,
                         * then don't do it.  Otherwise, do it.
                         *
                         * NOTE:  Hardware USUALLY doesn't expand tabs
                         * properly for multi-byte situations anyway;
                         * that's a known problem with the 3B2
                         * "PORTS" board firmware, and any other
                         * hardware that doesn't ACTUALLY know about
                         * the current EUC mapping that WE are using
                         * at this very moment.  The problem is that
                         * memory width is INDEPENDENT of screen
                         * width - no relation - so WE know how wide
                         * the characters are, but an off-the-host
                         * board probably doesn't.  So, until we're
                         * SURE that the hardware below us can
                         * correctly expand tabs in a
                         * multi-byte/multi-column EUC situation, we
                         * do it ourselves.
                         */
                        /*
                         * Map <CR>to<NL> on output if OCRNL flag
                         * set. ONLCR processing is not done if OCRNL
                         * is set.
                         */
                        if (c == '\r' && (tp->t_modes.c_oflag & OCRNL)) {
                                c = '\n';
                                ctype = typetab[c];
                                goto jocrnl;
                        }

                        if (tp->t_csdata.codeset_type == LDTERM_CS_TYPE_EUC) {
                                ctype = typetab[c];
                        } else {
                                /*
                                 * In other codeset types, we safely assume
                                 * any byte of a multibyte character will have
                                 * 'ORDINARY' type. For ASCII characters, we
                                 * still use the typetab[].
                                 */
                                if (tp->t_eucign == 0)
                                        ctype = typetab[c];
                                else
                                        ctype = ORDINARY;
                        }

                        /*
                         * Map <NL> to <CR><NL> on output if ONLCR
                         * flag is set.
                         */
                        if (c == '\n' && (tp->t_modes.c_oflag & ONLCR)) {
                                if (!(tp->t_state & TS_TTCR)) {
                                        tp->t_state |= TS_TTCR;
                                        c = '\r';
                                        ctype = typetab['\r'];
                                        --ibp->b_rptr;
                                } else
                                        tp->t_state &= ~TS_TTCR;
                        }
                        /*
                         * Delay values and column position
                         * calculated here.  For EUC chars in
                         * multi-byte mode, we use "t_eucign" to help
                         * calculate columns.  When we see the first
                         * byte of an EUC, we set t_eucign to the
                         * number of bytes that will FOLLOW it, and
                         * we add the screen width of the WHOLE EUC
                         * character to the column position.  In
                         * particular, we can't count SS2 or SS3 as
                         * printing characters.  Remember, folks, the
                         * screen width and memory width are
                         * independent - no relation. We could have
                         * dropped through for ASCII, but we want to
                         * catch any bad characters (i.e., t_eucign
                         * set and an ASCII char received) and
                         * possibly report the garbage situation.
                         */
        jocrnl:

                        count = 0;
                        switch (ctype) {

                        case T_SS2:
                        case T_SS3:
                        case ORDINARY:
                                if (tp->t_state & TS_MEUC) {
                                        if (tp->t_eucign) {
                                                *obp->b_wptr++ = c;
                                                bytes_left--;

                                                tp->t_scratch[tp->t_scratch_len
                                                    - tp->t_eucign] = c;

                                                --tp->t_eucign;

                                                if (tp->t_csdata.codeset_type
                                                    == LDTERM_CS_TYPE_UTF8 &&
                                                    tp->t_eucign <= 0) {
                                                        tp->t_col +=
                                                            ldterm_utf8_width(
                                                            tp->t_scratch,
                                                            tp->t_scratch_len);
                                                }
                                        } else {
                                                if (tp->t_modes.c_oflag & OLCUC)
                                                        n = elcuctab[c];
                                                else
                                                        n = enotrantab[c];
                                                if (n)
                                                        c = n;
                                                tp->t_col++;
                                                *obp->b_wptr++ = c;
                                                bytes_left--;
                                        }
                                } else {        /* ho hum, ASCII mode... */
                                        if (tp->t_modes.c_oflag & OLCUC)
                                                n = lcuctab[c];
                                        else
                                                n = notrantab[c];
                                        if (n)
                                                c = n;
                                        tp->t_col++;
                                        *obp->b_wptr++ = c;
                                        bytes_left--;
                                }
                                break;

                                /*
                                 * If we're doing ECHOCTL, we've
                                 * already mapped the thing during
                                 * the process of canonising.  Don't
                                 * bother here, as it's not one that
                                 * we did.
                                 */
                        case CONTROL:
                                *obp->b_wptr++ = c;
                                bytes_left--;
                                break;

                                /*
                                 * This is probably a backspace
                                 * received, not one that we're
                                 * echoing.  Let it go as a
                                 * single-column backspace.
                                 */
                        case BACKSPACE:
                                if (tp->t_col)
                                        tp->t_col--;
                                if (tp->t_modes.c_oflag & BSDLY) {
                                        if (tp->t_modes.c_oflag & OFILL)
                                                count = 1;
                                }
                                *obp->b_wptr++ = c;
                                bytes_left--;
                                break;

                        case NEWLINE:
                                if (tp->t_modes.c_oflag & ONLRET)
                                        goto cr;
                                if ((tp->t_modes.c_oflag & NLDLY) == NL1)
                                        count = 2;
                                *obp->b_wptr++ = c;
                                bytes_left--;
                                break;

                        case TAB:
                                /*
                                 * Map '\t' to spaces if XTABS flag
                                 * is set.  The calculation of
                                 * "t_eucign" has probably insured
                                 * that column will be correct, as we
                                 * bumped t_col by the DISP width,
                                 * not the memory width.
                                 */
                                if ((tp->t_modes.c_oflag & TABDLY) == XTABS) {
                                        for (;;) {
                                                *obp->b_wptr++ = ' ';
                                                bytes_left--;
                                                tp->t_col++;
                                                if ((tp->t_col & 07) == 0)
                                                        break;  /* every 8th */
                                                /*
                                                 * If we don't have
                                                 * room to fully
                                                 * expand this tab in
                                                 * this block, back
                                                 * up to continue
                                                 * expanding it into
                                                 * the next block.
                                                 */
                                                if (obp->b_wptr >=
                                                    obp->b_datap->db_lim) {
                                                        ibp->b_rptr--;
                                                        break;
                                                }
                                        }
                                } else {
                                        tp->t_col |= 07;
                                        tp->t_col++;
                                        if (tp->t_modes.c_oflag & OFILL) {
                                                if (tp->t_modes.c_oflag &
                                                    TABDLY)
                                                        count = 2;
                                        } else {
                                                switch (tp->t_modes.c_oflag &
                                                    TABDLY) {
                                                case TAB2:
                                                        count = 6;
                                                        break;

                                                case TAB1:
                                                        count = 1 + (tp->t_col |
                                                            ~07);
                                                        if (count < 5)
                                                                count = 0;
                                                        break;
                                                }
                                        }
                                        *obp->b_wptr++ = c;
                                        bytes_left--;
                                }
                                break;

                        case VTAB:
                                if ((tp->t_modes.c_oflag & VTDLY) &&
                                    !(tp->t_modes.c_oflag & OFILL))
                                        count = 127;
                                *obp->b_wptr++ = c;
                                bytes_left--;
                                break;

                        case RETURN:
                                /*
                                 * Ignore <CR> in column 0 if ONOCR
                                 * flag set.
                                 */
                                if (tp->t_col == 0 &&
                                    (tp->t_modes.c_oflag & ONOCR))
                                        break;

                cr:
                                switch (tp->t_modes.c_oflag & CRDLY) {

                                case CR1:
                                        if (tp->t_modes.c_oflag & OFILL)
                                                count = 2;
                                        else
                                                count = tp->t_col % 2;
                                        break;

                                case CR2:
                                        if (tp->t_modes.c_oflag & OFILL)
                                                count = 4;
                                        else
                                                count = 6;
                                        break;

                                case CR3:
                                        if (tp->t_modes.c_oflag & OFILL)
                                                count = 0;
                                        else
                                                count = 9;
                                        break;
                                }
                                tp->t_col = 0;
                                *obp->b_wptr++ = c;
                                bytes_left--;
                                break;
                        }

                        if (count != 0) {
                                if (tp->t_modes.c_oflag & OFILL) {
                                        do {
                                                if (bytes_left == 0) {
                                                        /* LINTED */
                                                        NEW_BLOCK(0);
                                                }
                                                if (tp->t_modes.c_oflag & OFDEL)
                                                        *obp->b_wptr++ = CDEL;
                                                else
                                                        *obp->b_wptr++ = CNUL;
                                                bytes_left--;
                                        } while (--count != 0);
                                } else {
                                        if ((tp->t_modes.c_lflag & FLUSHO) &&
                                            (tp->t_modes.c_lflag & IEXTEN)) {
                                                /* drop on floor */
                                                freemsg(*omp);
                                        } else {
                                                /*
                                                 * Update sysinfo
                                                 * outch
                                                 */
                                                (void) drv_setparm(SYSOUTC,
                                                    msgdsize(*omp));
                                                putnext(q, *omp);
                                                /*
                                                 * Send M_DELAY
                                                 * downstream
                                                 */
                                                if ((bp =
                                                    allocb(1, BPRI_MED)) !=
                                                    NULL) {
                                                        bp->b_datap->db_type =
                                                            M_DELAY;
                                                        *bp->b_wptr++ =
                                                            (uchar_t)count;
                                                        putnext(q, bp);
                                                }
                                        }
                                        bytes_left = 0;
                                        /*
                                         * We have to start a new
                                         * message; the delay
                                         * introduces a break between
                                         * messages.
                                         */
                                        *omp = NULL;
                                        contpp = omp;
                                }
                        }
                }
                cbp = ibp->b_cont;
                freeb(ibp);
        } while ((ibp = cbp) != NULL);  /* next block, if any */

outofbufs:
        return (ibp);
#undef NEW_BLOCK
}


int
movtuc(size_t size, unsigned char *from, unsigned char *origto,
    unsigned char *table)
{
        unsigned char *to = origto;
        unsigned char c;

        while (size != 0 && (c = table[*from++]) != 0) {
                *to++ = c;
                size--;
        }
        return (to - origto);
}

static void
ldterm_flush_output(uchar_t c, queue_t *q, ldtermstd_state_t *tp)
{
        /* Already conditioned with IEXTEN during VDISCARD processing */
        if (tp->t_modes.c_lflag & FLUSHO)
                tp->t_modes.c_lflag &= ~FLUSHO;
        else {
                flushq(q, FLUSHDATA);   /* flush our write queue */
                /* flush ones below us */
                (void) putnextctl1(q, M_FLUSH, FLUSHW);
                if ((tp->t_echomp = allocb(EBSIZE, BPRI_HI)) != NULL) {
                        (void) ldterm_echo(c, q, 1, tp);
                        if (tp->t_msglen != 0)
                                ldterm_reprint(q, EBSIZE, tp);
                        if (tp->t_echomp != NULL) {
                                putnext(q, tp->t_echomp);
                                tp->t_echomp = NULL;
                        }
                }
                tp->t_modes.c_lflag |= FLUSHO;
        }
}


/*
 * Signal generated by the reader: M_PCSIG and M_FLUSH messages sent.
 */
static void
ldterm_dosig(queue_t *q, int sig, uchar_t c, int mtype, int mode)
{
        ldtermstd_state_t *tp = (ldtermstd_state_t *)q->q_ptr;
        int sndsig = 0;

        /*
         * c == \0 is brk case; need to flush on BRKINT even if
         * noflsh is set.
         */
        if ((!(tp->t_modes.c_lflag & NOFLSH)) || (c == '\0')) {
                if (mode) {
                        if (tp->t_state & TS_TTSTOP) {
                                sndsig = 1;
                                (void) putnextctl1(q, mtype, sig);
                        }
                        /*
                         * Flush read or write side.
                         * Restart the input or output.
                         */
                        if (mode & FLUSHR) {
                                flushq(q, FLUSHDATA);
                                (void) putnextctl1(WR(q), M_FLUSH, mode);
                                if (tp->t_state & (TS_TBLOCK|TS_IFBLOCK)) {
                                        (void) putnextctl(WR(q), M_STARTI);
                                        tp->t_state &= ~(TS_TBLOCK|TS_IFBLOCK);
                                }
                        }
                        if (mode & FLUSHW) {
                                flushq(WR(q), FLUSHDATA);
                                /*
                                 * XXX This is extremely gross.
                                 * Since we can't be sure our M_FLUSH
                                 * will have run its course by the
                                 * time we do the echo below, we set
                                 * state and toss it in the write put
                                 * routine to prevent flushing our
                                 * own data.  Note that downstream
                                 * modules on the write side will be
                                 * flushed by the M_FLUSH sent above.
                                 */
                                tp->t_state |= TS_FLUSHWAIT;
                                (void) putnextctl1(q, M_FLUSH, FLUSHW);
                                if (tp->t_state & TS_TTSTOP) {
                                        (void) putnextctl(WR(q), M_START);
                                        tp->t_state &= ~(TS_TTSTOP|TS_OFBLOCK);
                                }
                        }
                }
        }
        tp->t_state &= ~TS_QUOT;
        if (sndsig == 0)
                (void) putnextctl1(q, mtype, sig);

        if (c != '\0') {
                if ((tp->t_echomp = allocb(4, BPRI_HI)) != NULL) {
                        if (ldterm_echo(c, WR(q), 4, tp) > 0)
                                putnext(WR(q), tp->t_echomp);
                        else
                                freemsg(tp->t_echomp);
                        tp->t_echomp = NULL;
                }
        }
}


/*
 * Called when an M_IOCTL message is seen on the write queue; does
 * whatever we're supposed to do with it, and either replies
 * immediately or passes it to the next module down.
 */
static void
ldterm_do_ioctl(queue_t *q, mblk_t *mp)
{
        ldtermstd_state_t *tp;
        struct iocblk *iocp;
        struct eucioc *euciocp; /* needed for EUC ioctls */
        ldterm_cs_data_user_t *csdp;
        int i;
        int locale_name_sz;
        uchar_t maxbytelen;
        uchar_t maxscreenlen;
        int error;

        iocp = (struct iocblk *)mp->b_rptr;
        tp = (ldtermstd_state_t *)q->q_ptr;

        switch (iocp->ioc_cmd) {

        case TCSETS:
        case TCSETSW:
        case TCSETSF:
                {
                        /*
                         * Set current parameters and special
                         * characters.
                         */
                        struct termios *cb;
                        struct termios oldmodes;

                        error = miocpullup(mp, sizeof (struct termios));
                        if (error != 0) {
                                miocnak(q, mp, 0, error);
                                return;
                        }

                        cb = (struct termios *)mp->b_cont->b_rptr;

                        oldmodes = tp->t_amodes;
                        tp->t_amodes = *cb;
                        if ((tp->t_amodes.c_lflag & PENDIN) &&
                            (tp->t_modes.c_lflag & IEXTEN)) {
                                /*
                                 * Yuk.  The C shell file completion
                                 * code actually uses this "feature",
                                 * so we have to support it.
                                 */
                                if (tp->t_message != NULL) {
                                        tp->t_state |= TS_RESCAN;
                                        qenable(RD(q));
                                }
                                tp->t_amodes.c_lflag &= ~PENDIN;
                        }
                        bcopy(tp->t_amodes.c_cc, tp->t_modes.c_cc, NCCS);

                        /*
                         * ldterm_adjust_modes does not deal with
                         * cflags
                         */
                        tp->t_modes.c_cflag = tp->t_amodes.c_cflag;

                        ldterm_adjust_modes(tp);
                        if (chgstropts(&oldmodes, tp, RD(q)) == (-1)) {
                                miocnak(q, mp, 0, EAGAIN);
                                return;
                        }
                        /*
                         * The driver may want to know about the
                         * following iflags: IGNBRK, BRKINT, IGNPAR,
                         * PARMRK, INPCK, IXON, IXANY.
                         */
                        break;
                }

        case TCSETA:
        case TCSETAW:
        case TCSETAF:
                {
                        /*
                         * Old-style "ioctl" to set current
                         * parameters and special characters. Don't
                         * clear out the unset portions, leave them
                         * as they are.
                         */
                        struct termio *cb;
                        struct termios oldmodes;

                        error = miocpullup(mp, sizeof (struct termio));
                        if (error != 0) {
                                miocnak(q, mp, 0, error);
                                return;
                        }

                        cb = (struct termio *)mp->b_cont->b_rptr;

                        oldmodes = tp->t_amodes;
                        tp->t_amodes.c_iflag =
                            (tp->t_amodes.c_iflag & 0xffff0000 | cb->c_iflag);
                        tp->t_amodes.c_oflag =
                            (tp->t_amodes.c_oflag & 0xffff0000 | cb->c_oflag);
                        tp->t_amodes.c_cflag =
                            (tp->t_amodes.c_cflag & 0xffff0000 | cb->c_cflag);
                        tp->t_amodes.c_lflag =
                            (tp->t_amodes.c_lflag & 0xffff0000 | cb->c_lflag);

                        bcopy(cb->c_cc, tp->t_modes.c_cc, NCC);
                        /* TCGETS returns amodes, so update that too */
                        bcopy(cb->c_cc, tp->t_amodes.c_cc, NCC);

                        /* ldterm_adjust_modes does not deal with cflags */

                        tp->t_modes.c_cflag = tp->t_amodes.c_cflag;

                        ldterm_adjust_modes(tp);
                        if (chgstropts(&oldmodes, tp, RD(q)) == (-1)) {
                                miocnak(q, mp, 0, EAGAIN);
                                return;
                        }
                        /*
                         * The driver may want to know about the
                         * following iflags: IGNBRK, BRKINT, IGNPAR,
                         * PARMRK, INPCK, IXON, IXANY.
                         */
                        break;
                }

        case TCFLSH:
                /*
                 * Do the flush on the write queue immediately, and
                 * queue up any flush on the read queue for the
                 * service procedure to see.  Then turn it into the
                 * appropriate M_FLUSH message, so that the module
                 * below us doesn't have to know about TCFLSH.
                 */
                error = miocpullup(mp, sizeof (int));
                if (error != 0) {
                        miocnak(q, mp, 0, error);
                        return;
                }

                ASSERT(mp->b_datap != NULL);
                if (*(int *)mp->b_cont->b_rptr == 0) {
                        ASSERT(mp->b_datap != NULL);
                        (void) putnextctl1(q, M_FLUSH, FLUSHR);
                        (void) putctl1(RD(q), M_FLUSH, FLUSHR);
                } else if (*(int *)mp->b_cont->b_rptr == 1) {
                        flushq(q, FLUSHDATA);
                        ASSERT(mp->b_datap != NULL);
                        tp->t_state |= TS_FLUSHWAIT;
                        (void) putnextctl1(RD(q), M_FLUSH, FLUSHW);
                        (void) putnextctl1(q, M_FLUSH, FLUSHW);
                } else if (*(int *)mp->b_cont->b_rptr == 2) {
                        flushq(q, FLUSHDATA);
                        ASSERT(mp->b_datap != NULL);
                        (void) putnextctl1(q, M_FLUSH, FLUSHRW);
                        tp->t_state |= TS_FLUSHWAIT;
                        (void) putnextctl1(RD(q), M_FLUSH, FLUSHRW);
                } else {
                        miocnak(q, mp, 0, EINVAL);
                        return;
                }
                ASSERT(mp->b_datap != NULL);
                iocp->ioc_rval = 0;
                miocack(q, mp, 0, 0);
                return;

        case TCXONC:
                error = miocpullup(mp, sizeof (int));
                if (error != 0) {
                        miocnak(q, mp, 0, error);
                        return;
                }

                switch (*(int *)mp->b_cont->b_rptr) {
                case 0:
                        if (!(tp->t_state & TS_TTSTOP)) {
                                (void) putnextctl(q, M_STOP);
                                tp->t_state |= (TS_TTSTOP|TS_OFBLOCK);
                        }
                        break;

                case 1:
                        if (tp->t_state & TS_TTSTOP) {
                                (void) putnextctl(q, M_START);
                                tp->t_state &= ~(TS_TTSTOP|TS_OFBLOCK);
                        }
                        break;

                case 2:
                        (void) putnextctl(q, M_STOPI);
                        tp->t_state |= (TS_TBLOCK|TS_IFBLOCK);
                        break;

                case 3:
                        (void) putnextctl(q, M_STARTI);
                        tp->t_state &= ~(TS_TBLOCK|TS_IFBLOCK);
                        break;

                default:
                        miocnak(q, mp, 0, EINVAL);
                        return;
                }
                ASSERT(mp->b_datap != NULL);
                iocp->ioc_rval = 0;
                miocack(q, mp, 0, 0);
                return;
                /*
                 * TCSBRK is expected to be handled by the driver.
                 * The reason its left for the driver is that when
                 * the argument to TCSBRK is zero driver has to drain
                 * the data and sending a M_IOCACK from LDTERM before
                 * the driver drains the data is going to cause
                 * problems.
                 */

                /*
                 * The following are EUC related ioctls.  For
                 * EUC_WSET, we have to pass the information on, even
                 * though we ACK the call.  It's vital in the EUC
                 * environment that everybody downstream knows about
                 * the EUC codeset widths currently in use; we
                 * therefore pass down the information in an M_CTL
                 * message.  It will bottom out in the driver.
                 */
        case EUC_WSET:
                {

                        /* only needed for EUC_WSET */
                        struct iocblk *riocp;

                        mblk_t *dmp, *dmp_cont;

                        /*
                         * If the user didn't supply any information,
                         * NAK it.
                         */
                        error = miocpullup(mp, sizeof (struct eucioc));
                        if (error != 0) {
                                miocnak(q, mp, 0, error);
                                return;
                        }

                        euciocp = (struct eucioc *)mp->b_cont->b_rptr;
                        /*
                         * Check here for something reasonable.  If
                         * anything will take more than EUC_MAXW
                         * columns or more than EUC_MAXW bytes
                         * following SS2 or SS3, then just reject it
                         * out of hand. It's not impossible for us to
                         * do it, it just isn't reasonable.  So far,
                         * in the world, we've seen the absolute max
                         * columns to be 2 and the max number of
                         * bytes to be 3.  This allows room for some
                         * expansion of that, but it probably won't
                         * even be necessary. At the moment, we
                         * return a "range" error.  If you really
                         * need to, you can push EUC_MAXW up to over
                         * 200; it doesn't make sense, though, with
                         * only a CANBSIZ sized input limit (usually
                         * 256)!
                         */
                        for (i = 0; i < 4; i++) {
                                if ((euciocp->eucw[i] > EUC_MAXW) ||
                                    (euciocp->scrw[i] > EUC_MAXW)) {
                                        miocnak(q, mp, 0, ERANGE);
                                        return;
                                }
                        }
                        /*
                         * Otherwise, save the information in tp,
                         * force codeset 0 (ASCII) to be one byte,
                         * one column.
                         */
                        cp_eucwioc(euciocp, &tp->eucwioc, EUCIN);
                        tp->eucwioc.eucw[0] = tp->eucwioc.scrw[0] = 1;
                        /*
                         * Now, check out whether we're doing
                         * multibyte processing. if we are, we need
                         * to allocate a block to hold the parallel
                         * array. By convention, we've been passed
                         * what amounts to a CSWIDTH definition.  We
                         * actually NEED the number of bytes for
                         * Codesets 2 & 3.
                         */
                        tp->t_maxeuc = 0;       /* reset to say we're NOT */

                        tp->t_state &= ~TS_MEUC;
                        /*
                         * We'll set TS_MEUC if we're doing
                         * multi-column OR multi- byte OR both.  It
                         * makes things easier...  NOTE:  If we fail
                         * to get the buffer we need to hold display
                         * widths, then DON'T let the TS_MEUC bit get
                         * set!
                         */
                        for (i = 0; i < 4; i++) {
                                if (tp->eucwioc.eucw[i] > tp->t_maxeuc)
                                        tp->t_maxeuc = tp->eucwioc.eucw[i];
                                if (tp->eucwioc.scrw[i] > 1)
                                        tp->t_state |= TS_MEUC;
                        }
                        if ((tp->t_maxeuc > 1) || (tp->t_state & TS_MEUC)) {
                                if (!tp->t_eucp_mp) {
                                        if ((tp->t_eucp_mp = allocb(_TTY_BUFSIZ,
                                            BPRI_HI)) == NULL) {
                                                tp->t_maxeuc = 1;
                                                tp->t_state &= ~TS_MEUC;
                                                cmn_err(CE_WARN,
                                                    "Can't allocate eucp_mp");
                                                miocnak(q, mp, 0, ENOSR);
                                                return;
                                        }
                                        /*
                                         * here, if there's junk in
                                         * the canonical buffer, then
                                         * move the eucp pointer past
                                         * it, so we don't run off
                                         * the beginning.  This is a
                                         * total botch, but will
                                         * hopefully keep stuff from
                                         * getting too messed up
                                         * until the user flushes
                                         * this line!
                                         */
                                        if (tp->t_msglen) {
                                                tp->t_eucp =
                                                    tp->t_eucp_mp->b_rptr;
                                                for (i = tp->t_msglen; i; i--)
                                                        *tp->t_eucp++ = 1;
                                        } else {
                                                tp->t_eucp =
                                                    tp->t_eucp_mp->b_rptr;
                                        }
                                }
                                /* doing multi-byte handling */
                                tp->t_state |= TS_MEUC;

                        } else if (tp->t_eucp_mp) {
                                freemsg(tp->t_eucp_mp);
                                tp->t_eucp_mp = NULL;
                                tp->t_eucp = NULL;
                        }

                        /*
                         * Save the EUC width data we have at
                         * the t_csdata, set t_csdata.codeset_type to
                         * EUC one, and, switch the codeset methods at
                         * t_csmethods.
                         */
                        bzero(&tp->t_csdata.eucpc_data,
                            (sizeof (ldterm_eucpc_data_t) *
                            LDTERM_CS_MAX_CODESETS));
                        tp->t_csdata.eucpc_data[0].byte_length =
                            tp->eucwioc.eucw[1];
                        tp->t_csdata.eucpc_data[0].screen_width =
                            tp->eucwioc.scrw[1];
                        tp->t_csdata.eucpc_data[1].byte_length =
                            tp->eucwioc.eucw[2];
                        tp->t_csdata.eucpc_data[1].screen_width =
                            tp->eucwioc.scrw[2];
                        tp->t_csdata.eucpc_data[2].byte_length =
                            tp->eucwioc.eucw[3];
                        tp->t_csdata.eucpc_data[2].screen_width =
                            tp->eucwioc.scrw[3];
                        tp->t_csdata.version = LDTERM_DATA_VERSION;
                        tp->t_csdata.codeset_type = LDTERM_CS_TYPE_EUC;
                        /*
                         * We are not using the 'csinfo_num' anyway if the
                         * current codeset type is EUC. So, set it to
                         * the maximum possible.
                         */
                        tp->t_csdata.csinfo_num =
                            LDTERM_CS_TYPE_EUC_MAX_SUBCS;
                        if (tp->t_csdata.locale_name != NULL) {
                                kmem_free(tp->t_csdata.locale_name,
                                    strlen(tp->t_csdata.locale_name) + 1);
                                tp->t_csdata.locale_name = NULL;
                        }
                        tp->t_csmethods = cs_methods[LDTERM_CS_TYPE_EUC];

                        /*
                         * If we are able to allocate two blocks (the
                         * iocblk and the associated data), then pass
                         * it downstream, otherwise we'll need to NAK
                         * it, and drop whatever we WERE able to
                         * allocate.
                         */
                        if ((dmp = mkiocb(EUC_WSET)) == NULL) {
                                miocnak(q, mp, 0, ENOSR);
                                return;
                        }
                        if ((dmp_cont = allocb(EUCSIZE, BPRI_HI)) == NULL) {
                                freemsg(dmp);
                                miocnak(q, mp, 0, ENOSR);
                                return;
                        }

                        /*
                         * We got both buffers.  Copy out the EUC
                         * information (as we received it, not what
                         * we're using!) & pass it on.
                         */
                        bcopy(mp->b_cont->b_rptr, dmp_cont->b_rptr, EUCSIZE);
                        dmp_cont->b_wptr += EUCSIZE;
                        dmp->b_cont = dmp_cont;
                        dmp->b_datap->db_type = M_CTL;
                        dmp_cont->b_datap->db_type = M_DATA;
                        riocp = (struct iocblk *)dmp->b_rptr;
                        riocp->ioc_count = EUCSIZE;
                        putnext(q, dmp);

                        /*
                         * Now ACK the ioctl.
                         */
                        iocp->ioc_rval = 0;
                        miocack(q, mp, 0, 0);
                        return;
                }

        case EUC_WGET:
                error = miocpullup(mp, sizeof (struct eucioc));
                if (error != 0) {
                        miocnak(q, mp, 0, error);
                        return;
                }
                euciocp = (struct eucioc *)mp->b_cont->b_rptr;
                cp_eucwioc(&tp->eucwioc, euciocp, EUCOUT);
                iocp->ioc_rval = 0;
                miocack(q, mp, EUCSIZE, 0);
                return;

        case CSDATA_SET:
                error = miocpullup(mp, sizeof (ldterm_cs_data_user_t));
                if (error != 0) {
                        miocnak(q, mp, 0, error);
                        return;
                }

                csdp = (ldterm_cs_data_user_t *)mp->b_cont->b_rptr;

                /* Validate the codeset data provided. */
                if (csdp->version > LDTERM_DATA_VERSION ||
                    csdp->codeset_type < LDTERM_CS_TYPE_MIN ||
                    csdp->codeset_type > LDTERM_CS_TYPE_MAX) {
                        miocnak(q, mp, 0, ERANGE);
                        return;
                }

                if ((csdp->codeset_type == LDTERM_CS_TYPE_EUC &&
                    csdp->csinfo_num > LDTERM_CS_TYPE_EUC_MAX_SUBCS) ||
                    (csdp->codeset_type == LDTERM_CS_TYPE_PCCS &&
                    (csdp->csinfo_num < LDTERM_CS_TYPE_PCCS_MIN_SUBCS ||
                    csdp->csinfo_num > LDTERM_CS_TYPE_PCCS_MAX_SUBCS))) {
                        miocnak(q, mp, 0, ERANGE);
                        return;
                }

                maxbytelen = maxscreenlen = 0;
                if (csdp->codeset_type == LDTERM_CS_TYPE_EUC) {
                        for (i = 0; i < LDTERM_CS_TYPE_EUC_MAX_SUBCS; i++) {
                                if (csdp->eucpc_data[i].byte_length >
                                    EUC_MAXW ||
                                    csdp->eucpc_data[i].screen_width >
                                    EUC_MAXW) {
                                        miocnak(q, mp, 0, ERANGE);
                                        return;
                                }

                                if (csdp->eucpc_data[i].byte_length >
                                    maxbytelen)
                                        maxbytelen =
                                            csdp->eucpc_data[i].byte_length;
                                if (csdp->eucpc_data[i].screen_width >
                                    maxscreenlen)
                                        maxscreenlen =
                                            csdp->eucpc_data[i].screen_width;
                        }
                        /* POSIX/C locale? */
                        if (maxbytelen == 0 && maxscreenlen == 0)
                                maxbytelen = maxscreenlen = 1;
                } else if (csdp->codeset_type == LDTERM_CS_TYPE_PCCS) {
                        for (i = 0; i < LDTERM_CS_MAX_CODESETS; i++) {
                                if (csdp->eucpc_data[i].byte_length >
                                    LDTERM_CS_MAX_BYTE_LENGTH) {
                                        miocnak(q, mp, 0, ERANGE);
                                        return;
                                }
                                if (csdp->eucpc_data[i].byte_length >
                                    maxbytelen)
                                        maxbytelen =
                                            csdp->eucpc_data[i].byte_length;
                                if (csdp->eucpc_data[i].screen_width >
                                    maxscreenlen)
                                        maxscreenlen =
                                            csdp->eucpc_data[i].screen_width;
                        }
                } else if (csdp->codeset_type == LDTERM_CS_TYPE_UTF8) {
                        maxbytelen = 4;
                        maxscreenlen = 2;
                }

                locale_name_sz = 0;
                if (csdp->locale_name) {
                        for (i = 0; i < MAXNAMELEN; i++)
                                if (csdp->locale_name[i] == '\0')
                                        break;
                        /*
                         * We cannot have any string that is not NULL byte
                         * terminated.
                         */
                        if (i >= MAXNAMELEN) {
                                miocnak(q, mp, 0, ERANGE);
                                return;
                        }

                        locale_name_sz = i + 1;
                }

                /*
                 * As the final check, if there was invalid codeset_type
                 * given, or invalid byte_length was specified, it's an error.
                 */
                if (maxbytelen <= 0 || maxscreenlen <= 0) {
                        miocnak(q, mp, 0, ERANGE);
                        return;
                }

                /* Do the switching. */
                tp->t_maxeuc = maxbytelen;
                tp->t_state &= ~TS_MEUC;
                if (maxbytelen > 1 || maxscreenlen > 1) {
                        if (!tp->t_eucp_mp) {
                                if (!(tp->t_eucp_mp = allocb(_TTY_BUFSIZ,
                                    BPRI_HI))) {
                                        cmn_err(CE_WARN,
                                            "Can't allocate eucp_mp");
                                        miocnak(q, mp, 0, ENOSR);
                                        return;
                                }
                                /*
                                 * If there's junk in the canonical buffer,
                                 * then move the eucp pointer past it,
                                 * so we don't run off the beginning. This is
                                 * a total botch, but will hopefully keep
                                 * stuff from getting too messed up until
                                 * the user flushes this line!
                                 */
                                if (tp->t_msglen) {
                                        tp->t_eucp = tp->t_eucp_mp->b_rptr;
                                        for (i = tp->t_msglen; i; i--)
                                                *tp->t_eucp++ = 1;
                                } else {
                                        tp->t_eucp = tp->t_eucp_mp->b_rptr;
                                }
                        }

                        /*
                         * We only set TS_MEUC for a multibyte/multi-column
                         * codeset.
                         */
                        tp->t_state |= TS_MEUC;

                        tp->t_csdata.version = csdp->version;
                        tp->t_csdata.codeset_type = csdp->codeset_type;
                        tp->t_csdata.csinfo_num = csdp->csinfo_num;
                        bcopy(csdp->eucpc_data, tp->t_csdata.eucpc_data,
                            sizeof (ldterm_eucpc_data_t) *
                            LDTERM_CS_MAX_CODESETS);
                        tp->t_csmethods = cs_methods[csdp->codeset_type];

                        if (csdp->codeset_type == LDTERM_CS_TYPE_EUC) {
                                tp->eucwioc.eucw[0] = 1;
                                tp->eucwioc.scrw[0] = 1;

                                tp->eucwioc.eucw[1] =
                                    csdp->eucpc_data[0].byte_length;
                                tp->eucwioc.scrw[1] =
                                    csdp->eucpc_data[0].screen_width;

                                tp->eucwioc.eucw[2] =
                                    csdp->eucpc_data[1].byte_length + 1;
                                tp->eucwioc.scrw[2] =
                                    csdp->eucpc_data[1].screen_width;

                                tp->eucwioc.eucw[3] =
                                    csdp->eucpc_data[2].byte_length + 1;
                                tp->eucwioc.scrw[3] =
                                    csdp->eucpc_data[2].screen_width;
                        } else {
                                /*
                                 * We are not going to use this data
                                 * structure. So, clear it. Also, stty(1) will
                                 * make use of the cleared tp->eucwioc when
                                 * it prints out codeset width setting.
                                 */
                                bzero(&tp->eucwioc, EUCSIZE);
                        }
                } else {
                        /*
                         * If this codeset is a single byte codeset that
                         * requires only single display column for all
                         * characters, we switch to default EUC codeset
                         * methods and data setting.
                         */

                        if (tp->t_eucp_mp) {
                                freemsg(tp->t_eucp_mp);
                                tp->t_eucp_mp = NULL;
                                tp->t_eucp = NULL;
                        }

                        bzero(&tp->eucwioc, EUCSIZE);
                        tp->eucwioc.eucw[0] = 1;
                        tp->eucwioc.scrw[0] = 1;
                        if (tp->t_csdata.locale_name != NULL) {
                                kmem_free(tp->t_csdata.locale_name,
                                    strlen(tp->t_csdata.locale_name) + 1);
                        }
                        tp->t_csdata = default_cs_data;
                        tp->t_csmethods = cs_methods[LDTERM_CS_TYPE_EUC];
                }

                /* Copy over locale_name. */
                if (tp->t_csdata.locale_name != NULL) {
                        kmem_free(tp->t_csdata.locale_name,
                            strlen(tp->t_csdata.locale_name) + 1);
                }
                if (locale_name_sz > 1) {
                        tp->t_csdata.locale_name = kmem_alloc(
                            locale_name_sz, KM_SLEEP);
                        (void) strcpy(tp->t_csdata.locale_name,
                            csdp->locale_name);
                } else {
                        tp->t_csdata.locale_name = NULL;
                }

                /*
                 * Now ACK the ioctl.
                 */
                iocp->ioc_rval = 0;
                miocack(q, mp, 0, 0);
                return;

        case CSDATA_GET:
                error = miocpullup(mp, sizeof (ldterm_cs_data_user_t));
                if (error != 0) {
                        miocnak(q, mp, 0, error);
                        return;
                }

                csdp = (ldterm_cs_data_user_t *)mp->b_cont->b_rptr;

                csdp->version = tp->t_csdata.version;
                csdp->codeset_type = tp->t_csdata.codeset_type;
                csdp->csinfo_num = tp->t_csdata.csinfo_num;
                csdp->pad = tp->t_csdata.pad;
                if (tp->t_csdata.locale_name) {
                        (void) strcpy(csdp->locale_name,
                            tp->t_csdata.locale_name);
                } else {
                        csdp->locale_name[0] = '\0';
                }
                bcopy(tp->t_csdata.eucpc_data, csdp->eucpc_data,
                    sizeof (ldterm_eucpc_data_t) * LDTERM_CS_MAX_CODESETS);
                /*
                 * If the codeset is an EUC codeset and if it has 2nd and/or
                 * 3rd supplementary codesets, we subtract one from each
                 * byte length of the supplementary codesets. This is
                 * because single shift characters, SS2 and SS3, are not
                 * included in the byte lengths in the user space.
                 */
                if (csdp->codeset_type == LDTERM_CS_TYPE_EUC) {
                        if (csdp->eucpc_data[1].byte_length)
                                csdp->eucpc_data[1].byte_length -= 1;
                        if (csdp->eucpc_data[2].byte_length)
                                csdp->eucpc_data[2].byte_length -= 1;
                }
                iocp->ioc_rval = 0;
                miocack(q, mp, sizeof (ldterm_cs_data_user_t), 0);
                return;

        case PTSSTTY:
                tp->t_state |= TS_ISPTSTTY;
                break;

        }

        putnext(q, mp);
}


/*
 * Send an M_SETOPTS message upstream if any mode changes are being
 * made that affect the stream head options. returns -1 if allocb
 * fails, else returns 0.
 */
static int
chgstropts(struct termios *oldmodep, ldtermstd_state_t *tp, queue_t *q)
{
        struct stroptions optbuf;
        mblk_t *bp;

        optbuf.so_flags = 0;
        if ((oldmodep->c_lflag ^ tp->t_modes.c_lflag) & ICANON) {
                /*
                 * Canonical mode is changing state; switch the
                 * stream head to message-nondiscard or byte-stream
                 * mode.  Also, rerun the service procedure so it can
                 * change its mind about whether to send data
                 * upstream or not.
                 */
                if (tp->t_modes.c_lflag & ICANON) {
                        DEBUG4(("CHANGING TO CANON MODE\n"));
                        optbuf.so_flags = SO_READOPT|SO_MREADOFF;
                        optbuf.so_readopt = RMSGN;

                        /*
                         * if there is a pending raw mode timeout,
                         * clear it
                         */

                        /*
                         * Clear VMIN/VTIME state, cancel timers
                         */
                        vmin_satisfied(q, tp, 0);
                } else {
                        DEBUG4(("CHANGING TO RAW MODE\n"));
                        optbuf.so_flags = SO_READOPT|SO_MREADON;
                        optbuf.so_readopt = RNORM;
                }
        }
        if ((oldmodep->c_lflag ^ tp->t_modes.c_lflag) & TOSTOP) {
                /*
                 * The "stop on background write" bit is changing.
                 */
                if (tp->t_modes.c_lflag & TOSTOP)
                        optbuf.so_flags |= SO_TOSTOP;
                else
                        optbuf.so_flags |= SO_TONSTOP;
        }
        if (optbuf.so_flags != 0) {
                if ((bp = allocb(sizeof (struct stroptions), BPRI_HI)) ==
                    NULL) {
                        return (-1);
                }
                *(struct stroptions *)bp->b_wptr = optbuf;
                bp->b_wptr += sizeof (struct stroptions);
                bp->b_datap->db_type = M_SETOPTS;
                DEBUG4(("M_SETOPTS to stream head\n"));
                putnext(q, bp);
        }
        return (0);
}


/*
 * Called when an M_IOCACK message is seen on the read queue;
 * modifies the data being returned, if necessary, and passes the
 * reply up.
 */
static void
ldterm_ioctl_reply(queue_t *q, mblk_t *mp)
{
        ldtermstd_state_t *tp;
        struct iocblk *iocp;

        iocp = (struct iocblk *)mp->b_rptr;
        tp = (ldtermstd_state_t *)q->q_ptr;

        switch (iocp->ioc_cmd) {

        case TCGETS:
                {
                        /*
                         * Get current parameters and return them to
                         * stream head eventually.
                         */
                        struct termios *cb =
                            (struct termios *)mp->b_cont->b_rptr;

                        /*
                         * cflag has cflags sent upstream by the
                         * driver
                         */
                        tcflag_t cflag = cb->c_cflag;

                        *cb = tp->t_amodes;
                        if (cflag != 0)
                                cb->c_cflag = cflag;    /* set by driver */
                        break;
                }

        case TCGETA:
                {
                        /*
                         * Old-style "ioctl" to get current
                         * parameters and return them to stream head
                         * eventually.
                         */
                        struct termio *cb =
                            (struct termio *)mp->b_cont->b_rptr;

                        cb->c_iflag = tp->t_amodes.c_iflag; /* all except the */
                        cb->c_oflag = tp->t_amodes.c_oflag; /* cb->c_cflag */
                        cb->c_lflag = tp->t_amodes.c_lflag;

                        if (cb->c_cflag == 0)   /* not set by driver */
                                cb->c_cflag = tp->t_amodes.c_cflag;

                        cb->c_line = 0;
                        bcopy(tp->t_amodes.c_cc, cb->c_cc, NCC);
                        break;
                }
        }
        putnext(q, mp);
}


/*
 * A VMIN/VTIME request has been satisfied. Cancel outstanding timers
 * if they exist, clear TS_MREAD state, and send upstream. If a NULL
 * queue ptr is passed, just reset VMIN/VTIME state.
 */
static void
vmin_satisfied(queue_t *q, ldtermstd_state_t *tp, int sendup)
{
        ASSERT(q);
        if (tp->t_vtid != 0)  {
                DEBUG4(("vmin_satisfied: cancelled timer id %d\n", tp->t_vtid));
                (void) quntimeout(q, tp->t_vtid);
                tp->t_vtid = 0;
        }
        if (sendup) {
                if (tp->t_msglen == 0 && V_MIN) {
                        /* EMPTY */
                        DEBUG4(("vmin_satisfied: data swiped, msglen = 0\n"));
                } else {
                        if ((!q->q_first) ||
                            (q->q_first->b_datap->db_type != M_DATA) ||
                            (tp->t_msglen >= LDCHUNK)) {
                                ldterm_msg_upstream(q, tp);
                                DEBUG4(("vmin_satisfied: delivering data\n"));
                        }
                }
        } else {
                /* EMPTY */
                DEBUG4(("vmin_satisfied: VMIN/TIME state reset\n"));
        }
        tp->t_state &= ~TS_MREAD;
}

static void
vmin_settimer(queue_t *q)
{
        ldtermstd_state_t *tp;

        tp = (ldtermstd_state_t *)q->q_ptr;

        /*
         * Don't start any time bombs.
         */
        if (tp->t_state & TS_CLOSE)
                return;

        /*
         * tp->t_vtid should NOT be set here unless VMIN > 0 and
         * VTIME > 0.
         */
        if (tp->t_vtid) {
                if (V_MIN && V_TIME) {
                        /* EMPTY */
                        DEBUG4(("vmin_settimer: timer restarted, old tid=%d\n",
                            tp->t_vtid));
                } else {
                        /* EMPTY */
                        DEBUG4(("vmin_settimer: tid = %d was still active!\n",
                            tp->t_vtid));
                }
                (void) quntimeout(q, tp->t_vtid);
                tp->t_vtid = 0;
        }
        tp->t_vtid = qtimeout(q, vmin_timed_out, q,
            (clock_t)(V_TIME * (hz / 10)));
        DEBUG4(("vmin_settimer: timer started, tid = %d\n", tp->t_vtid));
}


/*
 * BRRrrringgg!! VTIME was satisfied instead of VMIN
 */
static void
vmin_timed_out(void *arg)
{
        queue_t *q = arg;
        ldtermstd_state_t *tp;

        tp = (ldtermstd_state_t *)q->q_ptr;

        DEBUG4(("vmin_timed_out: tid = %d\n", tp->t_vtid));
        /* don't call untimeout now that we are in the timeout */
        tp->t_vtid = 0;
        vmin_satisfied(q, tp, 1);
}


/*
 * Routine to adjust termios flags to be processed by the line
 * discipline. Driver below sends a termios structure, with the flags
 * the driver intends to process. XOR'ing the driver sent termios
 * structure with current termios structure with the default values
 * (or set by ioctls from userland), we come up with a new termios
 * structrue, the flags of which will be used by the line discipline
 * in processing input and output. On return from this routine, we
 * will have the following fields set in tp structure -->
 * tp->t_modes: modes the line discipline will process tp->t_amodes:
 * modes the user process thinks the line discipline is processing
 */

static void
ldterm_adjust_modes(ldtermstd_state_t *tp)
{

        DEBUG6(("original iflag = %o\n", tp->t_modes.c_iflag));
        tp->t_modes.c_iflag = tp->t_amodes.c_iflag & ~(tp->t_dmodes.c_iflag);
        tp->t_modes.c_oflag = tp->t_amodes.c_oflag & ~(tp->t_dmodes.c_oflag);
        tp->t_modes.c_lflag = tp->t_amodes.c_lflag & ~(tp->t_dmodes.c_lflag);
        DEBUG6(("driver iflag = %o\n", tp->t_dmodes.c_iflag));
        DEBUG6(("apparent iflag = %o\n", tp->t_amodes.c_iflag));
        DEBUG6(("effective iflag = %o\n", tp->t_modes.c_iflag));

        /* No negotiation of clfags  c_cc array special characters */
        /*
         * Copy from amodes to modes already done by TCSETA/TCSETS
         * code
         */
}


/*
 * Erase one multi-byte character.  If TS_MEUC is set AND this
 * is a multi-byte character, then this should be called instead of
 * ldterm_erase.  "ldterm_erase" will handle ASCII nicely, thank you.
 *
 * We'd better be pointing to the last byte.  If we aren't, it will get
 * screwed up.
 */
static void
ldterm_csi_erase(queue_t *q, size_t ebsize, ldtermstd_state_t *tp)
{
        int i, ung;
        uchar_t *p, *bottom;
        uchar_t u8[LDTERM_CS_MAX_BYTE_LENGTH];
        int c;
        int j;
        int len;

        if (tp->t_eucleft) {
                /* XXX Ick.  We're in the middle of an EUC! */
                /* What to do now? */
                ldterm_eucwarn(tp);
                return;         /* ignore it??? */
        }
        bottom = tp->t_eucp_mp->b_rptr;
        p = tp->t_eucp - 1;     /* previous byte */
        if (p < bottom)
                return;
        ung = 1;                /* number of bytes to un-get from buffer */
        /*
         * go through the buffer until we find the beginning of the
         * multi-byte char.
         */
        while ((*p == 0) && (p > bottom)) {
                p--;
                ++ung;
        }

        /*
         * Now, "ung" is the number of bytes to unget from the buffer
         * and "*p" is the disp width of it. Fool "ldterm_rubout"
         * into thinking we're rubbing out ASCII characters.  Do that
         * for the display width of the character.
         *
         * Also we accumulate bytes of the character so that if the character
         * is a UTF-8 character, we will get the display width of the UTF-8
         * character.
         */
        if (ung >= LDTERM_CS_MAX_BYTE_LENGTH) {
                j = len = LDTERM_CS_MAX_BYTE_LENGTH;
        } else {
                j = len = ung;
        }
        for (i = 0; i < ung; i++) {     /* remove from buf */
                if ((c = ldterm_unget(tp)) != (-1)) {
                        ldterm_trim(tp);
                        if (j > 0)
                                u8[--j] = (uchar_t)c;
                }
        }
        if (*p == UNKNOWN_WIDTH) {
                if (tp->t_csdata.codeset_type == LDTERM_CS_TYPE_UTF8) {
                        *p = ldterm_utf8_width(u8, len);
                } else {
                        *p = 1;
                }
        }
        for (i = 0; i < (int)*p; i++)   /* remove from screen */
                ldterm_rubout(' ', q, ebsize, tp);
        /*
         * Adjust the parallel array pointer.  Zero out the contents
         * of parallel array for this position, just to make sure...
         */
        tp->t_eucp = p;
        *p = 0;
}


/*
 * This is kind of a safety valve.  Whenever we see a bad sequence
 * come up, we call eucwarn.  It just tallies the junk until a
 * threshold is reached.  Then it prints ONE message on the console
 * and not any more. Hopefully, we can catch garbage; maybe it will
 * be useful to somebody.
 */
static void
ldterm_eucwarn(ldtermstd_state_t *tp)
{
        ++tp->t_eucwarn;
#ifdef DEBUG
        if ((tp->t_eucwarn > EUC_WARNCNT) && !(tp->t_state & TS_WARNED)) {
                cmn_err(CE_WARN,
                    "ldterm: tty at addr %p in multi-byte mode --",
                    (void *)tp);
                cmn_err(CE_WARN,
                    "Over %d bad EUC characters this session", EUC_WARNCNT);
                tp->t_state |= TS_WARNED;
        }
#endif
}


/*
 * Copy an "eucioc_t" structure.  We use the structure with
 * incremented values for Codesets 2 & 3.  The specification in
 * eucioctl is that the sames values as the CSWIDTH definition at
 * user level are passed to us. When we copy it "in" to ourselves, we
 * do the increment.  That allows us to avoid treating each character
 * set separately for "t_eucleft" purposes. When we copy it "out" to
 * return it to the user, we decrement the values so the user gets
 * what it expects, and it matches CSWIDTH in the environment (if
 * things are consistent!).
 */
static void
cp_eucwioc(eucioc_t *from, eucioc_t *to, int dir)
{
        bcopy(from, to, EUCSIZE);
        if (dir == EUCOUT) {    /* copying out to user */
                if (to->eucw[2])
                        --to->eucw[2];
                if (to->eucw[3])
                        --to->eucw[3];
        } else {                /* copying in */
                if (to->eucw[2])
                        ++to->eucw[2];
                if (to->eucw[3])
                        ++to->eucw[3];
        }
}


/*
 * Take the first byte of a multi-byte, or an ASCII char.  Return its
 * codeset. If it's NOT the first byte of an EUC, then the return
 * value may be garbage, as it's probably not SS2 or SS3, and
 * therefore must be in codeset 1.  Another bizarre catch here is the
 * fact that we don't do anything about the "C1" control codes.  In
 * real life, we should; but nobody's come up with a good way of
 * treating them.
 */

static int
ldterm_codeset(uchar_t codeset_type, uchar_t c)
{

        if (ISASCII(c))
                return (0);

        if (codeset_type != LDTERM_CS_TYPE_EUC)
                return (1);

        switch (c) {
        case SS2:
                return (2);
        case SS3:
                return (3);
        default:
                return (1);
        }
}

/* The following two functions are additional EUC codeset specific methods. */
/*
 * ldterm_dispwidth - Take the first byte of an EUC (or ASCII) and
 * return the display width.  Since this is intended mostly for
 * multi-byte handling, it returns EUC_TWIDTH for tabs so they can be
 * differentiated from EUC characters (assumption: EUC require fewer
 * than 255 columns).  Also, if it's a backspace and !flag, it
 * returns EUC_BSWIDTH.  Newline & CR also depend on flag.  This
 * routine SHOULD be cleaner than this, but we have the situation
 * where we may or may not be counting control characters as having a
 * column width. Therefore, the computation of ASCII is pretty messy.
 * The caller will be storing the value, and then switching on it
 * when it's used.  We really should define the EUC_TWIDTH and other
 * constants in a header so that the routine could be used in other
 * modules in the kernel.
 */
static int
__ldterm_dispwidth_euc(uchar_t c, void *p, int mode)
{
        ldtermstd_state_t *tp = (ldtermstd_state_t *)p;

        if (ISASCII(c)) {
                if (c <= '\037') {
                        switch (c) {
                        case '\t':
                                return (EUC_TWIDTH);
                        case '\b':
                                return (mode ? 2 : EUC_BSWIDTH);
                        case '\n':
                                return (EUC_NLWIDTH);
                        case '\r':
                                return (mode ? 2 : EUC_CRWIDTH);
                        default:
                                return (mode ? 2 : 0);
                        }
                }
                return (1);
        }
        switch (c) {
        case SS2:
                return (tp->eucwioc.scrw[2]);
        case SS3:
                return (tp->eucwioc.scrw[3]);
        default:
                return (tp->eucwioc.scrw[1]);
        }
}

/*
 * ldterm_memwidth_euc - Take the first byte of an EUC (or an ASCII char)
 * and return its memory width.  The routine could have been
 * implemented to use only the codeset number, but that would require
 * the caller to have that value available.  Perhaps the user doesn't
 * want to make the extra call or keep the value of codeset around.
 * Therefore, we use the actual character with which they're
 * concerned.  This should never be called with anything but the
 * first byte of an EUC, otherwise it will return a garbage value.
 */
static int
__ldterm_memwidth_euc(uchar_t c, void *p)
{
        ldtermstd_state_t *tp = (ldtermstd_state_t *)p;

        if (ISASCII(c))
                return (1);
        switch (c) {
        case SS2:
                return (tp->eucwioc.eucw[2]);
        case SS3:
                return (tp->eucwioc.eucw[3]);
        default:
                return (tp->eucwioc.eucw[1]);
        }
}


/* The following two functions are PCCS codeset specific methods. */
static int
__ldterm_dispwidth_pccs(uchar_t c, void *p, int mode)
{
        ldtermstd_state_t *tp = (ldtermstd_state_t *)p;
        int i;

        if (ISASCII(c)) {
                if (c <= '\037') {
                        switch (c) {
                        case '\t':
                                return (EUC_TWIDTH);
                        case '\b':
                                return (mode ? 2 : EUC_BSWIDTH);
                        case '\n':
                                return (EUC_NLWIDTH);
                        case '\r':
                                return (mode ? 2 : EUC_CRWIDTH);
                        default:
                                return (mode ? 2 : 0);
                        }
                }
                return (1);
        }

        for (i = 0; i < tp->t_csdata.csinfo_num; i++) {
                if (c >= tp->t_csdata.eucpc_data[i].msb_start &&
                    c <= tp->t_csdata.eucpc_data[i].msb_end)
                        return (tp->t_csdata.eucpc_data[i].screen_width);
        }

        /*
         * If this leading byte is not in the range list, either provided
         * locale data is not sufficient or we encountered an invalid
         * character. We return 1 in this case as a fallback value.
         */
        return (1);
}

static int
__ldterm_memwidth_pccs(uchar_t c, void *p)
{
        ldtermstd_state_t *tp = (ldtermstd_state_t *)p;
        int i;

        for (i = 0; i < tp->t_csdata.csinfo_num; i++) {
                if (c >= tp->t_csdata.eucpc_data[i].msb_start &&
                    c <= tp->t_csdata.eucpc_data[i].msb_end)
                        return (tp->t_csdata.eucpc_data[i].byte_length);
        }

        /*
         * If this leading byte is not in the range list, either provided
         * locale data is not sufficient or we encountered an invalid
         * character. We return 1 in this case as a fallback value.
         */
        return (1);
}


/* The following two functions are UTF-8 codeset specific methods. */
static int
__ldterm_dispwidth_utf8(uchar_t c, void *p, int mode)
{
        ldtermstd_state_t *tp = (ldtermstd_state_t *)p;

        if (ISASCII(c)) {
                if (c <= '\037') {
                        switch (c) {
                        case '\t':
                                return (EUC_TWIDTH);
                        case '\b':
                                return (mode ? 2 : EUC_BSWIDTH);
                        case '\n':
                                return (EUC_NLWIDTH);
                        case '\r':
                                return (mode ? 2 : EUC_CRWIDTH);
                        default:
                                return (mode ? 2 : 0);
                        }
                }
                return (1);
        }

        /* This is to silence the lint. */
        if (tp->t_csdata.codeset_type != LDTERM_CS_TYPE_UTF8)
                return (1);

        /*
         * If it is a valid leading byte of a UTF-8 character, we set
         * the width as 'UNKNOWN_WIDTH' for now. We need to have all
         * the bytes to figure out the display width.
         */
        if (c >= (uchar_t)0xc0 && c <= (uchar_t)0xfd)
                return (UNKNOWN_WIDTH);

        /*
         * If it is an invalid leading byte, we just do our best by
         * giving the display width of 1.
         */
        return (1);
}


static int
__ldterm_memwidth_utf8(uchar_t c, void *p)
{
        ldtermstd_state_t *tp = (ldtermstd_state_t *)p;
        int len;

        /*
         * If the codeset type doesn't match, we treat them as
         * an illegal character and return 1.
         */
        if (tp->t_csdata.codeset_type != LDTERM_CS_TYPE_UTF8)
                return (1);

        len = u8_number_of_bytes[c];

        /*
         * If this is a start of an illegal character, we treat
         * such as an 1 byte character and screen out.
         */
        return ((len <= 0) ? 1 : len);
}

static uchar_t
ldterm_utf8_width(uchar_t *u8, int length)
{
        int i;
        int j;
        uint_t intcode = 0;

        if (length == 0)
                return ('\0');

        j = u8_number_of_bytes[u8[0]] - 1;

        /*
         * If the UTF-8 character is out of UTF-16 code range, or,
         * if it is either an ASCII character or an invalid leading byte for
         * a UTF-8 character, return 1.
         */
        if (length > 4 || j <= 0)
                return ('\1');

        intcode = u8[0] & u8_masks_tbl[j];
        for (i = 1; j > 0; j--, i++) {
                /*
                 * The following additional checking is needed to conform to
                 * the "UTF-8 Corrigendum" introduced at the Unicode 3.1 and
                 * then updated one more time at the Unicode 3.2.
                 */
                if (i == 1) {
                        if (u8[i] < u8_valid_min_2nd_byte[u8[0]] ||
                            u8[i] > u8_valid_max_2nd_byte[u8[0]])
                                return ('\1');
                } else if (u8[i] < (uchar_t)LDTERM_CS_TYPE_UTF8_MIN_BYTE ||
                    u8[i] > (uchar_t)LDTERM_CS_TYPE_UTF8_MAX_BYTE)
                        return ('\1');

                /*
                 * All subsequent bytes of UTF-8 character has the following
                 * binary encoding:
                 *
                 * 10xx xxxx
                 *
                 * hence left shift six bits to make space and then get
                 * six bits from the new byte.
                 */
                intcode = (intcode << LDTERM_CS_TYPE_UTF8_SHIFT_BITS) |
                    (u8[i] & LDTERM_CS_TYPE_UTF8_BIT_MASK);
        }

        i = 0;
        if (intcode <= LDTERM_CS_TYPE_UTF8_MAX_P00) {
                /* Basic Multilingual Plane. */
                i = intcode / 4;
                j = intcode % 4;
                switch (j) {
                case 0:
                        i = ldterm_ucode[0][i].u0;
                        break;
                case 1:
                        i = ldterm_ucode[0][i].u1;
                        break;
                case 2:
                        i = ldterm_ucode[0][i].u2;
                        break;
                case 3:
                        i = ldterm_ucode[0][i].u3;
                        break;
                }
        } else if (intcode <= LDTERM_CS_TYPE_UTF8_MAX_P01) {
                /* Secondary Multilingual Plane. */
                intcode = intcode & (uint_t)0xffff;
                i = intcode / 4;
                j = intcode % 4;
                switch (j) {
                case 0:
                        i = ldterm_ucode[1][i].u0;
                        break;
                case 1:
                        i = ldterm_ucode[1][i].u1;
                        break;
                case 2:
                        i = ldterm_ucode[1][i].u2;
                        break;
                case 3:
                        i = ldterm_ucode[1][i].u3;
                        break;
                }
        } else if ((intcode >= LDTERM_CS_TYPE_UTF8_MIN_CJKEXTB &&
            intcode <= LDTERM_CS_TYPE_UTF8_MAX_CJKEXTB) ||
            (intcode >= LDTERM_CS_TYPE_UTF8_MIN_CJKCOMP &&
            intcode <= LDTERM_CS_TYPE_UTF8_MAX_CJKCOMP) ||
            (intcode >= LDTERM_CS_TYPE_UTF8_MIN_P15 &&
            intcode <= LDTERM_CS_TYPE_UTF8_MAX_P15) ||
            (intcode >= LDTERM_CS_TYPE_UTF8_MIN_P16 &&
            intcode <= LDTERM_CS_TYPE_UTF8_MAX_P16)) {
                /*
                 * Supplementary Plane for CJK Ideographs and
                 * Private Use Planes.
                 */
                return ('\2');
        } else if ((intcode >= LDTERM_CS_TYPE_UTF8_MIN_P14 &&
            intcode <= LDTERM_CS_TYPE_UTF8_MAX_P14) ||
            (intcode >= LDTERM_CS_TYPE_UTF8_MIN_VARSEL &&
            intcode <= LDTERM_CS_TYPE_UTF8_MAX_VARSEL)) {
                /*
                 * Some Special Purpose Plane characters:
                 * These are like control characters and not printable.
                 */
                return ('\0');
        }

        /*
         * We return the display width of 1 for all character code points
         * that we didn't catch from the above logic and also for combining
         * and conjoining characters with width value of zero.
         *
         * In particular, the reason why we are returning 1 for combining
         * and conjoining characters is because the GUI-based terminal
         * emulators are not yet capable of properly handling such characters
         * and in most of the cases, they just treat such characters as if
         * they occupy a display cell. If the terminal emulators are capable of
         * handling the characters correctly, then, this logic of returning
         * 1 should be revisited and changed. See CR 6660526 for more
         * details on this.
         */
        return ((i == 0) ? '\1' : (uchar_t)i);
}