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

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