root/compat/common/tty_43.c

DEFINITIONS

1. ttcompat
2. ttcompatgetflags
3. ttcompatsetflags
4. ttcompatsetlflags

    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 $  */
    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  */
   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>
   50 /*
   51  * XXX libcompat files should be included with config attributes
   52  */
   53 #ifdef COMPAT_OLDTTY
   55 int ttydebug = 0;
   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 };
   84 int ttcompatgetflags(struct tty *);
   85 void ttcompatsetflags(struct tty *, struct termios *);
   86 void ttcompatsetlflags(struct tty *, struct termios *);
   88 /*ARGSUSED*/
   89 int
ttcompat(tp, com, data, flag, p)
   91         register struct tty *tp;
u_long com;
caddr_t data;
   94         int flag;
   95         struct proc *p;
   96 {
   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;
speed = ttspeedtab(tp->t_ospeed, compatspeeds);
sg->sg_ospeed = (speed == -1) ? MAX_SPEED : speed;
  106                 if (tp->t_ispeed == 0)
sg->sg_ispeed = sg->sg_ospeed;
  108                 else {
speed = ttspeedtab(tp->t_ispeed, compatspeeds);
sg->sg_ispeed = (speed == -1) ? MAX_SPEED : speed;
  111                 }
sg->sg_erase = cc[VERASE];
sg->sg_kill = cc[VKILL];
sg->sg_flags = ttcompatgetflags(tp);
  115                 break;
  116         }
  118         case TIOCSETP:
  119         case TIOCSETN: {
  120                 register struct sgttyb *sg = (struct sgttyb *)data;
  121                 struct termios term;
  122                 int speed;
term = tp->t_termios;
  125                 if ((speed = sg->sg_ispeed) > MAX_SPEED || speed < 0)
term.c_ispeed = speed;
  127                 else
term.c_ispeed = compatspcodes[speed];
  129                 if ((speed = sg->sg_ospeed) > MAX_SPEED || speed < 0)
term.c_ospeed = speed;
  131                 else
term.c_ospeed = compatspcodes[speed];
term.c_cc[VERASE] = sg->sg_erase;
term.c_cc[VKILL] = sg->sg_kill;
tp->t_flags = (ttcompatgetflags(tp)&0xffff0000) | (sg->sg_flags&0xffff);
ttcompatsetflags(tp, &term);
  137                 return (ttioctl(tp, com == TIOCSETP ? TIOCSETAF : TIOCSETA,
  138                         (caddr_t)&term, flag, p));
  139         }
  141         case TIOCGETC: {
  142                 struct tchars *tc = (struct tchars *)data;
  143                 register u_char *cc = tp->t_cc;
tc->t_intrc = cc[VINTR];
tc->t_quitc = cc[VQUIT];
tc->t_startc = cc[VSTART];
tc->t_stopc = cc[VSTOP];
tc->t_eofc = cc[VEOF];
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;
cc[VINTR] = tc->t_intrc;
cc[VQUIT] = tc->t_quitc;
cc[VSTART] = tc->t_startc;
cc[VSTOP] = tc->t_stopc;
cc[VEOF] = tc->t_eofc;
cc[VEOL] = tc->t_brkc;
  163                 if (tc->t_brkc == (char)-1)
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;
cc[VSUSP] = ltc->t_suspc;
cc[VDSUSP] = ltc->t_dsuspc;
cc[VREPRINT] = ltc->t_rprntc;
cc[VDISCARD] = ltc->t_flushc;
cc[VWERASE] = ltc->t_werasc;
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;
ltc->t_suspc = cc[VSUSP];
ltc->t_dsuspc = cc[VDSUSP];
ltc->t_rprntc = cc[VREPRINT];
ltc->t_flushc = cc[VDISCARD];
ltc->t_werasc = cc[VWERASE];
ltc->t_lnextc = cc[VLNEXT];
  189                 break;
  190         }
  191         case TIOCLBIS:
  192         case TIOCLBIC:
  193         case TIOCLSET: {
  194                 struct termios term;
  195                 int flags;
term = tp->t_termios;
flags = ttcompatgetflags(tp);
  199                 switch (com) {
  200                 case TIOCLSET:
tp->t_flags = (flags&0xffff) | (*(int *)data<<16);
  202                         break;
  203                 case TIOCLBIS:
tp->t_flags = flags | (*(int *)data<<16);
  205                         break;
  206                 case TIOCLBIC:
tp->t_flags = flags & ~(*(int *)data<<16);
  208                         break;
  209                 }
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)
printf("CLGET: returning %x\n", *(int *)data);
  217                 break;
  219         case OTIOCGETD:
  220                 *(int *)data = tp->t_line ? tp->t_line : 2;
  221                 break;
  223         case OTIOCSETD: {
  224                 int ldisczero = 0;
  226                 return (ttioctl(tp, TIOCSETD,
  227                         *(int *)data == 2 ? (caddr_t)&ldisczero : data, flag,
p));
  229             }
  231         case OTIOCCONS:
  232                 *(int *)data = 1;
  233                 return (ttioctl(tp, TIOCCONS, data, flag, p));
  235         case TIOCHPCL:
