Annotation of sys/compat/common/tty_43.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: tty_43.c,v 1.9 2004/09/19 21:34:42 mickey Exp $ */
! 2: /* $NetBSD: tty_43.c,v 1.5 1996/05/20 14:29:17 mark Exp $ */
! 3:
! 4: /*-
! 5: * Copyright (c) 1982, 1986, 1991, 1993
! 6: * The Regents of the University of California. 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. Neither the name of the University nor the names of its contributors
! 17: * may be used to endorse or promote products derived from this software
! 18: * without specific prior written permission.
! 19: *
! 20: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 21: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 22: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 23: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 24: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 25: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 26: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 27: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 28: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 29: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 30: * SUCH DAMAGE.
! 31: *
! 32: * @(#)tty_compat.c 8.1 (Berkeley) 6/10/93
! 33: */
! 34:
! 35: /*
! 36: * mapping routines for old line discipline (yuck)
! 37: */
! 38: #include <sys/param.h>
! 39: #include <sys/systm.h>
! 40: #include <sys/ioctl.h>
! 41: #include <sys/proc.h>
! 42: #include <sys/tty.h>
! 43: #include <sys/termios.h>
! 44: #include <sys/file.h>
! 45: #include <sys/conf.h>
! 46: #include <sys/kernel.h>
! 47: #include <sys/syslog.h>
! 48: #include <sys/ioctl_compat.h>
! 49:
! 50: /*
! 51: * XXX libcompat files should be included with config attributes
! 52: */
! 53: #ifdef COMPAT_OLDTTY
! 54:
! 55: int ttydebug = 0;
! 56:
! 57: static const struct speedtab compatspeeds[] = {
! 58: #define MAX_SPEED 17
! 59: { 115200, 17 },
! 60: { 57600, 16 },
! 61: { 38400, 15 },
! 62: { 19200, 14 },
! 63: { 9600, 13 },
! 64: { 4800, 12 },
! 65: { 2400, 11 },
! 66: { 1800, 10 },
! 67: { 1200, 9 },
! 68: { 600, 8 },
! 69: { 300, 7 },
! 70: { 200, 6 },
! 71: { 150, 5 },
! 72: { 134, 4 },
! 73: { 110, 3 },
! 74: { 75, 2 },
! 75: { 50, 1 },
! 76: { 0, 0 },
! 77: { -1, -1 },
! 78: };
! 79: static const int compatspcodes[] = {
! 80: 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
! 81: 1800, 2400, 4800, 9600, 19200, 38400, 57600, 115200
! 82: };
! 83:
! 84: int ttcompatgetflags(struct tty *);
! 85: void ttcompatsetflags(struct tty *, struct termios *);
! 86: void ttcompatsetlflags(struct tty *, struct termios *);
! 87:
! 88: /*ARGSUSED*/
! 89: int
! 90: ttcompat(tp, com, data, flag, p)
! 91: register struct tty *tp;
! 92: u_long com;
! 93: caddr_t data;
! 94: int flag;
! 95: struct proc *p;
! 96: {
! 97:
! 98: switch (com) {
! 99: case TIOCGETP: {
! 100: register struct sgttyb *sg = (struct sgttyb *)data;
! 101: register u_char *cc = tp->t_cc;
! 102: register int speed;
! 103:
! 104: speed = ttspeedtab(tp->t_ospeed, compatspeeds);
! 105: sg->sg_ospeed = (speed == -1) ? MAX_SPEED : speed;
! 106: if (tp->t_ispeed == 0)
! 107: sg->sg_ispeed = sg->sg_ospeed;
! 108: else {
! 109: speed = ttspeedtab(tp->t_ispeed, compatspeeds);
! 110: sg->sg_ispeed = (speed == -1) ? MAX_SPEED : speed;
! 111: }
! 112: sg->sg_erase = cc[VERASE];
! 113: sg->sg_kill = cc[VKILL];
! 114: sg->sg_flags = ttcompatgetflags(tp);
! 115: break;
! 116: }
! 117:
! 118: case TIOCSETP:
! 119: case TIOCSETN: {
! 120: register struct sgttyb *sg = (struct sgttyb *)data;
! 121: struct termios term;
! 122: int speed;
! 123:
! 124: term = tp->t_termios;
! 125: if ((speed = sg->sg_ispeed) > MAX_SPEED || speed < 0)
! 126: term.c_ispeed = speed;
! 127: else
! 128: term.c_ispeed = compatspcodes[speed];
! 129: if ((speed = sg->sg_ospeed) > MAX_SPEED || speed < 0)
! 130: term.c_ospeed = speed;
! 131: else
! 132: term.c_ospeed = compatspcodes[speed];
! 133: term.c_cc[VERASE] = sg->sg_erase;
! 134: term.c_cc[VKILL] = sg->sg_kill;
! 135: tp->t_flags = (ttcompatgetflags(tp)&0xffff0000) | (sg->sg_flags&0xffff);
! 136: ttcompatsetflags(tp, &term);
! 137: return (ttioctl(tp, com == TIOCSETP ? TIOCSETAF : TIOCSETA,
! 138: (caddr_t)&term, flag, p));
! 139: }
! 140:
! 141: case TIOCGETC: {
! 142: struct tchars *tc = (struct tchars *)data;
! 143: register u_char *cc = tp->t_cc;
! 144:
! 145: tc->t_intrc = cc[VINTR];
! 146: tc->t_quitc = cc[VQUIT];
! 147: tc->t_startc = cc[VSTART];
! 148: tc->t_stopc = cc[VSTOP];
! 149: tc->t_eofc = cc[VEOF];
! 150: tc->t_brkc = cc[VEOL];
! 151: break;
! 152: }
! 153: case TIOCSETC: {
! 154: struct tchars *tc = (struct tchars *)data;
! 155: register u_char *cc = tp->t_cc;
! 156:
! 157: cc[VINTR] = tc->t_intrc;
! 158: cc[VQUIT] = tc->t_quitc;
! 159: cc[VSTART] = tc->t_startc;
! 160: cc[VSTOP] = tc->t_stopc;
! 161: cc[VEOF] = tc->t_eofc;
! 162: cc[VEOL] = tc->t_brkc;
! 163: if (tc->t_brkc == (char)-1)
! 164: cc[VEOL2] = _POSIX_VDISABLE;
! 165: break;
! 166: }
! 167: case TIOCSLTC: {
! 168: struct ltchars *ltc = (struct ltchars *)data;
! 169: register u_char *cc = tp->t_cc;
! 170:
! 171: cc[VSUSP] = ltc->t_suspc;
! 172: cc[VDSUSP] = ltc->t_dsuspc;
! 173: cc[VREPRINT] = ltc->t_rprntc;
! 174: cc[VDISCARD] = ltc->t_flushc;
! 175: cc[VWERASE] = ltc->t_werasc;
! 176: cc[VLNEXT] = ltc->t_lnextc;
! 177: break;
! 178: }
! 179: case TIOCGLTC: {
! 180: struct ltchars *ltc = (struct ltchars *)data;
! 181: register u_char *cc = tp->t_cc;
! 182:
! 183: ltc->t_suspc = cc[VSUSP];
! 184: ltc->t_dsuspc = cc[VDSUSP];
! 185: ltc->t_rprntc = cc[VREPRINT];
! 186: ltc->t_flushc = cc[VDISCARD];
! 187: ltc->t_werasc = cc[VWERASE];
! 188: ltc->t_lnextc = cc[VLNEXT];
! 189: break;
! 190: }
! 191: case TIOCLBIS:
! 192: case TIOCLBIC:
! 193: case TIOCLSET: {
! 194: struct termios term;
! 195: int flags;
! 196:
! 197: term = tp->t_termios;
! 198: flags = ttcompatgetflags(tp);
! 199: switch (com) {
! 200: case TIOCLSET:
! 201: tp->t_flags = (flags&0xffff) | (*(int *)data<<16);
! 202: break;
! 203: case TIOCLBIS:
! 204: tp->t_flags = flags | (*(int *)data<<16);
! 205: break;
! 206: case TIOCLBIC:
! 207: tp->t_flags = flags & ~(*(int *)data<<16);
! 208: break;
! 209: }
! 210: ttcompatsetlflags(tp, &term);
! 211: return (ttioctl(tp, TIOCSETA, (caddr_t)&term, flag, p));
! 212: }
! 213: case TIOCLGET:
! 214: *(int *)data = ttcompatgetflags(tp)>>16;
! 215: if (ttydebug)
! 216: printf("CLGET: returning %x\n", *(int *)data);
! 217: break;
! 218:
! 219: case OTIOCGETD:
! 220: *(int *)data = tp->t_line ? tp->t_line : 2;
! 221: break;
! 222:
! 223: case OTIOCSETD: {
! 224: int ldisczero = 0;
! 225:
! 226: return (ttioctl(tp, TIOCSETD,
! 227: *(int *)data == 2 ? (caddr_t)&ldisczero : data, flag,
! 228: p));
! 229: }
! 230:
! 231: case OTIOCCONS:
! 232: *(int *)data = 1;
! 233: return (ttioctl(tp, TIOCCONS, data, flag, p));
! 234:
! 235: case TIOCHPCL:
! 236: SET(tp->t_cflag, HUPCL);
! 237: break;
! 238:
! 239: case TIOCGSID:
! 240: if (tp->t_session == NULL)
! 241: return ENOTTY;
! 242:
! 243: if (tp->t_session->s_leader == NULL)
! 244: return ENOTTY;
! 245:
! 246: *(int *) data = tp->t_session->s_leader->p_pid;
! 247: break;
! 248:
! 249: default:
! 250: return (-1);
! 251: }
! 252: return (0);
! 253: }
! 254:
! 255: int
! 256: ttcompatgetflags(tp)
! 257: register struct tty *tp;
! 258: {
! 259: register tcflag_t iflag = tp->t_iflag;
! 260: register tcflag_t lflag = tp->t_lflag;
! 261: register tcflag_t oflag = tp->t_oflag;
! 262: register tcflag_t cflag = tp->t_cflag;
! 263: register int flags = 0;
! 264:
! 265: if (ISSET(iflag, IXOFF))
! 266: SET(flags, TANDEM);
! 267: if (ISSET(iflag, ICRNL) || ISSET(oflag, ONLCR))
! 268: SET(flags, CRMOD);
! 269: if (ISSET(cflag, PARENB)) {
! 270: if (ISSET(iflag, INPCK)) {
! 271: if (ISSET(cflag, PARODD))
! 272: SET(flags, ODDP);
! 273: else
! 274: SET(flags, EVENP);
! 275: } else
! 276: SET(flags, ANYP);
! 277: }
! 278:
! 279: if (!ISSET(lflag, ICANON)) {
! 280: /* fudge */
! 281: if (ISSET(iflag, IXON) || ISSET(lflag, ISIG|IEXTEN) ||
! 282: ISSET(cflag, PARENB))
! 283: SET(flags, CBREAK);
! 284: else
! 285: SET(flags, RAW);
! 286: }
! 287:
! 288: if (ISSET(flags, RAW))
! 289: SET(flags, ISSET(tp->t_flags, LITOUT|PASS8));
! 290: else if (ISSET(cflag, CSIZE) == CS8) {
! 291: if (!ISSET(oflag, OPOST))
! 292: SET(flags, LITOUT);
! 293: if (!ISSET(iflag, ISTRIP))
! 294: SET(flags, PASS8);
! 295: }
! 296:
! 297: if (ISSET(cflag, MDMBUF))
! 298: SET(flags, MDMBUF);
! 299: if (!ISSET(cflag, HUPCL))
! 300: SET(flags, NOHANG);
! 301: if (ISSET(cflag, XCASE) && ISSET(iflag, IUCLC) && ISSET(oflag, OLCUC))
! 302: SET(flags, LCASE);
! 303: if (ISSET(oflag, OXTABS))
! 304: SET(flags, XTABS);
! 305: if (ISSET(lflag, ECHOE))
! 306: SET(flags, CRTERA|CRTBS);
! 307: if (ISSET(lflag, ECHOKE))
! 308: SET(flags, CRTKIL|CRTBS);
! 309: if (ISSET(lflag, ECHOPRT))
! 310: SET(flags, PRTERA);
! 311: if (ISSET(lflag, ECHOCTL))
! 312: SET(flags, CTLECH);
! 313: if (!ISSET(iflag, IXANY))
! 314: SET(flags, DECCTQ);
! 315: SET(flags, ISSET(lflag, ECHO|TOSTOP|FLUSHO|PENDIN|NOFLSH));
! 316: if (ttydebug)
! 317: printf("getflags: %x\n", flags);
! 318: return (flags);
! 319: }
! 320:
! 321: void
! 322: ttcompatsetflags(tp, t)
! 323: register struct tty *tp;
! 324: register struct termios *t;
! 325: {
! 326: register int flags = tp->t_flags;
! 327: register tcflag_t iflag = t->c_iflag;
! 328: register tcflag_t oflag = t->c_oflag;
! 329: register tcflag_t lflag = t->c_lflag;
! 330: register tcflag_t cflag = t->c_cflag;
! 331:
! 332: if (ISSET(flags, TANDEM))
! 333: SET(iflag, IXOFF);
! 334: else
! 335: CLR(iflag, IXOFF);
! 336: if (ISSET(flags, ECHO))
! 337: SET(lflag, ECHO);
! 338: else
! 339: CLR(lflag, ECHO);
! 340: if (ISSET(flags, CRMOD)) {
! 341: SET(iflag, ICRNL);
! 342: SET(oflag, ONLCR);
! 343: } else {
! 344: CLR(iflag, ICRNL);
! 345: CLR(oflag, ONLCR);
! 346: }
! 347: if (ISSET(flags, XTABS))
! 348: SET(oflag, OXTABS);
! 349: else
! 350: CLR(oflag, OXTABS);
! 351: if (ISSET(flags, LCASE)) {
! 352: SET(iflag, IUCLC);
! 353: SET(oflag, OLCUC);
! 354: SET(cflag, XCASE);
! 355: }
! 356: else {
! 357: CLR(iflag, IUCLC);
! 358: CLR(oflag, OLCUC);
! 359: CLR(cflag, XCASE);
! 360: }
! 361:
! 362:
! 363: if (ISSET(flags, RAW)) {
! 364: iflag &= IXOFF|IXANY;
! 365: CLR(lflag, ISIG|ICANON|IEXTEN);
! 366: CLR(cflag, PARENB);
! 367: } else {
! 368: SET(iflag, BRKINT|IXON|IMAXBEL);
! 369: SET(lflag, ISIG|IEXTEN);
! 370: if (ISSET(flags, CBREAK))
! 371: CLR(lflag, ICANON);
! 372: else
! 373: SET(lflag, ICANON);
! 374: switch (ISSET(flags, ANYP)) {
! 375: case 0:
! 376: CLR(cflag, PARENB);
! 377: break;
! 378: case ANYP:
! 379: SET(cflag, PARENB);
! 380: CLR(iflag, INPCK);
! 381: break;
! 382: case EVENP:
! 383: SET(cflag, PARENB);
! 384: SET(iflag, INPCK);
! 385: CLR(cflag, PARODD);
! 386: break;
! 387: case ODDP:
! 388: SET(cflag, PARENB);
! 389: SET(iflag, INPCK);
! 390: SET(cflag, PARODD);
! 391: break;
! 392: }
! 393: }
! 394:
! 395: if (ISSET(flags, RAW|LITOUT|PASS8)) {
! 396: CLR(cflag, CSIZE|XCASE);
! 397: SET(cflag, CS8);
! 398: if (!ISSET(flags, RAW|PASS8))
! 399: SET(iflag, ISTRIP);
! 400: else
! 401: CLR(iflag, ISTRIP);
! 402: if (!ISSET(flags, RAW|LITOUT))
! 403: SET(oflag, OPOST);
! 404: else
! 405: CLR(oflag, OPOST);
! 406: } else {
! 407: CLR(cflag, CSIZE);
! 408: SET(cflag, CS7);
! 409: if (ISSET(iflag, IUCLC) && ISSET(oflag, OLCUC))
! 410: SET(cflag, XCASE);
! 411: SET(iflag, ISTRIP);
! 412: SET(oflag, OPOST);
! 413: }
! 414:
! 415: t->c_iflag = iflag;
! 416: t->c_oflag = oflag;
! 417: t->c_lflag = lflag;
! 418: t->c_cflag = cflag;
! 419: }
! 420:
! 421: void
! 422: ttcompatsetlflags(tp, t)
! 423: register struct tty *tp;
! 424: register struct termios *t;
! 425: {
! 426: register int flags = tp->t_flags;
! 427: register tcflag_t iflag = t->c_iflag;
! 428: register tcflag_t oflag = t->c_oflag;
! 429: register tcflag_t lflag = t->c_lflag;
! 430: register tcflag_t cflag = t->c_cflag;
! 431:
! 432: /* Nothing we can do with CRTBS. */
! 433: if (ISSET(flags, PRTERA))
! 434: SET(lflag, ECHOPRT);
! 435: else
! 436: CLR(lflag, ECHOPRT);
! 437: if (ISSET(flags, CRTERA))
! 438: SET(lflag, ECHOE);
! 439: else
! 440: CLR(lflag, ECHOE);
! 441: /* Nothing we can do with TILDE. */
! 442: if (ISSET(flags, MDMBUF))
! 443: SET(cflag, MDMBUF);
! 444: else
! 445: CLR(cflag, MDMBUF);
! 446: if (ISSET(flags, NOHANG))
! 447: CLR(cflag, HUPCL);
! 448: else
! 449: SET(cflag, HUPCL);
! 450: if (ISSET(flags, CRTKIL))
! 451: SET(lflag, ECHOKE);
! 452: else
! 453: CLR(lflag, ECHOKE);
! 454: if (ISSET(flags, CTLECH))
! 455: SET(lflag, ECHOCTL);
! 456: else
! 457: CLR(lflag, ECHOCTL);
! 458: if (!ISSET(flags, DECCTQ))
! 459: SET(iflag, IXANY);
! 460: else
! 461: CLR(iflag, IXANY);
! 462: if (ISSET(flags, LCASE)) {
! 463: SET(oflag, OLCUC);
! 464: SET(iflag, IUCLC);
! 465: SET(cflag, XCASE);
! 466: }
! 467: CLR(lflag, TOSTOP|FLUSHO|PENDIN|NOFLSH);
! 468: SET(lflag, ISSET(flags, TOSTOP|FLUSHO|PENDIN|NOFLSH));
! 469:
! 470: if (ISSET(flags, RAW|LITOUT|PASS8)) {
! 471: CLR(cflag, CSIZE);
! 472: SET(cflag, CS8);
! 473: if (!ISSET(flags, RAW|PASS8))
! 474: SET(iflag, ISTRIP);
! 475: else
! 476: CLR(iflag, ISTRIP);
! 477: if (!ISSET(flags, RAW|LITOUT))
! 478: SET(oflag, OPOST);
! 479: else {
! 480: CLR(oflag, OPOST);
! 481: CLR(cflag, XCASE);
! 482: }
! 483: } else {
! 484: CLR(cflag, CSIZE);
! 485: SET(cflag, CS7);
! 486: SET(iflag, ISTRIP);
! 487: SET(oflag, OPOST);
! 488: if (ISSET(oflag, OLCUC) && ISSET(iflag, IUCLC))
! 489: SET(cflag, XCASE);
! 490: }
! 491:
! 492: t->c_iflag = iflag;
! 493: t->c_oflag = oflag;
! 494: t->c_lflag = lflag;
! 495: t->c_cflag = cflag;
! 496: }
! 497:
! 498: #endif /* COMPAT_OLDTTY */
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to tty_43.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / compat / common