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