SET(tp->t_cflag, HUPCL);
  237                 break;
  239         case TIOCGSID:
  240                 if (tp->t_session == NULL)
  241                         return ENOTTY;
  243                 if (tp->t_session->s_leader == NULL)
  244                         return ENOTTY;
  246                 *(int *) data =  tp->t_session->s_leader->p_pid;
  247                 break;
  249         default:
  250                 return (-1);
  251         }
  252         return (0);
  253 }
  255 int
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;
  265         if (ISSET(iflag, IXOFF))
SET(flags, TANDEM);
  267         if (ISSET(iflag, ICRNL) || ISSET(oflag, ONLCR))
SET(flags, CRMOD);
  269         if (ISSET(cflag, PARENB)) {
  270                 if (ISSET(iflag, INPCK)) {
  271                         if (ISSET(cflag, PARODD))
SET(flags, ODDP);
  273                         else
SET(flags, EVENP);
  275                 } else
SET(flags, ANYP);
  277         }
  279         if (!ISSET(lflag, ICANON)) {
  280                 /* fudge */
  281                 if (ISSET(iflag, IXON) || ISSET(lflag, ISIG|IEXTEN) ||
ISSET(cflag, PARENB))
SET(flags, CBREAK);
  284                 else
SET(flags, RAW);
  286         }
  288         if (ISSET(flags, RAW))
SET(flags, ISSET(tp->t_flags, LITOUT|PASS8));
  290         else if (ISSET(cflag, CSIZE) == CS8) {
  291                 if (!ISSET(oflag, OPOST))
SET(flags, LITOUT);
  293                 if (!ISSET(iflag, ISTRIP))
SET(flags, PASS8);
  295         }
  297         if (ISSET(cflag, MDMBUF))
SET(flags, MDMBUF);
  299         if (!ISSET(cflag, HUPCL))
SET(flags, NOHANG);
  301         if (ISSET(cflag, XCASE) && ISSET(iflag, IUCLC) && ISSET(oflag, OLCUC))
SET(flags, LCASE);
  303         if (ISSET(oflag, OXTABS))
SET(flags, XTABS);
  305         if (ISSET(lflag, ECHOE))
SET(flags, CRTERA|CRTBS);
  307         if (ISSET(lflag, ECHOKE))
SET(flags, CRTKIL|CRTBS);
  309         if (ISSET(lflag, ECHOPRT))
SET(flags, PRTERA);
  311         if (ISSET(lflag, ECHOCTL))
SET(flags, CTLECH);
  313         if (!ISSET(iflag, IXANY))
SET(flags, DECCTQ);
SET(flags, ISSET(lflag, ECHO|TOSTOP|FLUSHO|PENDIN|NOFLSH));
  316         if (ttydebug)
printf("getflags: %x\n", flags);
  318         return (flags);
  319 }
  321 void
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;
  332         if (ISSET(flags, TANDEM))
SET(iflag, IXOFF);
  334         else
CLR(iflag, IXOFF);
  336         if (ISSET(flags, ECHO))
SET(lflag, ECHO);
  338         else
CLR(lflag, ECHO);
  340         if (ISSET(flags, CRMOD)) {
SET(iflag, ICRNL);
SET(oflag, ONLCR);
  343         } else {
CLR(iflag, ICRNL);
CLR(oflag, ONLCR);
  346         }
  347         if (ISSET(flags, XTABS))
SET(oflag, OXTABS);
  349         else
