Annotation of sys/compat/svr4/svr4_termios.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: svr4_termios.c,v 1.12 2002/03/14 01:26:51 millert Exp $ */
! 2: /* $NetBSD: svr4_termios.c,v 1.9 1996/04/11 12:53:48 christos Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1994 Christos Zoulas
! 6: * All rights reserved.
! 7: *
! 8: * Redistribution and use in source and binary forms, with or without
! 9: * modification, are permitted provided that the following conditions
! 10: * are met:
! 11: * 1. Redistributions of source code must retain the above copyright
! 12: * notice, this list of conditions and the following disclaimer.
! 13: * 2. Redistributions in binary form must reproduce the above copyright
! 14: * notice, this list of conditions and the following disclaimer in the
! 15: * documentation and/or other materials provided with the distribution.
! 16: * 3. The name of the author may not be used to endorse or promote products
! 17: * derived from this software without specific prior written permission
! 18: *
! 19: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 20: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
! 21: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
! 22: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
! 23: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
! 24: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
! 25: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
! 26: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 27: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
! 28: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 29: */
! 30:
! 31: #include <sys/param.h>
! 32: #include <sys/proc.h>
! 33: #include <sys/systm.h>
! 34: #include <sys/file.h>
! 35: #include <sys/filedesc.h>
! 36: #include <sys/ioctl.h>
! 37: #include <sys/termios.h>
! 38: #include <sys/tty.h>
! 39: #include <sys/socket.h>
! 40: #include <sys/mount.h>
! 41: #include <net/if.h>
! 42: #include <sys/malloc.h>
! 43:
! 44: #include <sys/syscallargs.h>
! 45:
! 46: #include <compat/svr4/svr4_types.h>
! 47: #include <compat/svr4/svr4_util.h>
! 48: #include <compat/svr4/svr4_signal.h>
! 49: #include <compat/svr4/svr4_ioctl.h>
! 50: #include <compat/svr4/svr4_syscallargs.h>
! 51: #include <compat/svr4/svr4_stropts.h>
! 52: #include <compat/svr4/svr4_termios.h>
! 53:
! 54: #define SVR4_OXTABS SVR4_XTABS /* XXX */
! 55:
! 56: #ifndef __CONCAT3
! 57: # if __STDC__
! 58: # define __CONCAT3(a,b,c) a ## b ## c
! 59: # else
! 60: # define __CONCAT3(a,b,c) a/**/b/**/c
! 61: # endif
! 62: #endif
! 63:
! 64: u_long bsd_to_svr4_speed(u_long, u_long);
! 65: u_long svr4_to_bsd_speed(u_long, u_long);
! 66: void svr4_to_bsd_termios(const struct svr4_termios *, struct termios *,
! 67: int);
! 68: void bsd_to_svr4_termios(const struct termios *, struct svr4_termios *);
! 69: void svr4_termio_to_termios(const struct svr4_termio *,
! 70: struct svr4_termios *);
! 71: void svr4_termios_to_termio(const struct svr4_termios *,
! 72: struct svr4_termio *);
! 73: #ifdef DEBUG_SVR4
! 74: void print_svr4_termios(const struct svr4_termios *);
! 75: void print_bsd_termios(const struct termios *);
! 76: #endif /* DEBUG_SVR4 */
! 77:
! 78: #define undefined_char(a,b) /**/
! 79: #define undefined_flag1(f,a,b) /**/
! 80: #define undefined_flag2(f,a,b,c1,t1,c2,t2) /**/
! 81: #define undefined_flag4(f,a,b,c1,t1,c2,t2,c3,t3,c4,t4) /**/
! 82:
! 83: #define svr4_to_bsd_char(a,b) \
! 84: if (new || __CONCAT3(SVR4_,a,b) < SVR4_NCC) { \
! 85: if (st->c_cc[__CONCAT3(SVR4_,a,b)] == SVR4_POSIX_VDISABLE) \
! 86: bt->c_cc[__CONCAT(a,b)] = _POSIX_VDISABLE; \
! 87: else \
! 88: bt->c_cc[__CONCAT(a,b)] = \
! 89: st->c_cc[__CONCAT3(SVR4_,a,b)]; \
! 90: }
! 91:
! 92: #define svr4_to_bsd_flag1(f,a,b) \
! 93: if (new || __CONCAT3(SVR4_,a,b) < 0200000) { \
! 94: if (st->f & __CONCAT3(SVR4_,a,b)) \
! 95: bt->f |= __CONCAT(a,b); \
! 96: else \
! 97: bt->f &= ~__CONCAT(a,b); \
! 98: }
! 99:
! 100: #define svr4_to_bsd_flag2(f,a,b,c1,t1,c2,t2) \
! 101: if (new || __CONCAT3(SVR4_,a,b) < 0200000) { \
! 102: bt->f &= ~__CONCAT(a,b); \
! 103: switch (st->f & __CONCAT3(SVR4_,a,b)) { \
! 104: case __CONCAT3(SVR4_,c1,t1): bt->f |= __CONCAT(c1,t1); break; \
! 105: case __CONCAT3(SVR4_,c2,t2): bt->f |= __CONCAT(c2,t2); break; \
! 106: } \
! 107: }
! 108:
! 109: #define svr4_to_bsd_flag4(f,a,b,c1,t1,c2,t2,c3,t3,c4,t4) \
! 110: if (new || __CONCAT3(SVR4_,a,b) < 0200000) { \
! 111: bt->f &= ~__CONCAT(a,b); \
! 112: switch (st->f & __CONCAT3(SVR4_,a,b)) { \
! 113: case __CONCAT3(SVR4_,c1,t1): bt->f |= __CONCAT(c1,t1); break; \
! 114: case __CONCAT3(SVR4_,c2,t2): bt->f |= __CONCAT(c2,t2); break; \
! 115: case __CONCAT3(SVR4_,c3,t3): bt->f |= __CONCAT(c3,t3); break; \
! 116: case __CONCAT3(SVR4_,c4,t4): bt->f |= __CONCAT(c4,t4); break; \
! 117: } \
! 118: }
! 119:
! 120:
! 121: #define bsd_to_svr4_char(a,b) \
! 122: if (bt->c_cc[__CONCAT(a,b)] == _POSIX_VDISABLE) \
! 123: st->c_cc[__CONCAT3(SVR4_,a,b)] = SVR4_POSIX_VDISABLE; \
! 124: else \
! 125: st->c_cc[__CONCAT3(SVR4_,a,b)] = bt->c_cc[__CONCAT(a,b)]
! 126:
! 127: #define bsd_to_svr4_flag1(f,a,b) \
! 128: if (bt->f & __CONCAT(a,b)) \
! 129: st->f |= __CONCAT3(SVR4_,a,b); \
! 130: else \
! 131: st->f &= ~__CONCAT3(SVR4_,a,b)
! 132:
! 133: #define bsd_to_svr4_flag2(f,a,b,c1,t1,c2,t2) \
! 134: st->f &= ~__CONCAT3(SVR4_,a,b); \
! 135: switch (bt->f & __CONCAT(a,b)) { \
! 136: case __CONCAT(c1,t1): st->f |= __CONCAT3(SVR4_,c1,t1); break; \
! 137: case __CONCAT(c2,t2): st->f |= __CONCAT3(SVR4_,c2,t2); break; \
! 138: }
! 139:
! 140: #define bsd_to_svr4_flag4(f,a,b,c1,t1,c2,t2,c3,t3,c4,t4) \
! 141: st->f &= ~__CONCAT3(SVR4_,a,b); \
! 142: switch (bt->f & __CONCAT(a,b)) { \
! 143: case __CONCAT(c1,t1): st->f |= __CONCAT3(SVR4_,c1,t1); break; \
! 144: case __CONCAT(c2,t2): st->f |= __CONCAT3(SVR4_,c2,t2); break; \
! 145: case __CONCAT(c3,t3): st->f |= __CONCAT3(SVR4_,c3,t3); break; \
! 146: case __CONCAT(c4,t4): st->f |= __CONCAT3(SVR4_,c4,t4); break; \
! 147: }
! 148:
! 149: #ifdef DEBUG_SVR4
! 150: void
! 151: print_svr4_termios(st)
! 152: const struct svr4_termios *st;
! 153: {
! 154: int i;
! 155: uprintf("SVR4\niflag=%lo oflag=%lo cflag=%lo lflag=%lo\n",
! 156: st->c_iflag, st->c_oflag, st->c_cflag, st->c_lflag);
! 157: uprintf("cc: ");
! 158: for (i = 0; i < SVR4_NCCS; i++)
! 159: uprintf("%o ", st->c_cc[i]);
! 160: uprintf("\n");
! 161: }
! 162:
! 163: void
! 164: print_bsd_termios(bt)
! 165: const struct termios *bt;
! 166: {
! 167: int i;
! 168: uprintf(
! 169: "BSD\niflag=%x oflag=%x cflag=%x lflag=%x ispeed=%d osped=%d\n",
! 170: bt->c_iflag, bt->c_oflag, bt->c_cflag, bt->c_lflag, bt->c_ispeed,
! 171: bt->c_ospeed);
! 172: uprintf("cc: ");
! 173: for (i = 0; i < NCCS; i++)
! 174: uprintf("%o ", bt->c_cc[i]);
! 175: uprintf("\n");
! 176: }
! 177: #endif /* DEBUG_SVR4 */
! 178:
! 179: u_long
! 180: bsd_to_svr4_speed(sp, mask)
! 181: u_long sp;
! 182: u_long mask;
! 183: {
! 184: switch (sp) {
! 185: #undef getval
! 186: #define getval(a,b) case __CONCAT(a,b): sp = __CONCAT3(SVR4_,a,b); break
! 187: getval(B,0);
! 188: getval(B,50);
! 189: getval(B,75);
! 190: getval(B,110);
! 191: getval(B,134);
! 192: getval(B,150);
! 193: getval(B,200);
! 194: getval(B,300);
! 195: getval(B,600);
! 196: getval(B,1200);
! 197: getval(B,1800);
! 198: getval(B,2400);
! 199: getval(B,4800);
! 200: getval(B,9600);
! 201: getval(B,19200);
! 202: getval(B,38400);
! 203: #if 0
! 204: /* XXX These don't fit in CBAUD */
! 205: getval(B,57600);
! 206: getval(B,115200);
! 207: #endif
! 208: default: sp = SVR4_B9600; /* XXX */
! 209: }
! 210:
! 211: while ((mask & 1) == 0) {
! 212: mask >>= 1;
! 213: sp <<= 1;
! 214: }
! 215:
! 216: return (sp);
! 217: }
! 218:
! 219: u_long
! 220: svr4_to_bsd_speed(sp, mask)
! 221: u_long sp;
! 222: u_long mask;
! 223: {
! 224: while ((mask & 1) == 0) {
! 225: mask >>= 1;
! 226: sp >>= 1;
! 227: }
! 228:
! 229: switch (sp & mask) {
! 230: #undef getval
! 231: #define getval(a,b) case __CONCAT3(SVR4_,a,b): return (__CONCAT(a,b))
! 232: getval(B,0);
! 233: getval(B,50);
! 234: getval(B,75);
! 235: getval(B,110);
! 236: getval(B,134);
! 237: getval(B,150);
! 238: getval(B,200);
! 239: getval(B,300);
! 240: getval(B,600);
! 241: getval(B,1200);
! 242: getval(B,1800);
! 243: getval(B,2400);
! 244: getval(B,4800);
! 245: getval(B,9600);
! 246: getval(B,19200);
! 247: getval(B,38400);
! 248: #if 0
! 249: /* XXX These don't fit in CBAUD */
! 250: getval(B,57600);
! 251: getval(B,115200);
! 252: #endif
! 253: default: return (B9600); /* XXX */
! 254: }
! 255: }
! 256:
! 257: void
! 258: svr4_to_bsd_termios(st, bt, new)
! 259: const struct svr4_termios *st;
! 260: struct termios *bt;
! 261: int new;
! 262: {
! 263: /* control characters */
! 264: svr4_to_bsd_char(V,INTR);
! 265: svr4_to_bsd_char(V,QUIT);
! 266: svr4_to_bsd_char(V,ERASE);
! 267: svr4_to_bsd_char(V,KILL);
! 268: if (st->c_lflag & ICANON) {
! 269: svr4_to_bsd_char(V,EOF);
! 270: svr4_to_bsd_char(V,EOL);
! 271: } else {
! 272: /*
! 273: * These are not chars so _POSIX_DISABLE values should not be
! 274: * special cased.
! 275: */
! 276: bt->c_cc[VMIN] = st->c_cc[SVR4_VMIN];
! 277: bt->c_cc[VTIME] = st->c_cc[SVR4_VTIME];
! 278: }
! 279: svr4_to_bsd_char(V,EOF);
! 280: svr4_to_bsd_char(V,EOL);
! 281: svr4_to_bsd_char(V,EOL2);
! 282: undefined_char(V,SWTCH);
! 283: svr4_to_bsd_char(V,START);
! 284: svr4_to_bsd_char(V,STOP);
! 285: svr4_to_bsd_char(V,SUSP);
! 286: svr4_to_bsd_char(V,DSUSP);
! 287: svr4_to_bsd_char(V,REPRINT);
! 288: svr4_to_bsd_char(V,DISCARD);
! 289: svr4_to_bsd_char(V,WERASE);
! 290: svr4_to_bsd_char(V,LNEXT);
! 291:
! 292: /* Input modes */
! 293: svr4_to_bsd_flag1(c_iflag,I,GNBRK);
! 294: svr4_to_bsd_flag1(c_iflag,B,RKINT);
! 295: svr4_to_bsd_flag1(c_iflag,I,GNPAR);
! 296: svr4_to_bsd_flag1(c_iflag,P,ARMRK);
! 297: svr4_to_bsd_flag1(c_iflag,I,NPCK);
! 298: svr4_to_bsd_flag1(c_iflag,I,STRIP);
! 299: svr4_to_bsd_flag1(c_iflag,I,NLCR);
! 300: svr4_to_bsd_flag1(c_iflag,I,GNCR);
! 301: svr4_to_bsd_flag1(c_iflag,I,CRNL);
! 302: undefined_flag1(c_iflag,I,UCLC);
! 303: svr4_to_bsd_flag1(c_iflag,I,XON);
! 304: svr4_to_bsd_flag1(c_iflag,I,XANY);
! 305: svr4_to_bsd_flag1(c_iflag,I,XOFF);
! 306: svr4_to_bsd_flag1(c_iflag,I,MAXBEL);
! 307: undefined_flag1(c_iflag,D,OSMODE);
! 308:
! 309: /* Output modes */
! 310: svr4_to_bsd_flag1(c_oflag,O,POST);
! 311: undefined_flag1(c_oflag,O,LCUC);
! 312: svr4_to_bsd_flag1(c_oflag,O,NLCR);
! 313: undefined_flag1(c_oflag,O,CRNL);
! 314: undefined_flag1(c_oflag,O,NOCR);
! 315: undefined_flag1(c_oflag,O,NLRET);
! 316: undefined_flag1(c_oflag,O,FILL);
! 317: undefined_flag1(c_oflag,O,FDEL);
! 318: undefined_flag2(c_oflag,N,LDLY,N,L0,N,L1);
! 319: undefined_flag4(c_oflag,C,RDLY,C,R0,C,R1,C,R2,C,R3);
! 320: undefined_flag4(c_oflag,T,ABDLY,T,AB0,T,AB1,T,AB2,T,AB3);
! 321: /*
! 322: * XXX Note, we cannot use svr4_to_bsd_flag1 here because the SVR4
! 323: * field is a two bit value where identity is important, i.e. any bit
! 324: * set in that field is *not* enough. Someday we might to wish to
! 325: * support the other values of this bitfield, but not now...
! 326: */
! 327: if ((st->c_oflag & SVR4_XTABS) == SVR4_XTABS)
! 328: bt->c_oflag |= OXTABS;
! 329: else
! 330: bt->c_oflag &= ~OXTABS;
! 331: undefined_flag2(c_oflag,B,SDLY,B,S0,B,S1);
! 332: undefined_flag2(c_oflag,V,TDLY,V,T0,V,T1);
! 333: undefined_flag2(c_oflag,F,FDLY,F,F0,F,F1);
! 334: undefined_flag1(c_oflag,P,AGEOUT);
! 335: undefined_flag1(c_oflag,W,RAP);
! 336:
! 337: /* Control modes */
! 338: bt->c_ospeed = svr4_to_bsd_speed(st->c_cflag, SVR4_CBAUD);
! 339: svr4_to_bsd_flag4(c_cflag,C,SIZE,C,S5,C,S6,C,S7,C,S8)
! 340: svr4_to_bsd_flag1(c_cflag,C,STOPB);
! 341: svr4_to_bsd_flag1(c_cflag,C,READ);
! 342: svr4_to_bsd_flag1(c_cflag,P,ARENB);
! 343: svr4_to_bsd_flag1(c_cflag,P,ARODD);
! 344: svr4_to_bsd_flag1(c_cflag,H,UPCL);
! 345: svr4_to_bsd_flag1(c_cflag,C,LOCAL);
! 346: undefined_flag1(c_cflag,R,CV1EN);
! 347: undefined_flag1(c_cflag,X,MT1EN);
! 348: undefined_flag1(c_cflag,L,OBLK);
! 349: undefined_flag1(c_cflag,X,CLUDE);
! 350: bt->c_ispeed = svr4_to_bsd_speed(st->c_cflag, SVR4_CIBAUD);
! 351: undefined_flag1(c_cflag,P,AREXT);
! 352:
! 353: /* line discipline modes */
! 354: svr4_to_bsd_flag1(c_lflag,I,SIG);
! 355: svr4_to_bsd_flag1(c_lflag,I,CANON);
! 356: undefined_flag1(c_lflag,X,CASE);
! 357: svr4_to_bsd_flag1(c_lflag,E,CHO);
! 358: svr4_to_bsd_flag1(c_lflag,E,CHOE);
! 359: svr4_to_bsd_flag1(c_lflag,E,CHOK);
! 360: svr4_to_bsd_flag1(c_lflag,E,CHONL);
! 361: svr4_to_bsd_flag1(c_lflag,N,OFLSH);
! 362: svr4_to_bsd_flag1(c_lflag,T,OSTOP);
! 363: svr4_to_bsd_flag1(c_lflag,E,CHOCTL);
! 364: svr4_to_bsd_flag1(c_lflag,E,CHOPRT);
! 365: svr4_to_bsd_flag1(c_lflag,E,CHOKE);
! 366: undefined_flag1(c_lflag,D,EFECHO);
! 367: svr4_to_bsd_flag1(c_lflag,F,LUSHO);
! 368: svr4_to_bsd_flag1(c_lflag,P,ENDIN);
! 369: svr4_to_bsd_flag1(c_lflag,I,EXTEN);
! 370: }
! 371:
! 372: void
! 373: bsd_to_svr4_termios(bt, st)
! 374: const struct termios *bt;
! 375: struct svr4_termios *st;
! 376: {
! 377: /* control characters */
! 378: bsd_to_svr4_char(V,INTR);
! 379: bsd_to_svr4_char(V,QUIT);
! 380: bsd_to_svr4_char(V,ERASE);
! 381: bsd_to_svr4_char(V,KILL);
! 382: if (bt->c_lflag & ICANON) {
! 383: bsd_to_svr4_char(V,EOF);
! 384: bsd_to_svr4_char(V,EOL);
! 385: } else {
! 386: /*
! 387: * These are not chars so _POSIX_DISABLE values should not be
! 388: * special cased.
! 389: */
! 390: st->c_cc[SVR4_VMIN] = bt->c_cc[VMIN];
! 391: st->c_cc[SVR4_VTIME] = bt->c_cc[VTIME];
! 392: }
! 393: bsd_to_svr4_char(V,EOL2);
! 394: undefined_char(V,SWTCH);
! 395: bsd_to_svr4_char(V,START);
! 396: bsd_to_svr4_char(V,STOP);
! 397: bsd_to_svr4_char(V,SUSP);
! 398: bsd_to_svr4_char(V,DSUSP);
! 399: bsd_to_svr4_char(V,REPRINT);
! 400: bsd_to_svr4_char(V,DISCARD);
! 401: bsd_to_svr4_char(V,WERASE);
! 402: bsd_to_svr4_char(V,LNEXT);
! 403:
! 404: /* Input modes */
! 405: bsd_to_svr4_flag1(c_iflag,I,GNBRK);
! 406: bsd_to_svr4_flag1(c_iflag,B,RKINT);
! 407: bsd_to_svr4_flag1(c_iflag,I,GNPAR);
! 408: bsd_to_svr4_flag1(c_iflag,P,ARMRK);
! 409: bsd_to_svr4_flag1(c_iflag,I,NPCK);
! 410: bsd_to_svr4_flag1(c_iflag,I,STRIP);
! 411: bsd_to_svr4_flag1(c_iflag,I,NLCR);
! 412: bsd_to_svr4_flag1(c_iflag,I,GNCR);
! 413: bsd_to_svr4_flag1(c_iflag,I,CRNL);
! 414: undefined_flag1(c_iflag,I,UCLC);
! 415: bsd_to_svr4_flag1(c_iflag,I,XON);
! 416: bsd_to_svr4_flag1(c_iflag,I,XANY);
! 417: bsd_to_svr4_flag1(c_iflag,I,XOFF);
! 418: bsd_to_svr4_flag1(c_iflag,I,MAXBEL);
! 419: undefined_flag1(c_iflag,D,OSMODE);
! 420:
! 421: /* Output modes */
! 422: bsd_to_svr4_flag1(c_oflag,O,POST);
! 423: undefined_flag1(c_oflag,O,LCUC);
! 424: bsd_to_svr4_flag1(c_oflag,O,NLCR);
! 425: undefined_flag1(c_oflag,O,CRNL);
! 426: undefined_flag1(c_oflag,O,NOCR);
! 427: undefined_flag1(c_oflag,O,NLRET);
! 428: undefined_flag1(c_oflag,O,FILL);
! 429: undefined_flag1(c_oflag,O,FDEL);
! 430: undefined_flag2(c_oflag,N,LDLY,N,L0,N,L1);
! 431: undefined_flag4(c_oflag,C,RDLY,C,R0,C,R1,C,R2,C,R3);
! 432: undefined_flag4(c_oflag,T,ABDLY,T,AB0,T,AB1,T,AB2,T,AB3);
! 433: /*
! 434: * XXX This isn't what it seem to be, a one bit flag... It's actually
! 435: * a two bit value in SVR4 with composite semantics, where we only
! 436: * support one of them. Be careful if you change this...
! 437: */
! 438: bsd_to_svr4_flag1(c_oflag,OX,TABS);
! 439: undefined_flag2(c_oflag,B,SDLY,B,S0,B,S1);
! 440: undefined_flag2(c_oflag,V,TDLY,V,T0,V,T1);
! 441: undefined_flag2(c_oflag,F,FDLY,F,F0,F,F1);
! 442: undefined_flag1(c_oflag,P,AGEOUT);
! 443: undefined_flag1(c_oflag,W,RAP);
! 444:
! 445: /* Control modes */
! 446: st->c_cflag &= ~SVR4_CBAUD;
! 447: st->c_cflag |= bsd_to_svr4_speed(bt->c_ospeed, SVR4_CBAUD);
! 448: bsd_to_svr4_flag4(c_cflag,C,SIZE,C,S5,C,S6,C,S7,C,S8)
! 449: bsd_to_svr4_flag1(c_cflag,C,STOPB);
! 450: bsd_to_svr4_flag1(c_cflag,C,READ);
! 451: bsd_to_svr4_flag1(c_cflag,P,ARENB);
! 452: bsd_to_svr4_flag1(c_cflag,P,ARODD);
! 453: bsd_to_svr4_flag1(c_cflag,H,UPCL);
! 454: bsd_to_svr4_flag1(c_cflag,C,LOCAL);
! 455: undefined_flag1(c_cflag,R,CV1EN);
! 456: undefined_flag1(c_cflag,X,MT1EN);
! 457: undefined_flag1(c_cflag,L,OBLK);
! 458: undefined_flag1(c_cflag,X,CLUDE);
! 459: st->c_cflag &= ~SVR4_CIBAUD;
! 460: st->c_cflag |= bsd_to_svr4_speed(bt->c_ispeed, SVR4_CIBAUD);
! 461:
! 462: undefined_flag1(c_oflag,P,AREXT);
! 463:
! 464: /* line discipline modes */
! 465: bsd_to_svr4_flag1(c_lflag,I,SIG);
! 466: bsd_to_svr4_flag1(c_lflag,I,CANON);
! 467: undefined_flag1(c_lflag,X,CASE);
! 468: bsd_to_svr4_flag1(c_lflag,E,CHO);
! 469: bsd_to_svr4_flag1(c_lflag,E,CHOE);
! 470: bsd_to_svr4_flag1(c_lflag,E,CHOK);
! 471: bsd_to_svr4_flag1(c_lflag,E,CHONL);
! 472: bsd_to_svr4_flag1(c_lflag,N,OFLSH);
! 473: bsd_to_svr4_flag1(c_lflag,T,OSTOP);
! 474: bsd_to_svr4_flag1(c_lflag,E,CHOCTL);
! 475: bsd_to_svr4_flag1(c_lflag,E,CHOPRT);
! 476: bsd_to_svr4_flag1(c_lflag,E,CHOKE);
! 477: undefined_flag1(c_lflag,D,EFECHO);
! 478: bsd_to_svr4_flag1(c_lflag,F,LUSHO);
! 479: bsd_to_svr4_flag1(c_lflag,P,ENDIN);
! 480: bsd_to_svr4_flag1(c_lflag,I,EXTEN);
! 481: }
! 482:
! 483: void
! 484: svr4_termio_to_termios(t, ts)
! 485: const struct svr4_termio *t;
! 486: struct svr4_termios *ts;
! 487: {
! 488: int i;
! 489:
! 490: ts->c_iflag = (svr4_tcflag_t)t->c_iflag;
! 491: ts->c_oflag = (svr4_tcflag_t)t->c_oflag;
! 492: ts->c_cflag = (svr4_tcflag_t)t->c_cflag & ~SVR4_CIBAUD;
! 493: /* XXX because SVR4_CIBAUD == SVR4_CBAUD << 16 we can do: */
! 494: ts->c_cflag |= (ts->c_cflag & SVR4_CBAUD) << 16;
! 495: ts->c_lflag = (svr4_tcflag_t)t->c_lflag;
! 496:
! 497: for (i = 0; i < SVR4_NCC; i++)
! 498: ts->c_cc[i] = (svr4_cc_t)t->c_cc[i];
! 499: }
! 500:
! 501: void
! 502: svr4_termios_to_termio(ts, t)
! 503: const struct svr4_termios *ts;
! 504: struct svr4_termio *t;
! 505: {
! 506: int i;
! 507:
! 508: t->c_iflag = (u_short)ts->c_iflag;
! 509: t->c_oflag = (u_short)ts->c_oflag;
! 510: t->c_cflag = (u_short)ts->c_cflag;
! 511: t->c_lflag = (u_short)ts->c_lflag;
! 512: t->c_line = 0; /* XXX */
! 513:
! 514: for (i = 0; i < SVR4_NCC; i++)
! 515: t->c_cc[i] = (u_char)ts->c_cc[i];
! 516: }
! 517:
! 518: int
! 519: svr4_term_ioctl(fp, p, retval, fd, cmd, data)
! 520: struct file *fp;
! 521: struct proc *p;
! 522: register_t *retval;
! 523: int fd;
! 524: u_long cmd;
! 525: caddr_t data;
! 526: {
! 527: struct termios bt;
! 528: struct svr4_termios st;
! 529: struct svr4_termio t;
! 530: int error, new;
! 531: int (*ctl)(struct file *, u_long, caddr_t, struct proc *) =
! 532: fp->f_ops->fo_ioctl;
! 533:
! 534: *retval = 0;
! 535:
! 536: switch (cmd) {
! 537: case SVR4_TCGETA:
! 538: case SVR4_TCGETS:
! 539: if ((error = (*ctl)(fp, TIOCGETA, (caddr_t)&bt, p)) != 0)
! 540: return (error);
! 541:
! 542: bzero(&st,sizeof(st));
! 543: bsd_to_svr4_termios(&bt, &st);
! 544:
! 545: DPRINTF(("ioctl(TCGET%c);\n", cmd == SVR4_TCGETA ? 'A' : 'S'));
! 546: #ifdef DEBUG_SVR4
! 547: print_bsd_termios(&bt);
! 548: print_svr4_termios(&st);
! 549: #endif /* DEBUG_SVR4 */
! 550:
! 551: if (cmd == SVR4_TCGETA) {
! 552: svr4_termios_to_termio(&st, &t);
! 553: return (copyout(&t, data, sizeof(t)));
! 554: }
! 555: else {
! 556: return (copyout(&st, data, sizeof(st)));
! 557: }
! 558:
! 559: case SVR4_TCSETA:
! 560: case SVR4_TCSETS:
! 561: case SVR4_TCSETAW:
! 562: case SVR4_TCSETSW:
! 563: case SVR4_TCSETAF:
! 564: case SVR4_TCSETSF:
! 565: /* get full BSD termios so we don't lose information */
! 566: if ((error = (*ctl)(fp, TIOCGETA, (caddr_t) &bt, p)) != 0)
! 567: return (error);
! 568:
! 569: switch (cmd) {
! 570: case SVR4_TCSETS:
! 571: case SVR4_TCSETSW:
! 572: case SVR4_TCSETSF:
! 573: if ((error = copyin(data, &st, sizeof(st))) != 0)
! 574: return (error);
! 575: new = 1;
! 576: break;
! 577:
! 578: case SVR4_TCSETA:
! 579: case SVR4_TCSETAW:
! 580: case SVR4_TCSETAF:
! 581: if ((error = copyin(data, &t, sizeof(t))) != 0)
! 582: return (error);
! 583:
! 584: bsd_to_svr4_termios(&bt, &st);
! 585: svr4_termio_to_termios(&t, &st);
! 586: new = 0;
! 587: break;
! 588:
! 589: default:
! 590: return (EINVAL);
! 591: }
! 592:
! 593: svr4_to_bsd_termios(&st, &bt, new);
! 594:
! 595: switch (cmd) {
! 596: case SVR4_TCSETA:
! 597: case SVR4_TCSETS:
! 598: DPRINTF(("ioctl(TCSET[A|S]);\n"));
! 599: cmd = TIOCSETA;
! 600: break;
! 601: case SVR4_TCSETAW:
! 602: case SVR4_TCSETSW:
! 603: DPRINTF(("ioctl(TCSET[A|S]W);\n"));
! 604: cmd = TIOCSETAW;
! 605: break;
! 606: case SVR4_TCSETAF:
! 607: case SVR4_TCSETSF:
! 608: DPRINTF(("ioctl(TCSET[A|S]F);\n"));
! 609: cmd = TIOCSETAF;
! 610: break;
! 611: }
! 612:
! 613: #ifdef DEBUG_SVR4
! 614: print_bsd_termios(&bt);
! 615: print_svr4_termios(&st);
! 616: #endif /* DEBUG_SVR4 */
! 617:
! 618: return ((*ctl)(fp, cmd, (caddr_t) &bt, p));
! 619:
! 620: case SVR4_TIOCGWINSZ:
! 621: {
! 622: struct svr4_winsize ws;
! 623:
! 624: error = (*ctl)(fp, TIOCGWINSZ, (caddr_t)&ws, p);
! 625: if (error)
! 626: return (error);
! 627: return (copyout(&ws, data, sizeof(ws)));
! 628: }
! 629:
! 630: case SVR4_TIOCSWINSZ:
! 631: {
! 632: struct svr4_winsize ws;
! 633:
! 634: if ((error = copyin(data, &ws, sizeof(ws))) != 0)
! 635: return (error);
! 636: return ((*ctl)(fp, TIOCSWINSZ, (caddr_t) &ws, p));
! 637: }
! 638:
! 639: default:
! 640: return (svr4_stream_ti_ioctl(fp, p, retval, fd, cmd, data));
! 641: }
! 642: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to svr4_termios.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / compat / svr4