xref: /titanic_51/usr/src/uts/common/io/ldterm.c (revision da5ab83fc888325fc812733d8a54bc5eab65c65c)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  * Copyright (c) 2014, Joyent, Inc.  All rights reserved.
25  */
26 
27 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
28 /* All Rights Reserved					*/
29 
30 /*
31  * University Copyright- Copyright (c) 1982, 1986, 1988
32  * The Regents of the University of California
33  * All Rights Reserved
34  *
35  * University Acknowledgment- Portions of this document are derived from
36  * software developed by the University of California, Berkeley, and its
37  * contributors.
38  */
39 
40 /*
41  * Standard Streams Terminal Line Discipline module.
42  */
43 
44 #include <sys/param.h>
45 #include <sys/types.h>
46 #include <sys/termio.h>
47 #include <sys/stream.h>
48 #include <sys/conf.h>
49 #include <sys/stropts.h>
50 #include <sys/strsubr.h>
51 #include <sys/strsun.h>
52 #include <sys/strtty.h>
53 #include <sys/signal.h>
54 #include <sys/file.h>
55 #include <sys/errno.h>
56 #include <sys/debug.h>
57 #include <sys/cmn_err.h>
58 #include <sys/euc.h>
59 #include <sys/eucioctl.h>
60 #include <sys/csiioctl.h>
61 #include <sys/ptms.h>
62 #include <sys/ldterm.h>
63 #include <sys/cred.h>
64 #include <sys/ddi.h>
65 #include <sys/sunddi.h>
66 #include <sys/kmem.h>
67 #include <sys/modctl.h>
68 
69 /* Time limit when draining during a close(9E) invoked by exit(2) */
70 /* Can be set to zero to emulate the old, broken behavior */
71 int ldterm_drain_limit = 15000000;
72 
73 /*
74  * Character types.
75  */
76 #define	ORDINARY	0
77 #define	CONTROL		1
78 #define	BACKSPACE	2
79 #define	NEWLINE		3
80 #define	TAB		4
81 #define	VTAB		5
82 #define	RETURN		6
83 
84 /*
85  * The following for EUC handling:
86  */
87 #define	T_SS2		7
88 #define	T_SS3		8
89 
90 /*
91  * Table indicating character classes to tty driver.  In particular,
92  * if the class is ORDINARY, then the character needs no special
93  * processing on output.
94  *
95  * Characters in the C1 set are all considered CONTROL; this will
96  * work with terminals that properly use the ANSI/ISO extensions,
97  * but might cause distress with terminals that put graphics in
98  * the range 0200-0237.  On the other hand, characters in that
99  * range cause even greater distress to other UNIX terminal drivers....
100  */
101 
102 static char typetab[256] = {
103 /* 000 */	CONTROL,	CONTROL,	CONTROL,	CONTROL,
104 /* 004 */	CONTROL,	CONTROL,	CONTROL,	CONTROL,
105 /* 010 */	BACKSPACE,	TAB,		NEWLINE,	CONTROL,
106 /* 014 */	VTAB,		RETURN,		CONTROL,	CONTROL,
107 /* 020 */	CONTROL,	CONTROL,	CONTROL,	CONTROL,
108 /* 024 */	CONTROL,	CONTROL,	CONTROL,	CONTROL,
109 /* 030 */	CONTROL,	CONTROL,	CONTROL,	CONTROL,
110 /* 034 */	CONTROL,	CONTROL,	CONTROL,	CONTROL,
111 /* 040 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
112 /* 044 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
113 /* 050 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
114 /* 054 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
115 /* 060 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
116 /* 064 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
117 /* 070 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
118 /* 074 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
119 /* 100 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
120 /* 104 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
121 /* 110 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
122 /* 114 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
123 /* 120 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
124 /* 124 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
125 /* 130 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
126 /* 134 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
127 /* 140 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
128 /* 144 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
129 /* 150 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
130 /* 154 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
131 /* 160 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
132 /* 164 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
133 /* 170 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
134 /* 174 */	ORDINARY,	ORDINARY,	ORDINARY,	CONTROL,
135 /* 200 */	CONTROL,	CONTROL,	CONTROL,	CONTROL,
136 /* 204 */	CONTROL,	CONTROL,	T_SS2,		T_SS3,
137 /* 210 */	CONTROL,	CONTROL,	CONTROL,	CONTROL,
138 /* 214 */	CONTROL,	CONTROL,	CONTROL,	CONTROL,
139 /* 220 */	CONTROL,	CONTROL,	CONTROL,	CONTROL,
140 /* 224 */	CONTROL,	CONTROL,	CONTROL,	CONTROL,
141 /* 230 */	CONTROL,	CONTROL,	CONTROL,	CONTROL,
142 /* 234 */	CONTROL,	CONTROL,	CONTROL,	CONTROL,
143 /* 240 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
144 /* 244 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
145 /* 250 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
146 /* 254 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
147 /* 260 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
148 /* 264 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
149 /* 270 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
150 /* 274 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
151 /* 300 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
152 /* 304 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
153 /* 310 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
154 /* 314 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
155 /* 320 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
156 /* 324 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
157 /* 330 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
158 /* 334 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
159 /* 340 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
160 /* 344 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
161 /* 350 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
162 /* 354 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
163 /* 360 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
164 /* 364 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
165 /* 370 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
166 /*
167  * WARNING:  For EUC, 0xFF must be an ordinary character.  It is used with
168  * single-byte EUC in some of the "ISO Latin Alphabet" codesets, and occupies
169  * a screen position; in those ISO sets where that position isn't used, it
170  * shouldn't make any difference.
171  */
172 /* 374 */	ORDINARY,	ORDINARY,	ORDINARY,	ORDINARY,
173 };
174 
175 /*
176  * Translation table for output without OLCUC.  All ORDINARY-class characters
177  * translate to themselves.  All other characters have a zero in the table,
178  * which stops the copying.
179  */
180 static unsigned char notrantab[256] = {
181 /* 000 */	0,	0,	0,	0,	0,	0,	0,	0,
182 /* 010 */	0,	0,	0,	0,	0,	0,	0,	0,
183 /* 020 */	0,	0,	0,	0,	0,	0,	0,	0,
184 /* 030 */	0,	0,	0,	0,	0,	0,	0,	0,
185 /* 040 */	' ',	'!',	'"',	'#',	'$',	'%',	'&',	'\'',
186 /* 050 */	'(',	')',	'*',	'+',	',',	'-',	'.',	'/',
187 /* 060 */	'0',	'1',	'2',	'3',	'4',	'5',	'6',	'7',
188 /* 070 */	'8',	'9',	':',	';',	'<',	'=',	'>',	'?',
189 /* 100 */	'@',	'A',	'B',	'C',	'D',	'E',	'F',	'G',
190 /* 110 */	'H',	'I',	'J',	'K',	'L',	'M',	'N',	'O',
191 /* 120 */	'P',	'Q',	'R',	'S',	'T',	'U',	'V',	'W',
192 /* 130 */	'X',	'Y',	'Z',	'[',	'\\',	']',	'^',	'_',
193 /* 140 */	'`',	'a',	'b',	'c',	'd',	'e',	'f',	'g',
194 /* 150 */	'h',	'i',	'j',	'k',	'l',	'm',	'n',	'o',
195 /* 160 */	'p',	'q',	'r',	's',	't',	'u',	'v',	'w',
196 /* 170 */	'x',	'y',	'z',	'{',	'|',	'}',	'~',	0,
197 /* 200 */	0,	0,	0,	0,	0,	0,	0,	0,
198 /* 210 */	0,	0,	0,	0,	0,	0,	0,	0,
199 /* 220 */	0,	0,	0,	0,	0,	0,	0,	0,
200 /* 230 */	0,	0,	0,	0,	0,	0,	0,	0,
201 /* 240 */	0240,	0241,	0242,	0243,	0244,	0245,	0246,	0247,
202 /* 250 */	0250,	0251,	0252,	0253,	0254,	0255,	0256,	0257,
203 /* 260 */	0260,	0261,	0262,	0263,	0264,	0265,	0266,	0267,
204 /* 270 */	0270,	0271,	0272,	0273,	0274,	0275,	0276,	0277,
205 /* 300 */	0300,	0301,	0302,	0303,	0304,	0305,	0306,	0307,
206 /* 310 */	0310,	0311,	0312,	0313,	0314,	0315,	0316,	0317,
207 /* 320 */	0320,	0321,	0322,	0323,	0324,	0325,	0326,	0327,
208 /* 330 */	0330,	0331,	0332,	0333,	0334,	0335,	0336,	0337,
209 /* 340 */	0340,	0341,	0342,	0343,	0344,	0345,	0346,	0347,
210 /* 350 */	0350,	0351,	0352,	0353,	0354,	0355,	0356,	0357,
211 /* 360 */	0360,	0361,	0362,	0363,	0364,	0365,	0366,	0367,
212 /*
213  * WARNING: as for above ISO sets, \377 may be used.  Translate it to
214  * itself.
215  */
216 /* 370 */	0370,	0371,	0372,	0373,	0374,	0375,	0376,	0377,
217 };
218 
219 /*
220  * Translation table for output with OLCUC.  All ORDINARY-class characters
221  * translate to themselves, except for lower-case letters which translate
222  * to their upper-case equivalents.  All other characters have a zero in
223  * the table, which stops the copying.
224  */
225 static unsigned char lcuctab[256] = {
226 /* 000 */	0,	0,	0,	0,	0,	0,	0,	0,
227 /* 010 */	0,	0,	0,	0,	0,	0,	0,	0,
228 /* 020 */	0,	0,	0,	0,	0,	0,	0,	0,
229 /* 030 */	0,	0,	0,	0,	0,	0,	0,	0,
230 /* 040 */	' ',	'!',	'"',	'#',	'$',	'%',	'&',	'\'',
231 /* 050 */	'(',	')',	'*',	'+',	',',	'-',	'.',	'/',
232 /* 060 */	'0',	'1',	'2',	'3',	'4',	'5',	'6',	'7',
233 /* 070 */	'8',	'9',	':',	';',	'<',	'=',	'>',	'?',
234 /* 100 */	'@',	'A',	'B',	'C',	'D',	'E',	'F',	'G',
235 /* 110 */	'H',	'I',	'J',	'K',	'L',	'M',	'N',	'O',
236 /* 120 */	'P',	'Q',	'R',	'S',	'T',	'U',	'V',	'W',
237 /* 130 */	'X',	'Y',	'Z',	'[',	'\\',	']',	'^',	'_',
238 /* 140 */	'`',	'A',	'B',	'C',	'D',	'E',	'F',	'G',
239 /* 150 */	'H',	'I',	'J',	'K',	'L',	'M',	'N',	'O',
240 /* 160 */	'P',	'Q',	'R',	'S',	'T',	'U',	'V',	'W',
241 /* 170 */	'X',	'Y',	'Z',	'{',	'|',	'}',	'~',	0,
242 /* 200 */	0,	0,	0,	0,	0,	0,	0,	0,
243 /* 210 */	0,	0,	0,	0,	0,	0,	0,	0,
244 /* 220 */	0,	0,	0,	0,	0,	0,	0,	0,
245 /* 230 */	0,	0,	0,	0,	0,	0,	0,	0,
246 /* 240 */	0240,	0241,	0242,	0243,	0244,	0245,	0246,	0247,
247 /* 250 */	0250,	0251,	0252,	0253,	0254,	0255,	0256,	0257,
248 /* 260 */	0260,	0261,	0262,	0263,	0264,	0265,	0266,	0267,
249 /* 270 */	0270,	0271,	0272,	0273,	0274,	0275,	0276,	0277,
250 /* 300 */	0300,	0301,	0302,	0303,	0304,	0305,	0306,	0307,
251 /* 310 */	0310,	0311,	0312,	0313,	0314,	0315,	0316,	0317,
252 /* 320 */	0320,	0321,	0322,	0323,	0324,	0325,	0326,	0327,
253 /* 330 */	0330,	0331,	0332,	0333,	0334,	0335,	0336,	0337,
254 /* 340 */	0340,	0341,	0342,	0343,	0344,	0345,	0346,	0347,
255 /* 350 */	0350,	0351,	0352,	0353,	0354,	0355,	0356,	0357,
256 /* 360 */	0360,	0361,	0362,	0363,	0364,	0365,	0366,	0367,
257 /*
258  * WARNING: as for above ISO sets, \377 may be used.  Translate it to
259  * itself.
260  */
261 /* 370 */	0370,	0371,	0372,	0373,	0374,	0375,	0376,	0377,
262 };
263 
264 /*
265  * Input mapping table -- if an entry is non-zero, and XCASE is set,
266  * when the corresponding character is typed preceded by "\" the escape
267  * sequence is replaced by the table value.  Mostly used for
268  * upper-case only terminals.
269  */
270 static char	imaptab[256] = {
271 /* 000 */	0,	0,	0,	0,	0,	0,	0,	0,
272 /* 010 */	0,	0,	0,	0,	0,	0,	0,	0,
273 /* 020 */	0,	0,	0,	0,	0,	0,	0,	0,
274 /* 030 */	0,	0,	0,	0,	0,	0,	0,	0,
275 /* 040 */	0,	'|',	0,	0,	0,	0,	0,	'`',
276 /* 050 */	'{',	'}',	0,	0,	0,	0,	0,	0,
277 /* 060 */	0,	0,	0,	0,	0,	0,	0,	0,
278 /* 070 */	0,	0,	0,	0,	0,	0,	0,	0,
279 /* 100 */	0,	0,	0,	0,	0,	0,	0,	0,
280 /* 110 */	0,	0,	0,	0,	0,	0,	0,	0,
281 /* 120 */	0,	0,	0,	0,	0,	0,	0,	0,
282 /* 130 */	0,	0,	0,	0,	'\\',	0,	'~',	0,
283 /* 140 */	0,	'A',	'B',	'C',	'D',	'E',	'F',	'G',
284 /* 150 */	'H',	'I',	'J',	'K',	'L',	'M',	'N',	'O',
285 /* 160 */	'P',	'Q',	'R',	'S',	'T',	'U',	'V',	'W',
286 /* 170 */	'X',	'Y',	'Z',	0,	0,	0,	0,	0,
287 /* 200-377 aren't mapped */
288 };
289 
290 /*
291  * Output mapping table -- if an entry is non-zero, and XCASE is set,
292  * the corresponding character is printed as "\" followed by the table
293  * value.  Mostly used for upper-case only terminals.
294  */
295 static char	omaptab[256] = {
296 /* 000 */	0,	0,	0,	0,	0,	0,	0,	0,
297 /* 010 */	0,	0,	0,	0,	0,	0,	0,	0,
298 /* 020 */	0,	0,	0,	0,	0,	0,	0,	0,
299 /* 030 */	0,	0,	0,	0,	0,	0,	0,	0,
300 /* 040 */	0,	0,	0,	0,	0,	0,	0,	0,
301 /* 050 */	0,	0,	0,	0,	0,	0,	0,	0,
302 /* 060 */	0,	0,	0,	0,	0,	0,	0,	0,
303 /* 070 */	0,	0,	0,	0,	0,	0,	0,	0,
304 /* 100 */	0,	'A',	'B',	'C',	'D',	'E',	'F',	'G',
305 /* 110 */	'H',	'I',	'J',	'K',	'L',	'M',	'N',	'O',
306 /* 120 */	'P',	'Q',	'R',	'S',	'T',	'U',	'V',	'W',
307 /* 130 */	'X',	'Y',	'Z',	0,	0,	0,	0,	0,
308 /* 140 */	'\'',	0,	0,	0,	0,	0,	0,	0,
309 /* 150 */	0,	0,	0,	0,	0,	0,	0,	0,
310 /* 160 */	0,	0,	0,	0,	0,	0,	0,	0,
311 /* 170 */	0,	0,	0,	'(',	'!',	')',	'^',	0,
312 /* 200-377 aren't mapped */
313 };
314 
315 /*
316  * Translation table for TS_MEUC output without OLCUC.  All printing ASCII
317  * characters translate to themselves.  All other _bytes_ have a zero in
318  * the table, which stops the copying.  This and the following table exist
319  * only so we can use the existing movtuc processing with or without OLCUC.
320  * Maybe it speeds up something...because we can copy a block of characters
321  * by only looking for zeros in the table.
322  *
323  * If we took the simple expedient of DISALLOWING "olcuc" with multi-byte
324  * processing, we could rid ourselves of both these tables and save 512 bytes;
325  * seriously, it doesn't make much sense to use olcuc with multi-byte, and
326  * it will probably never be used.  Consideration should be given to disallowing
327  * the combination TS_MEUC & OLCUC.
328  */
329 static unsigned char enotrantab[256] = {
330 /* 000 */	0,	0,	0,	0,	0,	0,	0,	0,
331 /* 010 */	0,	0,	0,	0,	0,	0,	0,	0,
332 /* 020 */	0,	0,	0,	0,	0,	0,	0,	0,
333 /* 030 */	0,	0,	0,	0,	0,	0,	0,	0,
334 /* 040 */	' ',	'!',	'"',	'#',	'$',	'%',	'&',	'\'',
335 /* 050 */	'(',	')',	'*',	'+',	',',	'-',	'.',	'/',
336 /* 060 */	'0',	'1',	'2',	'3',	'4',	'5',	'6',	'7',
337 /* 070 */	'8',	'9',	':',	';',	'<',	'=',	'>',	'?',
338 /* 100 */	'@',	'A',	'B',	'C',	'D',	'E',	'F',	'G',
339 /* 110 */	'H',	'I',	'J',	'K',	'L',	'M',	'N',	'O',
340 /* 120 */	'P',	'Q',	'R',	'S',	'T',	'U',	'V',	'W',
341 /* 130 */	'X',	'Y',	'Z',	'[',	'\\',	']',	'^',	'_',
342 /* 140 */	'`',	'a',	'b',	'c',	'd',	'e',	'f',	'g',
343 /* 150 */	'h',	'i',	'j',	'k',	'l',	'm',	'n',	'o',
344 /* 160 */	'p',	'q',	'r',	's',	't',	'u',	'v',	'w',
345 /* 170 */	'x',	'y',	'z',	'{',	'|',	'}',	'~',	0,
346 /* 200 - 377 aren't mapped (they're stoppers). */
347 };
348 
349 /*
350  * Translation table for TS_MEUC output with OLCUC.  All printing ASCII
351  * translate to themselves, except for lower-case letters which translate
352  * to their upper-case equivalents.  All other bytes have a zero in
353  * the table, which stops the copying.  Useless for ISO Latin Alphabet
354  * translations, but *sigh* OLCUC is really only defined for ASCII anyway.
355  * We only have this table so we can use the existing OLCUC processing with
356  * TS_MEUC set (multi-byte mode).  Nobody would ever think of actually
357  * _using_ it...would they?
358  */
359 static unsigned char elcuctab[256] = {
360 /* 000 */	0,	0,	0,	0,	0,	0,	0,	0,
361 /* 010 */	0,	0,	0,	0,	0,	0,	0,	0,
362 /* 020 */	0,	0,	0,	0,	0,	0,	0,	0,
363 /* 030 */	0,	0,	0,	0,	0,	0,	0,	0,
364 /* 040 */	' ',	'!',	'"',	'#',	'$',	'%',	'&',	'\'',
365 /* 050 */	'(',	')',	'*',	'+',	',',	'-',	'.',	'/',
366 /* 060 */	'0',	'1',	'2',	'3',	'4',	'5',	'6',	'7',
367 /* 070 */	'8',	'9',	':',	';',	'<',	'=',	'>',	'?',
368 /* 100 */	'@',	'A',	'B',	'C',	'D',	'E',	'F',	'G',
369 /* 110 */	'H',	'I',	'J',	'K',	'L',	'M',	'N',	'O',
370 /* 120 */	'P',	'Q',	'R',	'S',	'T',	'U',	'V',	'W',
371 /* 130 */	'X',	'Y',	'Z',	'[',	'\\',	']',	'^',	'_',
372 /* 140 */	'`',	'A',	'B',	'C',	'D',	'E',	'F',	'G',
373 /* 150 */	'H',	'I',	'J',	'K',	'L',	'M',	'N',	'O',
374 /* 160 */	'P',	'Q',	'R',	'S',	'T',	'U',	'V',	'W',
375 /* 170 */	'X',	'Y',	'Z',	'{',	'|',	'}',	'~',	0,
376 /* 200 - 377 aren't mapped (they're stoppers). */
377 };
378 
379 static struct streamtab ldtrinfo;
380 
381 static struct fmodsw fsw = {
382 	"ldterm",
383 	&ldtrinfo,
384 	D_MTQPAIR | D_MP
385 };
386 
387 static struct modlstrmod modlstrmod = {
388 	&mod_strmodops, "terminal line discipline", &fsw
389 };
390 
391 
392 static struct modlinkage modlinkage = {
393 	MODREV_1, &modlstrmod, NULL
394 };
395 
396 
397 int
398 _init(void)
399 {
400 	return (mod_install(&modlinkage));
401 }
402 
403 int
404 _fini(void)
405 {
406 	return (mod_remove(&modlinkage));
407 }
408 
409 int
410 _info(struct modinfo *modinfop)
411 {
412 	return (mod_info(&modlinkage, modinfop));
413 }
414 
415 
416 static int	ldtermopen(queue_t *, dev_t *, int, int, cred_t *);
417 static int	ldtermclose(queue_t *, int, cred_t *);
418 static void	ldtermrput(queue_t *, mblk_t *);
419 static void	ldtermrsrv(queue_t *);
420 static int	ldtermrmsg(queue_t *, mblk_t *);
421 static void	ldtermwput(queue_t *, mblk_t *);
422 static void	ldtermwsrv(queue_t *);
423 static int	ldtermwmsg(queue_t *, mblk_t *);
424 static mblk_t	*ldterm_docanon(unsigned char, mblk_t *, size_t, queue_t *,
425 				ldtermstd_state_t *, int *);
426 static int	ldterm_unget(ldtermstd_state_t *);
427 static void	ldterm_trim(ldtermstd_state_t *);
428 static void	ldterm_rubout(unsigned char, queue_t *, size_t,
429 				ldtermstd_state_t *);
430 static int	ldterm_tabcols(ldtermstd_state_t *);
431 static void	ldterm_erase(queue_t *, size_t, ldtermstd_state_t *);
432 static void	ldterm_werase(queue_t *, size_t, ldtermstd_state_t *);
433 static void	ldterm_kill(queue_t *, size_t, ldtermstd_state_t *);
434 static void	ldterm_reprint(queue_t *, size_t, ldtermstd_state_t *);
435 static mblk_t	*ldterm_dononcanon(mblk_t *, mblk_t *, size_t, queue_t *,
436 					ldtermstd_state_t *);
437 static int	ldterm_echo(unsigned char, queue_t *, size_t,
438 				ldtermstd_state_t *);
439 static void	ldterm_outchar(unsigned char, queue_t *, size_t,
440 				ldtermstd_state_t *);
441 static void	ldterm_outstring(unsigned char *, int, queue_t *, size_t,
442 					ldtermstd_state_t *tp);
443 static mblk_t	*newmsg(ldtermstd_state_t *);
444 static void	ldterm_msg_upstream(queue_t *, ldtermstd_state_t *);
445 static void	ldterm_wenable(void *);
446 static mblk_t	*ldterm_output_msg(queue_t *, mblk_t *, mblk_t **,
447 				ldtermstd_state_t *, size_t, int);
448 static void	ldterm_flush_output(unsigned char, queue_t *,
449 					ldtermstd_state_t *);
450 static void	ldterm_dosig(queue_t *, int, unsigned char, int, int);
451 static void	ldterm_do_ioctl(queue_t *, mblk_t *);
452 static int	chgstropts(struct termios *, ldtermstd_state_t *, queue_t *);
453 static void	ldterm_ioctl_reply(queue_t *, mblk_t *);
454 static void	vmin_satisfied(queue_t *, ldtermstd_state_t *, int);
455 static void	vmin_settimer(queue_t *);
456 static void	vmin_timed_out(void *);
457 static void	ldterm_adjust_modes(ldtermstd_state_t *);
458 static void	ldterm_eucwarn(ldtermstd_state_t *);
459 static void	cp_eucwioc(eucioc_t *, eucioc_t *, int);
460 static int	ldterm_codeset(uchar_t, uchar_t);
461 
462 static void	ldterm_csi_erase(queue_t *, size_t, ldtermstd_state_t *);
463 static void	ldterm_csi_werase(queue_t *, size_t, ldtermstd_state_t *);
464 
465 static uchar_t	ldterm_utf8_width(uchar_t *, int);
466 
467 /* Codeset type specific methods for EUC, PCCS, and, UTF-8 codeset types. */
468 static int	__ldterm_dispwidth_euc(uchar_t, void *, int);
469 static int	__ldterm_memwidth_euc(uchar_t, void *);
470 
471 static int	__ldterm_dispwidth_pccs(uchar_t, void *, int);
472 static int	__ldterm_memwidth_pccs(uchar_t, void *);
473 
474 static int	__ldterm_dispwidth_utf8(uchar_t, void *, int);
475 static int	__ldterm_memwidth_utf8(uchar_t, void *);
476 
477 static const ldterm_cs_methods_t cs_methods[LDTERM_CS_TYPE_MAX + 1] = {
478 	{
479 		NULL,
480 		NULL
481 	},
482 	{
483 		__ldterm_dispwidth_euc,
484 		__ldterm_memwidth_euc
485 	},
486 	{
487 		__ldterm_dispwidth_pccs,
488 		__ldterm_memwidth_pccs
489 	},
490 	{
491 		__ldterm_dispwidth_utf8,
492 		__ldterm_memwidth_utf8
493 	}
494 };
495 
496 /*
497  * The default codeset is presumably C locale's ISO 646 in EUC but
498  * the data structure at below defined as the default codeset data also
499  * support any single byte (EUC) locales.
500  */
501 static const ldterm_cs_data_t default_cs_data = {
502 	LDTERM_DATA_VERSION,
503 	LDTERM_CS_TYPE_EUC,
504 	(uchar_t)0,
505 	(uchar_t)0,
506 	(char *)NULL,
507 	{
508 		'\0', '\0', '\0', '\0',
509 		'\0', '\0', '\0', '\0',
510 		'\0', '\0', '\0', '\0',
511 		'\0', '\0', '\0', '\0',
512 		'\0', '\0', '\0', '\0',
513 		'\0', '\0', '\0', '\0',
514 		'\0', '\0', '\0', '\0',
515 		'\0', '\0', '\0', '\0',
516 		'\0', '\0', '\0', '\0',
517 		'\0', '\0', '\0', '\0'
518 	}
519 };
520 
521 /*
522  * The following tables are from either u8_textprep.c or uconv.c at
523  * usr/src/common/unicode/. The tables are used to figure out corresponding
524  * UTF-8 character byte lengths and also the validity of given character bytes.
525  */
526 extern const int8_t u8_number_of_bytes[];
527 extern const uchar_t u8_masks_tbl[];
528 extern const uint8_t u8_valid_min_2nd_byte[];
529 extern const uint8_t u8_valid_max_2nd_byte[];
530 
531 /*
532  * Unicode character width definition tables from uwidth.c:
533  */
534 extern const ldterm_unicode_data_cell_t ldterm_ucode[][16384];
535 
536 #ifdef LDDEBUG
537 int	ldterm_debug = 0;
538 #define	DEBUG1(a)	if (ldterm_debug == 1) printf a
539 #define	DEBUG2(a)	if (ldterm_debug >= 2) printf a	/* allocations */
540 #define	DEBUG3(a)	if (ldterm_debug >= 3) printf a	/* M_CTL Stuff */
541 #define	DEBUG4(a)	if (ldterm_debug >= 4) printf a	/* M_READ Stuff */
542 #define	DEBUG5(a)	if (ldterm_debug >= 5) printf a
543 #define	DEBUG6(a)	if (ldterm_debug >= 6) printf a
544 #define	DEBUG7(a)	if (ldterm_debug >= 7) printf a
545 #else
546 #define	DEBUG1(a)
547 #define	DEBUG2(a)
548 #define	DEBUG3(a)
549 #define	DEBUG4(a)
550 #define	DEBUG5(a)
551 #define	DEBUG6(a)
552 #define	DEBUG7(a)
553 #endif		/* LDDEBUG */
554 
555 
556 /*
557  * Since most of the buffering occurs either at the stream head or in
558  * the "message currently being assembled" buffer, we have a
559  * relatively small input queue, so that blockages above us get
560  * reflected fairly quickly to the module below us.  We also have a
561  * small maximum packet size, since you can put a message of that
562  * size on an empty queue no matter how much bigger than the high
563  * water mark it is.
564  */
565 static struct module_info ldtermmiinfo = {
566 	0x0bad,
567 	"ldterm",
568 	0,
569 	256,
570 	HIWAT,
571 	LOWAT
572 };
573 
574 
575 static struct qinit ldtermrinit = {
576 	(int (*)())ldtermrput,
577 	(int (*)())ldtermrsrv,
578 	ldtermopen,
579 	ldtermclose,
580 	NULL,
581 	&ldtermmiinfo
582 };
583 
584 
585 static struct module_info ldtermmoinfo = {
586 	0x0bad,
587 	"ldterm",
588 	0,
589 	INFPSZ,
590 	1,
591 	0
592 };
593 
594 
595 static struct qinit ldtermwinit = {
596 	(int (*)())ldtermwput,
597 	(int (*)())ldtermwsrv,
598 	ldtermopen,
599 	ldtermclose,
600 	NULL,
601 	&ldtermmoinfo
602 };
603 
604 
605 static struct streamtab ldtrinfo = {
606 	&ldtermrinit,
607 	&ldtermwinit,
608 	NULL,
609 	NULL
610 };
611 
612 /*
613  * Dummy qbufcall callback routine used by open and close.
614  * The framework will wake up qwait_sig when we return from
615  * this routine (as part of leaving the perimeters.)
616  * (The framework enters the perimeters before calling the qbufcall() callback
617  * and leaves the perimeters after the callback routine has executed. The
618  * framework performs an implicit wakeup of any thread in qwait/qwait_sig
619  * when it leaves the perimeter. See qwait(9E).)
620  */
621 /* ARGSUSED */
622 static void
623 dummy_callback(void *arg)
624 {}
625 
626 
627 static mblk_t *
628 open_ioctl(queue_t *q, uint_t cmd)
629 {
630 	mblk_t *mp;
631 	bufcall_id_t id;
632 	int retv;
633 
634 	while ((mp = mkiocb(cmd)) == NULL) {
635 		id = qbufcall(q, sizeof (struct iocblk), BPRI_MED,
636 		    dummy_callback, NULL);
637 		retv = qwait_sig(q);
638 		qunbufcall(q, id);
639 		if (retv == 0)
640 			break;
641 	}
642 	return (mp);
643 }
644 
645 static mblk_t *
646 open_mblk(queue_t *q, size_t len)
647 {
648 	mblk_t *mp;
649 	bufcall_id_t id;
650 	int retv;
651 
652 	while ((mp = allocb(len, BPRI_MED)) == NULL) {
653 		id = qbufcall(q, len, BPRI_MED, dummy_callback, NULL);
654 		retv = qwait_sig(q);
655 		qunbufcall(q, id);
656 		if (retv == 0)
657 			break;
658 	}
659 	return (mp);
660 }
661 
662 /*
663  * Line discipline open.
664  */
665 /* ARGSUSED1 */
666 static int
667 ldtermopen(queue_t *q, dev_t *devp, int oflag, int sflag, cred_t *crp)
668 {
669 	ldtermstd_state_t *tp;
670 	mblk_t *bp, *qryp;
671 	int len;
672 	struct stroptions *strop;
673 	struct termios *termiosp;
674 	queue_t *wq;
675 
676 	if (q->q_ptr != NULL) {
677 		return (0);	/* already attached */
678 	}
679 
680 	tp = (ldtermstd_state_t *)kmem_zalloc(sizeof (ldtermstd_state_t),
681 	    KM_SLEEP);
682 
683 	/*
684 	 * Get termios defaults.  These are stored as
685 	 * a property in the "options" node.
686 	 */
687 	if (ddi_getlongprop(DDI_DEV_T_ANY, ddi_root_node(), DDI_PROP_NOTPROM,
688 	    "ttymodes", (caddr_t)&termiosp, &len) == DDI_PROP_SUCCESS &&
689 	    len == sizeof (struct termios)) {
690 		tp->t_modes = *termiosp;
691 		tp->t_amodes = *termiosp;
692 		kmem_free(termiosp, len);
693 	} else {
694 		/*
695 		 * Gack!  Whine about it.
696 		 */
697 		cmn_err(CE_WARN, "ldterm: Couldn't get ttymodes property!");
698 	}
699 	bzero(&tp->t_dmodes, sizeof (struct termios));
700 
701 	tp->t_state = 0;
702 
703 	tp->t_line = 0;
704 	tp->t_col = 0;
705 
706 	tp->t_rocount = 0;
707 	tp->t_rocol = 0;
708 
709 	tp->t_message = NULL;
710 	tp->t_endmsg = NULL;
711 	tp->t_msglen = 0;
712 	tp->t_rd_request = 0;
713 
714 	tp->t_echomp = NULL;
715 	tp->t_iocid = 0;
716 	tp->t_wbufcid = 0;
717 	tp->t_vtid = 0;
718 
719 	q->q_ptr = (caddr_t)tp;
720 	WR(q)->q_ptr = (caddr_t)tp;
721 	/*
722 	 * The following for EUC and also non-EUC codesets:
723 	 */
724 	tp->t_codeset = tp->t_eucleft = tp->t_eucign = tp->t_scratch_len = 0;
725 	bzero(&tp->eucwioc, EUCSIZE);
726 	tp->eucwioc.eucw[0] = 1;	/* ASCII mem & screen width */
727 	tp->eucwioc.scrw[0] = 1;
728 	tp->t_maxeuc = 1;	/* the max len in bytes of an EUC char */
729 	tp->t_eucp = NULL;
730 	tp->t_eucp_mp = NULL;
731 	tp->t_eucwarn = 0;	/* no bad chars seen yet */
732 
733 	tp->t_csdata = default_cs_data;
734 	tp->t_csmethods = cs_methods[LDTERM_CS_TYPE_EUC];
735 
736 	qprocson(q);
737 
738 	/*
739 	 * Find out if the module below us does canonicalization; if
740 	 * so, we won't do it ourselves.
741 	 */
742 
743 	if ((qryp = open_ioctl(q, MC_CANONQUERY)) == NULL)
744 		goto open_abort;
745 
746 	/*
747 	 * Reformulate as an M_CTL message. The actual data will
748 	 * be in the b_cont field.
749 	 */
750 	qryp->b_datap->db_type = M_CTL;
751 	wq = OTHERQ(q);
752 	putnext(wq, qryp);
753 
754 	/* allocate a TCSBRK ioctl in case we'll need it on close */
755 	if ((qryp = open_ioctl(q, TCSBRK)) == NULL)
756 		goto open_abort;
757 	tp->t_drainmsg = qryp;
758 	if ((bp = open_mblk(q, sizeof (int))) == NULL)
759 		goto open_abort;
760 	qryp->b_cont = bp;
761 
762 	/*
763 	 * Find out if the underlying driver supports proper POSIX close
764 	 * semantics.  If not, we'll have to approximate it using TCSBRK.  If
765 	 * it does, it will respond with MC_HAS_POSIX, and we'll catch that in
766 	 * the ldtermrput routine.
767 	 *
768 	 * When the ldterm_drain_limit tunable is set to zero, we behave the
769 	 * same as old ldterm: don't send this new message, and always use
770 	 * TCSBRK during close.
771 	 */
772 	if (ldterm_drain_limit != 0) {
773 		if ((qryp = open_ioctl(q, MC_POSIXQUERY)) == NULL)
774 			goto open_abort;
775 		qryp->b_datap->db_type = M_CTL;
776 		putnext(wq, qryp);
777 	}
778 
779 	/* prepare to clear the water marks on close */
780 	if ((bp = open_mblk(q, sizeof (struct stroptions))) == NULL)
781 		goto open_abort;
782 	tp->t_closeopts = bp;
783 
784 	/*
785 	 * Set the high-water and low-water marks on the stream head
786 	 * to values appropriate for a terminal.  Also set the "vmin"
787 	 * and "vtime" values to 1 and 0, turn on message-nondiscard
788 	 * mode (as we're in ICANON mode), and turn on "old-style
789 	 * NODELAY" mode.
790 	 */
791 	if ((bp = open_mblk(q, sizeof (struct stroptions))) == NULL)
792 		goto open_abort;
793 	strop = (struct stroptions *)bp->b_wptr;
794 	strop->so_flags = SO_READOPT|SO_HIWAT|SO_LOWAT|SO_NDELON|SO_ISTTY;
795 	strop->so_readopt = RMSGN;
796 	strop->so_hiwat = HIWAT;
797 	strop->so_lowat = LOWAT;
798 	bp->b_wptr += sizeof (struct stroptions);
799 	bp->b_datap->db_type = M_SETOPTS;
800 	putnext(q, bp);
801 
802 	return (0);		/* this can become a controlling TTY */
803 
804 open_abort:
805 	qprocsoff(q);
806 	q->q_ptr = NULL;
807 	WR(q)->q_ptr = NULL;
808 	freemsg(tp->t_closeopts);
809 	freemsg(tp->t_drainmsg);
810 	/* Dump the state structure */
811 	kmem_free(tp, sizeof (ldtermstd_state_t));
812 	return (EINTR);
813 }
814 
815 struct close_timer {
816 	timeout_id_t id;
817 	ldtermstd_state_t *tp;
818 };
819 
820 static void
821 drain_timed_out(void *arg)
822 {
823 	struct close_timer *ctp = arg;
824 
825 	ctp->id = 0;
826 	ctp->tp->t_state &= ~TS_IOCWAIT;
827 }
828 
829 /* ARGSUSED2 */
830 static int
831 ldtermclose(queue_t *q, int cflag, cred_t *crp)
832 {
833 	ldtermstd_state_t *tp = (ldtermstd_state_t *)q->q_ptr;
834 	struct stroptions *strop;
835 	mblk_t *bp;
836 	struct close_timer cltimer;
837 
838 	/*
839 	 * If we have an outstanding vmin timeout, cancel it.
840 	 */
841 	tp->t_state |= TS_CLOSE;
842 	if (tp->t_vtid != 0)
843 		(void) quntimeout(q, tp->t_vtid);
844 	tp->t_vtid = 0;
845 
846 	/*
847 	 * Cancel outstanding qbufcall request.
848 	 */
849 	if (tp->t_wbufcid != 0)
850 		qunbufcall(q, tp->t_wbufcid);
851 
852 	/*
853 	 * Reset the high-water and low-water marks on the stream
854 	 * head (?), turn on byte-stream mode, and turn off
855 	 * "old-style NODELAY" mode.
856 	 */
857 	bp = tp->t_closeopts;
858 	strop = (struct stroptions *)bp->b_wptr;
859 	strop->so_flags = SO_READOPT|SO_NDELOFF;
860 	strop->so_readopt = RNORM;
861 	bp->b_wptr += sizeof (struct stroptions);
862 	bp->b_datap->db_type = M_SETOPTS;
863 	putnext(q, bp);
864 
865 	if (cflag & (FNDELAY|FNONBLOCK)) {
866 		freemsg(tp->t_drainmsg);
867 	} else if ((bp = tp->t_drainmsg) != NULL) {
868 		struct iocblk *iocb;
869 
870 		/*
871 		 * If the driver isn't known to have POSIX close semantics,
872 		 * then we have to emulate this the old way.  This is done by
873 		 * sending down TCSBRK,1 to drain the output and waiting for
874 		 * the reply.
875 		 */
876 		iocb = (struct iocblk *)bp->b_rptr;
877 		iocb->ioc_count = sizeof (int);
878 		*(int *)bp->b_cont->b_rptr = 1;
879 		bp->b_cont->b_wptr += sizeof (int);
880 		tp->t_state |= TS_IOCWAIT;
881 		tp->t_iocid = iocb->ioc_id;
882 		if (!putq(WR(q), bp))
883 			putnext(WR(q), bp);
884 
885 		/*
886 		 * If we're not able to receive signals at this point, then
887 		 * launch a timer.  This timer will prevent us from waiting
888 		 * forever for a signal that won't arrive.
889 		 */
890 		cltimer.id = 0;
891 		if (!ddi_can_receive_sig() && ldterm_drain_limit != 0) {
892 			cltimer.tp = tp;
893 			cltimer.id = qtimeout(q, drain_timed_out, &cltimer,
894 			    drv_usectohz(ldterm_drain_limit));
895 		}
896 
897 		/*
898 		 * Note that the read side of ldterm and the qtimeout are
899 		 * protected by D_MTQPAIR, so no additional locking is needed
900 		 * here.
901 		 */
902 		while (tp->t_state & TS_IOCWAIT) {
903 			if (qwait_sig(q) == 0)
904 				break;
905 		}
906 		if (cltimer.id != 0)
907 			(void) quntimeout(q, cltimer.id);
908 	}
909 
910 	/*
911 	 * From here to the end, the routine does not sleep and does not
912 	 * reference STREAMS, so it's guaranteed to run to completion.
913 	 */
914 
915 	qprocsoff(q);
916 
917 	freemsg(tp->t_message);
918 	freemsg(tp->t_eucp_mp);
919 
920 	/* Dump the state structure, then unlink it */
921 	if (tp->t_csdata.locale_name != NULL)
922 		kmem_free(tp->t_csdata.locale_name,
923 		    strlen(tp->t_csdata.locale_name) + 1);
924 	kmem_free(tp, sizeof (ldtermstd_state_t));
925 	q->q_ptr = NULL;
926 	return (0);
927 }
928 
929 
930 /*
931  * Put procedure for input from driver end of stream (read queue).
932  */
933 static void
934 ldtermrput(queue_t *q, mblk_t *mp)
935 {
936 	ldtermstd_state_t *tp;
937 	unsigned char c;
938 	queue_t *wrq = WR(q);		/* write queue of ldterm mod */
939 	queue_t *nextq = q->q_next;	/* queue below us */
940 	mblk_t *bp;
941 	struct iocblk *qryp;
942 	unsigned char *readp;
943 	unsigned char *writep;
944 	struct termios *emodes;		/* effective modes set by driver */
945 	int dbtype;
946 
947 	tp = (ldtermstd_state_t *)q->q_ptr;
948 	/*
949 	 * We received our ack from the driver saying there is nothing left to
950 	 * shovel out, so wake up the close routine.
951 	 */
952 	dbtype = DB_TYPE(mp);
953 	if ((dbtype == M_IOCACK || dbtype == M_IOCNAK) &&
954 	    (tp->t_state & (TS_CLOSE|TS_IOCWAIT)) == (TS_CLOSE|TS_IOCWAIT)) {
955 		struct iocblk *iocp = (struct iocblk *)mp->b_rptr;
956 
957 		if (iocp->ioc_id == tp->t_iocid) {
958 			tp->t_state &= ~TS_IOCWAIT;
959 			freemsg(mp);
960 			return;
961 		}
962 	}
963 
964 	switch (dbtype) {
965 
966 	default:
967 		(void) putq(q, mp);
968 		return;
969 
970 		/*
971 		 * Send these up unmolested
972 		 *
973 		 */
974 	case M_PCSIG:
975 	case M_SIG:
976 	case M_IOCNAK:
977 
978 		putnext(q, mp);
979 		return;
980 
981 	case M_IOCACK:
982 
983 		ldterm_ioctl_reply(q, mp);
984 		return;
985 
986 	case M_BREAK:
987 
988 		/*
989 		 * Parity errors are sent up as M_BREAKS with single
990 		 * character data (formerly handled in the driver)
991 		 */
992 		if (mp->b_wptr - mp->b_rptr == 1) {
993 			/*
994 			 * IGNPAR	PARMRK		RESULT
995 			 * off		off		0
996 			 * off		on		3 byte sequence
997 			 * on		either		ignored
998 			 */
999 			if (!(tp->t_amodes.c_iflag & IGNPAR)) {
1000 				mp->b_wptr = mp->b_rptr;
1001 				if (tp->t_amodes.c_iflag & PARMRK) {
1002 					unsigned char c;
1003 
1004 					c = *mp->b_rptr;
1005 					freemsg(mp);
1006 					if ((mp = allocb(3, BPRI_HI)) == NULL) {
1007 						cmn_err(CE_WARN,
1008 						    "ldtermrput: no blocks");
1009 						return;
1010 					}
1011 					mp->b_datap->db_type = M_DATA;
1012 					*mp->b_wptr++ = (uchar_t)'\377';
1013 					*mp->b_wptr++ = '\0';
1014 					*mp->b_wptr++ = c;
1015 					putnext(q, mp);
1016 				} else {
1017 					mp->b_datap->db_type = M_DATA;
1018 					*mp->b_wptr++ = '\0';
1019 					putnext(q, mp);
1020 				}
1021 			} else {
1022 				freemsg(mp);
1023 			}
1024 			return;
1025 		}
1026 		/*
1027 		 * We look at the apparent modes here instead of the
1028 		 * effective modes. Effective modes cannot be used if
1029 		 * IGNBRK, BRINT and PARMRK have been negotiated to
1030 		 * be handled by the driver. Since M_BREAK should be
1031 		 * sent upstream only if break processing was not
1032 		 * already done, it should be ok to use the apparent
1033 		 * modes.
1034 		 */
1035 
1036 		if (!(tp->t_amodes.c_iflag & IGNBRK)) {
1037 			if (tp->t_amodes.c_iflag & BRKINT) {
1038 				ldterm_dosig(q, SIGINT, '\0', M_PCSIG, FLUSHRW);
1039 				freemsg(mp);
1040 			} else if (tp->t_amodes.c_iflag & PARMRK) {
1041 				/*
1042 				 * Send '\377','\0', '\0'.
1043 				 */
1044 				freemsg(mp);
1045 				if ((mp = allocb(3, BPRI_HI)) == NULL) {
1046 					cmn_err(CE_WARN,
1047 					    "ldtermrput: no blocks");
1048 					return;
1049 				}
1050 				mp->b_datap->db_type = M_DATA;
1051 				*mp->b_wptr++ = (uchar_t)'\377';
1052 				*mp->b_wptr++ = '\0';
1053 				*mp->b_wptr++ = '\0';
1054 				putnext(q, mp);
1055 			} else {
1056 				/*
1057 				 * Act as if a '\0' came in.
1058 				 */
1059 				freemsg(mp);
1060 				if ((mp = allocb(1, BPRI_HI)) == NULL) {
1061 					cmn_err(CE_WARN,
1062 					    "ldtermrput: no blocks");
1063 					return;
1064 				}
1065 				mp->b_datap->db_type = M_DATA;
1066 				*mp->b_wptr++ = '\0';
1067 				putnext(q, mp);
1068 			}
1069 		} else {
1070 			freemsg(mp);
1071 		}
1072 		return;
1073 
1074 	case M_CTL:
1075 		DEBUG3(("ldtermrput: M_CTL received\n"));
1076 		/*
1077 		 * The M_CTL has been standardized to look like an
1078 		 * M_IOCTL message.
1079 		 */
1080 
1081 		if ((mp->b_wptr - mp->b_rptr) != sizeof (struct iocblk)) {
1082 			DEBUG3((
1083 			    "Non standard M_CTL received by ldterm module\n"));
1084 			/* May be for someone else; pass it on */
1085 			putnext(q, mp);
1086 			return;
1087 		}
1088 		qryp = (struct iocblk *)mp->b_rptr;
1089 
1090 		switch (qryp->ioc_cmd) {
1091 
1092 		case MC_PART_CANON:
1093 
1094 			DEBUG3(("ldtermrput: M_CTL Query Reply\n"));
1095 			if (!mp->b_cont) {
1096 				DEBUG3(("No information in Query Message\n"));
1097 				break;
1098 			}
1099 			if ((mp->b_cont->b_wptr - mp->b_cont->b_rptr) ==
1100 			    sizeof (struct termios)) {
1101 				DEBUG3(("ldtermrput: M_CTL GrandScheme\n"));
1102 				/* elaborate turning off scheme */
1103 				emodes = (struct termios *)mp->b_cont->b_rptr;
1104 				bcopy(emodes, &tp->t_dmodes,
1105 					sizeof (struct termios));
1106 				ldterm_adjust_modes(tp);
1107 				break;
1108 			} else {
1109 				DEBUG3(("Incorrect query replysize\n"));
1110 				break;
1111 			}
1112 
1113 		case MC_NO_CANON:
1114 			tp->t_state |= TS_NOCANON;
1115 			/*
1116 			 * Note: this is very nasty.  It's not clear
1117 			 * what the right thing to do with a partial
1118 			 * message is; We throw it out
1119 			 */
1120 			if (tp->t_message != NULL) {
1121 				freemsg(tp->t_message);
1122 				tp->t_message = NULL;
1123 				tp->t_endmsg = NULL;
1124 				tp->t_msglen = 0;
1125 				tp->t_rocount = 0;
1126 				tp->t_rocol = 0;
1127 				if (tp->t_state & TS_MEUC) {
1128 					ASSERT(tp->t_eucp_mp);
1129 					tp->t_eucp = tp->t_eucp_mp->b_rptr;
1130 					tp->t_codeset = 0;
1131 					tp->t_eucleft = 0;
1132 				}
1133 			}
1134 			break;
1135 
1136 		case MC_DO_CANON:
1137 			tp->t_state &= ~TS_NOCANON;
1138 			break;
1139 
1140 		case MC_HAS_POSIX:
1141 			/* no longer any reason to drain from ldterm */
1142 			if (ldterm_drain_limit != 0) {
1143 				freemsg(tp->t_drainmsg);
1144 				tp->t_drainmsg = NULL;
1145 			}
1146 			break;
1147 
1148 		default:
1149 			DEBUG3(("Unknown M_CTL Message\n"));
1150 			break;
1151 		}
1152 		putnext(q, mp);	/* In case anyone else has to see it */
1153 		return;
1154 
1155 	case M_FLUSH:
1156 		/*
1157 		 * Flush everything we haven't looked at yet.
1158 		 */
1159 
1160 		if ((tp->t_state & TS_ISPTSTTY) && (*mp->b_rptr & FLUSHBAND))
1161 			flushband(q, *(mp->b_rptr + 1), FLUSHDATA);
1162 		else
1163 			flushq(q, FLUSHDATA);
1164 
1165 		/*
1166 		 * Flush everything we have looked at.
1167 		 */
1168 		freemsg(tp->t_message);
1169 		tp->t_message = NULL;
1170 		tp->t_endmsg = NULL;
1171 		tp->t_msglen = 0;
1172 		tp->t_rocount = 0;
1173 		tp->t_rocol = 0;
1174 		if (tp->t_state & TS_MEUC) {	/* EUC multi-byte */
1175 			ASSERT(tp->t_eucp_mp);
1176 			tp->t_eucp = tp->t_eucp_mp->b_rptr;
1177 		}
1178 		putnext(q, mp);	/* pass it on */
1179 
1180 		/*
1181 		 * Relieve input flow control
1182 		 */
1183 		if ((tp->t_modes.c_iflag & IXOFF) &&
1184 		    (tp->t_state & TS_TBLOCK) &&
1185 		    !(tp->t_state & TS_IFBLOCK) && q->q_count <= TTXOLO) {
1186 			tp->t_state &= ~TS_TBLOCK;
1187 			(void) putnextctl(wrq, M_STARTI);
1188 			DEBUG1(("M_STARTI down\n"));
1189 		}
1190 		return;
1191 
1192 	case M_DATA:
1193 		break;
1194 	}
1195 	(void) drv_setparm(SYSRAWC, msgdsize(mp));
1196 
1197 	/*
1198 	 * Flow control: send "start input" message if blocked and
1199 	 * our queue is below its low water mark.
1200 	 */
1201 	if ((tp->t_modes.c_iflag & IXOFF) && (tp->t_state & TS_TBLOCK) &&
1202 	    !(tp->t_state & TS_IFBLOCK) && q->q_count <= TTXOLO) {
1203 		tp->t_state &= ~TS_TBLOCK;
1204 		(void) putnextctl(wrq, M_STARTI);
1205 		DEBUG1(("M_STARTI down\n"));
1206 	}
1207 	/*
1208 	 * If somebody below us ("intelligent" communications
1209 	 * board, pseudo-tty controlled by an editor) is doing
1210 	 * canonicalization, don't scan it for special characters.
1211 	 */
1212 	if (tp->t_state & TS_NOCANON) {
1213 		(void) putq(q, mp);
1214 		return;
1215 	}
1216 	bp = mp;
1217 
1218 	do {
1219 		readp = bp->b_rptr;
1220 		writep = readp;
1221 		if (tp->t_modes.c_iflag & (INLCR|IGNCR|ICRNL|IUCLC|IXON) ||
1222 		    tp->t_modes.c_lflag & (ISIG|ICANON)) {
1223 			/*
1224 			 * We're doing some sort of non-trivial
1225 			 * processing of input; look at every
1226 			 * character.
1227 			 */
1228 			while (readp < bp->b_wptr) {
1229 				c = *readp++;
1230 
1231 				if (tp->t_modes.c_iflag & ISTRIP)
1232 					c &= 0177;
1233 
1234 				/*
1235 				 * First, check that this hasn't been
1236 				 * escaped with the "literal next"
1237 				 * character.
1238 				 */
1239 				if (tp->t_state & TS_PLNCH) {
1240 					tp->t_state &= ~TS_PLNCH;
1241 					tp->t_modes.c_lflag &= ~FLUSHO;
1242 					*writep++ = c;
1243 					continue;
1244 				}
1245 				/*
1246 				 * Setting a special character to NUL
1247 				 * disables it, so if this character
1248 				 * is NUL, it should not be compared
1249 				 * with any of the special characters.
1250 				 * It should, however, restart frozen
1251 				 * output if IXON and IXANY are set.
1252 				 */
1253 				if (c == _POSIX_VDISABLE) {
1254 					if (tp->t_modes.c_iflag & IXON &&
1255 					    tp->t_state & TS_TTSTOP &&
1256 					    tp->t_modes.c_lflag & IEXTEN &&
1257 					    tp->t_modes.c_iflag & IXANY) {
1258 						tp->t_state &=
1259 						    ~(TS_TTSTOP|TS_OFBLOCK);
1260 						(void) putnextctl(wrq, M_START);
1261 					}
1262 					tp->t_modes.c_lflag &= ~FLUSHO;
1263 					*writep++ = c;
1264 					continue;
1265 				}
1266 				/*
1267 				 * If stopped, start if you can; if
1268 				 * running, stop if you must.
1269 				 */
1270 				if (tp->t_modes.c_iflag & IXON) {
1271 					if (tp->t_state & TS_TTSTOP) {
1272 						if (c ==
1273 						    tp->t_modes.c_cc[VSTART] ||
1274 						    (tp->t_modes.c_lflag &
1275 						    IEXTEN &&
1276 						    tp->t_modes.c_iflag &
1277 						    IXANY)) {
1278 							tp->t_state &=
1279 							    ~(TS_TTSTOP |
1280 							    TS_OFBLOCK);
1281 							(void) putnextctl(wrq,
1282 							    M_START);
1283 						}
1284 					} else {
1285 						if (c ==
1286 						    tp->t_modes.c_cc[VSTOP]) {
1287 							tp->t_state |=
1288 							    TS_TTSTOP;
1289 							(void) putnextctl(wrq,
1290 							    M_STOP);
1291 						}
1292 					}
1293 					if (c == tp->t_modes.c_cc[VSTOP] ||
1294 					    c == tp->t_modes.c_cc[VSTART])
1295 						continue;
1296 				}
1297 				/*
1298 				 * Check for "literal next" character
1299 				 * and "flush output" character.
1300 				 * Note that we omit checks for ISIG
1301 				 * and ICANON, since the IEXTEN
1302 				 * setting subsumes them.
1303 				 */
1304 				if (tp->t_modes.c_lflag & IEXTEN) {
1305 					if (c == tp->t_modes.c_cc[VLNEXT]) {
1306 						/*
1307 						 * Remember that we saw a
1308 						 * "literal next" while
1309 						 * scanning input, but leave
1310 						 * leave it in the message so
1311 						 * that the service routine
1312 						 * can see it too.
1313 						 */
1314 						tp->t_state |= TS_PLNCH;
1315 						tp->t_modes.c_lflag &= ~FLUSHO;
1316 						*writep++ = c;
1317 						continue;
1318 					}
1319 					if (c == tp->t_modes.c_cc[VDISCARD]) {
1320 						ldterm_flush_output(c, wrq, tp);
1321 						continue;
1322 					}
1323 				}
1324 				tp->t_modes.c_lflag &= ~FLUSHO;
1325 
1326 				/*
1327 				 * Check for signal-generating
1328 				 * characters.
1329 				 */
1330 				if (tp->t_modes.c_lflag & ISIG) {
1331 					if (c == tp->t_modes.c_cc[VINTR]) {
1332 						ldterm_dosig(q, SIGINT, c,
1333 						    M_PCSIG, FLUSHRW);
1334 						continue;
1335 					}
1336 					if (c == tp->t_modes.c_cc[VQUIT]) {
1337 						ldterm_dosig(q, SIGQUIT, c,
1338 						    M_PCSIG, FLUSHRW);
1339 						continue;
1340 					}
1341 					if (c == tp->t_modes.c_cc[VSWTCH]) {
1342 						/*
1343 						 * Ancient SXT support; discard
1344 						 * character without action.
1345 						 */
1346 						continue;
1347 					}
1348 					if (c == tp->t_modes.c_cc[VSUSP]) {
1349 						ldterm_dosig(q, SIGTSTP, c,
1350 						    M_PCSIG, FLUSHRW);
1351 						continue;
1352 					}
1353 					if ((tp->t_modes.c_lflag & IEXTEN) &&
1354 					    (c == tp->t_modes.c_cc[VDSUSP])) {
1355 						ldterm_dosig(q, SIGTSTP, c,
1356 						    M_SIG, 0);
1357 						continue;
1358 					}
1359 
1360 					/*
1361 					 * Consumers do not expect the ^T to be
1362 					 * echoed out when we generate a
1363 					 * VSTATUS.
1364 					 */
1365 					if (c == tp->t_modes.c_cc[VSTATUS]) {
1366 						ldterm_dosig(q, SIGINFO, '\0',
1367 						    M_PCSIG, FLUSHRW);
1368 						continue;
1369 					}
1370 				}
1371 				/*
1372 				 * Throw away CR if IGNCR set, or
1373 				 * turn it into NL if ICRNL set.
1374 				 */
1375 				if (c == '\r') {
1376 					if (tp->t_modes.c_iflag & IGNCR)
1377 						continue;
1378 					if (tp->t_modes.c_iflag & ICRNL)
1379 						c = '\n';
1380 				} else {
1381 					/*
1382 					 * Turn NL into CR if INLCR
1383 					 * set.
1384 					 */
1385 					if (c == '\n' &&
1386 					    tp->t_modes.c_iflag & INLCR)
1387 						c = '\r';
1388 				}
1389 
1390 				/*
1391 				 * Map upper case input to lower case
1392 				 * if IUCLC flag set.
1393 				 */
1394 				if (tp->t_modes.c_iflag & IUCLC &&
1395 				    c >= 'A' && c <= 'Z')
1396 					c += 'a' - 'A';
1397 
1398 				/*
1399 				 * Put the possibly-transformed
1400 				 * character back in the message.
1401 				 */
1402 				*writep++ = c;
1403 			}
1404 
1405 			/*
1406 			 * If we didn't copy some characters because
1407 			 * we were ignoring them, fix the size of the
1408 			 * data block by adjusting the write pointer.
1409 			 * XXX This may result in a zero-length
1410 			 * block; will this cause anybody gastric
1411 			 * distress?
1412 			 */
1413 			bp->b_wptr -= (readp - writep);
1414 		} else {
1415 			/*
1416 			 * We won't be doing anything other than
1417 			 * possibly stripping the input.
1418 			 */
1419 			if (tp->t_modes.c_iflag & ISTRIP) {
1420 				while (readp < bp->b_wptr)
1421 					*writep++ = *readp++ & 0177;
1422 			}
1423 			tp->t_modes.c_lflag &= ~FLUSHO;
1424 		}
1425 
1426 	} while ((bp = bp->b_cont) != NULL);	/* next block, if any */
1427 
1428 	/*
1429 	 * Queue the message for service procedure if the
1430 	 * queue is not empty or canputnext() fails or
1431 	 * tp->t_state & TS_RESCAN is true.
1432 	 */
1433 
1434 	if (q->q_first != NULL || !bcanputnext(q, mp->b_band) ||
1435 	    (tp->t_state & TS_RESCAN))
1436 		(void) putq(q, mp);
1437 	else
1438 		(void) ldtermrmsg(q, mp);
1439 
1440 	/*
1441 	 * Flow control: send "stop input" message if our queue is
1442 	 * approaching its high-water mark. The message will be
1443 	 * dropped on the floor in the service procedure, if we
1444 	 * cannot ship it up and we have had it upto our neck!
1445 	 *
1446 	 * Set QWANTW to ensure that the read queue service procedure
1447 	 * gets run when nextq empties up again, so that it can
1448 	 * unstop the input.
1449 	 */
1450 	if ((tp->t_modes.c_iflag & IXOFF) && !(tp->t_state & TS_TBLOCK) &&
1451 	    q->q_count >= TTXOHI) {
1452 		mutex_enter(QLOCK(nextq));
1453 		nextq->q_flag |= QWANTW;
1454 		mutex_exit(QLOCK(nextq));
1455 		tp->t_state |= TS_TBLOCK;
1456 		(void) putnextctl(wrq, M_STOPI);
1457 		DEBUG1(("M_STOPI down\n"));
1458 	}
1459 }
1460 
1461 
1462 /*
1463  * Line discipline input server processing.  Erase/kill and escape
1464  * ('\') processing, gathering into messages, upper/lower case input
1465  * mapping.
1466  */
1467 static void
1468 ldtermrsrv(queue_t *q)
1469 {
1470 	ldtermstd_state_t *tp;
1471 	mblk_t *mp;
1472 
1473 	tp = (ldtermstd_state_t *)q->q_ptr;
1474 
1475 	if (tp->t_state & TS_RESCAN) {
1476 		/*
1477 		 * Canonicalization was turned on or off. Put the
1478 		 * message being assembled back in the input queue,
1479 		 * so that we rescan it.
1480 		 */
1481 		if (tp->t_message != NULL) {
1482 			DEBUG5(("RESCAN WAS SET; put back in q\n"));
1483 			if (tp->t_msglen != 0)
1484 				(void) putbq(q, tp->t_message);
1485 			else
1486 				freemsg(tp->t_message);
1487 			tp->t_message = NULL;
1488 			tp->t_endmsg = NULL;
1489 			tp->t_msglen = 0;
1490 		}
1491 		if (tp->t_state & TS_MEUC) {
1492 			ASSERT(tp->t_eucp_mp);
1493 			tp->t_eucp = tp->t_eucp_mp->b_rptr;
1494 			tp->t_codeset = 0;
1495 			tp->t_eucleft = 0;
1496 		}
1497 		tp->t_state &= ~TS_RESCAN;
1498 	}
1499 
1500 	while ((mp = getq(q)) != NULL) {
1501 		if (!ldtermrmsg(q, mp))
1502 			break;
1503 	}
1504 
1505 	/*
1506 	 * Flow control: send start message if blocked and our queue
1507 	 * is below its low water mark.
1508 	 */
1509 	if ((tp->t_modes.c_iflag & IXOFF) && (tp->t_state & TS_TBLOCK) &&
1510 	    !(tp->t_state & TS_IFBLOCK) && q->q_count <= TTXOLO) {
1511 		tp->t_state &= ~TS_TBLOCK;
1512 		(void) putctl(WR(q), M_STARTI);
1513 	}
1514 }
1515 
1516 /*
1517  * This routine is called from both ldtermrput and ldtermrsrv to
1518  * do the actual work of dealing with mp. Return 1 on sucesss and
1519  * 0 on failure.
1520  */
1521 static int
1522 ldtermrmsg(queue_t *q, mblk_t *mp)
1523 {
1524 	unsigned char c;
1525 	int dofree;
1526 	int status = 1;
1527 	size_t   ebsize;
1528 	mblk_t *bp;
1529 	mblk_t *bpt;
1530 	ldtermstd_state_t *tp;
1531 
1532 	bpt = NULL;
1533 
1534 	tp = (ldtermstd_state_t *)q->q_ptr;
1535 
1536 	if (mp->b_datap->db_type <= QPCTL && !bcanputnext(q, mp->b_band)) {
1537 		/*
1538 		 * Stream head is flow controlled. If echo is
1539 		 * turned on, flush the read side or send a
1540 		 * bell down the line to stop input and
1541 		 * process the current message.
1542 		 * Otherwise(putbq) the user will not see any
1543 		 * response to to the typed input. Typically
1544 		 * happens if there is no reader process.
1545 		 * Note that you will loose the data in this
1546 		 * case if the data is coming too fast. There
1547 		 * is an assumption here that if ECHO is
1548 		 * turned on its some user typing the data on
1549 		 * a terminal and its not network.
1550 		 */
1551 		if (tp->t_modes.c_lflag & ECHO) {
1552 			if ((tp->t_modes.c_iflag & IMAXBEL) &&
1553 			    (tp->t_modes.c_lflag & ICANON)) {
1554 				freemsg(mp);
1555 				if (canputnext(WR(q)))
1556 					ldterm_outchar(CTRL('g'), WR(q), 4, tp);
1557 				status = 0;
1558 				goto echo;
1559 			} else {
1560 				(void) putctl1(q, M_FLUSH, FLUSHR);
1561 			}
1562 		} else {
1563 			(void) putbq(q, mp);
1564 			status = 0;
1565 			goto out;	/* read side is blocked */
1566 		}
1567 	}
1568 	switch (mp->b_datap->db_type) {
1569 
1570 	default:
1571 		putnext(q, mp);	/* pass it on */
1572 		goto out;
1573 
1574 	case M_HANGUP:
1575 		/*
1576 		 * Flush everything we haven't looked at yet.
1577 		 */
1578 		flushq(q, FLUSHDATA);
1579 
1580 		/*
1581 		 * Flush everything we have looked at.
1582 		 */
1583 		freemsg(tp->t_message);
1584 		tp->t_message = NULL;
1585 		tp->t_endmsg = NULL;
1586 		tp->t_msglen = 0;
1587 		/*
1588 		 * XXX  should we set read request
1589 		 * tp->t_rd_request to NULL?
1590 		 */
1591 		tp->t_rocount = 0;	/* if it hasn't been typed */
1592 		tp->t_rocol = 0;	/* it hasn't been echoed :-) */
1593 		if (tp->t_state & TS_MEUC) {
1594 			ASSERT(tp->t_eucp_mp);
1595 			tp->t_eucp = tp->t_eucp_mp->b_rptr;
1596 		}
1597 		/*
1598 		 * Restart output, since it's probably got
1599 		 * nowhere to go anyway, and we're probably
1600 		 * not going to see another ^Q for a while.
1601 		 */
1602 		if (tp->t_state & TS_TTSTOP) {
1603 			tp->t_state &= ~(TS_TTSTOP|TS_OFBLOCK);
1604 			(void) putnextctl(WR(q), M_START);
1605 		}
1606 		/*
1607 		 * This message will travel up the read
1608 		 * queue, flushing as it goes, get turned
1609 		 * around at the stream head, and travel back
1610 		 * down the write queue, flushing as it goes.
1611 		 */
1612 		(void) putnextctl1(q, M_FLUSH, FLUSHW);
1613 
1614 		/*
1615 		 * This message will travel down the write
1616 		 * queue, flushing as it goes, get turned
1617 		 * around at the driver, and travel back up
1618 		 * the read queue, flushing as it goes.
1619 		 */
1620 		(void) putctl1(WR(q), M_FLUSH, FLUSHR);
1621 
1622 		/*
1623 		 * Now that that's done, we send a SIGCONT
1624 		 * upstream, followed by the M_HANGUP.
1625 		 */
1626 		/* (void) putnextctl1(q, M_PCSIG, SIGCONT); */
1627 		putnext(q, mp);
1628 		goto out;
1629 
1630 	case M_IOCACK:
1631 
1632 		/*
1633 		 * Augment whatever information the driver is
1634 		 * returning  with the information we supply.
1635 		 */
1636 		ldterm_ioctl_reply(q, mp);
1637 		goto out;
1638 
1639 	case M_DATA:
1640 		break;
1641 	}
1642 
1643 	/*
1644 	 * This is an M_DATA message.
1645 	 */
1646 
1647 	/*
1648 	 * If somebody below us ("intelligent" communications
1649 	 * board, pseudo-tty controlled by an editor) is
1650 	 * doing canonicalization, don't scan it for special
1651 	 * characters.
1652 	 */
1653 	if (tp->t_state & TS_NOCANON) {
1654 		putnext(q, mp);
1655 		goto out;
1656 	}
1657 	bp = mp;
1658 
1659 	if ((bpt = newmsg(tp)) != NULL) {
1660 		mblk_t *bcont;
1661 
1662 		do {
1663 			ASSERT(bp->b_wptr >= bp->b_rptr);
1664 			ebsize = bp->b_wptr - bp->b_rptr;
1665 			if (ebsize > EBSIZE)
1666 				ebsize = EBSIZE;
1667 			bcont = bp->b_cont;
1668 			if (CANON_MODE) {
1669 				/*
1670 				 * By default, free the message once processed
1671 				 */
1672 				dofree = 1;
1673 
1674 				/*
1675 				 * update sysinfo canch
1676 				 * character. The value of
1677 				 * canch may vary as compared
1678 				 * to character tty
1679 				 * implementation.
1680 				 */
1681 				while (bp->b_rptr < bp->b_wptr) {
1682 					c = *bp->b_rptr++;
1683 					if ((bpt = ldterm_docanon(c,
1684 					    bpt, ebsize, q, tp, &dofree)) ==
1685 					    NULL)
1686 						break;
1687 				}
1688 				/*
1689 				 * Release this block or put back on queue.
1690 				 */
1691 				if (dofree)
1692 					freeb(bp);
1693 				else {
1694 					(void) putbq(q, bp);
1695 					break;
1696 				}
1697 			} else
1698 				bpt = ldterm_dononcanon(bp, bpt, ebsize, q, tp);
1699 			if (bpt == NULL) {
1700 				cmn_err(CE_WARN,
1701 				    "ldtermrsrv: out of blocks");
1702 				freemsg(bcont);
1703 				break;
1704 			}
1705 		} while ((bp = bcont) != NULL);
1706 	}
1707 echo:
1708 	/*
1709 	 * Send whatever we echoed downstream.
1710 	 */
1711 	if (tp->t_echomp != NULL) {
1712 		if (canputnext(WR(q)))
1713 			putnext(WR(q), tp->t_echomp);
1714 		else
1715 			freemsg(tp->t_echomp);
1716 		tp->t_echomp = NULL;
1717 	}
1718 
1719 out:
1720 	return (status);
1721 }
1722 
1723 
1724 /*
1725  * Do canonical mode input; check whether this character is to be
1726  * treated as a special character - if so, check whether it's equal
1727  * to any of the special characters and handle it accordingly.
1728  * Otherwise, just add it to the current line.
1729  */
1730 static mblk_t *
1731 ldterm_docanon(uchar_t c, mblk_t *bpt, size_t ebsize, queue_t *q,
1732     ldtermstd_state_t *tp, int *dofreep)
1733 {
1734 	queue_t *wrq = WR(q);
1735 	int i;
1736 
1737 	/*
1738 	 * If the previous character was the "literal next"
1739 	 * character, treat this character as regular input.
1740 	 */
1741 	if (tp->t_state & TS_SLNCH)
1742 		goto escaped;
1743 
1744 	/*
1745 	 * Setting a special character to NUL disables it, so if this
1746 	 * character is NUL, it should not be compared with any of
1747 	 * the special characters.
1748 	 */
1749 	if (c == _POSIX_VDISABLE) {
1750 		tp->t_state &= ~TS_QUOT;
1751 		goto escaped;
1752 	}
1753 	/*
1754 	 * If this character is the literal next character, echo it
1755 	 * as '^', backspace over it, and record that fact.
1756 	 */
1757 	if ((tp->t_modes.c_lflag & IEXTEN) && c == tp->t_modes.c_cc[VLNEXT]) {
1758 		if (tp->t_modes.c_lflag & ECHO)
1759 			ldterm_outstring((unsigned char *)"^\b", 2, wrq,
1760 			    ebsize, tp);
1761 		tp->t_state |= TS_SLNCH;
1762 		goto out;
1763 	}
1764 	/*
1765 	 * Check for the editing character. If the display width of
1766 	 * the last byte at the canonical buffer is not one and also
1767 	 * smaller than or equal to UNKNOWN_WIDTH, the character at
1768 	 * the end of the buffer is a multi-byte and/or multi-column
1769 	 * character.
1770 	 */
1771 	if (c == tp->t_modes.c_cc[VERASE]) {
1772 		if (tp->t_state & TS_QUOT) {
1773 			/*
1774 			 * Get rid of the backslash, and put the
1775 			 * erase character in its place.
1776 			 */
1777 			ldterm_erase(wrq, ebsize, tp);
1778 			bpt = tp->t_endmsg;
1779 			goto escaped;
1780 		} else {
1781 			if ((tp->t_state & TS_MEUC) && tp->t_msglen &&
1782 			    (*(tp->t_eucp - 1) != 1 &&
1783 			    *(tp->t_eucp - 1) <= UNKNOWN_WIDTH))
1784 				ldterm_csi_erase(wrq, ebsize, tp);
1785 			else
1786 				ldterm_erase(wrq, ebsize, tp);
1787 			bpt = tp->t_endmsg;
1788 			goto out;
1789 		}
1790 	}
1791 	if ((tp->t_modes.c_lflag & IEXTEN) && c == tp->t_modes.c_cc[VWERASE]) {
1792 		/*
1793 		 * Do "ASCII word" or "multibyte character token/chunk" erase.
1794 		 */
1795 		if (tp->t_state & TS_MEUC)
1796 			ldterm_csi_werase(wrq, ebsize, tp);
1797 		else
1798 			ldterm_werase(wrq, ebsize, tp);
1799 		bpt = tp->t_endmsg;
1800 		goto out;
1801 	}
1802 	if (c == tp->t_modes.c_cc[VKILL]) {
1803 		if (tp->t_state & TS_QUOT) {
1804 			/*
1805 			 * Get rid of the backslash, and put the kill
1806 			 * character in its place.
1807 			 */
1808 			ldterm_erase(wrq, ebsize, tp);
1809 			bpt = tp->t_endmsg;
1810 			goto escaped;
1811 		} else {
1812 			ldterm_kill(wrq, ebsize, tp);
1813 			bpt = tp->t_endmsg;
1814 			goto out;
1815 		}
1816 	}
1817 	if ((tp->t_modes.c_lflag & IEXTEN) && c == tp->t_modes.c_cc[VREPRINT]) {
1818 		ldterm_reprint(wrq, ebsize, tp);
1819 		goto out;
1820 	}
1821 	/*
1822 	 * If the preceding character was a backslash: if the current
1823 	 * character is an EOF, get rid of the backslash and treat
1824 	 * the EOF as data; if we're in XCASE mode and the current
1825 	 * character is part of a backslash-X escape sequence,
1826 	 * process it; otherwise, just treat the current character
1827 	 * normally.
1828 	 */
1829 	if (tp->t_state & TS_QUOT) {
1830 		tp->t_state &= ~TS_QUOT;
1831 		if (c == tp->t_modes.c_cc[VEOF]) {
1832 			/*
1833 			 * EOF character. Since it's escaped, get rid
1834 			 * of the backslash and put the EOF character
1835 			 * in its place.
1836 			 */
1837 			ldterm_erase(wrq, ebsize, tp);
1838 			bpt = tp->t_endmsg;
1839 		} else {
1840 			/*
1841 			 * If we're in XCASE mode, and the current
1842 			 * character is part of a backslash-X
1843 			 * sequence, get rid of the backslash and
1844 			 * replace the current character with what
1845 			 * that sequence maps to.
1846 			 */
1847 			if ((tp->t_modes.c_lflag & XCASE) &&
1848 			    imaptab[c] != '\0') {
1849 				ldterm_erase(wrq, ebsize, tp);
1850 				bpt = tp->t_endmsg;
1851 				c = imaptab[c];
1852 			}
1853 		}
1854 	} else {
1855 		/*
1856 		 * Previous character wasn't backslash; check whether
1857 		 * this was the EOF character.
1858 		 */
1859 		if (c == tp->t_modes.c_cc[VEOF]) {
1860 			/*
1861 			 * EOF character. Don't echo it unless
1862 			 * ECHOCTL is set, don't stuff it in the
1863 			 * current line, but send the line up the
1864 			 * stream.
1865 			 */
1866 			if ((tp->t_modes.c_lflag & ECHOCTL) &&
1867 			    (tp->t_modes.c_lflag & IEXTEN) &&
1868 			    (tp->t_modes.c_lflag & ECHO)) {
1869 				i = ldterm_echo(c, wrq, ebsize, tp);
1870 				while (i > 0) {
1871 					ldterm_outchar('\b', wrq, ebsize, tp);
1872 					i--;
1873 				}
1874 			}
1875 			bpt->b_datap->db_type = M_DATA;
1876 			ldterm_msg_upstream(q, tp);
1877 			if (!canputnext(q)) {
1878 				bpt = NULL;
1879 				*dofreep = 0;
1880 			} else {
1881 				bpt = newmsg(tp);
1882 				*dofreep = 1;
1883 			}
1884 			goto out;
1885 		}
1886 	}
1887 
1888 escaped:
1889 	/*
1890 	 * First, make sure we can fit one WHOLE multi-byte char in the
1891 	 * buffer.  This is one place where we have overhead even if
1892 	 * not in multi-byte mode; the overhead is subtracting
1893 	 * tp->t_maxeuc from MAX_CANON before checking.
1894 	 *
1895 	 * Allows MAX_CANON bytes in the buffer before throwing awaying
1896 	 * the the overflow of characters.
1897 	 */
1898 	if ((tp->t_msglen > ((MAX_CANON + 1) - (int)tp->t_maxeuc)) &&
1899 	    !((tp->t_state & TS_MEUC) && tp->t_eucleft)) {
1900 
1901 		/*
1902 		 * Byte will cause line to overflow, or the next EUC
1903 		 * won't fit: Ring the bell or discard all input, and
1904 		 * don't save the byte away.
1905 		 */
1906 		if (tp->t_modes.c_iflag & IMAXBEL) {
1907 			if (canputnext(wrq))
1908 				ldterm_outchar(CTRL('g'), wrq, ebsize, tp);
1909 			goto out;
1910 		} else {
1911 			/*
1912 			 * MAX_CANON processing. free everything in
1913 			 * the current line and start with the
1914 			 * current character as the first character.
1915 			 */
1916 			DEBUG7(("ldterm_docanon: MAX_CANON processing\n"));
1917 			freemsg(tp->t_message);
1918 			tp->t_message = NULL;
1919 			tp->t_endmsg = NULL;
1920 			tp->t_msglen = 0;
1921 			tp->t_rocount = 0;	/* if it hasn't been type */
1922 			tp->t_rocol = 0;	/* it hasn't been echoed :-) */
1923 			if (tp->t_state & TS_MEUC) {
1924 				ASSERT(tp->t_eucp_mp);
1925 				tp->t_eucp = tp->t_eucp_mp->b_rptr;
1926 			}
1927 			tp->t_state &= ~TS_SLNCH;
1928 			bpt = newmsg(tp);
1929 		}
1930 	}
1931 	/*
1932 	 * Add the character to the current line.
1933 	 */
1934 	if (bpt->b_wptr >= bpt->b_datap->db_lim) {
1935 		/*
1936 		 * No more room in this mblk; save this one away, and
1937 		 * allocate a new one.
1938 		 */
1939 		bpt->b_datap->db_type = M_DATA;
1940 		if ((bpt = allocb(IBSIZE, BPRI_MED)) == NULL)
1941 			goto out;
1942 
1943 		/*
1944 		 * Chain the new one to the end of the old one, and
1945 		 * mark it as the last block in the current line.
1946 		 */
1947 		tp->t_endmsg->b_cont = bpt;
1948 		tp->t_endmsg = bpt;
1949 	}
1950 	*bpt->b_wptr++ = c;
1951 	tp->t_msglen++;		/* message length in BYTES */
1952 
1953 	/*
1954 	 * In multi-byte mode, we have to keep track of where we are.
1955 	 * The first bytes of multi-byte chars get the full count for the
1956 	 * whole character.  We don't do any column calculations
1957 	 * here, but we need the information for when we do. We could
1958 	 * come across cases where we are getting garbage on the
1959 	 * line, but we're in multi-byte mode.  In that case, we may
1960 	 * see ASCII controls come in the middle of what should have been a
1961 	 * multi-byte character.  Call ldterm_eucwarn...eventually, a
1962 	 * warning message will be printed about it.
1963 	 */
1964 	if (tp->t_state & TS_MEUC) {
1965 		if (tp->t_eucleft) {	/* if in a multi-byte char already */
1966 			--tp->t_eucleft;
1967 			*tp->t_eucp++ = 0;	/* is a subsequent byte */
1968 			if (c < (uchar_t)0x20)
1969 				ldterm_eucwarn(tp);
1970 		} else { /* is the first byte of a multi-byte, or is ASCII */
1971 			if (ISASCII(c)) {
1972 				*tp->t_eucp++ =
1973 				    tp->t_csmethods.ldterm_dispwidth(c,
1974 				    (void *)tp, tp->t_modes.c_lflag & ECHOCTL);
1975 				tp->t_codeset = 0;
1976 			} else {
1977 				*tp->t_eucp++ =
1978 				    tp->t_csmethods.ldterm_dispwidth(c,
1979 				    (void *)tp, tp->t_modes.c_lflag & ECHOCTL);
1980 				tp->t_eucleft =
1981 				    tp->t_csmethods.ldterm_memwidth(c,
1982 				    (void *)tp) - 1;
1983 				tp->t_codeset = ldterm_codeset(
1984 				    tp->t_csdata.codeset_type, c);
1985 			}
1986 		}
1987 	}
1988 	/*
1989 	 * AT&T is concerned about the following but we aren't since
1990 	 * we have already shipped code that works.
1991 	 *
1992 	 * EOL2/XCASE should be conditioned with IEXTEN to be truly
1993 	 * POSIX conformant. This is going to cause problems for
1994 	 * pre-SVR4.0 programs that don't know about IEXTEN. Hence
1995 	 * EOL2/IEXTEN is not conditioned with IEXTEN.
1996 	 */
1997 	if (!(tp->t_state & TS_SLNCH) &&
1998 	    (c == '\n' || (c != '\0' && (c == tp->t_modes.c_cc[VEOL] ||
1999 	    (c == tp->t_modes.c_cc[VEOL2]))))) {
2000 		/*
2001 		 * || ((tp->t_modes.c_lflag & IEXTEN) && c ==
2002 		 * tp->t_modes.c_cc[VEOL2]))))) {
2003 		 */
2004 		/*
2005 		 * It's a line-termination character; send the line
2006 		 * up the stream.
2007 		 */
2008 		bpt->b_datap->db_type = M_DATA;
2009 		ldterm_msg_upstream(q, tp);
2010 		if (tp->t_state & TS_MEUC) {
2011 			ASSERT(tp->t_eucp_mp);
2012 			tp->t_eucp = tp->t_eucp_mp->b_rptr;
2013 		}
2014 		if ((bpt = newmsg(tp)) == NULL)
2015 			goto out;
2016 	} else {
2017 		/*
2018 		 * Character was escaped with LNEXT.
2019 		 */
2020 		if (tp->t_rocount++ == 0)
2021 			tp->t_rocol = tp->t_col;
2022 		tp->t_state &= ~(TS_SLNCH|TS_QUOT);
2023 		/*
2024 		 * If the current character is a single byte and single
2025 		 * column character and it is the backslash character and
2026 		 * IEXTEN, then the state will have TS_QUOT.
2027 		 */
2028 		if ((c == '\\') && (tp->t_modes.c_lflag & IEXTEN) &&
2029 		    (!(tp->t_state & TS_MEUC) ||
2030 		    ((tp->t_state & TS_MEUC) && (!tp->t_eucleft))))
2031 			tp->t_state |= TS_QUOT;
2032 	}
2033 
2034 	/*
2035 	 * Echo it.
2036 	 */
2037 	if (tp->t_state & TS_ERASE) {
2038 		tp->t_state &= ~TS_ERASE;
2039 		if (tp->t_modes.c_lflag & ECHO)
2040 			ldterm_outchar('/', wrq, ebsize, tp);
2041 	}
2042 	if (tp->t_modes.c_lflag & ECHO)
2043 		(void) ldterm_echo(c, wrq, ebsize, tp);
2044 	else {
2045 		/*
2046 		 * Echo NL when ECHO turned off, if ECHONL flag is
2047 		 * set.
2048 		 */
2049 		if (c == '\n' && (tp->t_modes.c_lflag & ECHONL))
2050 			ldterm_outchar(c, wrq, ebsize, tp);
2051 	}
2052 
2053 out:
2054 
2055 	return (bpt);
2056 }
2057 
2058 
2059 static int
2060 ldterm_unget(ldtermstd_state_t *tp)
2061 {
2062 	mblk_t *bpt;
2063 
2064 	if ((bpt = tp->t_endmsg) == NULL)
2065 		return (-1);	/* no buffers */
2066 	if (bpt->b_rptr == bpt->b_wptr)
2067 		return (-1);	/* zero-length record */
2068 	tp->t_msglen--;		/* one fewer character */
2069 	return (*--bpt->b_wptr);
2070 }
2071 
2072 
2073 static void
2074 ldterm_trim(ldtermstd_state_t *tp)
2075 {
2076 	mblk_t *bpt;
2077 	mblk_t *bp;
2078 
2079 	ASSERT(tp->t_endmsg);
2080 	bpt = tp->t_endmsg;
2081 
2082 	if (bpt->b_rptr == bpt->b_wptr) {
2083 		/*
2084 		 * This mblk is now empty. Find the previous mblk;
2085 		 * throw this one away, unless it's the first one.
2086 		 */
2087 		bp = tp->t_message;
2088 		if (bp != bpt) {
2089 			while (bp->b_cont != bpt) {
2090 				ASSERT(bp->b_cont);
2091 				bp = bp->b_cont;
2092 			}
2093 			bp->b_cont = NULL;
2094 			freeb(bpt);
2095 			tp->t_endmsg = bp;	/* point to that mblk */
2096 		}
2097 	}
2098 }
2099 
2100 
2101 /*
2102  * Rubout one character from the current line being built for tp as
2103  * cleanly as possible.  q is the write queue for tp. Most of this
2104  * can't be applied to multi-byte processing.  We do our own thing
2105  * for that... See the "ldterm_eucerase" routine.  We never call
2106  * ldterm_rubout on a multi-byte or multi-column character.
2107  */
2108 static void
2109 ldterm_rubout(uchar_t c, queue_t *q, size_t ebsize, ldtermstd_state_t *tp)
2110 {
2111 	int tabcols;
2112 	static unsigned char crtrubout[] = "\b \b\b \b";
2113 #define	RUBOUT1	&crtrubout[3]	/* rub out one position */
2114 #define	RUBOUT2	&crtrubout[0]	/* rub out two positions */
2115 
2116 	if (!(tp->t_modes.c_lflag & ECHO))
2117 		return;
2118 	if (tp->t_modes.c_lflag & ECHOE) {
2119 		/*
2120 		 * "CRT rubout"; try erasing it from the screen.
2121 		 */
2122 		if (tp->t_rocount == 0) {
2123 			/*
2124 			 * After the character being erased was
2125 			 * echoed, some data was written to the
2126 			 * terminal; we can't erase it cleanly, so we
2127 			 * just reprint the whole line as if the user
2128 			 * had typed the reprint character.
2129 			 */
2130 			ldterm_reprint(q, ebsize, tp);
2131 			return;
2132 		} else {
2133 			/*
2134 			 * XXX what about escaped characters?
2135 			 */
2136 			switch (typetab[c]) {
2137 
2138 			case ORDINARY:
2139 				if ((tp->t_modes.c_lflag & XCASE) &&
2140 				    omaptab[c])
2141 					ldterm_outstring(RUBOUT1, 3, q, ebsize,
2142 					    tp);
2143 				ldterm_outstring(RUBOUT1, 3, q, ebsize, tp);
2144 				break;
2145 
2146 			case VTAB:
2147 			case BACKSPACE:
2148 			case CONTROL:
2149 			case RETURN:
2150 			case NEWLINE:
2151 				if ((tp->t_modes.c_lflag & ECHOCTL) &&
2152 				    (tp->t_modes.c_lflag & IEXTEN))
2153 					ldterm_outstring(RUBOUT2, 6, q, ebsize,
2154 					    tp);
2155 				break;
2156 
2157 			case TAB:
2158 				if (tp->t_rocount < tp->t_msglen) {
2159 					/*
2160 					 * While the tab being erased was
2161 					 * expanded, some data was written
2162 					 * to the terminal; we can't erase
2163 					 * it cleanly, so we just reprint
2164 					 * the whole line as if the user
2165 					 * had typed the reprint character.
2166 					 */
2167 					ldterm_reprint(q, ebsize, tp);
2168 					return;
2169 				}
2170 				tabcols = ldterm_tabcols(tp);
2171 				while (--tabcols >= 0)
2172 					ldterm_outchar('\b', q, ebsize, tp);
2173 				break;
2174 			}
2175 		}
2176 	} else if ((tp->t_modes.c_lflag & ECHOPRT) &&
2177 	    (tp->t_modes.c_lflag & IEXTEN)) {
2178 		/*
2179 		 * "Printing rubout"; echo it between \ and /.
2180 		 */
2181 		if (!(tp->t_state & TS_ERASE)) {
2182 			ldterm_outchar('\\', q, ebsize, tp);
2183 			tp->t_state |= TS_ERASE;
2184 		}
2185 		(void) ldterm_echo(c, q, ebsize, tp);
2186 	} else
2187 		(void) ldterm_echo(tp->t_modes.c_cc[VERASE], q, ebsize, tp);
2188 	tp->t_rocount--;	/* we "unechoed" this character */
2189 }
2190 
2191 
2192 /*
2193  * Find the number of characters the tab we just deleted took up by
2194  * zipping through the current line and recomputing the column
2195  * number.
2196  */
2197 static int
2198 ldterm_tabcols(ldtermstd_state_t *tp)
2199 {
2200 	int col;
2201 	int i;
2202 	mblk_t *bp;
2203 	unsigned char *readp, *endp;
2204 	unsigned char c;
2205 	uchar_t *startp;
2206 	char errflg;
2207 	uchar_t u8[LDTERM_CS_MAX_BYTE_LENGTH];
2208 
2209 	col = tp->t_rocol;
2210 	/*
2211 	 * If we're doing multi-byte stuff, zip through the list of
2212 	 * widths to figure out where we are (we've kept track in most
2213 	 * cases).
2214 	 */
2215 	if (tp->t_state & TS_MEUC) {
2216 		ASSERT(tp->t_eucp_mp);
2217 		bp = tp->t_message;
2218 		startp = bp->b_datap->db_base;
2219 		readp = tp->t_eucp_mp->b_rptr;
2220 		endp = tp->t_eucp;
2221 		errflg = (char)0;
2222 		while (readp < endp) {
2223 			switch (*readp) {
2224 			case EUC_TWIDTH:	/* it's a tab */
2225 				col |= 07;	/* bump up */
2226 				col++;
2227 				break;
2228 			case EUC_BSWIDTH:	/* backspace */
2229 				if (col)
2230 					col--;
2231 				break;
2232 			case EUC_NLWIDTH:	/* newline */
2233 				if (tp->t_modes.c_oflag & ONLRET)
2234 					col = 0;
2235 				break;
2236 			case EUC_CRWIDTH:	/* return */
2237 				col = 0;
2238 				break;
2239 			case UNKNOWN_WIDTH:	/* UTF-8 unknown width */
2240 				if (tp->t_csdata.codeset_type !=
2241 				    LDTERM_CS_TYPE_UTF8 || errflg) {
2242 					*readp = 1;
2243 					col++;
2244 					break;
2245 				}
2246 				/*
2247 				 * Collect the current UTF-8 character bytes
2248 				 * from (possibly multiple) data buffers so
2249 				 * that we can figure out the display width.
2250 				 */
2251 				u8[0] = *startp;
2252 				for (i = 1; (i < LDTERM_CS_MAX_BYTE_LENGTH) &&
2253 				    (*(readp + i) == 0); i++) {
2254 					startp++;
2255 					if (startp >= bp->b_datap->db_lim) {
2256 						if (bp->b_cont) {
2257 							bp = bp->b_cont;
2258 							startp =
2259 							    bp->b_datap->
2260 							    db_base;
2261 						} else {
2262 							*readp = 1;
2263 							col++;
2264 							break;
2265 						}
2266 					}
2267 					u8[i] = *startp;
2268 				}
2269 
2270 				/* tp->t_eucp_mp contains wrong info?? */
2271 				if (*readp == 1)
2272 					break;
2273 
2274 				*readp = ldterm_utf8_width(u8, i);
2275 
2276 				col += *readp;
2277 				readp += (i - 1);
2278 				break;
2279 			default:
2280 				col += *readp;
2281 				break;
2282 			}
2283 			++readp;
2284 			++startp;
2285 			if (startp >= bp->b_datap->db_lim) {
2286 				if (bp->b_cont) {
2287 					bp = bp->b_cont;
2288 					startp = bp->b_datap->db_base;
2289 				} else {
2290 					/*
2291 					 * This will happen only if
2292 					 * tp->t_eucp_mp contains wrong
2293 					 * display width info.
2294 					 */
2295 					errflg = (char)1;
2296 					startp--;
2297 				}
2298 			}
2299 		}
2300 		goto eucout;	/* finished! */
2301 	}
2302 	bp = tp->t_message;
2303 	do {
2304 		readp = bp->b_rptr;
2305 		while (readp < bp->b_wptr) {
2306 			c = *readp++;
2307 			if ((tp->t_modes.c_lflag & ECHOCTL) &&
2308 			    (tp->t_modes.c_lflag & IEXTEN)) {
2309 				if (c <= 037 && c != '\t' && c != '\n' ||
2310 				    c == 0177) {
2311 					col += 2;
2312 					continue;
2313 				}
2314 			}
2315 			/*
2316 			 * Column position calculated here.
2317 			 */
2318 			switch (typetab[c]) {
2319 
2320 				/*
2321 				 * Ordinary characters; advance by
2322 				 * one.
2323 				 */
2324 			case ORDINARY:
2325 				col++;
2326 				break;
2327 
2328 				/*
2329 				 * Non-printing characters; nothing
2330 				 * happens.
2331 				 */
2332 			case CONTROL:
2333 				break;
2334 
2335 				/* Backspace */
2336 			case BACKSPACE:
2337 				if (col != 0)
2338 					col--;
2339 				break;
2340 
2341 				/* Newline; column depends on flags. */
2342 			case NEWLINE:
2343 				if (tp->t_modes.c_oflag & ONLRET)
2344 					col = 0;
2345 				break;
2346 
2347 				/* tab */
2348 			case TAB:
2349 				col |= 07;
2350 				col++;
2351 				break;
2352 
2353 				/* vertical motion */
2354 			case VTAB:
2355 				break;
2356 
2357 				/* carriage return */
2358 			case RETURN:
2359 				col = 0;
2360 				break;
2361 			}
2362 		}
2363 	} while ((bp = bp->b_cont) != NULL);	/* next block, if any */
2364 
2365 	/*
2366 	 * "col" is now the column number before the tab. "tp->t_col"
2367 	 * is still the column number after the tab, since we haven't
2368 	 * erased the tab yet. Thus "tp->t_col - col" is the number
2369 	 * of positions the tab moved.
2370 	 */
2371 eucout:
2372 	col = tp->t_col - col;
2373 	if (col > 8)
2374 		col = 8;	/* overflow screw */
2375 	return (col);
2376 }
2377 
2378 
2379 /*
2380  * Erase a single character; We ONLY ONLY deal with ASCII or
2381  * single-column single-byte codeset character.  For multi-byte characters,
2382  * see "ldterm_csi_erase".
2383  */
2384 static void
2385 ldterm_erase(queue_t *q, size_t ebsize, ldtermstd_state_t *tp)
2386 {
2387 	int c;
2388 
2389 	if ((c = ldterm_unget(tp)) != -1) {
2390 		ldterm_rubout((unsigned char) c, q, ebsize, tp);
2391 		ldterm_trim(tp);
2392 		if (tp->t_state & TS_MEUC)
2393 			--tp->t_eucp;
2394 	}
2395 }
2396 
2397 
2398 /*
2399  * Erase an entire word, single-byte EUC only please.
2400  */
2401 static void
2402 ldterm_werase(queue_t *q, size_t ebsize, ldtermstd_state_t *tp)
2403 {
2404 	int c;
2405 
2406 	/*
2407 	 * Erase trailing white space, if any.
2408 	 */
2409 	while ((c = ldterm_unget(tp)) == ' ' || c == '\t') {
2410 		ldterm_rubout((unsigned char) c, q, ebsize, tp);
2411 		ldterm_trim(tp);
2412 	}
2413 
2414 	/*
2415 	 * Erase non-white-space characters, if any.
2416 	 */
2417 	while (c != -1 && c != ' ' && c != '\t') {
2418 		ldterm_rubout((unsigned char) c, q, ebsize, tp);
2419 		ldterm_trim(tp);
2420 		c = ldterm_unget(tp);
2421 	}
2422 	if (c != -1) {
2423 		/*
2424 		 * We removed one too many characters; put the last
2425 		 * one back.
2426 		 */
2427 		tp->t_endmsg->b_wptr++;	/* put 'c' back */
2428 		tp->t_msglen++;
2429 	}
2430 }
2431 
2432 
2433 /*
2434  * ldterm_csi_werase - This is multi-byte equivalent of "word erase".
2435  * "Word erase" only makes sense in languages which space between words,
2436  * and it's presumptuous for us to attempt "word erase" when we don't
2437  * know anything about what's really going on.  It makes no sense for
2438  * many languages, as the criteria for defining words and tokens may
2439  * be completely different.
2440  *
2441  * In the TS_MEUC case (which is how we got here), we define a token to
2442  * be space- or tab-delimited, and erase one of them.  It helps to
2443  * have this for command lines, but it's otherwise useless for text
2444  * editing applications; you need more sophistication than we can
2445  * provide here.
2446  */
2447 static void
2448 ldterm_csi_werase(queue_t *q, size_t ebsize, ldtermstd_state_t *tp)
2449 {
2450 	int c, i;
2451 	int len;
2452 	uchar_t *ip;
2453 	uchar_t	u8[LDTERM_CS_MAX_BYTE_LENGTH];
2454 	uchar_t	u8_2[LDTERM_CS_MAX_BYTE_LENGTH];
2455 
2456 	/*
2457 	 * ip points to the width of the actual bytes.  t_eucp points
2458 	 * one byte beyond, where the next thing will be inserted.
2459 	 */
2460 	ip = tp->t_eucp - 1;
2461 	/*
2462 	 * Erase trailing white space, if any.
2463 	 */
2464 	while ((c = ldterm_unget(tp)) == ' ' || c == '\t') {
2465 		tp->t_eucp--;
2466 		ldterm_rubout((unsigned char) c, q, ebsize, tp);
2467 		ldterm_trim(tp);
2468 		--ip;
2469 	}
2470 
2471 	/*
2472 	 * Erase non-white-space characters, if any.  The outer loop
2473 	 * bops through each byte in the buffer. Multi-byte is removed, as
2474 	 * is ASCII, one byte at a time. The inner loop (for) is only
2475 	 * executed for first bytes of multi-byte.  The inner loop erases
2476 	 * the number of columns required for the multi-byte char.  We check
2477 	 * for ASCII first, and ldterm_rubout knows about ASCII.
2478 	 */
2479 	len = 0;
2480 	while (c != -1 && c != ' ' && c != '\t') {
2481 		tp->t_eucp--;
2482 		if (len < LDTERM_CS_MAX_BYTE_LENGTH) {
2483 			u8[len++] = (uchar_t)c;
2484 		}
2485 		/*
2486 		 * Unlike EUC, except the leading byte, some bytes of
2487 		 * a non-EUC multi-byte characters are in the ASCII code
2488 		 * range, esp., 0x41 ~ 0x7a. Thus, we cannot simply check
2489 		 * ISASCII().
2490 		 * Checking the (*ip == 1 || *ip == 2 || *ip > UNKNOWN_WIDTH)
2491 		 * will ensure that it is a single byte character (even though
2492 		 * it is on display width not byte length) and can be further
2493 		 * checked whether it is an ASCII character or not.
2494 		 *
2495 		 * When ECHOCTL is on and 'c' is an ASCII control character,
2496 		 * *ip == 2 happens.
2497 		 */
2498 		if ((*ip == 1 || *ip == 2 || *ip > UNKNOWN_WIDTH) &&
2499 		    ISASCII(c)) {
2500 			ldterm_rubout((unsigned char) c, q, ebsize, tp);
2501 			len = 0;
2502 		} else if (*ip) {
2503 			if (*ip == UNKNOWN_WIDTH) {
2504 				if (tp->t_csdata.codeset_type ==
2505 				    LDTERM_CS_TYPE_UTF8) {
2506 					for (i = 0; i < len; i++)
2507 						u8_2[i] = u8[len - i - 1];
2508 					*ip = ldterm_utf8_width(u8_2, len);
2509 				} else {
2510 					*ip = 1;
2511 				}
2512 			}
2513 			/*
2514 			 * erase for number of columns required for
2515 			 * this multi-byte character. Hopefully, matches
2516 			 * ldterm_dispwidth!
2517 			 */
2518 			for (i = 0; i < (int)*ip; i++)
2519 				ldterm_rubout(' ', q, ebsize, tp);
2520 			len = 0;
2521 		}
2522 		ldterm_trim(tp);
2523 		--ip;
2524 		c = ldterm_unget(tp);
2525 	}
2526 	if (c != -1) {
2527 		/*
2528 		 * We removed one too many characters; put the last
2529 		 * one back.
2530 		 */
2531 		tp->t_endmsg->b_wptr++;	/* put 'c' back */
2532 		tp->t_msglen++;
2533 	}
2534 }
2535 
2536 
2537 /*
2538  * Kill an entire line, erasing each character one-by-one (if ECHOKE
2539  * is set) or just echoing the kill character, followed by a newline
2540  * (if ECHOK is set).  Multi-byte processing is included here.
2541  */
2542 
2543 static void
2544 ldterm_kill(queue_t *q, size_t ebsize, ldtermstd_state_t *tp)
2545 {
2546 	int c, i;
2547 	int len;
2548 	uchar_t *ip;
2549 	uchar_t u8[LDTERM_CS_MAX_BYTE_LENGTH];
2550 	uchar_t u8_2[LDTERM_CS_MAX_BYTE_LENGTH];
2551 
2552 	if ((tp->t_modes.c_lflag & ECHOKE) &&
2553 	    (tp->t_modes.c_lflag & IEXTEN) &&
2554 	    (tp->t_msglen == tp->t_rocount)) {
2555 		if (tp->t_state & TS_MEUC) {
2556 			ip = tp->t_eucp - 1;
2557 			/*
2558 			 * This loop similar to "ldterm_csi_werase" above.
2559 			 */
2560 			len = 0;
2561 			while ((c = ldterm_unget(tp)) != (-1)) {
2562 				tp->t_eucp--;
2563 				if (len < LDTERM_CS_MAX_BYTE_LENGTH) {
2564 					u8[len++] = (uchar_t)c;
2565 				}
2566 				if ((*ip == 1 || *ip == 2 ||
2567 				    *ip > UNKNOWN_WIDTH) && ISASCII(c)) {
2568 					ldterm_rubout((unsigned char) c, q,
2569 					    ebsize, tp);
2570 					len = 0;
2571 				} else if (*ip) {
2572 					if (*ip == UNKNOWN_WIDTH) {
2573 						if (tp->t_csdata.codeset_type
2574 						    == LDTERM_CS_TYPE_UTF8) {
2575 							for (i = 0; i < len;
2576 							    i++)
2577 								u8_2[i] =
2578 								    u8[len-i-1];
2579 							*ip = ldterm_utf8_width(
2580 							    u8_2, len);
2581 						} else {
2582 							*ip = 1;
2583 						}
2584 					}
2585 					for (i = 0; i < (int)*ip; i++)
2586 						ldterm_rubout(' ', q, ebsize,
2587 						    tp);
2588 					len = 0;
2589 				}
2590 				ldterm_trim(tp);
2591 				--ip;
2592 			}
2593 		} else {
2594 			while ((c = ldterm_unget(tp)) != -1) {
2595 				ldterm_rubout((unsigned char) c, q, ebsize, tp);
2596 				ldterm_trim(tp);
2597 			}
2598 		}
2599 	} else {
2600 		(void) ldterm_echo(tp->t_modes.c_cc[VKILL], q, ebsize, tp);
2601 		if (tp->t_modes.c_lflag & ECHOK)
2602 			(void) ldterm_echo('\n', q, ebsize, tp);
2603 		while (ldterm_unget(tp) != -1) {
2604 			if (tp->t_state & TS_MEUC)
2605 				--tp->t_eucp;
2606 			ldterm_trim(tp);
2607 		}
2608 		tp->t_rocount = 0;
2609 		if (tp->t_state & TS_MEUC)
2610 			tp->t_eucp = tp->t_eucp_mp->b_rptr;
2611 	}
2612 	tp->t_state &= ~(TS_QUOT|TS_ERASE|TS_SLNCH);
2613 }
2614 
2615 
2616 /*
2617  * Reprint the current input line. We assume c_cc has already been
2618  * checked. XXX just the current line, not the whole queue? What
2619  * about DEFECHO mode?
2620  */
2621 static void
2622 ldterm_reprint(queue_t *q, size_t ebsize, ldtermstd_state_t *tp)
2623 {
2624 	mblk_t *bp;
2625 	unsigned char *readp;
2626 
2627 	if (tp->t_modes.c_cc[VREPRINT] != (unsigned char) 0)
2628 		(void) ldterm_echo(tp->t_modes.c_cc[VREPRINT], q, ebsize, tp);
2629 	ldterm_outchar('\n', q, ebsize, tp);
2630 
2631 	bp = tp->t_message;
2632 	do {
2633 		readp = bp->b_rptr;
2634 		while (readp < bp->b_wptr)
2635 			(void) ldterm_echo(*readp++, q, ebsize, tp);
2636 	} while ((bp = bp->b_cont) != NULL);	/* next block, if any */
2637 
2638 	tp->t_state &= ~TS_ERASE;
2639 	tp->t_rocount = tp->t_msglen;	/* we reechoed the entire line */
2640 	tp->t_rocol = 0;
2641 }
2642 
2643 
2644 /*
2645  * Non canonical processing. Called with q locked from  ldtermrsrv.
2646  *
2647  */
2648 static mblk_t *
2649 ldterm_dononcanon(mblk_t *bp, mblk_t *bpt, size_t ebsize, queue_t *q,
2650     ldtermstd_state_t *tp)
2651 {
2652 	queue_t *wrq = WR(q);
2653 	unsigned char *rptr;
2654 	size_t bytes_in_bp;
2655 	size_t roomleft;
2656 	size_t bytes_to_move;
2657 	int free_flag = 0;
2658 
2659 	if (tp->t_modes.c_lflag & (ECHO|ECHONL|IEXTEN)) {
2660 		unsigned char *wptr;
2661 		unsigned char c;
2662 
2663 		/*
2664 		 * Either we must echo the characters, or we must
2665 		 * echo NL, or we must check for VLNEXT. Process
2666 		 * characters one at a time.
2667 		 */
2668 		rptr = bp->b_rptr;
2669 		wptr = bp->b_rptr;
2670 		while (rptr < bp->b_wptr) {
2671 			c = *rptr++;
2672 			/*
2673 			 * If this character is the literal next
2674 			 * character, echo it as '^' and backspace
2675 			 * over it if echoing is enabled, indicate
2676 			 * that the next character is to be treated
2677 			 * literally, and remove the LNEXT from the
2678 			 * input stream.
2679 			 *
2680 			 * If the *previous* character was the literal
2681 			 * next character, don't check whether this
2682 			 * is a literal next or not.
2683 			 */
2684 			if ((tp->t_modes.c_lflag & IEXTEN) &&
2685 			    !(tp->t_state & TS_SLNCH) &&
2686 			    c != _POSIX_VDISABLE &&
2687 			    c == tp->t_modes.c_cc[VLNEXT]) {
2688 				if (tp->t_modes.c_lflag & ECHO)
2689 					ldterm_outstring(
2690 					    (unsigned char *)"^\b",
2691 					    2, wrq, ebsize, tp);
2692 				tp->t_state |= TS_SLNCH;
2693 				continue;	/* and ignore it */
2694 			}
2695 			/*
2696 			 * Not a "literal next" character, so it
2697 			 * should show up as input. If it was
2698 			 * literal-nexted, turn off the literal-next
2699 			 * flag.
2700 			 */
2701 			tp->t_state &= ~TS_SLNCH;
2702 			*wptr++ = c;
2703 			if (tp->t_modes.c_lflag & ECHO) {
2704 				/*
2705 				 * Echo the character.
2706 				 */
2707 				(void) ldterm_echo(c, wrq, ebsize, tp);
2708 			} else if (tp->t_modes.c_lflag & ECHONL) {
2709 				/*
2710 				 * Echo NL, even though ECHO is not
2711 				 * set.
2712 				 */
2713 				if (c == '\n')
2714 					ldterm_outchar('\n', wrq, 1, tp);
2715 			}
2716 		}
2717 		bp->b_wptr = wptr;
2718 	} else {
2719 		/*
2720 		 * If there are any characters in this buffer, and
2721 		 * the first of them was literal-nexted, turn off the
2722 		 * literal-next flag.
2723 		 */
2724 		if (bp->b_rptr != bp->b_wptr)
2725 			tp->t_state &= ~TS_SLNCH;
2726 	}
2727 
2728 	ASSERT(bp->b_wptr >= bp->b_rptr);
2729 	bytes_in_bp = bp->b_wptr - bp->b_rptr;
2730 	rptr = bp->b_rptr;
2731 	while (bytes_in_bp != 0) {
2732 		roomleft = bpt->b_datap->db_lim - bpt->b_wptr;
2733 		if (roomleft == 0) {
2734 			/*
2735 			 * No more room in this mblk; save this one
2736 			 * away, and allocate a new one.
2737 			 */
2738 			if ((bpt = allocb(IBSIZE, BPRI_MED)) == NULL) {
2739 				freeb(bp);
2740 				DEBUG4(("ldterm_do_noncanon: allcob failed\n"));
2741 				return (bpt);
2742 			}
2743 			/*
2744 			 * Chain the new one to the end of the old
2745 			 * one, and mark it as the last block in the
2746 			 * current lump.
2747 			 */
2748 			tp->t_endmsg->b_cont = bpt;
2749 			tp->t_endmsg = bpt;
2750 			roomleft = IBSIZE;
2751 		}
2752 		DEBUG5(("roomleft=%d, bytes_in_bp=%d, tp->t_rd_request=%d\n",
2753 		    roomleft, bytes_in_bp, tp->t_rd_request));
2754 		/*
2755 		 * if there is a read pending before this data got
2756 		 * here move bytes according to the minimum of room
2757 		 * left in this buffer, bytes in the message and byte
2758 		 * count requested in the read. If there is no read
2759 		 * pending, move the minimum of the first two
2760 		 */
2761 		if (tp->t_rd_request == 0)
2762 			bytes_to_move = MIN(roomleft, bytes_in_bp);
2763 		else
2764 			bytes_to_move =
2765 			    MIN(MIN(roomleft, bytes_in_bp), tp->t_rd_request);
2766 		DEBUG5(("Bytes to move = %lu\n", bytes_to_move));
2767 		if (bytes_to_move == 0)
2768 			break;
2769 		bcopy(rptr, bpt->b_wptr, bytes_to_move);
2770 		bpt->b_wptr += bytes_to_move;
2771 		rptr += bytes_to_move;
2772 		tp->t_msglen += bytes_to_move;
2773 		bytes_in_bp -= bytes_to_move;
2774 	}
2775 	if (bytes_in_bp == 0) {
2776 		DEBUG4(("bytes_in_bp is zero\n"));
2777 		freeb(bp);
2778 	} else
2779 		free_flag = 1;	/* for debugging olny */
2780 
2781 	DEBUG4(("ldterm_do_noncanon: VMIN = %d, VTIME = %d, msglen = %d, \
2782 		tid = %d\n", V_MIN, V_TIME, tp->t_msglen, tp->t_vtid));
2783 	/*
2784 	 * If there is a pending read request at the stream head we
2785 	 * need to do VMIN/VTIME processing. The four possible cases
2786 	 * are:
2787 	 *	MIN = 0, TIME > 0
2788 	 *	MIN = >, TIME = 0
2789 	 *	MIN > 0, TIME > 0
2790 	 *	MIN = 0, TIME = 0
2791 	 * If we can satisfy VMIN, send it up, and start a new
2792 	 * timer if necessary.  These four cases of VMIN/VTIME
2793 	 * are also dealt with in the write side put routine
2794 	 * when the M_READ is first seen.
2795 	 */
2796 
2797 	DEBUG4(("Incoming data while M_READ'ing\n"));
2798 	/*
2799 	 * Case 1:  Any data will satisfy the read, so send
2800 	 * it upstream.
2801 	 */
2802 	if (V_MIN == 0 && V_TIME > 0) {
2803 		if (tp->t_msglen)
2804 			vmin_satisfied(q, tp, 1);
2805 		else {
2806 			/* EMPTY */
2807 			DEBUG4(("ldterm_do_noncanon called, but no data!\n"));
2808 		}
2809 		/*
2810 		 * Case 2:  This should never time out, so
2811 		 * until there's enough data, do nothing.
2812 		 */
2813 	} else if (V_MIN > 0 && V_TIME == 0) {
2814 		if (tp->t_msglen >= (int)V_MIN)
2815 			vmin_satisfied(q, tp, 1);
2816 
2817 		/*
2818 		 * Case 3:  If MIN is satisfied, send it up.
2819 		 * Also, remember to start a new timer *every*
2820 		 * time we see something if MIN isn't
2821 		 * safisfied
2822 		 */
2823 	} else if (V_MIN > 0 && V_TIME > 0) {
2824 		if (tp->t_msglen >= (int)V_MIN)
2825 			vmin_satisfied(q, tp, 1);
2826 		else
2827 			vmin_settimer(q);
2828 		/*
2829 		 * Case 4:  Not possible.  This request
2830 		 * should always be satisfied from the write
2831 		 * side, left here for debugging.
2832 		 */
2833 	} else {	/* V_MIN == 0 && V_TIME == 0 */
2834 			vmin_satisfied(q, tp, 1);
2835 	}
2836 
2837 	if (free_flag) {
2838 		/* EMPTY */
2839 		DEBUG4(("CAUTION message block not freed\n"));
2840 	}
2841 	return (newmsg(tp));
2842 }
2843 
2844 
2845 /*
2846  * Echo a typed byte to the terminal.  Returns the number of bytes
2847  * printed. Bytes of EUC characters drop through the ECHOCTL stuff
2848  * and are just output as themselves.
2849  */
2850 static int
2851 ldterm_echo(uchar_t c, queue_t *q, size_t ebsize, ldtermstd_state_t *tp)
2852 {
2853 	int i;
2854 
2855 	if (!(tp->t_modes.c_lflag & ECHO))
2856 		return (0);
2857 	i = 0;
2858 
2859 	/*
2860 	 * Echo control characters (c <= 37) only if the ECHOCTRL
2861 	 * flag is set as ^X.
2862 	 */
2863 
2864 	if ((tp->t_modes.c_lflag & ECHOCTL) &&
2865 	    (tp->t_modes.c_lflag & IEXTEN)) {
2866 		if (c <= 037 && c != '\t' && c != '\n') {
2867 			ldterm_outchar('^', q, ebsize, tp);
2868 			i++;
2869 			if (tp->t_modes.c_oflag & OLCUC)
2870 				c += 'a' - 1;
2871 			else
2872 				c += 'A' - 1;
2873 		} else if (c == 0177) {
2874 			ldterm_outchar('^', q, ebsize, tp);
2875 			i++;
2876 			c = '?';
2877 		}
2878 		ldterm_outchar(c, q, ebsize, tp);
2879 		return (i + 1);
2880 		/* echo only special control character and the Bell */
2881 	} else if ((c > 037 && c != 0177) || c == '\t' || c == '\n' ||
2882 	    c == '\r' || c == '\b' || c == 007 ||
2883 	    c == tp->t_modes.c_cc[VKILL]) {
2884 		ldterm_outchar(c, q, ebsize, tp);
2885 		return (i + 1);
2886 	}
2887 	return (i);
2888 }
2889 
2890 
2891 /*
2892  * Put a character on the output queue.
2893  */
2894 static void
2895 ldterm_outchar(uchar_t c, queue_t *q, size_t bsize, ldtermstd_state_t *tp)
2896 {
2897 	mblk_t *curbp;
2898 
2899 	/*
2900 	 * Don't even look at the characters unless we have something
2901 	 * useful to do with them.
2902 	 */
2903 	if ((tp->t_modes.c_oflag & OPOST) ||
2904 	    ((tp->t_modes.c_lflag & XCASE) &&
2905 	    (tp->t_modes.c_lflag & ICANON))) {
2906 		mblk_t *mp;
2907 
2908 		if ((mp = allocb(4, BPRI_HI)) == NULL) {
2909 			cmn_err(CE_WARN,
2910 			    "ldterm: (ldterm_outchar) out of blocks");
2911 			return;
2912 		}
2913 		*mp->b_wptr++ = c;
2914 		mp = ldterm_output_msg(q, mp, &tp->t_echomp, tp, bsize, 1);
2915 		if (mp != NULL)
2916 			freemsg(mp);
2917 
2918 	} else {
2919 		if ((curbp = tp->t_echomp) != NULL) {
2920 			while (curbp->b_cont != NULL)
2921 				curbp = curbp->b_cont;
2922 			if (curbp->b_datap->db_lim == curbp->b_wptr) {
2923 				mblk_t *newbp;
2924 
2925 				if ((newbp = allocb(bsize, BPRI_HI)) == NULL) {
2926 					cmn_err(CE_WARN,
2927 					    "ldterm_outchar: out of blocks");
2928 					return;
2929 				}
2930 				curbp->b_cont = newbp;
2931 				curbp = newbp;
2932 			}
2933 		} else {
2934 			if ((curbp = allocb(bsize, BPRI_HI)) == NULL) {
2935 				cmn_err(CE_WARN,
2936 				    "ldterm_outchar: out of blocks");
2937 				return;
2938 			}
2939 			tp->t_echomp = curbp;
2940 		}
2941 		*curbp->b_wptr++ = c;
2942 	}
2943 }
2944 
2945 
2946 /*
2947  * Copy a string, of length len, to the output queue.
2948  */
2949 static void
2950 ldterm_outstring(uchar_t *cp, int len, queue_t *q, size_t bsize,
2951     ldtermstd_state_t *tp)
2952 {
2953 	while (len > 0) {
2954 		ldterm_outchar(*cp++, q, bsize, tp);
2955 		len--;
2956 	}
2957 }
2958 
2959 
2960 static mblk_t *
2961 newmsg(ldtermstd_state_t *tp)
2962 {
2963 	mblk_t *bp;
2964 
2965 	/*
2966 	 * If no current message, allocate a block for it.
2967 	 */
2968 	if ((bp = tp->t_endmsg) == NULL) {
2969 		if ((bp = allocb(IBSIZE, BPRI_MED)) == NULL) {
2970 			cmn_err(CE_WARN,
2971 			    "ldterm: (ldtermrsrv/newmsg) out of blocks");
2972 			return (bp);
2973 		}
2974 		tp->t_message = bp;
2975 		tp->t_endmsg = bp;
2976 	}
2977 	return (bp);
2978 }
2979 
2980 
2981 static void
2982 ldterm_msg_upstream(queue_t *q, ldtermstd_state_t *tp)
2983 {
2984 	ssize_t s;
2985 	mblk_t *bp;
2986 
2987 	bp = tp->t_message;
2988 	s = msgdsize(bp);
2989 	if (bp)
2990 		putnext(q, tp->t_message);
2991 
2992 	/*
2993 	 * update sysinfo canch character.
2994 	 */
2995 	if (CANON_MODE)
2996 		(void) drv_setparm(SYSCANC, s);
2997 	tp->t_message = NULL;
2998 	tp->t_endmsg = NULL;
2999 	tp->t_msglen = 0;
3000 	tp->t_rocount = 0;
3001 	tp->t_rd_request = 0;
3002 	if (tp->t_state & TS_MEUC) {
3003 		ASSERT(tp->t_eucp_mp);
3004 		tp->t_eucp = tp->t_eucp_mp->b_rptr;
3005 		/* can't reset everything, as we may have other input */
3006 	}
3007 }
3008 
3009 
3010 /*
3011  * Re-enable the write-side service procedure.  When an allocation
3012  * failure causes write-side processing to stall, we disable the
3013  * write side and arrange to call this function when allocation once
3014  * again becomes possible.
3015  */
3016 static void
3017 ldterm_wenable(void *addr)
3018 {
3019 	queue_t *q = addr;
3020 	ldtermstd_state_t *tp;
3021 
3022 	tp = (ldtermstd_state_t *)q->q_ptr;
3023 	/*
3024 	 * The bufcall is no longer pending.
3025 	 */
3026 	tp->t_wbufcid = 0;
3027 	enableok(q);
3028 	qenable(q);
3029 }
3030 
3031 
3032 /*
3033  * Line discipline output queue put procedure.  Attempts to process
3034  * the message directly and send it on downstream, queueing it only
3035  * if there's already something pending or if its downstream neighbor
3036  * is clogged.
3037  */
3038 static void
3039 ldtermwput(queue_t *q, mblk_t *mp)
3040 {
3041 	ldtermstd_state_t *tp;
3042 	unsigned char type = mp->b_datap->db_type;
3043 
3044 	tp = (ldtermstd_state_t *)q->q_ptr;
3045 
3046 	/*
3047 	 * Always process priority messages, regardless of whether or
3048 	 * not our queue is nonempty.
3049 	 */
3050 	if (type >= QPCTL) {
3051 		switch (type) {
3052 
3053 		case M_FLUSH:
3054 			/*
3055 			 * Get rid of it, see comment in
3056 			 * ldterm_dosig().
3057 			 */
3058 			if ((tp->t_state & TS_FLUSHWAIT) &&
3059 			    (*mp->b_rptr == FLUSHW)) {
3060 				tp->t_state &= ~TS_FLUSHWAIT;
3061 				freemsg(mp);
3062 				return;
3063 			}
3064 			/*
3065 			 * This is coming from above, so we only
3066 			 * handle the write queue here.  If FLUSHR is
3067 			 * set, it will get turned around at the
3068 			 * driver, and the read procedure will see it
3069 			 * eventually.
3070 			 */
3071 			if (*mp->b_rptr & FLUSHW) {
3072 				if ((tp->t_state & TS_ISPTSTTY) &&
3073 				    (*mp->b_rptr & FLUSHBAND))
3074 					flushband(q, *(mp->b_rptr + 1),
3075 					    FLUSHDATA);
3076 				else
3077 					flushq(q, FLUSHDATA);
3078 			}
3079 
3080 			putnext(q, mp);
3081 			/*
3082 			 * If a timed read is interrupted, there is
3083 			 * no way to cancel an existing M_READ
3084 			 * request.  We kludge by allowing a flush to
3085 			 * do so.
3086 			 */
3087 			if (tp->t_state & TS_MREAD)
3088 				vmin_satisfied(RD(q), tp, 0);
3089 			break;
3090 
3091 		case M_READ:
3092 			DEBUG1(("ldtermwmsg:M_READ RECEIVED\n"));
3093 			/*
3094 			 * Stream head needs data to satisfy timed
3095 			 * read. Has meaning only if ICANON flag is
3096 			 * off indicating raw mode
3097 			 */
3098 
3099 			DEBUG4((
3100 			    "M_READ: RAW_MODE=%d, CNT=%d, VMIN=%d, VTIME=%d\n",
3101 			    RAW_MODE, *(unsigned int *)mp->b_rptr, V_MIN,
3102 			    V_TIME));
3103 
3104 			tp->t_rd_request = *(unsigned int *)mp->b_rptr;
3105 
3106 			if (RAW_MODE) {
3107 				if (newmsg(tp) != NULL) {
3108 					/*
3109 					 * VMIN/VTIME processing...
3110 					 * The four possible cases are:
3111 					 *	MIN = 0, TIME > 0
3112 					 *	MIN = >, TIME = 0
3113 					 *	MIN > 0, TIME > 0
3114 					 *	MIN = 0, TIME = 0
3115 					 * These four conditions must be dealt
3116 					 * with on the read side as well in
3117 					 * ldterm_do_noncanon(). Set TS_MREAD
3118 					 * so that the read side will know
3119 					 * there is a pending read request
3120 					 * waiting at the stream head.  If we
3121 					 * can satisfy MIN do it here, rather
3122 					 * than on the read side.  If we can't,
3123 					 * start timers if necessary and let
3124 					 * the other side deal with it.
3125 					 *
3126 					 * We got another M_READ before the
3127 					 * pending one completed, cancel any
3128 					 * existing timeout.
3129 					 */
3130 					if (tp->t_state & TS_MREAD) {
3131 						vmin_satisfied(RD(q),
3132 						    tp, 0);
3133 					}
3134 					tp->t_state |= TS_MREAD;
3135 					/*
3136 					 * Case 1:  Any data will
3137 					 * satisfy read, otherwise
3138 					 * start timer
3139 					 */
3140 					if (V_MIN == 0 && V_TIME > 0) {
3141 						if (tp->t_msglen)
3142 							vmin_satisfied(RD(q),
3143 							    tp, 1);
3144 						else
3145 							vmin_settimer(RD(q));
3146 
3147 						/*
3148 						 * Case 2:  If we have enough
3149 						 * data, send up now.
3150 						 * Otherwise, the read side
3151 						 * should wait forever until MIN
3152 						 * is satisified.
3153 						 */
3154 					} else if (V_MIN > 0 && V_TIME == 0) {
3155 						if (tp->t_msglen >= (int)V_MIN)
3156 							vmin_satisfied(RD(q),
3157 							    tp, 1);
3158 
3159 						/*
3160 						 * Case 3:  If we can satisfy
3161 						 * the read, send it up. If we
3162 						 * don't have enough data, but
3163 						 * there is at least one char,
3164 						 * start a timer.  Otherwise,
3165 						 * let the read side start
3166 						 * the timer.
3167 						 */
3168 					} else if (V_MIN > 0 && V_TIME > 0) {
3169 						if (tp->t_msglen >= (int)V_MIN)
3170 							vmin_satisfied(RD(q),
3171 							    tp, 1);
3172 						else if (tp->t_msglen)
3173 							vmin_settimer(RD(q));
3174 						/*
3175 						 * Case 4:  Read returns
3176 						 * whatever data is available
3177 						 * or zero if none.
3178 						 */
3179 					} else { /* V_MIN == 0 && V_TIME == 0 */
3180 						vmin_satisfied(RD(q), tp, 1);
3181 					}
3182 
3183 				} else	/* should do bufcall, really! */
3184 					cmn_err(CE_WARN,
3185 					    "ldtermwmsg: out of blocks");
3186 			}
3187 			/*
3188 			 * pass M_READ down
3189 			 */
3190 			putnext(q, mp);
3191 			break;
3192 
3193 		default:
3194 			/* Pass it through unmolested. */
3195 			putnext(q, mp);
3196 			break;
3197 		}
3198 		return;
3199 	}
3200 	/*
3201 	 * If our queue is nonempty or there's a traffic jam
3202 	 * downstream, this message must get in line.
3203 	 */
3204 	if (q->q_first != NULL || !bcanputnext(q, mp->b_band)) {
3205 		/*
3206 		 * Exception: ioctls, except for those defined to
3207 		 * take effect after output has drained, should be
3208 		 * processed immediately.
3209 		 */
3210 		if (type == M_IOCTL) {
3211 			struct iocblk *iocp;
3212 
3213 			iocp = (struct iocblk *)mp->b_rptr;
3214 			switch (iocp->ioc_cmd) {
3215 
3216 				/*
3217 				 * Queue these.
3218 				 */
3219 			case TCSETSW:
3220 			case TCSETSF:
3221 			case TCSETAW:
3222 			case TCSETAF:
3223 			case TCSBRK:
3224 				break;
3225 
3226 				/*
3227 				 * Handle all others immediately.
3228 				 */
3229 			default:
3230 				(void) ldtermwmsg(q, mp);
3231 				return;
3232 			}
3233 		}
3234 		(void) putq(q, mp);
3235 		return;
3236 	}
3237 	/*
3238 	 * We can take the fast path through, by simply calling
3239 	 * ldtermwmsg to dispose of mp.
3240 	 */
3241 	(void) ldtermwmsg(q, mp);
3242 }
3243 
3244 
3245 /*
3246  * Line discipline output queue service procedure.
3247  */
3248 static void
3249 ldtermwsrv(queue_t *q)
3250 {
3251 	mblk_t *mp;
3252 
3253 	/*
3254 	 * We expect this loop to iterate at most once, but must be
3255 	 * prepared for more in case our upstream neighbor isn't
3256 	 * paying strict attention to what canput tells it.
3257 	 */
3258 	while ((mp = getq(q)) != NULL) {
3259 		/*
3260 		 * N.B.: ldtermwput has already handled high-priority
3261 		 * messages, so we don't have to worry about them
3262 		 * here. Hence, the putbq call is safe.
3263 		 */
3264 		if (!bcanputnext(q, mp->b_band)) {
3265 			(void) putbq(q, mp);
3266 			break;
3267 		}
3268 		if (!ldtermwmsg(q, mp)) {
3269 			/*
3270 			 * Couldn't handle the whole thing; give up
3271 			 * for now and wait to be rescheduled.
3272 			 */
3273 			break;
3274 		}
3275 	}
3276 }
3277 
3278 
3279 /*
3280  * Process the write-side message denoted by mp.  If mp can't be
3281  * processed completely (due to allocation failures), put the
3282  * residual unprocessed part on the front of the write queue, disable
3283  * the queue, and schedule a qbufcall to arrange to complete its
3284  * processing later.
3285  *
3286  * Return 1 if the message was processed completely and 0 if not.
3287  *
3288  * This routine is called from both ldtermwput and ldtermwsrv to do the
3289  * actual work of dealing with mp.  ldtermwput will have already
3290  * dealt with high priority messages.
3291  */
3292 static int
3293 ldtermwmsg(queue_t *q, mblk_t *mp)
3294 {
3295 	ldtermstd_state_t *tp;
3296 	mblk_t *residmp = NULL;
3297 	size_t size;
3298 
3299 	tp = (ldtermstd_state_t *)q->q_ptr;
3300 
3301 	switch (mp->b_datap->db_type) {
3302 
3303 	case M_IOCTL:
3304 		ldterm_do_ioctl(q, mp);
3305 		break;
3306 
3307 	case M_DATA:
3308 		{
3309 			mblk_t *omp = NULL;
3310 
3311 			if ((tp->t_modes.c_lflag & FLUSHO) &&
3312 			    (tp->t_modes.c_lflag & IEXTEN)) {
3313 				freemsg(mp);	/* drop on floor */
3314 				break;
3315 			}
3316 			tp->t_rocount = 0;
3317 			/*
3318 			 * Don't even look at the characters unless
3319 			 * we have something useful to do with them.
3320 			 */
3321 			if (((tp->t_modes.c_oflag & OPOST) ||
3322 			    ((tp->t_modes.c_lflag & XCASE) &&
3323 			    (tp->t_modes.c_lflag & ICANON))) &&
3324 			    (msgdsize(mp) || !(tp->t_state & TS_ISPTSTTY))) {
3325 				unsigned char band = mp->b_band;
3326 				short flag = mp->b_flag;
3327 
3328 				residmp = ldterm_output_msg(q, mp, &omp,
3329 				    tp, OBSIZE, 0);
3330 				if ((mp = omp) == NULL)
3331 					break;
3332 				mp->b_band |= band;
3333 				mp->b_flag |= flag;
3334 			}
3335 			/* Update sysinfo outch */
3336 			(void) drv_setparm(SYSOUTC, msgdsize(mp));
3337 			putnext(q, mp);
3338 			break;
3339 		}
3340 
3341 	default:
3342 		putnext(q, mp);	/* pass it through unmolested */
3343 		break;
3344 	}
3345 
3346 	if (residmp == NULL)
3347 		return (1);
3348 
3349 	/*
3350 	 * An allocation failure occurred that prevented the message
3351 	 * from being completely processed.  First, disable our
3352 	 * queue, since it's pointless to attempt further processing
3353 	 * until the allocation situation is resolved.  (This must
3354 	 * precede the putbq call below, which would otherwise mark
3355 	 * the queue to be serviced.)
3356 	 */
3357 	noenable(q);
3358 	/*
3359 	 * Stuff the remnant on our write queue so that we can
3360 	 * complete it later when times become less lean.  Note that
3361 	 * this sets QFULL, so that our upstream neighbor will be
3362 	 * blocked by flow control.
3363 	 */
3364 	(void) putbq(q, residmp);
3365 	/*
3366 	 * Schedule a qbufcall to re-enable the queue.  The failure
3367 	 * won't have been for an allocation of more than OBSIZE
3368 	 * bytes, so don't ask for more than that from bufcall.
3369 	 */
3370 	size = msgdsize(residmp);
3371 	if (size > OBSIZE)
3372 		size = OBSIZE;
3373 	if (tp->t_wbufcid)
3374 		qunbufcall(q, tp->t_wbufcid);
3375 	tp->t_wbufcid = qbufcall(q, size, BPRI_MED, ldterm_wenable, q);
3376 
3377 	return (0);
3378 }
3379 
3380 
3381 /*
3382  * Perform output processing on a message, accumulating the output
3383  * characters in a new message.
3384  */
3385 static mblk_t *
3386 ldterm_output_msg(queue_t *q, mblk_t *imp, mblk_t **omp,
3387     ldtermstd_state_t *tp, size_t bsize, int echoing)
3388 {
3389 	mblk_t *ibp;		/* block we're examining from input message */
3390 	mblk_t *obp;		/* block we're filling in output message */
3391 	mblk_t *cbp;		/* continuation block */
3392 	mblk_t *oobp;		/* old value of obp; valid if NEW_BLOCK fails */
3393 	mblk_t **contpp;	/* where to stuff ptr to newly-allocated blk */
3394 	unsigned char c, n;
3395 	int count, ctype;
3396 	ssize_t bytes_left;
3397 
3398 	mblk_t *bp;		/* block to stuff an M_DELAY message in */
3399 
3400 
3401 	/*
3402 	 * Allocate a new block into which to put bytes. If we can't,
3403 	 * we just drop the rest of the message on the floor. If x is
3404 	 * non-zero, just fall thru; failure requires cleanup before
3405 	 * going out
3406 	 */
3407 
3408 #define	NEW_BLOCK(x) \
3409 	{ \
3410 		oobp = obp; \
3411 		if ((obp = allocb(bsize, BPRI_MED)) == NULL) { \
3412 			if (x == 0) \
3413 				goto outofbufs; \
3414 		} else { \
3415 			*contpp = obp; \
3416 			contpp = &obp->b_cont; \
3417 			bytes_left = obp->b_datap->db_lim - obp->b_wptr; \
3418 		} \
3419 	}
3420 
3421 	ibp = imp;
3422 
3423 	/*
3424 	 * When we allocate the first block of a message, we should
3425 	 * stuff the pointer to it in "*omp".  All subsequent blocks
3426 	 * should have the pointer to them stuffed into the "b_cont"
3427 	 * field of the previous block.  "contpp" points to the place
3428 	 * where we should stuff the pointer.
3429 	 *
3430 	 * If we already have a message we're filling in, continue doing
3431 	 * so.
3432 	 */
3433 	if ((obp = *omp) != NULL) {
3434 		while (obp->b_cont != NULL)
3435 			obp = obp->b_cont;
3436 		contpp = &obp->b_cont;
3437 		bytes_left = obp->b_datap->db_lim - obp->b_wptr;
3438 	} else {
3439 		contpp = omp;
3440 		bytes_left = 0;
3441 	}
3442 
3443 	do {
3444 		while (ibp->b_rptr < ibp->b_wptr) {
3445 			/*
3446 			 * Make sure there's room for one more
3447 			 * character.  At most, we'll need "t_maxeuc"
3448 			 * bytes.
3449 			 */
3450 			if ((bytes_left < (int)tp->t_maxeuc)) {
3451 				/* LINTED */
3452 				NEW_BLOCK(0);
3453 			}
3454 			/*
3455 			 * If doing XCASE processing (not very
3456 			 * likely, in this day and age), look at each
3457 			 * character individually.
3458 			 */
3459 			if ((tp->t_modes.c_lflag & XCASE) &&
3460 			    (tp->t_modes.c_lflag & ICANON)) {
3461 				c = *ibp->b_rptr++;
3462 
3463 				/*
3464 				 * We need to make sure that this is not
3465 				 * a following byte of a multibyte character
3466 				 * before applying an XCASE processing.
3467 				 *
3468 				 * tp->t_eucign will be 0 if and only
3469 				 * if the current 'c' is an ASCII character
3470 				 * and also a byte. Otherwise, it will have
3471 				 * the byte length of a multibyte character.
3472 				 */
3473 				if ((tp->t_state & TS_MEUC) &&
3474 				    tp->t_eucign == 0 && NOTASCII(c)) {
3475 					tp->t_eucign =
3476 					    tp->t_csmethods.ldterm_memwidth(
3477 					    c, (void *)tp);
3478 					tp->t_scratch_len = tp->t_eucign;
3479 
3480 					if (tp->t_csdata.codeset_type !=
3481 					    LDTERM_CS_TYPE_UTF8) {
3482 						tp->t_col +=
3483 						    tp->
3484 						    t_csmethods.
3485 						    ldterm_dispwidth(c,
3486 						    (void *)tp,
3487 						    tp->t_modes.c_lflag &
3488 						    ECHOCTL);
3489 					}
3490 				}
3491 
3492 				/*
3493 				 * If character is mapped on output,
3494 				 * put out a backslash followed by
3495 				 * what it is mapped to.
3496 				 */
3497 				if (tp->t_eucign == 0 && omaptab[c] != 0 &&
3498 				    (!echoing || c != '\\')) {
3499 					/* backslash is an ordinary character */
3500 					tp->t_col++;
3501 					*obp->b_wptr++ = '\\';
3502 					bytes_left--;
3503 					if (bytes_left == 0) {
3504 						/* LINTED */
3505 						NEW_BLOCK(1);
3506 					}
3507 					/*
3508 					 * Allocation failed, make
3509 					 * state consistent before
3510 					 * returning
3511 					 */
3512 					if (obp == NULL) {
3513 						ibp->b_rptr--;
3514 						tp->t_col--;
3515 						oobp->b_wptr--;
3516 						goto outofbufs;
3517 					}
3518 					c = omaptab[c];
3519 				}
3520 				/*
3521 				 * If no other output processing is
3522 				 * required, push the character into
3523 				 * the block and get another.
3524 				 */
3525 				if (!(tp->t_modes.c_oflag & OPOST)) {
3526 					if (tp->t_eucign > 0) {
3527 						--tp->t_eucign;
3528 					} else {
3529 						tp->t_col++;
3530 					}
3531 					*obp->b_wptr++ = c;
3532 					bytes_left--;
3533 					continue;
3534 				}
3535 				/*
3536 				 * OPOST output flag is set. Map
3537 				 * lower case to upper case if OLCUC
3538 				 * flag is set and the 'c' is a lowercase
3539 				 * ASCII character.
3540 				 */
3541 				if (tp->t_eucign == 0 &&
3542 				    (tp->t_modes.c_oflag & OLCUC) &&
3543 				    c >= 'a' && c <= 'z')
3544 					c -= 'a' - 'A';
3545 			} else {
3546 				/*
3547 				 * Copy all the ORDINARY characters,
3548 				 * possibly mapping upper case to
3549 				 * lower case.  We use "movtuc",
3550 				 * STOPPING when we can't move some
3551 				 * character. For multi-byte or
3552 				 * multi-column EUC, we can't depend
3553 				 * on the regular tables. Rather than
3554 				 * just drop through to the "big
3555 				 * switch" for all characters, it
3556 				 * _might_ be faster to let "movtuc"
3557 				 * move a bunch of characters.
3558 				 * Chances are, even in multi-byte
3559 				 * mode we'll have lots of ASCII
3560 				 * going through. We check the flag
3561 				 * once, and call movtuc with the
3562 				 * appropriate table as an argument.
3563 				 *
3564 				 * "movtuc will work for all codeset
3565 				 * types since it stops at the beginning
3566 				 * byte of a multibyte character.
3567 				 */
3568 				size_t bytes_to_move;
3569 				size_t bytes_moved;
3570 
3571 				ASSERT(ibp->b_wptr >= ibp->b_rptr);
3572 				bytes_to_move = ibp->b_wptr - ibp->b_rptr;
3573 				if (bytes_to_move > bytes_left)
3574 					bytes_to_move = bytes_left;
3575 				if (tp->t_state & TS_MEUC) {
3576 					bytes_moved = movtuc(bytes_to_move,
3577 					    ibp->b_rptr, obp->b_wptr,
3578 					    (tp->t_modes.c_oflag & OLCUC ?
3579 					    elcuctab : enotrantab));
3580 				} else {
3581 					bytes_moved = movtuc(bytes_to_move,
3582 					    ibp->b_rptr, obp->b_wptr,
3583 					    (tp->t_modes.c_oflag & OLCUC ?
3584 					    lcuctab : notrantab));
3585 				}
3586 				/*
3587 				 * We're save to just do this column
3588 				 * calculation, because if TS_MEUC is
3589 				 * set, we used the proper EUC
3590 				 * tables, and won't have copied any
3591 				 * EUC bytes.
3592 				 */
3593 				tp->t_col += bytes_moved;
3594 				ibp->b_rptr += bytes_moved;
3595 				obp->b_wptr += bytes_moved;
3596 				bytes_left -= bytes_moved;
3597 				if (ibp->b_rptr >= ibp->b_wptr)
3598 					continue;	/* moved all of block */
3599 				if (bytes_left == 0) {
3600 					/* LINTED */
3601 					NEW_BLOCK(0);
3602 				}
3603 				c = *ibp->b_rptr++;	/* stopper */
3604 			}
3605 
3606 			/*
3607 			 * Again, we need to make sure that this is not
3608 			 * a following byte of a multibyte character at
3609 			 * here.
3610 			 *
3611 			 * 'tp->t_eucign' will be 0 iff the current 'c' is
3612 			 * an ASCII character. Otherwise, it will have
3613 			 * the byte length of a multibyte character.
3614 			 * We also add the display width to 'tp->t_col' if
3615 			 * the current codeset is not UTF-8 since this is
3616 			 * a leading byte of a multibyte character.
3617 			 * For UTF-8 codeset type, we add the display width
3618 			 * when we get the last byte of a character.
3619 			 */
3620 			if ((tp->t_state & TS_MEUC) && tp->t_eucign == 0 &&
3621 			    NOTASCII(c)) {
3622 				tp->t_eucign = tp->t_csmethods.ldterm_memwidth(
3623 				    c, (void *)tp);
3624 				tp->t_scratch_len = tp->t_eucign;
3625 
3626 				if (tp->t_csdata.codeset_type !=
3627 				    LDTERM_CS_TYPE_UTF8) {
3628 					tp->t_col +=
3629 					    tp->t_csmethods.ldterm_dispwidth(c,
3630 					    (void *)tp,
3631 					    tp->t_modes.c_lflag & ECHOCTL);
3632 				}
3633 			}
3634 
3635 			/*
3636 			 * If the driver has requested, don't process
3637 			 * output flags.  However, if we're in
3638 			 * multi-byte mode, we HAVE to look at
3639 			 * EVERYTHING going out to maintain column
3640 			 * position properly. Therefore IF the driver
3641 			 * says don't AND we're not doing multi-byte,
3642 			 * then don't do it.  Otherwise, do it.
3643 			 *
3644 			 * NOTE:  Hardware USUALLY doesn't expand tabs
3645 			 * properly for multi-byte situations anyway;
3646 			 * that's a known problem with the 3B2
3647 			 * "PORTS" board firmware, and any other
3648 			 * hardware that doesn't ACTUALLY know about
3649 			 * the current EUC mapping that WE are using
3650 			 * at this very moment.  The problem is that
3651 			 * memory width is INDEPENDENT of screen
3652 			 * width - no relation - so WE know how wide
3653 			 * the characters are, but an off-the-host
3654 			 * board probably doesn't.  So, until we're
3655 			 * SURE that the hardware below us can
3656 			 * correctly expand tabs in a
3657 			 * multi-byte/multi-column EUC situation, we
3658 			 * do it ourselves.
3659 			 */
3660 			/*
3661 			 * Map <CR>to<NL> on output if OCRNL flag
3662 			 * set. ONLCR processing is not done if OCRNL
3663 			 * is set.
3664 			 */
3665 			if (c == '\r' && (tp->t_modes.c_oflag & OCRNL)) {
3666 				c = '\n';
3667 				ctype = typetab[c];
3668 				goto jocrnl;
3669 			}
3670 
3671 			if (tp->t_csdata.codeset_type == LDTERM_CS_TYPE_EUC) {
3672 				ctype = typetab[c];
3673 			} else {
3674 				/*
3675 				 * In other codeset types, we safely assume
3676 				 * any byte of a multibyte character will have
3677 				 * 'ORDINARY' type. For ASCII characters, we
3678 				 * still use the typetab[].
3679 				 */
3680 				if (tp->t_eucign == 0)
3681 					ctype = typetab[c];
3682 				else
3683 					ctype = ORDINARY;
3684 			}
3685 
3686 			/*
3687 			 * Map <NL> to <CR><NL> on output if ONLCR
3688 			 * flag is set.
3689 			 */
3690 			if (c == '\n' && (tp->t_modes.c_oflag & ONLCR)) {
3691 				if (!(tp->t_state & TS_TTCR)) {
3692 					tp->t_state |= TS_TTCR;
3693 					c = '\r';
3694 					ctype = typetab['\r'];
3695 					--ibp->b_rptr;
3696 				} else
3697 					tp->t_state &= ~TS_TTCR;
3698 			}
3699 			/*
3700 			 * Delay values and column position
3701 			 * calculated here.  For EUC chars in
3702 			 * multi-byte mode, we use "t_eucign" to help
3703 			 * calculate columns.  When we see the first
3704 			 * byte of an EUC, we set t_eucign to the
3705 			 * number of bytes that will FOLLOW it, and
3706 			 * we add the screen width of the WHOLE EUC
3707 			 * character to the column position.  In
3708 			 * particular, we can't count SS2 or SS3 as
3709 			 * printing characters.  Remember, folks, the
3710 			 * screen width and memory width are
3711 			 * independent - no relation. We could have
3712 			 * dropped through for ASCII, but we want to
3713 			 * catch any bad characters (i.e., t_eucign
3714 			 * set and an ASCII char received) and
3715 			 * possibly report the garbage situation.
3716 			 */
3717 	jocrnl:
3718 
3719 			count = 0;
3720 			switch (ctype) {
3721 
3722 			case T_SS2:
3723 			case T_SS3:
3724 			case ORDINARY:
3725 				if (tp->t_state & TS_MEUC) {
3726 					if (tp->t_eucign) {
3727 						*obp->b_wptr++ = c;
3728 						bytes_left--;
3729 
3730 						tp->t_scratch[tp->t_scratch_len
3731 						    - tp->t_eucign] = c;
3732 
3733 						--tp->t_eucign;
3734 
3735 						if (tp->t_csdata.codeset_type
3736 						    == LDTERM_CS_TYPE_UTF8 &&
3737 						    tp->t_eucign <= 0) {
3738 							tp->t_col +=
3739 							    ldterm_utf8_width(
3740 							    tp->t_scratch,
3741 							    tp->t_scratch_len);
3742 						}
3743 					} else {
3744 						if (tp->t_modes.c_oflag & OLCUC)
3745 							n = elcuctab[c];
3746 						else
3747 							n = enotrantab[c];
3748 						if (n)
3749 							c = n;
3750 						tp->t_col++;
3751 						*obp->b_wptr++ = c;
3752 						bytes_left--;
3753 					}
3754 				} else {	/* ho hum, ASCII mode... */
3755 					if (tp->t_modes.c_oflag & OLCUC)
3756 						n = lcuctab[c];
3757 					else
3758 						n = notrantab[c];
3759 					if (n)
3760 						c = n;
3761 					tp->t_col++;
3762 					*obp->b_wptr++ = c;
3763 					bytes_left--;
3764 				}
3765 				break;
3766 
3767 				/*
3768 				 * If we're doing ECHOCTL, we've
3769 				 * already mapped the thing during
3770 				 * the process of canonising.  Don't
3771 				 * bother here, as it's not one that
3772 				 * we did.
3773 				 */
3774 			case CONTROL:
3775 				*obp->b_wptr++ = c;
3776 				bytes_left--;
3777 				break;
3778 
3779 				/*
3780 				 * This is probably a backspace
3781 				 * received, not one that we're
3782 				 * echoing.  Let it go as a
3783 				 * single-column backspace.
3784 				 */
3785 			case BACKSPACE:
3786 				if (tp->t_col)
3787 					tp->t_col--;
3788 				if (tp->t_modes.c_oflag & BSDLY) {
3789 					if (tp->t_modes.c_oflag & OFILL)
3790 						count = 1;
3791 				}
3792 				*obp->b_wptr++ = c;
3793 				bytes_left--;
3794 				break;
3795 
3796 			case NEWLINE:
3797 				if (tp->t_modes.c_oflag & ONLRET)
3798 					goto cr;
3799 				if ((tp->t_modes.c_oflag & NLDLY) == NL1)
3800 					count = 2;
3801 				*obp->b_wptr++ = c;
3802 				bytes_left--;
3803 				break;
3804 
3805 			case TAB:
3806 				/*
3807 				 * Map '\t' to spaces if XTABS flag
3808 				 * is set.  The calculation of
3809 				 * "t_eucign" has probably insured
3810 				 * that column will be correct, as we
3811 				 * bumped t_col by the DISP width,
3812 				 * not the memory width.
3813 				 */
3814 				if ((tp->t_modes.c_oflag & TABDLY) == XTABS) {
3815 					for (;;) {
3816 						*obp->b_wptr++ = ' ';
3817 						bytes_left--;
3818 						tp->t_col++;
3819 						if ((tp->t_col & 07) == 0)
3820 							break;	/* every 8th */
3821 						/*
3822 						 * If we don't have
3823 						 * room to fully
3824 						 * expand this tab in
3825 						 * this block, back
3826 						 * up to continue
3827 						 * expanding it into
3828 						 * the next block.
3829 						 */
3830 						if (obp->b_wptr >=
3831 						    obp->b_datap->db_lim) {
3832 							ibp->b_rptr--;
3833 							break;
3834 						}
3835 					}
3836 				} else {
3837 					tp->t_col |= 07;
3838 					tp->t_col++;
3839 					if (tp->t_modes.c_oflag & OFILL) {
3840 						if (tp->t_modes.c_oflag &
3841 						    TABDLY)
3842 							count = 2;
3843 					} else {
3844 						switch (tp->t_modes.c_oflag &
3845 						    TABDLY) {
3846 						case TAB2:
3847 							count = 6;
3848 							break;
3849 
3850 						case TAB1:
3851 							count = 1 + (tp->t_col |
3852 							    ~07);
3853 							if (count < 5)
3854 								count = 0;
3855 							break;
3856 						}
3857 					}
3858 					*obp->b_wptr++ = c;
3859 					bytes_left--;
3860 				}
3861 				break;
3862 
3863 			case VTAB:
3864 				if ((tp->t_modes.c_oflag & VTDLY) &&
3865 				    !(tp->t_modes.c_oflag & OFILL))
3866 					count = 127;
3867 				*obp->b_wptr++ = c;
3868 				bytes_left--;
3869 				break;
3870 
3871 			case RETURN:
3872 				/*
3873 				 * Ignore <CR> in column 0 if ONOCR
3874 				 * flag set.
3875 				 */
3876 				if (tp->t_col == 0 &&
3877 				    (tp->t_modes.c_oflag & ONOCR))
3878 					break;
3879 
3880 		cr:
3881 				switch (tp->t_modes.c_oflag & CRDLY) {
3882 
3883 				case CR1:
3884 					if (tp->t_modes.c_oflag & OFILL)
3885 						count = 2;
3886 					else
3887 						count = tp->t_col % 2;
3888 					break;
3889 
3890 				case CR2:
3891 					if (tp->t_modes.c_oflag & OFILL)
3892 						count = 4;
3893 					else
3894 						count = 6;
3895 					break;
3896 
3897 				case CR3:
3898 					if (tp->t_modes.c_oflag & OFILL)
3899 						count = 0;
3900 					else
3901 						count = 9;
3902 					break;
3903 				}
3904 				tp->t_col = 0;
3905 				*obp->b_wptr++ = c;
3906 				bytes_left--;
3907 				break;
3908 			}
3909 
3910 			if (count != 0) {
3911 				if (tp->t_modes.c_oflag & OFILL) {
3912 					do {
3913 						if (bytes_left == 0) {
3914 							/* LINTED */
3915 							NEW_BLOCK(0);
3916 						}
3917 						if (tp->t_modes.c_oflag & OFDEL)
3918 							*obp->b_wptr++ = CDEL;
3919 						else
3920 							*obp->b_wptr++ = CNUL;
3921 						bytes_left--;
3922 					} while (--count != 0);
3923 				} else {
3924 					if ((tp->t_modes.c_lflag & FLUSHO) &&
3925 					    (tp->t_modes.c_lflag & IEXTEN)) {
3926 						/* drop on floor */
3927 						freemsg(*omp);
3928 					} else {
3929 						/*
3930 						 * Update sysinfo
3931 						 * outch
3932 						 */
3933 						(void) drv_setparm(SYSOUTC,
3934 						    msgdsize(*omp));
3935 						putnext(q, *omp);
3936 						/*
3937 						 * Send M_DELAY
3938 						 * downstream
3939 						 */
3940 						if ((bp =
3941 						    allocb(1, BPRI_MED)) !=
3942 						    NULL) {
3943 							bp->b_datap->db_type =
3944 							    M_DELAY;
3945 							*bp->b_wptr++ =
3946 							    (uchar_t)count;
3947 							putnext(q, bp);
3948 						}
3949 					}
3950 					bytes_left = 0;
3951 					/*
3952 					 * We have to start a new
3953 					 * message; the delay
3954 					 * introduces a break between
3955 					 * messages.
3956 					 */
3957 					*omp = NULL;
3958 					contpp = omp;
3959 				}
3960 			}
3961 		}
3962 		cbp = ibp->b_cont;
3963 		freeb(ibp);
3964 	} while ((ibp = cbp) != NULL);	/* next block, if any */
3965 
3966 outofbufs:
3967 	return (ibp);
3968 #undef NEW_BLOCK
3969 }
3970 
3971 
3972 #if !defined(__sparc)
3973 int
3974 movtuc(size_t size, unsigned char *from, unsigned char *origto,
3975 	unsigned char *table)
3976 {
3977 	unsigned char *to = origto;
3978 	unsigned char c;
3979 
3980 	while (size != 0 && (c = table[*from++]) != 0) {
3981 		*to++ = c;
3982 		size--;
3983 	}
3984 	return (to - origto);
3985 }
3986 #endif
3987 
3988 static void
3989 ldterm_flush_output(uchar_t c, queue_t *q, ldtermstd_state_t *tp)
3990 {
3991 	/* Already conditioned with IEXTEN during VDISCARD processing */
3992 	if (tp->t_modes.c_lflag & FLUSHO)
3993 		tp->t_modes.c_lflag &= ~FLUSHO;
3994 	else {
3995 		flushq(q, FLUSHDATA);	/* flush our write queue */
3996 		/* flush ones below us */
3997 		(void) putnextctl1(q, M_FLUSH, FLUSHW);
3998 		if ((tp->t_echomp = allocb(EBSIZE, BPRI_HI)) != NULL) {
3999 			(void) ldterm_echo(c, q, 1, tp);
4000 			if (tp->t_msglen != 0)
4001 				ldterm_reprint(q, EBSIZE, tp);
4002 			if (tp->t_echomp != NULL) {
4003 				putnext(q, tp->t_echomp);
4004 				tp->t_echomp = NULL;
4005 			}
4006 		}
4007 		tp->t_modes.c_lflag |= FLUSHO;
4008 	}
4009 }
4010 
4011 
4012 /*
4013  * Signal generated by the reader: M_PCSIG and M_FLUSH messages sent.
4014  */
4015 static void
4016 ldterm_dosig(queue_t *q, int sig, uchar_t c, int mtype, int mode)
4017 {
4018 	ldtermstd_state_t *tp = (ldtermstd_state_t *)q->q_ptr;
4019 	int sndsig = 0;
4020 
4021 	/*
4022 	 * c == \0 is brk case; need to flush on BRKINT even if
4023 	 * noflsh is set.
4024 	 */
4025 	if ((!(tp->t_modes.c_lflag & NOFLSH)) || (c == '\0')) {
4026 		if (mode) {
4027 			if (tp->t_state & TS_TTSTOP) {
4028 				sndsig = 1;
4029 				(void) putnextctl1(q, mtype, sig);
4030 			}
4031 			/*
4032 			 * Flush read or write side.
4033 			 * Restart the input or output.
4034 			 */
4035 			if (mode & FLUSHR) {
4036 				flushq(q, FLUSHDATA);
4037 				(void) putnextctl1(WR(q), M_FLUSH, mode);
4038 				if (tp->t_state & (TS_TBLOCK|TS_IFBLOCK)) {
4039 					(void) putnextctl(WR(q), M_STARTI);
4040 					tp->t_state &= ~(TS_TBLOCK|TS_IFBLOCK);
4041 				}
4042 			}
4043 			if (mode & FLUSHW) {
4044 				flushq(WR(q), FLUSHDATA);
4045 				/*
4046 				 * XXX This is extremely gross.
4047 				 * Since we can't be sure our M_FLUSH
4048 				 * will have run its course by the
4049 				 * time we do the echo below, we set
4050 				 * state and toss it in the write put
4051 				 * routine to prevent flushing our
4052 				 * own data.  Note that downstream
4053 				 * modules on the write side will be
4054 				 * flushed by the M_FLUSH sent above.
4055 				 */
4056 				tp->t_state |= TS_FLUSHWAIT;
4057 				(void) putnextctl1(q, M_FLUSH, FLUSHW);
4058 				if (tp->t_state & TS_TTSTOP) {
4059 					(void) putnextctl(WR(q), M_START);
4060 					tp->t_state &= ~(TS_TTSTOP|TS_OFBLOCK);
4061 				}
4062 			}
4063 		}
4064 	}
4065 	tp->t_state &= ~TS_QUOT;
4066 	if (sndsig == 0)
4067 		(void) putnextctl1(q, mtype, sig);
4068 
4069 	if (c != '\0') {
4070 		if ((tp->t_echomp = allocb(4, BPRI_HI)) != NULL) {
4071 			(void) ldterm_echo(c, WR(q), 4, tp);
4072 			putnext(WR(q), tp->t_echomp);
4073 			tp->t_echomp = NULL;
4074 		}
4075 	}
4076 }
4077 
4078 
4079 /*
4080  * Called when an M_IOCTL message is seen on the write queue; does
4081  * whatever we're supposed to do with it, and either replies
4082  * immediately or passes it to the next module down.
4083  */
4084 static void
4085 ldterm_do_ioctl(queue_t *q, mblk_t *mp)
4086 {
4087 	ldtermstd_state_t *tp;
4088 	struct iocblk *iocp;
4089 	struct eucioc *euciocp;	/* needed for EUC ioctls */
4090 	ldterm_cs_data_user_t *csdp;
4091 	int i;
4092 	int locale_name_sz;
4093 	uchar_t maxbytelen;
4094 	uchar_t maxscreenlen;
4095 	int error;
4096 
4097 	iocp = (struct iocblk *)mp->b_rptr;
4098 	tp = (ldtermstd_state_t *)q->q_ptr;
4099 
4100 	switch (iocp->ioc_cmd) {
4101 
4102 	case TCSETS:
4103 	case TCSETSW:
4104 	case TCSETSF:
4105 		{
4106 			/*
4107 			 * Set current parameters and special
4108 			 * characters.
4109 			 */
4110 			struct termios *cb;
4111 			struct termios oldmodes;
4112 
4113 			error = miocpullup(mp, sizeof (struct termios));
4114 			if (error != 0) {
4115 				miocnak(q, mp, 0, error);
4116 				return;
4117 			}
4118 
4119 			cb = (struct termios *)mp->b_cont->b_rptr;
4120 
4121 			oldmodes = tp->t_amodes;
4122 			tp->t_amodes = *cb;
4123 			if ((tp->t_amodes.c_lflag & PENDIN) &&
4124 			    (tp->t_modes.c_lflag & IEXTEN)) {
4125 				/*
4126 				 * Yuk.  The C shell file completion
4127 				 * code actually uses this "feature",
4128 				 * so we have to support it.
4129 				 */
4130 				if (tp->t_message != NULL) {
4131 					tp->t_state |= TS_RESCAN;
4132 					qenable(RD(q));
4133 				}
4134 				tp->t_amodes.c_lflag &= ~PENDIN;
4135 			}
4136 			bcopy(tp->t_amodes.c_cc, tp->t_modes.c_cc, NCCS);
4137 
4138 			/*
4139 			 * ldterm_adjust_modes does not deal with
4140 			 * cflags
4141 			 */
4142 			tp->t_modes.c_cflag = tp->t_amodes.c_cflag;
4143 
4144 			ldterm_adjust_modes(tp);
4145 			if (chgstropts(&oldmodes, tp, RD(q)) == (-1)) {
4146 				miocnak(q, mp, 0, EAGAIN);
4147 				return;
4148 			}
4149 			/*
4150 			 * The driver may want to know about the
4151 			 * following iflags: IGNBRK, BRKINT, IGNPAR,
4152 			 * PARMRK, INPCK, IXON, IXANY.
4153 			 */
4154 			break;
4155 		}
4156 
4157 	case TCSETA:
4158 	case TCSETAW:
4159 	case TCSETAF:
4160 		{
4161 			/*
4162 			 * Old-style "ioctl" to set current
4163 			 * parameters and special characters. Don't
4164 			 * clear out the unset portions, leave them
4165 			 * as they are.
4166 			 */
4167 			struct termio *cb;
4168 			struct termios oldmodes;
4169 
4170 			error = miocpullup(mp, sizeof (struct termio));
4171 			if (error != 0) {
4172 				miocnak(q, mp, 0, error);
4173 				return;
4174 			}
4175 
4176 			cb = (struct termio *)mp->b_cont->b_rptr;
4177 
4178 			oldmodes = tp->t_amodes;
4179 			tp->t_amodes.c_iflag =
4180 			    (tp->t_amodes.c_iflag & 0xffff0000 | cb->c_iflag);
4181 			tp->t_amodes.c_oflag =
4182 			    (tp->t_amodes.c_oflag & 0xffff0000 | cb->c_oflag);
4183 			tp->t_amodes.c_cflag =
4184 			    (tp->t_amodes.c_cflag & 0xffff0000 | cb->c_cflag);
4185 			tp->t_amodes.c_lflag =
4186 			    (tp->t_amodes.c_lflag & 0xffff0000 | cb->c_lflag);
4187 
4188 			bcopy(cb->c_cc, tp->t_modes.c_cc, NCC);
4189 			/* TCGETS returns amodes, so update that too */
4190 			bcopy(cb->c_cc, tp->t_amodes.c_cc, NCC);
4191 
4192 			/* ldterm_adjust_modes does not deal with cflags */
4193 
4194 			tp->t_modes.c_cflag = tp->t_amodes.c_cflag;
4195 
4196 			ldterm_adjust_modes(tp);
4197 			if (chgstropts(&oldmodes, tp, RD(q)) == (-1)) {
4198 				miocnak(q, mp, 0, EAGAIN);
4199 				return;
4200 			}
4201 			/*
4202 			 * The driver may want to know about the
4203 			 * following iflags: IGNBRK, BRKINT, IGNPAR,
4204 			 * PARMRK, INPCK, IXON, IXANY.
4205 			 */
4206 			break;
4207 		}
4208 
4209 	case TCFLSH:
4210 		/*
4211 		 * Do the flush on the write queue immediately, and
4212 		 * queue up any flush on the read queue for the
4213 		 * service procedure to see.  Then turn it into the
4214 		 * appropriate M_FLUSH message, so that the module
4215 		 * below us doesn't have to know about TCFLSH.
4216 		 */
4217 		error = miocpullup(mp, sizeof (int));
4218 		if (error != 0) {
4219 			miocnak(q, mp, 0, error);
4220 			return;
4221 		}
4222 
4223 		ASSERT(mp->b_datap != NULL);
4224 		if (*(int *)mp->b_cont->b_rptr == 0) {
4225 			ASSERT(mp->b_datap != NULL);
4226 			(void) putnextctl1(q, M_FLUSH, FLUSHR);
4227 			(void) putctl1(RD(q), M_FLUSH, FLUSHR);
4228 		} else if (*(int *)mp->b_cont->b_rptr == 1) {
4229 			flushq(q, FLUSHDATA);
4230 			ASSERT(mp->b_datap != NULL);
4231 			tp->t_state |= TS_FLUSHWAIT;
4232 			(void) putnextctl1(RD(q), M_FLUSH, FLUSHW);
4233 			(void) putnextctl1(q, M_FLUSH, FLUSHW);
4234 		} else if (*(int *)mp->b_cont->b_rptr == 2) {
4235 			flushq(q, FLUSHDATA);
4236 			ASSERT(mp->b_datap != NULL);
4237 			(void) putnextctl1(q, M_FLUSH, FLUSHRW);
4238 			tp->t_state |= TS_FLUSHWAIT;
4239 			(void) putnextctl1(RD(q), M_FLUSH, FLUSHRW);
4240 		} else {
4241 			miocnak(q, mp, 0, EINVAL);
4242 			return;
4243 		}
4244 		ASSERT(mp->b_datap != NULL);
4245 		iocp->ioc_rval = 0;
4246 		miocack(q, mp, 0, 0);
4247 		return;
4248 
4249 	case TCXONC:
4250 		error = miocpullup(mp, sizeof (int));
4251 		if (error != 0) {
4252 			miocnak(q, mp, 0, error);
4253 			return;
4254 		}
4255 
4256 		switch (*(int *)mp->b_cont->b_rptr) {
4257 		case 0:
4258 			if (!(tp->t_state & TS_TTSTOP)) {
4259 				(void) putnextctl(q, M_STOP);
4260 				tp->t_state |= (TS_TTSTOP|TS_OFBLOCK);
4261 			}
4262 			break;
4263 
4264 		case 1:
4265 			if (tp->t_state & TS_TTSTOP) {
4266 				(void) putnextctl(q, M_START);
4267 				tp->t_state &= ~(TS_TTSTOP|TS_OFBLOCK);
4268 			}
4269 			break;
4270 
4271 		case 2:
4272 			(void) putnextctl(q, M_STOPI);
4273 			tp->t_state |= (TS_TBLOCK|TS_IFBLOCK);
4274 			break;
4275 
4276 		case 3:
4277 			(void) putnextctl(q, M_STARTI);
4278 			tp->t_state &= ~(TS_TBLOCK|TS_IFBLOCK);
4279 			break;
4280 
4281 		default:
4282 			miocnak(q, mp, 0, EINVAL);
4283 			return;
4284 		}
4285 		ASSERT(mp->b_datap != NULL);
4286 		iocp->ioc_rval = 0;
4287 		miocack(q, mp, 0, 0);
4288 		return;
4289 		/*
4290 		 * TCSBRK is expected to be handled by the driver.
4291 		 * The reason its left for the driver is that when
4292 		 * the argument to TCSBRK is zero driver has to drain
4293 		 * the data and sending a M_IOCACK from LDTERM before
4294 		 * the driver drains the data is going to cause
4295 		 * problems.
4296 		 */
4297 
4298 		/*
4299 		 * The following are EUC related ioctls.  For
4300 		 * EUC_WSET, we have to pass the information on, even
4301 		 * though we ACK the call.  It's vital in the EUC
4302 		 * environment that everybody downstream knows about
4303 		 * the EUC codeset widths currently in use; we
4304 		 * therefore pass down the information in an M_CTL
4305 		 * message.  It will bottom out in the driver.
4306 		 */
4307 	case EUC_WSET:
4308 		{
4309 
4310 			/* only needed for EUC_WSET */
4311 			struct iocblk *riocp;
4312 
4313 			mblk_t *dmp, *dmp_cont;
4314 
4315 			/*
4316 			 * If the user didn't supply any information,
4317 			 * NAK it.
4318 			 */
4319 			error = miocpullup(mp, sizeof (struct eucioc));
4320 			if (error != 0) {
4321 				miocnak(q, mp, 0, error);
4322 				return;
4323 			}
4324 
4325 			euciocp = (struct eucioc *)mp->b_cont->b_rptr;
4326 			/*
4327 			 * Check here for something reasonable.  If
4328 			 * anything will take more than EUC_MAXW
4329 			 * columns or more than EUC_MAXW bytes
4330 			 * following SS2 or SS3, then just reject it
4331 			 * out of hand. It's not impossible for us to
4332 			 * do it, it just isn't reasonable.  So far,
4333 			 * in the world, we've seen the absolute max
4334 			 * columns to be 2 and the max number of
4335 			 * bytes to be 3.  This allows room for some
4336 			 * expansion of that, but it probably won't
4337 			 * even be necessary. At the moment, we
4338 			 * return a "range" error.  If you really
4339 			 * need to, you can push EUC_MAXW up to over
4340 			 * 200; it doesn't make sense, though, with
4341 			 * only a CANBSIZ sized input limit (usually
4342 			 * 256)!
4343 			 */
4344 			for (i = 0; i < 4; i++) {
4345 				if ((euciocp->eucw[i] > EUC_MAXW) ||
4346 				    (euciocp->scrw[i] > EUC_MAXW)) {
4347 					miocnak(q, mp, 0, ERANGE);
4348 					return;
4349 				}
4350 			}
4351 			/*
4352 			 * Otherwise, save the information in tp,
4353 			 * force codeset 0 (ASCII) to be one byte,
4354 			 * one column.
4355 			 */
4356 			cp_eucwioc(euciocp, &tp->eucwioc, EUCIN);
4357 			tp->eucwioc.eucw[0] = tp->eucwioc.scrw[0] = 1;
4358 			/*
4359 			 * Now, check out whether we're doing
4360 			 * multibyte processing. if we are, we need
4361 			 * to allocate a block to hold the parallel
4362 			 * array. By convention, we've been passed
4363 			 * what amounts to a CSWIDTH definition.  We
4364 			 * actually NEED the number of bytes for
4365 			 * Codesets 2 & 3.
4366 			 */
4367 			tp->t_maxeuc = 0;	/* reset to say we're NOT */
4368 
4369 			tp->t_state &= ~TS_MEUC;
4370 			/*
4371 			 * We'll set TS_MEUC if we're doing
4372 			 * multi-column OR multi- byte OR both.  It
4373 			 * makes things easier...  NOTE:  If we fail
4374 			 * to get the buffer we need to hold display
4375 			 * widths, then DON'T let the TS_MEUC bit get
4376 			 * set!
4377 			 */
4378 			for (i = 0; i < 4; i++) {
4379 				if (tp->eucwioc.eucw[i] > tp->t_maxeuc)
4380 					tp->t_maxeuc = tp->eucwioc.eucw[i];
4381 				if (tp->eucwioc.scrw[i] > 1)
4382 					tp->t_state |= TS_MEUC;
4383 			}
4384 			if ((tp->t_maxeuc > 1) || (tp->t_state & TS_MEUC)) {
4385 				if (!tp->t_eucp_mp) {
4386 					if (!(tp->t_eucp_mp = allocb(CANBSIZ,
4387 					    BPRI_HI))) {
4388 						tp->t_maxeuc = 1;
4389 						tp->t_state &= ~TS_MEUC;
4390 						cmn_err(CE_WARN,
4391 						    "Can't allocate eucp_mp");
4392 						miocnak(q, mp, 0, ENOSR);
4393 						return;
4394 					}
4395 					/*
4396 					 * here, if there's junk in
4397 					 * the canonical buffer, then
4398 					 * move the eucp pointer past
4399 					 * it, so we don't run off
4400 					 * the beginning.  This is a
4401 					 * total botch, but will
4402 					 * hopefully keep stuff from
4403 					 * getting too messed up
4404 					 * until the user flushes
4405 					 * this line!
4406 					 */
4407 					if (tp->t_msglen) {
4408 						tp->t_eucp =
4409 						    tp->t_eucp_mp->b_rptr;
4410 						for (i = tp->t_msglen; i; i--)
4411 							*tp->t_eucp++ = 1;
4412 					} else {
4413 						tp->t_eucp =
4414 						    tp->t_eucp_mp->b_rptr;
4415 					}
4416 				}
4417 				/* doing multi-byte handling */
4418 				tp->t_state |= TS_MEUC;
4419 
4420 			} else if (tp->t_eucp_mp) {
4421 				freemsg(tp->t_eucp_mp);
4422 				tp->t_eucp_mp = NULL;
4423 				tp->t_eucp = NULL;
4424 			}
4425 
4426 			/*
4427 			 * Save the EUC width data we have at
4428 			 * the t_csdata, set t_csdata.codeset_type to
4429 			 * EUC one, and, switch the codeset methods at
4430 			 * t_csmethods.
4431 			 */
4432 			bzero(&tp->t_csdata.eucpc_data,
4433 			    (sizeof (ldterm_eucpc_data_t) *
4434 			    LDTERM_CS_MAX_CODESETS));
4435 			tp->t_csdata.eucpc_data[0].byte_length =
4436 			    tp->eucwioc.eucw[1];
4437 			tp->t_csdata.eucpc_data[0].screen_width =
4438 			    tp->eucwioc.scrw[1];
4439 			tp->t_csdata.eucpc_data[1].byte_length =
4440 			    tp->eucwioc.eucw[2];
4441 			tp->t_csdata.eucpc_data[1].screen_width =
4442 			    tp->eucwioc.scrw[2];
4443 			tp->t_csdata.eucpc_data[2].byte_length =
4444 			    tp->eucwioc.eucw[3];
4445 			tp->t_csdata.eucpc_data[2].screen_width =
4446 			    tp->eucwioc.scrw[3];
4447 			tp->t_csdata.version = LDTERM_DATA_VERSION;
4448 			tp->t_csdata.codeset_type = LDTERM_CS_TYPE_EUC;
4449 			/*
4450 			 * We are not using the 'csinfo_num' anyway if the
4451 			 * current codeset type is EUC. So, set it to
4452 			 * the maximum possible.
4453 			 */
4454 			tp->t_csdata.csinfo_num =
4455 			    LDTERM_CS_TYPE_EUC_MAX_SUBCS;
4456 			if (tp->t_csdata.locale_name != (char *)NULL) {
4457 				kmem_free(tp->t_csdata.locale_name,
4458 				    strlen(tp->t_csdata.locale_name) + 1);
4459 				tp->t_csdata.locale_name = (char *)NULL;
4460 			}
4461 			tp->t_csmethods = cs_methods[LDTERM_CS_TYPE_EUC];
4462 
4463 			/*
4464 			 * If we are able to allocate two blocks (the
4465 			 * iocblk and the associated data), then pass
4466 			 * it downstream, otherwise we'll need to NAK
4467 			 * it, and drop whatever we WERE able to
4468 			 * allocate.
4469 			 */
4470 			if ((dmp = mkiocb(EUC_WSET)) == NULL) {
4471 				miocnak(q, mp, 0, ENOSR);
4472 				return;
4473 			}
4474 			if ((dmp_cont = allocb(EUCSIZE, BPRI_HI)) == NULL) {
4475 				freemsg(dmp);
4476 				miocnak(q, mp, 0, ENOSR);
4477 				return;
4478 			}
4479 
4480 			/*
4481 			 * We got both buffers.  Copy out the EUC
4482 			 * information (as we received it, not what
4483 			 * we're using!) & pass it on.
4484 			 */
4485 			bcopy(mp->b_cont->b_rptr, dmp_cont->b_rptr, EUCSIZE);
4486 			dmp_cont->b_wptr += EUCSIZE;
4487 			dmp->b_cont = dmp_cont;
4488 			dmp->b_datap->db_type = M_CTL;
4489 			dmp_cont->b_datap->db_type = M_DATA;
4490 			riocp = (struct iocblk *)dmp->b_rptr;
4491 			riocp->ioc_count = EUCSIZE;
4492 			putnext(q, dmp);
4493 
4494 			/*
4495 			 * Now ACK the ioctl.
4496 			 */
4497 			iocp->ioc_rval = 0;
4498 			miocack(q, mp, 0, 0);
4499 			return;
4500 		}
4501 
4502 	case EUC_WGET:
4503 		error = miocpullup(mp, sizeof (struct eucioc));
4504 		if (error != 0) {
4505 			miocnak(q, mp, 0, error);
4506 			return;
4507 		}
4508 		euciocp = (struct eucioc *)mp->b_cont->b_rptr;
4509 		cp_eucwioc(&tp->eucwioc, euciocp, EUCOUT);
4510 		iocp->ioc_rval = 0;
4511 		miocack(q, mp, EUCSIZE, 0);
4512 		return;
4513 
4514 	case CSDATA_SET:
4515 		error = miocpullup(mp, sizeof (ldterm_cs_data_user_t));
4516 		if (error != 0) {
4517 			miocnak(q, mp, 0, error);
4518 			return;
4519 		}
4520 
4521 		csdp = (ldterm_cs_data_user_t *)mp->b_cont->b_rptr;
4522 
4523 		/* Validate the codeset data provided. */
4524 		if (csdp->version > LDTERM_DATA_VERSION ||
4525 		    csdp->codeset_type < LDTERM_CS_TYPE_MIN ||
4526 		    csdp->codeset_type > LDTERM_CS_TYPE_MAX) {
4527 			miocnak(q, mp, 0, ERANGE);
4528 			return;
4529 		}
4530 
4531 		if ((csdp->codeset_type == LDTERM_CS_TYPE_EUC &&
4532 		    csdp->csinfo_num > LDTERM_CS_TYPE_EUC_MAX_SUBCS) ||
4533 		    (csdp->codeset_type == LDTERM_CS_TYPE_PCCS &&
4534 		    (csdp->csinfo_num < LDTERM_CS_TYPE_PCCS_MIN_SUBCS ||
4535 		    csdp->csinfo_num > LDTERM_CS_TYPE_PCCS_MAX_SUBCS))) {
4536 			miocnak(q, mp, 0, ERANGE);
4537 			return;
4538 		}
4539 
4540 		maxbytelen = maxscreenlen = 0;
4541 		if (csdp->codeset_type == LDTERM_CS_TYPE_EUC) {
4542 			for (i = 0; i < LDTERM_CS_TYPE_EUC_MAX_SUBCS; i++) {
4543 				if (csdp->eucpc_data[i].byte_length >
4544 				    EUC_MAXW ||
4545 				    csdp->eucpc_data[i].screen_width >
4546 				    EUC_MAXW) {
4547 					miocnak(q, mp, 0, ERANGE);
4548 					return;
4549 				}
4550 
4551 				if (csdp->eucpc_data[i].byte_length >
4552 				    maxbytelen)
4553 					maxbytelen =
4554 					    csdp->eucpc_data[i].byte_length;
4555 				if (csdp->eucpc_data[i].screen_width >
4556 				    maxscreenlen)
4557 					maxscreenlen =
4558 					    csdp->eucpc_data[i].screen_width;
4559 			}
4560 			/* POSIX/C locale? */
4561 			if (maxbytelen == 0 && maxscreenlen == 0)
4562 				maxbytelen = maxscreenlen = 1;
4563 		} else if (csdp->codeset_type == LDTERM_CS_TYPE_PCCS) {
4564 			for (i = 0; i < LDTERM_CS_MAX_CODESETS; i++) {
4565 				if (csdp->eucpc_data[i].byte_length >
4566 				    LDTERM_CS_MAX_BYTE_LENGTH) {
4567 					miocnak(q, mp, 0, ERANGE);
4568 					return;
4569 				}
4570 				if (csdp->eucpc_data[i].byte_length >
4571 				    maxbytelen)
4572 					maxbytelen =
4573 					    csdp->eucpc_data[i].byte_length;
4574 				if (csdp->eucpc_data[i].screen_width >
4575 				    maxscreenlen)
4576 					maxscreenlen =
4577 					    csdp->eucpc_data[i].screen_width;
4578 			}
4579 		} else if (csdp->codeset_type == LDTERM_CS_TYPE_UTF8) {
4580 			maxbytelen = 4;
4581 			maxscreenlen = 2;
4582 		}
4583 
4584 		locale_name_sz = 0;
4585 		if (csdp->locale_name) {
4586 			for (i = 0; i < MAXNAMELEN; i++)
4587 				if (csdp->locale_name[i] == '\0')
4588 					break;
4589 			/*
4590 			 * We cannot have any string that is not NULL byte
4591 			 * terminated.
4592 			 */
4593 			if (i >= MAXNAMELEN) {
4594 				miocnak(q, mp, 0, ERANGE);
4595 				return;
4596 			}
4597 
4598 			locale_name_sz = i + 1;
4599 		}
4600 
4601 		/*
4602 		 * As the final check, if there was invalid codeset_type
4603 		 * given, or invalid byte_length was specified, it's an error.
4604 		 */
4605 		if (maxbytelen <= 0 || maxscreenlen <= 0) {
4606 			miocnak(q, mp, 0, ERANGE);
4607 			return;
4608 		}
4609 
4610 		/* Do the switching. */
4611 		tp->t_maxeuc = maxbytelen;
4612 		tp->t_state &= ~TS_MEUC;
4613 		if (maxbytelen > 1 || maxscreenlen > 1) {
4614 			if (!tp->t_eucp_mp) {
4615 				if (!(tp->t_eucp_mp = allocb(CANBSIZ,
4616 				    BPRI_HI))) {
4617 					cmn_err(CE_WARN,
4618 					    "Can't allocate eucp_mp");
4619 					miocnak(q, mp, 0, ENOSR);
4620 					return;
4621 				}
4622 				/*
4623 				 * If there's junk in the canonical buffer,
4624 				 * then move the eucp pointer past it,
4625 				 * so we don't run off the beginning. This is
4626 				 * a total botch, but will hopefully keep
4627 				 * stuff from getting too messed up until
4628 				 * the user flushes this line!
4629 				 */
4630 				if (tp->t_msglen) {
4631 					tp->t_eucp = tp->t_eucp_mp->b_rptr;
4632 					for (i = tp->t_msglen; i; i--)
4633 						*tp->t_eucp++ = 1;
4634 				} else {
4635 					tp->t_eucp = tp->t_eucp_mp->b_rptr;
4636 				}
4637 			}
4638 
4639 			/*
4640 			 * We only set TS_MEUC for a multibyte/multi-column
4641 			 * codeset.
4642 			 */
4643 			tp->t_state |= TS_MEUC;
4644 
4645 			tp->t_csdata.version = csdp->version;
4646 			tp->t_csdata.codeset_type = csdp->codeset_type;
4647 			tp->t_csdata.csinfo_num = csdp->csinfo_num;
4648 			bcopy(csdp->eucpc_data, tp->t_csdata.eucpc_data,
4649 			    sizeof (ldterm_eucpc_data_t) *
4650 			    LDTERM_CS_MAX_CODESETS);
4651 			tp->t_csmethods = cs_methods[csdp->codeset_type];
4652 
4653 			if (csdp->codeset_type == LDTERM_CS_TYPE_EUC) {
4654 				tp->eucwioc.eucw[0] = 1;
4655 				tp->eucwioc.scrw[0] = 1;
4656 
4657 				tp->eucwioc.eucw[1] =
4658 				    csdp->eucpc_data[0].byte_length;
4659 				tp->eucwioc.scrw[1] =
4660 				    csdp->eucpc_data[0].screen_width;
4661 
4662 				tp->eucwioc.eucw[2] =
4663 				    csdp->eucpc_data[1].byte_length + 1;
4664 				tp->eucwioc.scrw[2] =
4665 				    csdp->eucpc_data[1].screen_width;
4666 
4667 				tp->eucwioc.eucw[3] =
4668 				    csdp->eucpc_data[2].byte_length + 1;
4669 				tp->eucwioc.scrw[3] =
4670 				    csdp->eucpc_data[2].screen_width;
4671 			} else {
4672 				/*
4673 				 * We are not going to use this data
4674 				 * structure. So, clear it. Also, stty(1) will
4675 				 * make use of the cleared tp->eucwioc when
4676 				 * it prints out codeset width setting.
4677 				 */
4678 				bzero(&tp->eucwioc, EUCSIZE);
4679 			}
4680 		} else {
4681 			/*
4682 			 * If this codeset is a single byte codeset that
4683 			 * requires only single display column for all
4684 			 * characters, we switch to default EUC codeset
4685 			 * methods and data setting.
4686 			 */
4687 
4688 			if (tp->t_eucp_mp) {
4689 				freemsg(tp->t_eucp_mp);
4690 				tp->t_eucp_mp = NULL;
4691 				tp->t_eucp = NULL;
4692 			}
4693 
4694 			bzero(&tp->eucwioc, EUCSIZE);
4695 			tp->eucwioc.eucw[0] = 1;
4696 			tp->eucwioc.scrw[0] = 1;
4697 			if (tp->t_csdata.locale_name != (char *)NULL) {
4698 				kmem_free(tp->t_csdata.locale_name,
4699 				    strlen(tp->t_csdata.locale_name) + 1);
4700 			}
4701 			tp->t_csdata = default_cs_data;
4702 			tp->t_csmethods = cs_methods[LDTERM_CS_TYPE_EUC];
4703 		}
4704 
4705 		/* Copy over locale_name. */
4706 		if (tp->t_csdata.locale_name != (char *)NULL) {
4707 			kmem_free(tp->t_csdata.locale_name,
4708 			    strlen(tp->t_csdata.locale_name) + 1);
4709 		}
4710 		if (locale_name_sz > 1) {
4711 			tp->t_csdata.locale_name = (char *)kmem_alloc(
4712 			    locale_name_sz, KM_SLEEP);
4713 			(void) strcpy(tp->t_csdata.locale_name,
4714 			    csdp->locale_name);
4715 		} else {
4716 			tp->t_csdata.locale_name = (char *)NULL;
4717 		}
4718 
4719 		/*
4720 		 * Now ACK the ioctl.
4721 		 */
4722 		iocp->ioc_rval = 0;
4723 		miocack(q, mp, 0, 0);
4724 		return;
4725 
4726 	case CSDATA_GET:
4727 		error = miocpullup(mp, sizeof (ldterm_cs_data_user_t));
4728 		if (error != 0) {
4729 			miocnak(q, mp, 0, error);
4730 			return;
4731 		}
4732 
4733 		csdp = (ldterm_cs_data_user_t *)mp->b_cont->b_rptr;
4734 
4735 		csdp->version = tp->t_csdata.version;
4736 		csdp->codeset_type = tp->t_csdata.codeset_type;
4737 		csdp->csinfo_num = tp->t_csdata.csinfo_num;
4738 		csdp->pad = tp->t_csdata.pad;
4739 		if (tp->t_csdata.locale_name) {
4740 			(void) strcpy(csdp->locale_name,
4741 			    tp->t_csdata.locale_name);
4742 		} else {
4743 			csdp->locale_name[0] = '\0';
4744 		}
4745 		bcopy(tp->t_csdata.eucpc_data, csdp->eucpc_data,
4746 		    sizeof (ldterm_eucpc_data_t) * LDTERM_CS_MAX_CODESETS);
4747 		/*
4748 		 * If the codeset is an EUC codeset and if it has 2nd and/or
4749 		 * 3rd supplementary codesets, we subtract one from each
4750 		 * byte length of the supplementary codesets. This is
4751 		 * because single shift characters, SS2 and SS3, are not
4752 		 * included in the byte lengths in the user space.
4753 		 */
4754 		if (csdp->codeset_type == LDTERM_CS_TYPE_EUC) {
4755 			if (csdp->eucpc_data[1].byte_length)
4756 				csdp->eucpc_data[1].byte_length -= 1;
4757 			if (csdp->eucpc_data[2].byte_length)
4758 				csdp->eucpc_data[2].byte_length -= 1;
4759 		}
4760 		iocp->ioc_rval = 0;
4761 		miocack(q, mp, sizeof (ldterm_cs_data_user_t), 0);
4762 		return;
4763 
4764 	case PTSSTTY:
4765 		tp->t_state |= TS_ISPTSTTY;
4766 		break;
4767 
4768 	}
4769 
4770 	putnext(q, mp);
4771 }
4772 
4773 
4774 /*
4775  * Send an M_SETOPTS message upstream if any mode changes are being
4776  * made that affect the stream head options. returns -1 if allocb
4777  * fails, else returns 0.
4778  */
4779 static int
4780 chgstropts(struct termios *oldmodep, ldtermstd_state_t *tp, queue_t *q)
4781 {
4782 	struct stroptions optbuf;
4783 	mblk_t *bp;
4784 
4785 	optbuf.so_flags = 0;
4786 	if ((oldmodep->c_lflag ^ tp->t_modes.c_lflag) & ICANON) {
4787 		/*
4788 		 * Canonical mode is changing state; switch the
4789 		 * stream head to message-nondiscard or byte-stream
4790 		 * mode.  Also, rerun the service procedure so it can
4791 		 * change its mind about whether to send data
4792 		 * upstream or not.
4793 		 */
4794 		if (tp->t_modes.c_lflag & ICANON) {
4795 			DEBUG4(("CHANGING TO CANON MODE\n"));
4796 			optbuf.so_flags = SO_READOPT|SO_MREADOFF;
4797 			optbuf.so_readopt = RMSGN;
4798 
4799 			/*
4800 			 * if there is a pending raw mode timeout,
4801 			 * clear it
4802 			 */
4803 
4804 			/*
4805 			 * Clear VMIN/VTIME state, cancel timers
4806 			 */
4807 			vmin_satisfied(q, tp, 0);
4808 		} else {
4809 			DEBUG4(("CHANGING TO RAW MODE\n"));
4810 			optbuf.so_flags = SO_READOPT|SO_MREADON;
4811 			optbuf.so_readopt = RNORM;
4812 		}
4813 	}
4814 	if ((oldmodep->c_lflag ^ tp->t_modes.c_lflag) & TOSTOP) {
4815 		/*
4816 		 * The "stop on background write" bit is changing.
4817 		 */
4818 		if (tp->t_modes.c_lflag & TOSTOP)
4819 			optbuf.so_flags |= SO_TOSTOP;
4820 		else
4821 			optbuf.so_flags |= SO_TONSTOP;
4822 	}
4823 	if (optbuf.so_flags != 0) {
4824 		if ((bp = allocb(sizeof (struct stroptions), BPRI_HI)) ==
4825 		    NULL) {
4826 			return (-1);
4827 		}
4828 		*(struct stroptions *)bp->b_wptr = optbuf;
4829 		bp->b_wptr += sizeof (struct stroptions);
4830 		bp->b_datap->db_type = M_SETOPTS;
4831 		DEBUG4(("M_SETOPTS to stream head\n"));
4832 		putnext(q, bp);
4833 	}
4834 	return (0);
4835 }
4836 
4837 
4838 /*
4839  * Called when an M_IOCACK message is seen on the read queue;
4840  * modifies the data being returned, if necessary, and passes the
4841  * reply up.
4842  */
4843 static void
4844 ldterm_ioctl_reply(queue_t *q, mblk_t *mp)
4845 {
4846 	ldtermstd_state_t *tp;
4847 	struct iocblk *iocp;
4848 
4849 	iocp = (struct iocblk *)mp->b_rptr;
4850 	tp = (ldtermstd_state_t *)q->q_ptr;
4851 
4852 	switch (iocp->ioc_cmd) {
4853 
4854 	case TCGETS:
4855 		{
4856 			/*
4857 			 * Get current parameters and return them to
4858 			 * stream head eventually.
4859 			 */
4860 			struct termios *cb =
4861 			    (struct termios *)mp->b_cont->b_rptr;
4862 
4863 			/*
4864 			 * cflag has cflags sent upstream by the
4865 			 * driver
4866 			 */
4867 			tcflag_t cflag = cb->c_cflag;
4868 
4869 			*cb = tp->t_amodes;
4870 			if (cflag != 0)
4871 				cb->c_cflag = cflag;	/* set by driver */
4872 			break;
4873 		}
4874 
4875 	case TCGETA:
4876 		{
4877 			/*
4878 			 * Old-style "ioctl" to get current
4879 			 * parameters and return them to stream head
4880 			 * eventually.
4881 			 */
4882 			struct termio *cb =
4883 			    (struct termio *)mp->b_cont->b_rptr;
4884 
4885 			cb->c_iflag = tp->t_amodes.c_iflag; /* all except the */
4886 			cb->c_oflag = tp->t_amodes.c_oflag; /* cb->c_cflag */
4887 			cb->c_lflag = tp->t_amodes.c_lflag;
4888 
4889 			if (cb->c_cflag == 0)	/* not set by driver */
4890 				cb->c_cflag = tp->t_amodes.c_cflag;
4891 
4892 			cb->c_line = 0;
4893 			bcopy(tp->t_amodes.c_cc, cb->c_cc, NCC);
4894 			break;
4895 		}
4896 	}
4897 	putnext(q, mp);
4898 }
4899 
4900 
4901 /*
4902  * A VMIN/VTIME request has been satisfied. Cancel outstanding timers
4903  * if they exist, clear TS_MREAD state, and send upstream. If a NULL
4904  * queue ptr is passed, just reset VMIN/VTIME state.
4905  */
4906 static void
4907 vmin_satisfied(queue_t *q, ldtermstd_state_t *tp, int sendup)
4908 {
4909 	ASSERT(q);
4910 	if (tp->t_vtid != 0)  {
4911 		DEBUG4(("vmin_satisfied: cancelled timer id %d\n", tp->t_vtid));
4912 		(void) quntimeout(q, tp->t_vtid);
4913 		tp->t_vtid = 0;
4914 	}
4915 	if (sendup) {
4916 		if (tp->t_msglen == 0 && V_MIN) {
4917 			/* EMPTY */
4918 			DEBUG4(("vmin_satisfied: data swiped, msglen = 0\n"));
4919 		} else {
4920 			if ((!q->q_first) ||
4921 			    (q->q_first->b_datap->db_type != M_DATA) ||
4922 			    (tp->t_msglen >= LDCHUNK)) {
4923 				ldterm_msg_upstream(q, tp);
4924 				DEBUG4(("vmin_satisfied: delivering data\n"));
4925 			}
4926 		}
4927 	} else {
4928 		/* EMPTY */
4929 		DEBUG4(("vmin_satisfied: VMIN/TIME state reset\n"));
4930 	}
4931 	tp->t_state &= ~TS_MREAD;
4932 }
4933 
4934 static void
4935 vmin_settimer(queue_t *q)
4936 {
4937 	ldtermstd_state_t *tp;
4938 
4939 	tp = (ldtermstd_state_t *)q->q_ptr;
4940 
4941 	/*
4942 	 * Don't start any time bombs.
4943 	 */
4944 	if (tp->t_state & TS_CLOSE)
4945 		return;
4946 
4947 	/*
4948 	 * tp->t_vtid should NOT be set here unless VMIN > 0 and
4949 	 * VTIME > 0.
4950 	 */
4951 	if (tp->t_vtid) {
4952 		if (V_MIN && V_TIME) {
4953 			/* EMPTY */
4954 			DEBUG4(("vmin_settimer: timer restarted, old tid=%d\n",
4955 			    tp->t_vtid));
4956 		} else {
4957 			/* EMPTY */
4958 			DEBUG4(("vmin_settimer: tid = %d was still active!\n",
4959 			    tp->t_vtid));
4960 		}
4961 		(void) quntimeout(q, tp->t_vtid);
4962 		tp->t_vtid = 0;
4963 	}
4964 	tp->t_vtid = qtimeout(q, vmin_timed_out, q,
4965 	    (clock_t)(V_TIME * (hz / 10)));
4966 	DEBUG4(("vmin_settimer: timer started, tid = %d\n", tp->t_vtid));
4967 }
4968 
4969 
4970 /*
4971  * BRRrrringgg!! VTIME was satisfied instead of VMIN
4972  */
4973 static void
4974 vmin_timed_out(void *arg)
4975 {
4976 	queue_t *q = arg;
4977 	ldtermstd_state_t *tp;
4978 
4979 	tp = (ldtermstd_state_t *)q->q_ptr;
4980 
4981 	DEBUG4(("vmin_timed_out: tid = %d\n", tp->t_vtid));
4982 	/* don't call untimeout now that we are in the timeout */
4983 	tp->t_vtid = 0;
4984 	vmin_satisfied(q, tp, 1);
4985 }
4986 
4987 
4988 /*
4989  * Routine to adjust termios flags to be processed by the line
4990  * discipline. Driver below sends a termios structure, with the flags
4991  * the driver intends to process. XOR'ing the driver sent termios
4992  * structure with current termios structure with the default values
4993  * (or set by ioctls from userland), we come up with a new termios
4994  * structrue, the flags of which will be used by the line discipline
4995  * in processing input and output. On return from this routine, we
4996  * will have the following fields set in tp structure -->
4997  * tp->t_modes:	modes the line discipline will process tp->t_amodes:
4998  * modes the user process thinks the line discipline is processing
4999  */
5000 
5001 static void
5002 ldterm_adjust_modes(ldtermstd_state_t *tp)
5003 {
5004 
5005 	DEBUG6(("original iflag = %o\n", tp->t_modes.c_iflag));
5006 	tp->t_modes.c_iflag = tp->t_amodes.c_iflag & ~(tp->t_dmodes.c_iflag);
5007 	tp->t_modes.c_oflag = tp->t_amodes.c_oflag & ~(tp->t_dmodes.c_oflag);
5008 	tp->t_modes.c_lflag = tp->t_amodes.c_lflag & ~(tp->t_dmodes.c_lflag);
5009 	DEBUG6(("driver iflag = %o\n", tp->t_dmodes.c_iflag));
5010 	DEBUG6(("apparent iflag = %o\n", tp->t_amodes.c_iflag));
5011 	DEBUG6(("effective iflag = %o\n", tp->t_modes.c_iflag));
5012 
5013 	/* No negotiation of clfags  c_cc array special characters */
5014 	/*
5015 	 * Copy from amodes to modes already done by TCSETA/TCSETS
5016 	 * code
5017 	 */
5018 }
5019 
5020 
5021 /*
5022  * Erase one multi-byte character.  If TS_MEUC is set AND this
5023  * is a multi-byte character, then this should be called instead of
5024  * ldterm_erase.  "ldterm_erase" will handle ASCII nicely, thank you.
5025  *
5026  * We'd better be pointing to the last byte.  If we aren't, it will get
5027  * screwed up.
5028  */
5029 static void
5030 ldterm_csi_erase(queue_t *q, size_t ebsize, ldtermstd_state_t *tp)
5031 {
5032 	int i, ung;
5033 	uchar_t *p, *bottom;
5034 	uchar_t u8[LDTERM_CS_MAX_BYTE_LENGTH];
5035 	int c;
5036 	int j;
5037 	int len;
5038 
5039 	if (tp->t_eucleft) {
5040 		/* XXX Ick.  We're in the middle of an EUC! */
5041 		/* What to do now? */
5042 		ldterm_eucwarn(tp);
5043 		return;		/* ignore it??? */
5044 	}
5045 	bottom = tp->t_eucp_mp->b_rptr;
5046 	p = tp->t_eucp - 1;	/* previous byte */
5047 	if (p < bottom)
5048 		return;
5049 	ung = 1;		/* number of bytes to un-get from buffer */
5050 	/*
5051 	 * go through the buffer until we find the beginning of the
5052 	 * multi-byte char.
5053 	 */
5054 	while ((*p == 0) && (p > bottom)) {
5055 		p--;
5056 		++ung;
5057 	}
5058 
5059 	/*
5060 	 * Now, "ung" is the number of bytes to unget from the buffer
5061 	 * and "*p" is the disp width of it. Fool "ldterm_rubout"
5062 	 * into thinking we're rubbing out ASCII characters.  Do that
5063 	 * for the display width of the character.
5064 	 *
5065 	 * Also we accumulate bytes of the character so that if the character
5066 	 * is a UTF-8 character, we will get the display width of the UTF-8
5067 	 * character.
5068 	 */
5069 	if (ung >= LDTERM_CS_MAX_BYTE_LENGTH) {
5070 		j = len = LDTERM_CS_MAX_BYTE_LENGTH;
5071 	} else {
5072 		j = len = ung;
5073 	}
5074 	for (i = 0; i < ung; i++) {	/* remove from buf */
5075 		if ((c = ldterm_unget(tp)) != (-1)) {
5076 			ldterm_trim(tp);
5077 			if (j > 0)
5078 				u8[--j] = (uchar_t)c;
5079 		}
5080 	}
5081 	if (*p == UNKNOWN_WIDTH) {
5082 		if (tp->t_csdata.codeset_type == LDTERM_CS_TYPE_UTF8) {
5083 			*p = ldterm_utf8_width(u8, len);
5084 		} else {
5085 			*p = 1;
5086 		}
5087 	}
5088 	for (i = 0; i < (int)*p; i++)	/* remove from screen */
5089 		ldterm_rubout(' ', q, ebsize, tp);
5090 	/*
5091 	 * Adjust the parallel array pointer.  Zero out the contents
5092 	 * of parallel array for this position, just to make sure...
5093 	 */
5094 	tp->t_eucp = p;
5095 	*p = 0;
5096 }
5097 
5098 
5099 /*
5100  * This is kind of a safety valve.  Whenever we see a bad sequence
5101  * come up, we call eucwarn.  It just tallies the junk until a
5102  * threshold is reached.  Then it prints ONE message on the console
5103  * and not any more. Hopefully, we can catch garbage; maybe it will
5104  * be useful to somebody.
5105  */
5106 static void
5107 ldterm_eucwarn(ldtermstd_state_t *tp)
5108 {
5109 	++tp->t_eucwarn;
5110 #ifdef DEBUG
5111 	if ((tp->t_eucwarn > EUC_WARNCNT) && !(tp->t_state & TS_WARNED)) {
5112 		cmn_err(CE_WARN,
5113 		    "ldterm: tty at addr %p in multi-byte mode --",
5114 		    (void *)tp);
5115 		cmn_err(CE_WARN,
5116 		    "Over %d bad EUC characters this session", EUC_WARNCNT);
5117 		tp->t_state |= TS_WARNED;
5118 	}
5119 #endif
5120 }
5121 
5122 
5123 /*
5124  * Copy an "eucioc_t" structure.  We use the structure with
5125  * incremented values for Codesets 2 & 3.  The specification in
5126  * eucioctl is that the sames values as the CSWIDTH definition at
5127  * user level are passed to us. When we copy it "in" to ourselves, we
5128  * do the increment.  That allows us to avoid treating each character
5129  * set separately for "t_eucleft" purposes. When we copy it "out" to
5130  * return it to the user, we decrement the values so the user gets
5131  * what it expects, and it matches CSWIDTH in the environment (if
5132  * things are consistent!).
5133  */
5134 static void
5135 cp_eucwioc(eucioc_t *from, eucioc_t *to, int dir)
5136 {
5137 	bcopy(from, to, EUCSIZE);
5138 	if (dir == EUCOUT) {	/* copying out to user */
5139 		if (to->eucw[2])
5140 			--to->eucw[2];
5141 		if (to->eucw[3])
5142 			--to->eucw[3];
5143 	} else {		/* copying in */
5144 		if (to->eucw[2])
5145 			++to->eucw[2];
5146 		if (to->eucw[3])
5147 			++to->eucw[3];
5148 	}
5149 }
5150 
5151 
5152 /*
5153  * Take the first byte of a multi-byte, or an ASCII char.  Return its
5154  * codeset. If it's NOT the first byte of an EUC, then the return
5155  * value may be garbage, as it's probably not SS2 or SS3, and
5156  * therefore must be in codeset 1.  Another bizarre catch here is the
5157  * fact that we don't do anything about the "C1" control codes.  In
5158  * real life, we should; but nobody's come up with a good way of
5159  * treating them.
5160  */
5161 
5162 static int
5163 ldterm_codeset(uchar_t codeset_type, uchar_t c)
5164 {
5165 
5166 	if (ISASCII(c))
5167 		return (0);
5168 
5169 	if (codeset_type != LDTERM_CS_TYPE_EUC)
5170 		return (1);
5171 
5172 	switch (c) {
5173 	case SS2:
5174 		return (2);
5175 	case SS3:
5176 		return (3);
5177 	default:
5178 		return (1);
5179 	}
5180 }
5181 
5182 /* The following two functions are additional EUC codeset specific methods. */
5183 /*
5184  * ldterm_dispwidth - Take the first byte of an EUC (or ASCII) and
5185  * return the display width.  Since this is intended mostly for
5186  * multi-byte handling, it returns EUC_TWIDTH for tabs so they can be
5187  * differentiated from EUC characters (assumption: EUC require fewer
5188  * than 255 columns).  Also, if it's a backspace and !flag, it
5189  * returns EUC_BSWIDTH.  Newline & CR also depend on flag.  This
5190  * routine SHOULD be cleaner than this, but we have the situation
5191  * where we may or may not be counting control characters as having a
5192  * column width. Therefore, the computation of ASCII is pretty messy.
5193  * The caller will be storing the value, and then switching on it
5194  * when it's used.  We really should define the EUC_TWIDTH and other
5195  * constants in a header so that the routine could be used in other
5196  * modules in the kernel.
5197  */
5198 static int
5199 __ldterm_dispwidth_euc(uchar_t c, void *p, int mode)
5200 {
5201 	ldtermstd_state_t *tp = (ldtermstd_state_t *)p;
5202 
5203 	if (ISASCII(c)) {
5204 		if (c <= '\037') {
5205 			switch (c) {
5206 			case '\t':
5207 				return (EUC_TWIDTH);
5208 			case '\b':
5209 				return (mode ? 2 : EUC_BSWIDTH);
5210 			case '\n':
5211 				return (EUC_NLWIDTH);
5212 			case '\r':
5213 				return (mode ? 2 : EUC_CRWIDTH);
5214 			default:
5215 				return (mode ? 2 : 0);
5216 			}
5217 		}
5218 		return (1);
5219 	}
5220 	switch (c) {
5221 	case SS2:
5222 		return (tp->eucwioc.scrw[2]);
5223 	case SS3:
5224 		return (tp->eucwioc.scrw[3]);
5225 	default:
5226 		return (tp->eucwioc.scrw[1]);
5227 	}
5228 }
5229 
5230 /*
5231  * ldterm_memwidth_euc - Take the first byte of an EUC (or an ASCII char)
5232  * and return its memory width.  The routine could have been
5233  * implemented to use only the codeset number, but that would require
5234  * the caller to have that value available.  Perhaps the user doesn't
5235  * want to make the extra call or keep the value of codeset around.
5236  * Therefore, we use the actual character with which they're
5237  * concerned.  This should never be called with anything but the
5238  * first byte of an EUC, otherwise it will return a garbage value.
5239  */
5240 static int
5241 __ldterm_memwidth_euc(uchar_t c, void *p)
5242 {
5243 	ldtermstd_state_t *tp = (ldtermstd_state_t *)p;
5244 
5245 	if (ISASCII(c))
5246 		return (1);
5247 	switch (c) {
5248 	case SS2:
5249 		return (tp->eucwioc.eucw[2]);
5250 	case SS3:
5251 		return (tp->eucwioc.eucw[3]);
5252 	default:
5253 		return (tp->eucwioc.eucw[1]);
5254 	}
5255 }
5256 
5257 
5258 /* The following two functions are PCCS codeset specific methods. */
5259 static int
5260 __ldterm_dispwidth_pccs(uchar_t c, void *p, int mode)
5261 {
5262 	ldtermstd_state_t *tp = (ldtermstd_state_t *)p;
5263 	int i;
5264 
5265 	if (ISASCII(c)) {
5266 		if (c <= '\037') {
5267 			switch (c) {
5268 			case '\t':
5269 				return (EUC_TWIDTH);
5270 			case '\b':
5271 				return (mode ? 2 : EUC_BSWIDTH);
5272 			case '\n':
5273 				return (EUC_NLWIDTH);
5274 			case '\r':
5275 				return (mode ? 2 : EUC_CRWIDTH);
5276 			default:
5277 				return (mode ? 2 : 0);
5278 			}
5279 		}
5280 		return (1);
5281 	}
5282 
5283 	for (i = 0; i < tp->t_csdata.csinfo_num; i++) {
5284 		if (c >= tp->t_csdata.eucpc_data[i].msb_start &&
5285 		    c <= tp->t_csdata.eucpc_data[i].msb_end)
5286 			return (tp->t_csdata.eucpc_data[i].screen_width);
5287 	}
5288 
5289 	/*
5290 	 * If this leading byte is not in the range list, either provided
5291 	 * locale data is not sufficient or we encountered an invalid
5292 	 * character. We return 1 in this case as a fallback value.
5293 	 */
5294 	return (1);
5295 }
5296 
5297 static int
5298 __ldterm_memwidth_pccs(uchar_t c, void *p)
5299 {
5300 	ldtermstd_state_t *tp = (ldtermstd_state_t *)p;
5301 	int i;
5302 
5303 	for (i = 0; i < tp->t_csdata.csinfo_num; i++) {
5304 		if (c >= tp->t_csdata.eucpc_data[i].msb_start &&
5305 		    c <= tp->t_csdata.eucpc_data[i].msb_end)
5306 			return (tp->t_csdata.eucpc_data[i].byte_length);
5307 	}
5308 
5309 	/*
5310 	 * If this leading byte is not in the range list, either provided
5311 	 * locale data is not sufficient or we encountered an invalid
5312 	 * character. We return 1 in this case as a fallback value.
5313 	 */
5314 	return (1);
5315 }
5316 
5317 
5318 /* The following two functions are UTF-8 codeset specific methods. */
5319 static int
5320 __ldterm_dispwidth_utf8(uchar_t c, void *p, int mode)
5321 {
5322 	ldtermstd_state_t *tp = (ldtermstd_state_t *)p;
5323 
5324 	if (ISASCII(c)) {
5325 		if (c <= '\037') {
5326 			switch (c) {
5327 			case '\t':
5328 				return (EUC_TWIDTH);
5329 			case '\b':
5330 				return (mode ? 2 : EUC_BSWIDTH);
5331 			case '\n':
5332 				return (EUC_NLWIDTH);
5333 			case '\r':
5334 				return (mode ? 2 : EUC_CRWIDTH);
5335 			default:
5336 				return (mode ? 2 : 0);
5337 			}
5338 		}
5339 		return (1);
5340 	}
5341 
5342 	/* This is to silence the lint. */
5343 	if (tp->t_csdata.codeset_type != LDTERM_CS_TYPE_UTF8)
5344 		return (1);
5345 
5346 	/*
5347 	 * If it is a valid leading byte of a UTF-8 character, we set
5348 	 * the width as 'UNKNOWN_WIDTH' for now. We need to have all
5349 	 * the bytes to figure out the display width.
5350 	 */
5351 	if (c >= (uchar_t)0xc0 && c <= (uchar_t)0xfd)
5352 		return (UNKNOWN_WIDTH);
5353 
5354 	/*
5355 	 * If it is an invalid leading byte, we just do our best by
5356 	 * giving the display width of 1.
5357 	 */
5358 	return (1);
5359 }
5360 
5361 
5362 static int
5363 __ldterm_memwidth_utf8(uchar_t c, void *p)
5364 {
5365 	ldtermstd_state_t *tp = (ldtermstd_state_t *)p;
5366 	int len;
5367 
5368 	/*
5369 	 * If the codeset type doesn't match, we treat them as
5370 	 * an illegal character and return 1.
5371 	 */
5372 	if (tp->t_csdata.codeset_type != LDTERM_CS_TYPE_UTF8)
5373 		return (1);
5374 
5375 	len = u8_number_of_bytes[c];
5376 
5377 	/*
5378 	 * If this is a start of an illegal character, we treat
5379 	 * such as an 1 byte character and screen out.
5380 	 */
5381 	return ((len <= 0) ? 1 : len);
5382 }
5383 
5384 static uchar_t
5385 ldterm_utf8_width(uchar_t *u8, int length)
5386 {
5387 	int i;
5388 	int j;
5389 	uint_t intcode = 0;
5390 
5391 	if (length == 0)
5392 		return ('\0');
5393 
5394 	j = u8_number_of_bytes[u8[0]] - 1;
5395 
5396 	/*
5397 	 * If the UTF-8 character is out of UTF-16 code range, or,
5398 	 * if it is either an ASCII character or an invalid leading byte for
5399 	 * a UTF-8 character, return 1.
5400 	 */
5401 	if (length > 4 || j <= 0)
5402 		return ('\1');
5403 
5404 	intcode = u8[0] & u8_masks_tbl[j];
5405 	for (i = 1; j > 0; j--, i++) {
5406 		/*
5407 		 * The following additional checking is needed to conform to
5408 		 * the "UTF-8 Corrigendum" introduced at the Unicode 3.1 and
5409 		 * then updated one more time at the Unicode 3.2.
5410 		 */
5411 		if (i == 1) {
5412 			if (u8[i] < u8_valid_min_2nd_byte[u8[0]] ||
5413 			    u8[i] > u8_valid_max_2nd_byte[u8[0]])
5414 				return ('\1');
5415 		} else if (u8[i] < (uchar_t)LDTERM_CS_TYPE_UTF8_MIN_BYTE ||
5416 		    u8[i] > (uchar_t)LDTERM_CS_TYPE_UTF8_MAX_BYTE)
5417 			return ('\1');
5418 
5419 		/*
5420 		 * All subsequent bytes of UTF-8 character has the following
5421 		 * binary encoding:
5422 		 *
5423 		 * 10xx xxxx
5424 		 *
5425 		 * hence left shift six bits to make space and then get
5426 		 * six bits from the new byte.
5427 		 */
5428 		intcode = (intcode << LDTERM_CS_TYPE_UTF8_SHIFT_BITS) |
5429 		    (u8[i] & LDTERM_CS_TYPE_UTF8_BIT_MASK);
5430 	}
5431 
5432 	i = 0;
5433 	if (intcode <= LDTERM_CS_TYPE_UTF8_MAX_P00) {
5434 		/* Basic Multilingual Plane. */
5435 		i = intcode / 4;
5436 		j = intcode % 4;
5437 		switch (j) {
5438 		case 0:
5439 			i = ldterm_ucode[0][i].u0;
5440 			break;
5441 		case 1:
5442 			i = ldterm_ucode[0][i].u1;
5443 			break;
5444 		case 2:
5445 			i = ldterm_ucode[0][i].u2;
5446 			break;
5447 		case 3:
5448 			i = ldterm_ucode[0][i].u3;
5449 			break;
5450 		}
5451 	} else if (intcode <= LDTERM_CS_TYPE_UTF8_MAX_P01) {
5452 		/* Secondary Multilingual Plane. */
5453 		intcode = intcode & (uint_t)0xffff;
5454 		i = intcode / 4;
5455 		j = intcode % 4;
5456 		switch (j) {
5457 		case 0:
5458 			i = ldterm_ucode[1][i].u0;
5459 			break;
5460 		case 1:
5461 			i = ldterm_ucode[1][i].u1;
5462 			break;
5463 		case 2:
5464 			i = ldterm_ucode[1][i].u2;
5465 			break;
5466 		case 3:
5467 			i = ldterm_ucode[1][i].u3;
5468 			break;
5469 		}
5470 	} else if ((intcode >= LDTERM_CS_TYPE_UTF8_MIN_CJKEXTB &&
5471 	    intcode <= LDTERM_CS_TYPE_UTF8_MAX_CJKEXTB) ||
5472 	    (intcode >= LDTERM_CS_TYPE_UTF8_MIN_CJKCOMP &&
5473 	    intcode <= LDTERM_CS_TYPE_UTF8_MAX_CJKCOMP) ||
5474 	    (intcode >= LDTERM_CS_TYPE_UTF8_MIN_P15 &&
5475 	    intcode <= LDTERM_CS_TYPE_UTF8_MAX_P15) ||
5476 	    (intcode >= LDTERM_CS_TYPE_UTF8_MIN_P16 &&
5477 	    intcode <= LDTERM_CS_TYPE_UTF8_MAX_P16)) {
5478 		/*
5479 		 * Supplementary Plane for CJK Ideographs and
5480 		 * Private Use Planes.
5481 		 */
5482 		return ('\2');
5483 	} else if ((intcode >= LDTERM_CS_TYPE_UTF8_MIN_P14 &&
5484 	    intcode <= LDTERM_CS_TYPE_UTF8_MAX_P14) ||
5485 	    (intcode >= LDTERM_CS_TYPE_UTF8_MIN_VARSEL &&
5486 	    intcode <= LDTERM_CS_TYPE_UTF8_MAX_VARSEL)) {
5487 		/*
5488 		 * Some Special Purpose Plane characters:
5489 		 * These are like control characters and not printable.
5490 		 */
5491 		return ('\0');
5492 	}
5493 
5494 	/*
5495 	 * We return the display width of 1 for all character code points
5496 	 * that we didn't catch from the above logic and also for combining
5497 	 * and conjoining characters with width value of zero.
5498 	 *
5499 	 * In particular, the reason why we are returning 1 for combining
5500 	 * and conjoining characters is because the GUI-based terminal
5501 	 * emulators are not yet capable of properly handling such characters
5502 	 * and in most of the cases, they just treat such characters as if
5503 	 * they occupy a display cell. If the terminal emulators are capable of
5504 	 * handling the characters correctly, then, this logic of returning
5505 	 * 1 should be revisited and changed. See CR 6660526 for more
5506 	 * details on this.
5507 	 */
5508 	return ((i == 0) ? '\1' : (uchar_t)i);
5509 }
5510