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

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