The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/i386/ibcs2/ibcs2_ioctl.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*      $NetBSD: ibcs2_ioctl.c,v 1.6 1995/03/14 15:12:28 scottb Exp $   */
    2 
    3 /*
    4  * Copyright (c) 1994, 1995 Scott Bartram
    5  * All rights reserved.
    6  *
    7  * based on compat/sunos/sun_ioctl.c
    8  *
    9  * Redistribution and use in source and binary forms, with or without
   10  * modification, are permitted provided that the following conditions
   11  * are met:
   12  * 1. Redistributions of source code must retain the above copyright
   13  *    notice, this list of conditions and the following disclaimer.
   14  * 2. The name of the author may not be used to endorse or promote products
   15  *    derived from this software without specific prior written permission
   16  *
   17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   27  */
   28 
   29 #include <sys/param.h>
   30 #include <sys/systm.h>
   31 #include <sys/fcntl.h>
   32 #include <sys/file.h>
   33 #include <sys/filedesc.h>
   34 #include <sys/filio.h>
   35 #include <sys/ioctl_compat.h>
   36 #include <sys/tty.h>
   37 #include <machine/console.h>
   38 
   39 #include <sys/sysproto.h>
   40 
   41 #include <i386/ibcs2/ibcs2_signal.h>
   42 #include <i386/ibcs2/ibcs2_socksys.h>
   43 #include <i386/ibcs2/ibcs2_stropts.h>
   44 #include <i386/ibcs2/ibcs2_proto.h>
   45 #include <i386/ibcs2/ibcs2_termios.h>
   46 #include <i386/ibcs2/ibcs2_util.h>
   47 #include <i386/ibcs2/ibcs2_ioctl.h>
   48 
   49 static void stios2btios __P((struct ibcs2_termios *, struct termios *));
   50 static void btios2stios __P((struct termios *, struct ibcs2_termios *));
   51 static void stios2stio  __P((struct ibcs2_termios *, struct ibcs2_termio *));
   52 static void stio2stios  __P((struct ibcs2_termio *, struct ibcs2_termios *));
   53 
   54 
   55 int
   56 ibcs2_gtty(struct proc *p, struct ibcs2_gtty_args *args)
   57 {
   58         struct ioctl_args ioctl_arg;
   59 
   60         ioctl_arg.fd = args->fd;
   61         ioctl_arg.com = TIOCGETC;
   62         ioctl_arg.data = (caddr_t)args->buf;
   63 
   64         return ioctl(p, &ioctl_arg);
   65 }
   66 
   67 int
   68 ibcs2_stty(struct proc *p, struct ibcs2_stty_args *args)
   69 {
   70         struct ioctl_args ioctl_arg;
   71 
   72         ioctl_arg.fd = args->fd;
   73         ioctl_arg.com = TIOCSETC;
   74         ioctl_arg.data = (caddr_t)args->buf;
   75 
   76         return ioctl(p, &ioctl_arg);
   77 }
   78 
   79 
   80 /*
   81  * iBCS2 ioctl calls.
   82  */
   83 
   84 static struct speedtab sptab[] = {
   85         { 0, 0 },
   86         { 50, 1 },
   87         { 75, 2 },
   88         { 110, 3 },
   89         { 134, 4 },
   90         { 135, 4 },
   91         { 150, 5 },
   92         { 200, 6 },
   93         { 300, 7 },
   94         { 600, 8 },
   95         { 1200, 9 },
   96         { 1800, 10 },
   97         { 2400, 11 },
   98         { 4800, 12 },
   99         { 9600, 13 },
  100         { 19200, 14 },
  101         { 38400, 15 },
  102         { -1, -1 }
  103 };
  104 
  105 static u_long s2btab[] = { 
  106         0,
  107         50,
  108         75,
  109         110,
  110         134,
  111         150,
  112         200,
  113         300,
  114         600,
  115         1200,
  116         1800,
  117         2400,
  118         4800,
  119         9600,
  120         19200,
  121         38400,
  122 };
  123 
  124 static void
  125 stios2btios(st, bt)
  126         struct ibcs2_termios *st;
  127         struct termios *bt;
  128 {
  129         register u_long l, r;
  130 
  131         l = st->c_iflag;        r = 0;
  132         if (l & IBCS2_IGNBRK)   r |= IGNBRK;
  133         if (l & IBCS2_BRKINT)   r |= BRKINT;
  134         if (l & IBCS2_IGNPAR)   r |= IGNPAR;
  135         if (l & IBCS2_PARMRK)   r |= PARMRK;
  136         if (l & IBCS2_INPCK)    r |= INPCK;
  137         if (l & IBCS2_ISTRIP)   r |= ISTRIP;
  138         if (l & IBCS2_INLCR)    r |= INLCR;
  139         if (l & IBCS2_IGNCR)    r |= IGNCR;
  140         if (l & IBCS2_ICRNL)    r |= ICRNL;
  141         if (l & IBCS2_IXON)     r |= IXON;
  142         if (l & IBCS2_IXANY)    r |= IXANY;
  143         if (l & IBCS2_IXOFF)    r |= IXOFF;
  144         if (l & IBCS2_IMAXBEL)  r |= IMAXBEL;
  145         bt->c_iflag = r;
  146 
  147         l = st->c_oflag;        r = 0;
  148         if (l & IBCS2_OPOST)    r |= OPOST;
  149         if (l & IBCS2_ONLCR)    r |= ONLCR;
  150         if (l & IBCS2_TAB3)     r |= OXTABS;
  151         bt->c_oflag = r;
  152 
  153         l = st->c_cflag;        r = 0;
  154         switch (l & IBCS2_CSIZE) {
  155         case IBCS2_CS5:         r |= CS5; break;
  156         case IBCS2_CS6:         r |= CS6; break;
  157         case IBCS2_CS7:         r |= CS7; break;
  158         case IBCS2_CS8:         r |= CS8; break;
  159         }
  160         if (l & IBCS2_CSTOPB)   r |= CSTOPB;
  161         if (l & IBCS2_CREAD)    r |= CREAD;
  162         if (l & IBCS2_PARENB)   r |= PARENB;
  163         if (l & IBCS2_PARODD)   r |= PARODD;
  164         if (l & IBCS2_HUPCL)    r |= HUPCL;
  165         if (l & IBCS2_CLOCAL)   r |= CLOCAL;
  166         bt->c_cflag = r;
  167 
  168         l = st->c_lflag;        r = 0;
  169         if (l & IBCS2_ISIG)     r |= ISIG;
  170         if (l & IBCS2_ICANON)   r |= ICANON;
  171         if (l & IBCS2_ECHO)     r |= ECHO;
  172         if (l & IBCS2_ECHOE)    r |= ECHOE;
  173         if (l & IBCS2_ECHOK)    r |= ECHOK;
  174         if (l & IBCS2_ECHONL)   r |= ECHONL;
  175         if (l & IBCS2_NOFLSH)   r |= NOFLSH;
  176         if (l & IBCS2_TOSTOP)   r |= TOSTOP;
  177         bt->c_lflag = r;
  178 
  179         bt->c_ispeed = bt->c_ospeed = s2btab[l & 0x0000000f];
  180 
  181         bt->c_cc[VINTR] =
  182             st->c_cc[IBCS2_VINTR]  ? st->c_cc[IBCS2_VINTR]  : _POSIX_VDISABLE;
  183         bt->c_cc[VQUIT] =
  184             st->c_cc[IBCS2_VQUIT]  ? st->c_cc[IBCS2_VQUIT]  : _POSIX_VDISABLE;
  185         bt->c_cc[VERASE] =
  186             st->c_cc[IBCS2_VERASE] ? st->c_cc[IBCS2_VERASE] : _POSIX_VDISABLE;
  187         bt->c_cc[VKILL] =
  188             st->c_cc[IBCS2_VKILL]  ? st->c_cc[IBCS2_VKILL]  : _POSIX_VDISABLE;
  189         if (bt->c_lflag & ICANON) {
  190                 bt->c_cc[VEOF] =
  191                     st->c_cc[IBCS2_VEOF] ? st->c_cc[IBCS2_VEOF] : _POSIX_VDISABLE;
  192                 bt->c_cc[VEOL] =
  193                     st->c_cc[IBCS2_VEOL] ? st->c_cc[IBCS2_VEOL] : _POSIX_VDISABLE;
  194         } else {
  195                 bt->c_cc[VMIN]  = st->c_cc[IBCS2_VMIN];
  196                 bt->c_cc[VTIME] = st->c_cc[IBCS2_VTIME];
  197         }
  198         bt->c_cc[VEOL2] =
  199             st->c_cc[IBCS2_VEOL2]  ? st->c_cc[IBCS2_VEOL2]  : _POSIX_VDISABLE;
  200 #if 0
  201         bt->c_cc[VSWTCH] =
  202             st->c_cc[IBCS2_VSWTCH] ? st->c_cc[IBCS2_VSWTCH] : _POSIX_VDISABLE;
  203 #endif
  204         bt->c_cc[VSTART] =
  205             st->c_cc[IBCS2_VSTART] ? st->c_cc[IBCS2_VSTART] : _POSIX_VDISABLE;
  206         bt->c_cc[VSTOP] =
  207             st->c_cc[IBCS2_VSTOP]  ? st->c_cc[IBCS2_VSTOP]  : _POSIX_VDISABLE;
  208         bt->c_cc[VSUSP] =
  209             st->c_cc[IBCS2_VSUSP]  ? st->c_cc[IBCS2_VSUSP]  : _POSIX_VDISABLE;
  210         bt->c_cc[VDSUSP]   = _POSIX_VDISABLE;
  211         bt->c_cc[VREPRINT] = _POSIX_VDISABLE;
  212         bt->c_cc[VDISCARD] = _POSIX_VDISABLE;
  213         bt->c_cc[VWERASE]  = _POSIX_VDISABLE;
  214         bt->c_cc[VLNEXT]   = _POSIX_VDISABLE;
  215         bt->c_cc[VSTATUS]  = _POSIX_VDISABLE;
  216 }
  217 
  218 static void
  219 btios2stios(bt, st)
  220         struct termios *bt;
  221         struct ibcs2_termios *st;
  222 {
  223         register u_long l, r;
  224 
  225         l = bt->c_iflag;        r = 0;
  226         if (l & IGNBRK)         r |= IBCS2_IGNBRK;
  227         if (l & BRKINT)         r |= IBCS2_BRKINT;
  228         if (l & IGNPAR)         r |= IBCS2_IGNPAR;
  229         if (l & PARMRK)         r |= IBCS2_PARMRK;
  230         if (l & INPCK)          r |= IBCS2_INPCK;
  231         if (l & ISTRIP)         r |= IBCS2_ISTRIP;
  232         if (l & INLCR)          r |= IBCS2_INLCR;
  233         if (l & IGNCR)          r |= IBCS2_IGNCR;
  234         if (l & ICRNL)          r |= IBCS2_ICRNL;
  235         if (l & IXON)           r |= IBCS2_IXON;
  236         if (l & IXANY)          r |= IBCS2_IXANY;
  237         if (l & IXOFF)          r |= IBCS2_IXOFF;
  238         if (l & IMAXBEL)        r |= IBCS2_IMAXBEL;
  239         st->c_iflag = r;
  240 
  241         l = bt->c_oflag;        r = 0;
  242         if (l & OPOST)          r |= IBCS2_OPOST;
  243         if (l & ONLCR)          r |= IBCS2_ONLCR;
  244         if (l & OXTABS)         r |= IBCS2_TAB3;
  245         st->c_oflag = r;
  246 
  247         l = bt->c_cflag;        r = 0;
  248         switch (l & CSIZE) {
  249         case CS5:               r |= IBCS2_CS5; break;
  250         case CS6:               r |= IBCS2_CS6; break;
  251         case CS7:               r |= IBCS2_CS7; break;
  252         case CS8:               r |= IBCS2_CS8; break;
  253         }
  254         if (l & CSTOPB)         r |= IBCS2_CSTOPB;
  255         if (l & CREAD)          r |= IBCS2_CREAD;
  256         if (l & PARENB)         r |= IBCS2_PARENB;
  257         if (l & PARODD)         r |= IBCS2_PARODD;
  258         if (l & HUPCL)          r |= IBCS2_HUPCL;
  259         if (l & CLOCAL)         r |= IBCS2_CLOCAL;
  260         st->c_cflag = r;
  261 
  262         l = bt->c_lflag;        r = 0;
  263         if (l & ISIG)           r |= IBCS2_ISIG;
  264         if (l & ICANON)         r |= IBCS2_ICANON;
  265         if (l & ECHO)           r |= IBCS2_ECHO;
  266         if (l & ECHOE)          r |= IBCS2_ECHOE;
  267         if (l & ECHOK)          r |= IBCS2_ECHOK;
  268         if (l & ECHONL)         r |= IBCS2_ECHONL;
  269         if (l & NOFLSH)         r |= IBCS2_NOFLSH;
  270         if (l & TOSTOP)         r |= IBCS2_TOSTOP;
  271         st->c_lflag = r;
  272 
  273         l = ttspeedtab(bt->c_ospeed, sptab);
  274         if ((int)l >= 0)
  275                 st->c_cflag |= l;
  276 
  277         st->c_cc[IBCS2_VINTR] =
  278             bt->c_cc[VINTR]  != _POSIX_VDISABLE ? bt->c_cc[VINTR]  : 0;
  279         st->c_cc[IBCS2_VQUIT] =
  280             bt->c_cc[VQUIT]  != _POSIX_VDISABLE ? bt->c_cc[VQUIT]  : 0;
  281         st->c_cc[IBCS2_VERASE] =
  282             bt->c_cc[VERASE] != _POSIX_VDISABLE ? bt->c_cc[VERASE] : 0;
  283         st->c_cc[IBCS2_VKILL] =
  284             bt->c_cc[VKILL]  != _POSIX_VDISABLE ? bt->c_cc[VKILL]  : 0;
  285         if (bt->c_lflag & ICANON) {
  286                 st->c_cc[IBCS2_VEOF] =
  287                     bt->c_cc[VEOF] != _POSIX_VDISABLE ? bt->c_cc[VEOF] : 0;
  288                 st->c_cc[IBCS2_VEOL] =
  289                     bt->c_cc[VEOL] != _POSIX_VDISABLE ? bt->c_cc[VEOL] : 0;
  290         } else {
  291                 st->c_cc[IBCS2_VMIN]  = bt->c_cc[VMIN];
  292                 st->c_cc[IBCS2_VTIME] = bt->c_cc[VTIME];
  293         }
  294         st->c_cc[IBCS2_VEOL2] =
  295             bt->c_cc[VEOL2]  != _POSIX_VDISABLE ? bt->c_cc[VEOL2]  : 0;
  296         st->c_cc[IBCS2_VSWTCH] =
  297             0;
  298         st->c_cc[IBCS2_VSUSP] =
  299             bt->c_cc[VSUSP]  != _POSIX_VDISABLE ? bt->c_cc[VSUSP]  : 0;
  300         st->c_cc[IBCS2_VSTART] =
  301             bt->c_cc[VSTART] != _POSIX_VDISABLE ? bt->c_cc[VSTART] : 0;
  302         st->c_cc[IBCS2_VSTOP] =
  303             bt->c_cc[VSTOP]  != _POSIX_VDISABLE ? bt->c_cc[VSTOP]  : 0;
  304 
  305         st->c_line = 0;
  306 }
  307 
  308 static void
  309 stios2stio(ts, t)
  310         struct ibcs2_termios *ts;
  311         struct ibcs2_termio *t;
  312 {
  313         t->c_iflag = ts->c_iflag;
  314         t->c_oflag = ts->c_oflag;
  315         t->c_cflag = ts->c_cflag;
  316         t->c_lflag = ts->c_lflag;
  317         t->c_line  = ts->c_line;
  318         bcopy(ts->c_cc, t->c_cc, IBCS2_NCC);
  319 }
  320 
  321 static void
  322 stio2stios(t, ts)
  323         struct ibcs2_termio *t;
  324         struct ibcs2_termios *ts;
  325 {
  326         ts->c_iflag = t->c_iflag;
  327         ts->c_oflag = t->c_oflag;
  328         ts->c_cflag = t->c_cflag;
  329         ts->c_lflag = t->c_lflag;
  330         ts->c_line  = t->c_line;
  331         bcopy(t->c_cc, ts->c_cc, IBCS2_NCC);
  332 }
  333 
  334 int
  335 ibcs2_ioctl(p, uap)
  336         struct proc *p;
  337         struct ibcs2_ioctl_args *uap;
  338 {
  339         struct filedesc *fdp = p->p_fd;
  340         struct file *fp;
  341         int (*ctl) __P((struct file *, u_long, caddr_t, struct proc *));
  342         int error;
  343 
  344         if (SCARG(uap, fd) < 0 || SCARG(uap, fd) >= fdp->fd_nfiles ||
  345             (fp = fdp->fd_ofiles[SCARG(uap, fd)]) == NULL) {
  346                 DPRINTF(("ibcs2_ioctl(%d): bad fd %d ", p->p_pid,
  347                          SCARG(uap, fd)));
  348                 return EBADF;
  349         }
  350 
  351         if ((fp->f_flag & (FREAD|FWRITE)) == 0) {
  352                 DPRINTF(("ibcs2_ioctl(%d): bad fp flag ", p->p_pid));
  353                 return EBADF;
  354         }
  355 
  356         ctl = fp->f_ops->fo_ioctl;
  357 
  358         switch (SCARG(uap, cmd)) {
  359         case IBCS2_TCGETA:
  360         case IBCS2_XCGETA:
  361         case IBCS2_OXCGETA:
  362             {
  363                 struct termios bts;
  364                 struct ibcs2_termios sts;
  365                 struct ibcs2_termio st;
  366         
  367                 if ((error = (*ctl)(fp, TIOCGETA, (caddr_t)&bts, p)) != 0)
  368                         return error;
  369         
  370                 btios2stios (&bts, &sts);
  371                 if (SCARG(uap, cmd) == IBCS2_TCGETA) {
  372                         stios2stio (&sts, &st);
  373                         error = copyout((caddr_t)&st, SCARG(uap, data),
  374                                         sizeof (st));
  375 #ifdef DEBUG_IBCS2
  376                         if (error)
  377                                 DPRINTF(("ibcs2_ioctl(%d): copyout failed ",
  378                                          p->p_pid));
  379 #endif
  380                         return error;
  381                 } else
  382                         return copyout((caddr_t)&sts, SCARG(uap, data),
  383                                         sizeof (sts));
  384                 /*NOTREACHED*/
  385             }
  386 
  387         case IBCS2_TCSETA:
  388         case IBCS2_TCSETAW:
  389         case IBCS2_TCSETAF:
  390             {
  391                 struct termios bts;
  392                 struct ibcs2_termios sts;
  393                 struct ibcs2_termio st;
  394 
  395                 if ((error = copyin(SCARG(uap, data), (caddr_t)&st,
  396                                     sizeof(st))) != 0) {
  397                         DPRINTF(("ibcs2_ioctl(%d): TCSET copyin failed ",
  398                                  p->p_pid));
  399                         return error;
  400                 }
  401 
  402                 /* get full BSD termios so we don't lose information */
  403                 if ((error = (*ctl)(fp, TIOCGETA, (caddr_t)&bts, p)) != 0) {
  404                         DPRINTF(("ibcs2_ioctl(%d): TCSET ctl failed fd %d ",
  405                                  p->p_pid, SCARG(uap, fd)));
  406                         return error;
  407                 }
  408 
  409                 /*
  410                  * convert to iBCS2 termios, copy in information from
  411                  * termio, and convert back, then set new values.
  412                  */
  413                 btios2stios(&bts, &sts);
  414                 stio2stios(&st, &sts);
  415                 stios2btios(&sts, &bts);
  416 
  417                 return (*ctl)(fp, SCARG(uap, cmd) - IBCS2_TCSETA + TIOCSETA,
  418                               (caddr_t)&bts, p);
  419             }
  420 
  421         case IBCS2_XCSETA:
  422         case IBCS2_XCSETAW:
  423         case IBCS2_XCSETAF:
  424             {
  425                 struct termios bts;
  426                 struct ibcs2_termios sts;
  427 
  428                 if ((error = copyin(SCARG(uap, data), (caddr_t)&sts,
  429                                     sizeof (sts))) != 0) {
  430                         return error;
  431                 }
  432                 stios2btios (&sts, &bts);
  433                 return (*ctl)(fp, SCARG(uap, cmd) - IBCS2_XCSETA + TIOCSETA,
  434                               (caddr_t)&bts, p);
  435             }
  436 
  437         case IBCS2_OXCSETA:
  438         case IBCS2_OXCSETAW:
  439         case IBCS2_OXCSETAF:
  440             {
  441                 struct termios bts;
  442                 struct ibcs2_termios sts;
  443 
  444                 if ((error = copyin(SCARG(uap, data), (caddr_t)&sts,
  445                                     sizeof (sts))) != 0) {
  446                         return error;
  447                 }
  448                 stios2btios (&sts, &bts);
  449                 return (*ctl)(fp, SCARG(uap, cmd) - IBCS2_OXCSETA + TIOCSETA,
  450                               (caddr_t)&bts, p);
  451             }
  452 
  453         case IBCS2_TCSBRK:
  454                 DPRINTF(("ibcs2_ioctl(%d): TCSBRK ", p->p_pid));
  455                 return ENOSYS;
  456 
  457         case IBCS2_TCXONC:
  458             {
  459                 switch ((int)SCARG(uap, data)) {
  460                 case 0:
  461                 case 1:
  462                         DPRINTF(("ibcs2_ioctl(%d): TCXONC ", p->p_pid));
  463                         return ENOSYS;
  464                 case 2:
  465                         return (*ctl)(fp, TIOCSTOP, (caddr_t)0, p);
  466                 case 3:
  467                         return (*ctl)(fp, TIOCSTART, (caddr_t)1, p);
  468                 default:
  469                         return EINVAL;
  470                 }
  471             }
  472 
  473         case IBCS2_TCFLSH:
  474             {
  475                 int arg;
  476 
  477                 switch ((int)SCARG(uap, data)) {
  478                 case 0:
  479                         arg = FREAD;
  480                         break;
  481                 case 1:
  482                         arg = FWRITE;
  483                         break;
  484                 case 2:
  485                         arg = FREAD | FWRITE;
  486                         break;
  487                 default:
  488                         return EINVAL;
  489                 }
  490                 return (*ctl)(fp, TIOCFLUSH, (caddr_t)&arg, p);
  491             }
  492 
  493         case IBCS2_TIOCGWINSZ:
  494                 SCARG(uap, cmd) = TIOCGWINSZ;
  495                 return ioctl(p, (struct ioctl_args *)uap);
  496 
  497         case IBCS2_TIOCSWINSZ:
  498                 SCARG(uap, cmd) = TIOCSWINSZ;
  499                 return ioctl(p, (struct ioctl_args *)uap);
  500 
  501         case IBCS2_TIOCGPGRP:
  502                 return copyout((caddr_t)&p->p_pgrp->pg_id, SCARG(uap, data),
  503                                 sizeof(p->p_pgrp->pg_id));
  504 
  505         case IBCS2_TIOCSPGRP:   /* XXX - is uap->data a pointer to pgid? */
  506             {
  507                 struct setpgid_args sa;
  508 
  509                 SCARG(&sa, pid) = 0;
  510                 SCARG(&sa, pgid) = (int)SCARG(uap, data);
  511                 if (error = setpgid(p, &sa))
  512                         return error;
  513                 return 0;
  514             }
  515 
  516         case IBCS2_TCGETSC:     /* SCO console - get scancode flags */
  517                 return EINTR;  /* ENOSYS; */
  518 
  519         case IBCS2_TCSETSC:     /* SCO console - set scancode flags */
  520                 return 0;   /* ENOSYS; */
  521 
  522         case IBCS2_JWINSIZE:    /* Unix to Jerq I/O control */
  523             {
  524                 struct ibcs2_jwinsize {
  525                   char bytex, bytey; 
  526                   short bitx, bity;
  527                 } ibcs2_jwinsize;
  528 
  529                 ibcs2_jwinsize.bytex = 80;
  530                   /* p->p_session->s_ttyp->t_winsize.ws_col; XXX */
  531                 ibcs2_jwinsize.bytey = 25;
  532                   /* p->p_session->s_ttyp->t_winsize.ws_row; XXX */
  533                 ibcs2_jwinsize.bitx = 
  534                   p->p_session->s_ttyp->t_winsize.ws_xpixel;
  535                 ibcs2_jwinsize.bity =
  536                   p->p_session->s_ttyp->t_winsize.ws_ypixel;
  537                 return copyout((caddr_t)&ibcs2_jwinsize, SCARG(uap, data),
  538                                sizeof(ibcs2_jwinsize));
  539              }
  540 
  541         /* keyboard and display ioctl's -- type 'K' */
  542         case IBCS2_KDGKBMODE:        /* get keyboard translation mode */
  543                 SCARG(uap, cmd) = KDGKBMODE;
  544 /* printf("ioctl KDGKBMODE = %x\n", SCARG(uap, cmd));*/
  545                 return ioctl(p, (struct ioctl_args *)uap);
  546 
  547         case IBCS2_KDSKBMODE:        /* set keyboard translation mode */
  548                 SCARG(uap, cmd) = KDSKBMODE;
  549                 return ioctl(p, (struct ioctl_args *)uap);
  550 
  551         case IBCS2_KDMKTONE:        /* sound tone */
  552                 SCARG(uap, cmd) = KDMKTONE;
  553                 return ioctl(p, (struct ioctl_args *)uap);
  554 
  555         case IBCS2_KDGETMODE:        /* get text/graphics mode */  
  556                 SCARG(uap, cmd) = KDGETMODE;
  557                 return ioctl(p, (struct ioctl_args *)uap);
  558 
  559         case IBCS2_KDSETMODE:       /* set text/graphics mode */
  560                 SCARG(uap, cmd) = KDSETMODE;
  561                 return ioctl(p, (struct ioctl_args *)uap);
  562 
  563         case IBCS2_KDSBORDER:       /* set ega color border */
  564                 SCARG(uap, cmd) = KDSBORDER;
  565                 return ioctl(p, (struct ioctl_args *)uap);
  566 
  567         case IBCS2_KDGKBSTATE:
  568                 SCARG(uap, cmd) = KDGKBSTATE;
  569                 return ioctl(p, (struct ioctl_args *)uap);
  570 
  571         case IBCS2_KDSETRAD:
  572                 SCARG(uap, cmd) = KDSETRAD;
  573                 return ioctl(p, (struct ioctl_args *)uap);
  574 
  575         case IBCS2_KDENABIO:       /* enable direct I/O to ports */
  576                 SCARG(uap, cmd) = KDENABIO;
  577                 return ioctl(p, (struct ioctl_args *)uap);
  578 
  579         case IBCS2_KDDISABIO:       /* disable direct I/O to ports */
  580                 SCARG(uap, cmd) = KDDISABIO;
  581                 return ioctl(p, (struct ioctl_args *)uap);
  582 
  583         case IBCS2_KIOCSOUND:       /* start sound generation */
  584                 SCARG(uap, cmd) = KIOCSOUND;
  585                 return ioctl(p, (struct ioctl_args *)uap);
  586 
  587         case IBCS2_KDGKBTYPE:       /* get keyboard type */
  588                 SCARG(uap, cmd) = KDGKBTYPE;
  589                 return ioctl(p, (struct ioctl_args *)uap);
  590 
  591         case IBCS2_KDGETLED:       /* get keyboard LED status */
  592                 SCARG(uap, cmd) = KDGETLED;
  593                 return ioctl(p, (struct ioctl_args *)uap);
  594 
  595         case IBCS2_KDSETLED:       /* set keyboard LED status */
  596                 SCARG(uap, cmd) = KDSETLED;
  597                 return ioctl(p, (struct ioctl_args *)uap);
  598 
  599             /* Xenix keyboard and display ioctl's from sys/kd.h -- type 'k' */
  600         case IBCS2_GETFKEY:      /* Get function key */
  601                 SCARG(uap, cmd) = GETFKEY;
  602                 return ioctl(p, (struct ioctl_args *)uap);
  603 
  604         case IBCS2_SETFKEY:      /* Set function key */
  605                 SCARG(uap, cmd) = SETFKEY;
  606                 return ioctl(p, (struct ioctl_args *)uap);
  607 
  608         case IBCS2_GIO_SCRNMAP:      /* Get screen output map table */
  609                 SCARG(uap, cmd) = GIO_SCRNMAP;
  610                 return ioctl(p, (struct ioctl_args *)uap);
  611 
  612         case IBCS2_PIO_SCRNMAP:      /* Set screen output map table */
  613                 SCARG(uap, cmd) = PIO_SCRNMAP;
  614                 return ioctl(p, (struct ioctl_args *)uap);
  615 
  616         case IBCS2_GIO_KEYMAP:      /* Get keyboard map table */
  617                 SCARG(uap, cmd) = GIO_KEYMAP;
  618                 return ioctl(p, (struct ioctl_args *)uap);
  619 
  620         case IBCS2_PIO_KEYMAP:      /* Set keyboard map table */
  621                 SCARG(uap, cmd) = PIO_KEYMAP;
  622                 return ioctl(p, (struct ioctl_args *)uap);
  623 
  624             /* socksys */
  625         case IBCS2_SIOCSOCKSYS:
  626                 return ibcs2_socksys(p, (struct ibcs2_socksys_args *)uap);
  627 
  628         case IBCS2_I_NREAD:     /* STREAMS */
  629                 SCARG(uap, cmd) = FIONREAD;
  630                 return ioctl(p, (struct ioctl_args *)uap);
  631 
  632         default:
  633                 DPRINTF(("ibcs2_ioctl(%d): unknown cmd 0x%lx ",
  634                          p->p_pid, SCARG(uap, cmd)));
  635                 return ENOSYS;
  636         }
  637         return ENOSYS;
  638 }

Cache object: 6612764a0e75bb2e82f8c302f75f9343


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.