CLR(oflag, OXTABS);
  351         if (ISSET(flags, LCASE)) {
SET(iflag, IUCLC);
SET(oflag, OLCUC);
SET(cflag, XCASE);
  355         }
  356         else {
CLR(iflag, IUCLC);
CLR(oflag, OLCUC);
CLR(cflag, XCASE);
  360         }
  363         if (ISSET(flags, RAW)) {
iflag &= IXOFF|IXANY;
CLR(lflag, ISIG|ICANON|IEXTEN);
CLR(cflag, PARENB);
  367         } else {
SET(iflag, BRKINT|IXON|IMAXBEL);
SET(lflag, ISIG|IEXTEN);
  370                 if (ISSET(flags, CBREAK))
CLR(lflag, ICANON);
  372                 else
SET(lflag, ICANON);
  374                 switch (ISSET(flags, ANYP)) {
  375                 case 0:
CLR(cflag, PARENB);
  377                         break;
  378                 case ANYP:
SET(cflag, PARENB);
CLR(iflag, INPCK);
  381                         break;
  382                 case EVENP:
SET(cflag, PARENB);
SET(iflag, INPCK);
CLR(cflag, PARODD);
  386                         break;
  387                 case ODDP:
SET(cflag, PARENB);
SET(iflag, INPCK);
SET(cflag, PARODD);
  391                         break;
  392                 }
  393         }
  395         if (ISSET(flags, RAW|LITOUT|PASS8)) {
CLR(cflag, CSIZE|XCASE);
SET(cflag, CS8);
  398                 if (!ISSET(flags, RAW|PASS8))
SET(iflag, ISTRIP);
  400                 else
CLR(iflag, ISTRIP);
  402                 if (!ISSET(flags, RAW|LITOUT))
SET(oflag, OPOST);
  404                 else
CLR(oflag, OPOST);
  406         } else {
CLR(cflag, CSIZE);
SET(cflag, CS7);
  409                 if (ISSET(iflag, IUCLC) && ISSET(oflag, OLCUC))
SET(cflag, XCASE);
SET(iflag, ISTRIP);
SET(oflag, OPOST);
  413         }
t->c_iflag = iflag;
t->c_oflag = oflag;
t->c_lflag = lflag;
t->c_cflag = cflag;
  419 }
  421 void
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;
  432         /* Nothing we can do with CRTBS. */
  433         if (ISSET(flags, PRTERA))
SET(lflag, ECHOPRT);
  435         else
CLR(lflag, ECHOPRT);
  437         if (ISSET(flags, CRTERA))
SET(lflag, ECHOE);
  439         else
CLR(lflag, ECHOE);
  441         /* Nothing we can do with TILDE. */
  442         if (ISSET(flags, MDMBUF))
SET(cflag, MDMBUF);
  444         else
CLR(cflag, MDMBUF);
  446         if (ISSET(flags, NOHANG))
CLR(cflag, HUPCL);
  448         else
SET(cflag, HUPCL);
  450         if (ISSET(flags, CRTKIL))
SET(lflag, ECHOKE);
  452         else
CLR(lflag, ECHOKE);
  454         if (ISSET(flags, CTLECH))
SET(lflag, ECHOCTL);
  456         else
CLR(lflag, ECHOCTL);
  458         if (!ISSET(flags, DECCTQ))
SET(iflag, IXANY);
  460         else
CLR(iflag, IXANY);
  462         if (ISSET(flags, LCASE)) {
SET(oflag, OLCUC);
SET(iflag, IUCLC);
SET(cflag, XCASE);
  466         }
CLR(lflag, TOSTOP|FLUSHO|PENDIN|NOFLSH);
SET(lflag, ISSET(flags, TOSTOP|FLUSHO|PENDIN|NOFLSH));
  470         if (ISSET(flags, RAW|LITOUT|PASS8)) {
CLR(cflag, CSIZE);
SET(cflag, CS8);
  473                 if (!ISSET(flags, RAW|PASS8))
SET(iflag, ISTRIP);
  475                 else
CLR(iflag, ISTRIP);
  477                 if (!ISSET(flags, RAW|LITOUT))
SET(oflag, OPOST);
  479                 else {
CLR(oflag, OPOST);
CLR(cflag, XCASE);
  482                 }
  483         } else {
CLR(cflag, CSIZE);
SET(cflag, CS7);
SET(iflag, ISTRIP);
SET(oflag, OPOST);
  488                 if (ISSET(oflag, OLCUC) && ISSET(iflag, IUCLC))
SET(cflag, XCASE);
  490         }
t->c_iflag = iflag;
t->c_oflag = oflag;
t->c_lflag = lflag;
t->c_cflag = cflag;
  496 }
  498 #endif /* COMPAT_OLDTTY */