svr4_ttold.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 /*
    2  * Copyright (c) 1998 Mark Newton
    3  * Copyright (c) 1994 Christos Zoulas
    4  * All rights reserved.
    5  *
    6  * Redistribution and use in source and binary forms, with or without
    7  * modification, are permitted provided that the following conditions
    8  * are met:
    9  * 1. Redistributions of source code must retain the above copyright
   10  *    notice, this list of conditions and the following disclaimer.
   11  * 2. Redistributions in binary form must reproduce the above copyright
   12  *    notice, this list of conditions and the following disclaimer in the
   13  *    documentation and/or other materials provided with the distribution.
   14  * 3. 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/proc.h>
   33 #include <sys/systm.h>
   34 #include <sys/file.h>
   35 #include <sys/filedesc.h>
   36 #include <sys/ioctl_compat.h>
   37 #include <sys/termios.h>
   38 
   39 #include <svr4/svr4.h>
   40 #include <svr4/svr4_util.h>
   41 #include <svr4/svr4_ttold.h>
   42 #include <svr4/svr4_ioctl.h>
   43 
   44 
   45 static void svr4_tchars_to_bsd_tchars __P((const struct svr4_tchars *st,
   46                                            struct tchars *bt));
   47 static void bsd_tchars_to_svr4_tchars __P((const struct tchars *bt,
   48                                            struct svr4_tchars *st));
   49 static void svr4_sgttyb_to_bsd_sgttyb __P((const struct svr4_sgttyb *ss,
   50                                            struct sgttyb *bs));
   51 static void bsd_sgttyb_to_svr4_sgttyb __P((const struct sgttyb *bs,
   52                                            struct svr4_sgttyb *ss));
   53 static void svr4_ltchars_to_bsd_ltchars __P((const struct svr4_ltchars *sl,
   54                                              struct ltchars *bl));
   55 static void bsd_ltchars_to_svr4_ltchars __P((const struct ltchars *bl,
   56                                              struct svr4_ltchars *sl));
   57 
   58 #ifdef DEBUG_SVR4
   59 static void print_svr4_sgttyb __P((const char *, struct svr4_sgttyb *));
   60 static void print_svr4_tchars __P((const char *, struct svr4_tchars *));
   61 static void print_svr4_ltchars __P((const char *, struct svr4_ltchars *));
   62 
   63 static void
   64 print_svr4_sgttyb(str, ss)
   65         const char *str;
   66         struct svr4_sgttyb *ss;
   67 {
   68 
   69         uprintf("%s\nispeed=%o ospeed=%o ", str, ss->sg_ispeed, ss->sg_ospeed);
   70         uprintf("erase=%o kill=%o flags=%o\n", ss->sg_erase, ss->sg_kill,
   71             ss->sg_flags);
   72 }
   73 
   74 static void
   75 print_svr4_tchars(str, st)
   76         const char *str;
   77         struct svr4_tchars *st;
   78 {
   79         uprintf("%s\nintrc=%o quitc=%o ", str, st->t_intrc, st->t_quitc);
   80         uprintf("startc=%o stopc=%o eofc=%o brkc=%o\n", st->t_startc,
   81             st->t_stopc, st->t_eofc, st->t_brkc);
   82 }
   83 
   84 static void
   85 print_svr4_ltchars(str, sl)
   86         const char *str;
   87         struct svr4_ltchars *sl;
   88 {
   89         uprintf("%s\nsuspc=%o dsuspc=%o ", str, sl->t_suspc, sl->t_dsuspc);
   90         uprintf("rprntc=%o flushc=%o werasc=%o lnextc=%o\n", sl->t_rprntc,
   91             sl->t_flushc, sl->t_werasc, sl->t_lnextc);
   92 }
   93 #endif /* DEBUG_SVR4 */
   94 
   95 static void
   96 svr4_tchars_to_bsd_tchars(st, bt)
   97         const struct svr4_tchars        *st;
   98         struct tchars                   *bt;
   99 {
  100         bt->t_intrc  = st->t_intrc;
  101         bt->t_quitc  = st->t_quitc;
  102         bt->t_startc = st->t_startc;
  103         bt->t_stopc  = st->t_stopc;
  104         bt->t_eofc   = st->t_eofc;
  105         bt->t_brkc   = st->t_brkc;
  106 }
  107 
  108 
  109 static void
  110 bsd_tchars_to_svr4_tchars(bt, st)
  111         const struct tchars     *bt;
  112         struct svr4_tchars      *st;
  113 {
  114         st->t_intrc  = bt->t_intrc;
  115         st->t_quitc  = bt->t_quitc;
  116         st->t_startc = bt->t_startc;
  117         st->t_stopc  = bt->t_stopc;
  118         st->t_eofc   = bt->t_eofc;
  119         st->t_brkc   = bt->t_brkc;
  120 }
  121 
  122 
  123 static void
  124 svr4_sgttyb_to_bsd_sgttyb(ss, bs)
  125         const struct svr4_sgttyb        *ss;
  126         struct sgttyb                   *bs;
  127 {
  128         bs->sg_ispeed = ss->sg_ispeed;
  129         bs->sg_ospeed = ss->sg_ospeed;
  130         bs->sg_erase  = ss->sg_erase;   
  131         bs->sg_kill   = ss->sg_kill;
  132         bs->sg_flags  = ss->sg_flags;
  133 };
  134 
  135 
  136 static void
  137 bsd_sgttyb_to_svr4_sgttyb(bs, ss)
  138         const struct sgttyb     *bs;
  139         struct svr4_sgttyb      *ss;
  140 {
  141         ss->sg_ispeed = bs->sg_ispeed;
  142         ss->sg_ospeed = bs->sg_ospeed;
  143         ss->sg_erase  = bs->sg_erase;   
  144         ss->sg_kill   = bs->sg_kill;
  145         ss->sg_flags  = bs->sg_flags;
  146 }
  147 
  148 
  149 static void
  150 svr4_ltchars_to_bsd_ltchars(sl, bl)
  151         const struct svr4_ltchars       *sl;
  152         struct ltchars                  *bl;
  153 {
  154         bl->t_suspc  = sl->t_suspc;
  155         bl->t_dsuspc = sl->t_dsuspc;
  156         bl->t_rprntc = sl->t_rprntc;
  157         bl->t_flushc = sl->t_flushc;
  158         bl->t_werasc = sl->t_werasc;
  159         bl->t_lnextc = sl->t_lnextc;
  160 }
  161 
  162 
  163 static void
  164 bsd_ltchars_to_svr4_ltchars(bl, sl)
  165         const struct ltchars    *bl;
  166         struct svr4_ltchars     *sl;
  167 {
  168         sl->t_suspc  = bl->t_suspc;
  169         sl->t_dsuspc = bl->t_dsuspc;
  170         sl->t_rprntc = bl->t_rprntc;
  171         sl->t_flushc = bl->t_flushc;
  172         sl->t_werasc = bl->t_werasc;
  173         sl->t_lnextc = bl->t_lnextc;
  174 }
  175 
  176 
  177 int
  178 svr4_ttold_ioctl(fp, p, retval, fd, cmd, data)
  179         struct file *fp;
  180         struct proc *p;
  181         register_t *retval;
  182         int fd;
  183         u_long cmd;
  184         caddr_t data;
  185 {
  186         int                     error;
  187 
  188         *retval = 0;
  189 
  190         switch (cmd) {
  191         case SVR4_TIOCGPGRP:
  192                 {
  193                         pid_t pid;
  194 
  195                         if ((error = fo_ioctl(fp, TIOCGPGRP, (caddr_t) &pid, p)) != 0)
  196                             return error;
  197 
  198                         DPRINTF(("TIOCGPGRP %d\n", pid));
  199 
  200                         if ((error = copyout(&pid, data, sizeof(pid))) != 0)
  201                                 return error;
  202 
  203                 }
  204 
  205         case SVR4_TIOCSPGRP:
  206                 {
  207                         pid_t pid;
  208 
  209                         if ((error = copyin(data, &pid, sizeof(pid))) != 0)
  210                                 return error;
  211 
  212                         DPRINTF(("TIOCSPGRP %d\n", pid));
  213 
  214                         return fo_ioctl(fp, TIOCSPGRP, (caddr_t) &pid, p);
  215                 }
  216 
  217         case SVR4_TIOCGSID:
  218                 {
  219 #if defined(TIOCGSID)
  220                         pid_t pid;
  221                         if ((error = fo_ioctl(fp, TIOCGSID, (caddr_t) &pid, p)) != 0)
  222                                 return error;
  223 
  224                         DPRINTF(("TIOCGSID %d\n", pid));
  225 
  226                         return copyout(&pid, data, sizeof(pid));
  227 #else
  228                         uprintf("ioctl(TIOCGSID) for pid %d unsupported\n", p->p_pid);
  229                         return EINVAL;
  230 #endif
  231                 }
  232 
  233         case SVR4_TIOCGETP:
  234                 {
  235                         struct sgttyb bs;
  236                         struct svr4_sgttyb ss;
  237 
  238                         error = fo_ioctl(fp, TIOCGETP, (caddr_t) &bs, p);
  239                         if (error)
  240                                 return error;
  241 
  242                         bsd_sgttyb_to_svr4_sgttyb(&bs, &ss);
  243 #ifdef DEBUG_SVR4
  244                         print_svr4_sgttyb("SVR4_TIOCGETP", &ss);
  245 #endif /* DEBUG_SVR4 */
  246                         return copyout(&ss, data, sizeof(ss));
  247                 }
  248 
  249         case SVR4_TIOCSETP:
  250         case SVR4_TIOCSETN:
  251                 {
  252                         struct sgttyb bs;
  253                         struct svr4_sgttyb ss;
  254 
  255                         if ((error = copyin(data, &ss, sizeof(ss))) != 0)
  256                                 return error;
  257 
  258                         svr4_sgttyb_to_bsd_sgttyb(&ss, &bs);
  259 #ifdef DEBUG_SVR4
  260                         print_svr4_sgttyb("SVR4_TIOCSET{P,N}", &ss);
  261 #endif /* DEBUG_SVR4 */
  262                         cmd = (cmd == SVR4_TIOCSETP) ? TIOCSETP : TIOCSETN;
  263                         return fo_ioctl(fp, cmd, (caddr_t) &bs, p);
  264                 }
  265 
  266         case SVR4_TIOCGETC:
  267                 {
  268                         struct tchars bt;
  269                         struct svr4_tchars st;
  270 
  271                         error = fo_ioctl(fp, TIOCGETC, (caddr_t) &bt, p);
  272                         if (error)
  273                                 return error;
  274 
  275                         bsd_tchars_to_svr4_tchars(&bt, &st);
  276 #ifdef DEBUG_SVR4
  277                         print_svr4_tchars("SVR4_TIOCGETC", &st);
  278 #endif /* DEBUG_SVR4 */
  279                         return copyout(&st, data, sizeof(st));
  280                 }
  281 
  282         case SVR4_TIOCSETC:
  283                 {
  284                         struct tchars bt;
  285                         struct svr4_tchars st;
  286 
  287                         if ((error = copyin(data, &st, sizeof(st))) != 0)
  288                                 return error;
  289 
  290                         svr4_tchars_to_bsd_tchars(&st, &bt);
  291 #ifdef DEBUG_SVR4
  292                         print_svr4_tchars("SVR4_TIOCSETC", &st);
  293 #endif /* DEBUG_SVR4 */
  294                         return fo_ioctl(fp, TIOCSETC, (caddr_t) &bt, p);
  295                 }
  296 
  297         case SVR4_TIOCGLTC:
  298                 {
  299                         struct ltchars bl;
  300                         struct svr4_ltchars sl;
  301 
  302                         error = fo_ioctl(fp, TIOCGLTC, (caddr_t) &bl, p);
  303                         if (error)
  304                                 return error;
  305 
  306                         bsd_ltchars_to_svr4_ltchars(&bl, &sl);
  307 #ifdef DEBUG_SVR4
  308                         print_svr4_ltchars("SVR4_TIOCGLTC", &sl);
  309 #endif /* DEBUG_SVR4 */
  310                         return copyout(&sl, data, sizeof(sl));
  311                 }
  312 
  313         case SVR4_TIOCSLTC:
  314                 {
  315                         struct ltchars bl;
  316                         struct svr4_ltchars sl;
  317 
  318                         if ((error = copyin(data, &sl, sizeof(sl))) != 0)
  319                                 return error;
  320 
  321                         svr4_ltchars_to_bsd_ltchars(&sl, &bl);
  322 #ifdef DEBUG_SVR4
  323                         print_svr4_ltchars("SVR4_TIOCSLTC", &sl);
  324 #endif /* DEBUG_SVR4 */
  325                         return fo_ioctl(fp, TIOCSLTC, (caddr_t) &bl, p);
  326                 }
  327 
  328         case SVR4_TIOCLGET:
  329                 {
  330                         int flags;
  331                         if ((error = fo_ioctl(fp, TIOCLGET, (caddr_t) &flags, p)) != 0)
  332                                 return error;
  333                         DPRINTF(("SVR4_TIOCLGET %o\n", flags));
  334                         return copyout(&flags, data, sizeof(flags));
  335                 }
  336 
  337         case SVR4_TIOCLSET:
  338         case SVR4_TIOCLBIS:
  339         case SVR4_TIOCLBIC:
  340                 {
  341                         int flags;
  342 
  343                         if ((error = copyin(data, &flags, sizeof(flags))) != 0)
  344                                 return error;
  345 
  346                         switch (cmd) {
  347                         case SVR4_TIOCLSET:
  348                                 cmd = TIOCLSET;
  349                                 break;
  350                         case SVR4_TIOCLBIS:
  351                                 cmd = TIOCLBIS;
  352                                 break;
  353                         case SVR4_TIOCLBIC:
  354                                 cmd = TIOCLBIC;
  355                                 break;
  356                         }
  357 
  358                         DPRINTF(("SVR4_TIOCL{SET,BIS,BIC} %o\n", flags));
  359                         return fo_ioctl(fp, cmd, (caddr_t) &flags, p);
  360                 }
  361 
  362         default:
  363                 DPRINTF(("Unknown svr4 ttold %lx\n", cmd));
  364                 return 0;       /* ENOSYS really */
  365         }
  366 }
Cache object: 02eae09022c4a8683a7807c593f20fb0
[ 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/svr4/svr4_ttold.c

FreeBSD/Linux Kernel Cross Reference
sys/svr4/svr4_ttold.c
