bsd/kern/tty_compat.c

   1 /*
   2  * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. The rights granted to you under the License
  10  * may not be used to create, or enable the creation or redistribution of,
  11  * unlawful or unlicensed copies of an Apple operating system, or to
  12  * circumvent, violate, or enable the circumvention or violation of, any
  13  * terms of an Apple operating system software license agreement.
  14  *
  15  * Please obtain a copy of the License at
  16  * http://www.opensource.apple.com/apsl/ and read it before using this file.
  17  *
  18  * The Original Code and all software distributed under the License are
  19  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  20  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  21  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  23  * Please see the License for the specific language governing rights and
  24  * limitations under the License.
  25  *
  26  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  27  */
  28 /* Copyright (c) 1997 Apple Computer, Inc. All Rights Reserved */
  29 /*-
  30  * Copyright (c) 1982, 1986, 1991, 1993
  31  *      The Regents of the University of California.  All rights reserved.
  32  *
  33  * Redistribution and use in source and binary forms, with or without
  34  * modification, are permitted provided that the following conditions
  35  * are met:
  36  * 1. Redistributions of source code must retain the above copyright
  37  *    notice, this list of conditions and the following disclaimer.
  38  * 2. Redistributions in binary form must reproduce the above copyright
  39  *    notice, this list of conditions and the following disclaimer in the
  40  *    documentation and/or other materials provided with the distribution.
  41  * 3. All advertising materials mentioning features or use of this software
  42  *    must display the following acknowledgement:
  43  *      This product includes software developed by the University of
  44  *      California, Berkeley and its contributors.
  45  * 4. Neither the name of the University nor the names of its contributors
  46  *    may be used to endorse or promote products derived from this software
  47  *    without specific prior written permission.
  48  *
  49  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  50  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  51  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  52  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  53  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  54  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  55  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  56  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  57  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  58  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  59  * SUCH DAMAGE.
  60  *
  61  *      @(#)tty_compat.c        8.1 (Berkeley) 6/10/93
  62  */
  63
  64 /*
  65  * Compatibility routines for BSD 4.3 tty ioctl() commands
  66  *
  67  * The only function externalized from this file is ttcompat() and it is
  68  * externalized as private extern to prevent exporting of the symbol when
  69  * KEXTs link against the kernel.
  70  *
  71  * Locks:       All functions in this file assume that the tty_lock()
  72  *              is held on the tty structure before these functions are
  73  *              called.
  74  */
  75
  76 #include <sys/param.h>
  77 #include <sys/systm.h>
  78 #include <sys/ioctl.h>
  79 #include <sys/proc_internal.h>
  80 #include <sys/tty.h>
  81 #include <sys/termios.h>
  82 #include <sys/file_internal.h>
  83 #include <sys/conf.h>
  84 #include <sys/kernel.h>
  85 #include <sys/sysctl.h>
  86 #include <sys/syslog.h>
  87
  88 static int ttcompatgetflags(struct tty *tp);
  89 static void ttcompatsetflags(struct tty *tp, struct termios *t);
  90 static void ttcompatsetlflags(struct tty *tp, struct termios *t);
  91 static int ttcompatspeedtab(int speed, struct speedtab *table);
  92
  93 /*
  94  * These two tables encode baud rate to speed code and speed code to
  95  * baud rate information.  They are a mapping between the <sys/termios.h>
  96  * baud rate constants and the <sys/ttydev.h> baud rate constants.  We
  97  * cannot use those constants directly here because they occupy the same
  98  * name space.
  99  */
 100 static struct speedtab compatspeeds[] = {
 101 #define MAX_SPEED       17
 102         { 115200, 17 },
 103         { 57600, 16 },
 104         { 38400, 15 },
 105         { 19200, 14 },
 106         { 9600, 13 },
 107         { 4800, 12 },
 108         { 2400, 11 },
 109         { 1800, 10 },
 110         { 1200, 9 },
 111         { 600, 8 },
 112         { 300, 7 },
 113         { 200, 6 },
 114         { 150, 5 },
 115         { 134, 4 },
 116         { 110, 3 },
 117         { 75, 2 },
 118         { 50, 1 },
 119         { 0, 0 },
 120         { -1, -1 },
 121 };
 122 static int compatspcodes[] = {
 123         0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
 124         1800, 2400, 4800, 9600, 19200, 38400, 57600, 115200,
 125 };
 126
 127 /*
 128  * ttcompatspeedtab
 129  *
 130  * Description: Given a baud rate value as an integer, and a speed table,
 131  *              convert the baud rate to a speed code, according to the
 132  *              contents of the table.  This effectively changes termios.h
 133  *              baud rate values into ttydev.h baud rate codes.
 134  *
 135  * Parameters:  int speed               Baud rate, as an integer
 136  *              struct speedtab *table  Baud rate table to speed code table
 137  *
 138  * Returns:     1                       B50 speed code; returned if we can
 139  *                                      not find an answer in the table.
 140  *              0                       If a 0 was requested in order to
 141  *                                      trigger a hangup (250ms of line
 142  *                                      silence, per Bell 103C standard).
 143  *              *                       A speed code matching the requested
 144  *                                      baud rate (potentially rounded down,
 145  *                                      if there is no exact match).
 146  *
 147  * Notes:       This function is used for TIOCGETP, TIOCSETP, and TIOCSETN.
 148  */
 149 static int
 150 ttcompatspeedtab(int speed, struct speedtab *table)
 151 {
 152         if (speed == 0) {
 153                 return 0; /* hangup */
 154         }
 155         for (; table->sp_speed > 0; table++) {
 156                 if (table->sp_speed <= speed) { /* nearest one, rounded down */
 157                         return table->sp_code;
 158                 }
 159         }
 160         return 1; /* 50, min and not hangup */
 161 }
 162
 163
 164 /*
 165  * ttsetcompat
 166  *
 167  * Description: Convert backward compatability set command arguments as
 168  *              follows:
 169  *
 170  *              TIOCSETP        ->      TIOSETAF
 171  *              TIOCSETN        ->      TIOCSETA
 172  *              TIOCSETC        ->      TIOCSETA
 173  *              TIOCSLTC        ->      TIOCSETA
 174  *              TIOCLBIS        ->      TIOCSETA
 175  *              TIOCLBIC        ->      TIOCSETA
 176  *              TIOCLSET        ->      TIOCSETA
 177  *
 178  *      The converted command argument and potentially modified 'term'
 179  *      argument are returned to ttcompat(), which will then call
 180  *      ttioctl_locked(), if this function returns successfully.
 181  *
 182  * Parameters   struct tty *tp          The tty on which the operation is
 183  *                                      being performed.
 184  *              u_long *com             A pointer to the terminal input/output
 185  *                                      command being requested; its contents
 186  *                                      will be modified per the table above,
 187  *                                      on a non-error return.
 188  *              caddr_t data            Command specific parameter data; this
 189  *                                      data is read but not modified.
 190  *              struct termios *term    A local stack termios structure from
 191  *                                      ttcompat(), whose contents are to be
 192  *                                      modified based on *com and *data.
 193  *
 194  * Returns:     EINVAL                  An input speed or output speed is
 195  *                                      outside the allowable range for a
 196  *                                      TIOCSETP or TIOCSETN command.
 197  *              0                       All other cases return 0.
 198  *
 199  * Notes:       This function may modify the contents of the tp->t_flags
 200  *              field in a successful call to TIOCSETP, TIOCSETN, TIOCLBIS,
 201  *              TIOCLBIC, or TIOCLSET.
 202  *
 203  *              All other tp fields will remain unmodifed, since the struct
 204  *              termios is a local stack copy from ttcompat(), and not the
 205  *              real thing.  A subsequent call to ttioctl_locked() in
 206  *              ttcompat(), however, may result in subsequent changes.
 207  *
 208  * WARNING:     This compatibility code is not 6/432 clean; it will only
 209  *              work for 32 bit processes on 32 bit kernels or 64 bit
 210  *              processes on 64 bit kernels.  We are not addressing this
 211  *              due to <rdar://6904053>.
 212  */
 213 static int
 214 ttsetcompat(struct tty *tp, u_long *com, caddr_t data, struct termios *term)
 215 {
 216         switch (*com) {
 217         case TIOCSETP:
 218         /*
 219          * Wait for all characters queued for output to drain, then
 220          * Discard all characters queued for input, and then set
 221          * the input and output speeds and device flags, per the
 222          * contents of the struct sgttyb that 'data' points to.
 223          */
 224         case TIOCSETN:
 225                 /*
 226                  * Same as TIOCSETP, but the output is not drained, and any
 227                  * pending input is not discarded.
 228                  */
 229         {
 230                 struct sgttyb *sg = (struct sgttyb *)data;
 231                 int speed;
 232
 233                 if ((speed = sg->sg_ispeed) > MAX_SPEED || speed < 0) {
 234                         return EINVAL;
 235                 } else if (speed != ttcompatspeedtab(tp->t_ispeed, compatspeeds)) {
 236                         term->c_ispeed = compatspcodes[speed];
 237                 } else {
 238                         term->c_ispeed = tp->t_ispeed;
 239                 }
 240                 if ((speed = sg->sg_ospeed) > MAX_SPEED || speed < 0) {
 241                         return EINVAL;
 242                 } else if (speed != ttcompatspeedtab(tp->t_ospeed, compatspeeds)) {
 243                         term->c_ospeed = compatspcodes[speed];
 244                 } else {
 245                         term->c_ospeed = tp->t_ospeed;
 246                 }
 247                 term->c_cc[VERASE] = sg->sg_erase;
 248                 term->c_cc[VKILL] = sg->sg_kill;
 249                 tp->t_flags = (tp->t_flags & 0xffff0000) | (sg->sg_flags & 0xffff);
 250                 ttcompatsetflags(tp, term);
 251                 *com = (*com == TIOCSETP) ? TIOCSETAF : TIOCSETA;
 252                 break;
 253         }
 254         case TIOCSETC:
 255                 /*
 256                  * Set the terminal control characters per the contents of
 257                  * the struct tchars that 'data' points to.
 258                  */
 259         {
 260                 struct tchars *tc = (struct tchars *)data;
 261                 cc_t *cc;
 262
 263                 cc = term->c_cc;
 264                 cc[VINTR] = tc->t_intrc;
 265                 cc[VQUIT] = tc->t_quitc;
 266                 cc[VSTART] = tc->t_startc;
 267                 cc[VSTOP] = tc->t_stopc;
 268                 cc[VEOF] = tc->t_eofc;
 269                 cc[VEOL] = tc->t_brkc;
 270                 if (tc->t_brkc == -1) {
 271                         cc[VEOL2] = _POSIX_VDISABLE;
 272                 }
 273                 *com = TIOCSETA;
 274                 break;
 275         }
 276         case TIOCSLTC:
 277                 /*
 278                  * Set the terminal control characters per the contents of
 279                  * the struct ltchars that 'data' points to.
 280                  */
 281         {
 282                 struct ltchars *ltc = (struct ltchars *)data;
 283                 cc_t *cc;
 284
 285                 cc = term->c_cc;
 286                 cc[VSUSP] = ltc->t_suspc;
 287                 cc[VDSUSP] = ltc->t_dsuspc;
 288                 cc[VREPRINT] = ltc->t_rprntc;
 289                 cc[VDISCARD] = ltc->t_flushc;
 290                 cc[VWERASE] = ltc->t_werasc;
 291                 cc[VLNEXT] = ltc->t_lnextc;
 292                 *com = TIOCSETA;
 293                 break;
 294         }
 295         case TIOCLBIS:
 296         /*
 297          * Set the bits in the terminal state local flags word
 298          * (16 bits) for the terminal to the current bits OR
 299          * those in the 16 bit value pointed to by 'data'.
 300          */
 301         case TIOCLBIC:
 302         /*
 303          * Clear the bits in the terminal state local flags word
 304          * for the terminal to the current bits AND those bits NOT
 305          * in the 16 bit value pointed to by 'data'.
 306          */
 307         case TIOCLSET:
 308                 /*
 309                  * Set the terminal state local flags word to exactly those
 310                  * bits that correspond to the 16 bit value pointed to by
 311                  * 'data'.
 312                  */
 313                 if (*com == TIOCLSET) {
 314                         tp->t_flags = (tp->t_flags & 0xffff) | *(int *)data << 16;
 315                 } else {
 316                         tp->t_flags =
 317                             (ttcompatgetflags(tp) & 0xffff0000) | (tp->t_flags & 0xffff);
 318                         if (*com == TIOCLBIS) {
 319                                 tp->t_flags |= *(int *)data << 16;
 320                         } else {
 321                                 tp->t_flags &= ~(*(int *)data << 16);
 322                         }
 323                 }
 324                 ttcompatsetlflags(tp, term);
 325                 *com = TIOCSETA;
 326                 break;
 327         }
 328         return 0;
 329 }
 330
 331 /*
 332  * ttcompat
 333  *
 334  * Description: For 'set' commands, convert the command and arguments as
 335  *              necessary, and call ttioctl_locked(), returning the result
 336  *              as our result; for 'get' commands, obtain the requested data
 337  *              from the appropriate source, and return it in the expected
 338  *              format.  If the command is not recognized, return EINVAL.
 339  *
 340  * Parameters   struct tty *tp          The tty on which the operation is
 341  *                                      being performed.
 342  *              u_long com              The terminal input/output command
 343  *                                      being requested.
 344  *              caddr_t data            The pointer to the user data argument
 345  *                                      provided with the command.
 346  *              int flag                The file open flags (e.g. FREAD).
 347  *              struct proc *p          The current process pointer for the
 348  *                                      operation.
 349  *
 350  * Returns:     0                       Most 'get' operations can't fail, and
 351  *                                      therefore return this.
 352  *              ENOTTY                  TIOCGSID may return this when you
 353  *                                      attempt to get the session ID for a
 354  *                                      terminal with no associated session,
 355  *                                      or for which there is a session, but
 356  *                                      no session leader.
 357  *              ENOTTY                  If the command cannot be handled at
 358  *                                      this layer, this will be returned.
 359  *              *                       Any value returned by ttioctl_locked(),
 360  *                                      if a set command is requested.
 361  *
 362  * Notes:       The process pointer may be a proxy on whose behalf we are
 363  *              operating, so it is not safe to simply use current_process()
 364  *              instead.
 365  */
 366 /*ARGSUSED*/
 367 __private_extern__ int
 368 ttcompat(struct tty *tp, u_long com, caddr_t data, int flag, struct proc *p)
 369 {
 370         switch (com) {
 371         case TIOCSETP:
 372         case TIOCSETN:
 373         case TIOCSETC:
 374         case TIOCSLTC:
 375         case TIOCLBIS:
 376         case TIOCLBIC:
 377         case TIOCLSET:
 378                 /*
 379                  * See ttsetcompat() for a full description of these command
 380                  * values and their meanings.
 381                  */
 382         {
 383                 struct termios term;
 384                 int error;
 385
 386                 term = tp->t_termios;
 387                 if ((error = ttsetcompat(tp, &com, data, &term)) != 0) {
 388                         return error;
 389                 }
 390                 return ttioctl_locked(tp, com, (caddr_t) &term, flag, p);
 391         }
 392         case TIOCGETP:
 393                 /*
 394                  * Get the current input and output speeds, and device
 395                  * flags, into the structure pointed to by 'data'.
 396                  */
 397         {
 398                 struct sgttyb *sg = (struct sgttyb *)data;
 399                 cc_t *cc = tp->t_cc;
 400
 401                 sg->sg_ospeed = ttcompatspeedtab(tp->t_ospeed, compatspeeds);
 402                 if (tp->t_ispeed == 0) {
 403                         sg->sg_ispeed = sg->sg_ospeed;
 404                 } else {
 405                         sg->sg_ispeed = ttcompatspeedtab(tp->t_ispeed, compatspeeds);
 406                 }
 407                 sg->sg_erase = cc[VERASE];
 408                 sg->sg_kill = cc[VKILL];
 409                 sg->sg_flags = tp->t_flags = ttcompatgetflags(tp);
 410                 break;
 411         }
 412         case TIOCGETC:
 413                 /*
 414                  * Get the terminal control characters into the struct
 415                  * tchars that 'data' points to.
 416                  */
 417         {
 418                 struct tchars *tc = (struct tchars *)data;
 419                 cc_t *cc = tp->t_cc;
 420
 421                 tc->t_intrc = cc[VINTR];
 422                 tc->t_quitc = cc[VQUIT];
 423                 tc->t_startc = cc[VSTART];
 424                 tc->t_stopc = cc[VSTOP];
 425                 tc->t_eofc = cc[VEOF];
 426                 tc->t_brkc = cc[VEOL];
 427                 break;
 428         }
 429         case TIOCGLTC:
 430                 /*
 431                  * Get the terminal control characters into the struct
 432                  * ltchars that 'data' points to.
 433                  */
 434         {
 435                 struct ltchars *ltc = (struct ltchars *)data;
 436                 cc_t *cc = tp->t_cc;
 437
 438                 ltc->t_suspc = cc[VSUSP];
 439                 ltc->t_dsuspc = cc[VDSUSP];
 440                 ltc->t_rprntc = cc[VREPRINT];
 441                 ltc->t_flushc = cc[VDISCARD];
 442                 ltc->t_werasc = cc[VWERASE];
 443                 ltc->t_lnextc = cc[VLNEXT];
 444                 break;
 445         }
 446         case TIOCLGET:
 447                 /*
 448                  * Get the terminal state local flags word into the 16 bit
 449                  * value pointed to by 'data'.
 450                  */
 451                 tp->t_flags =
 452                     (ttcompatgetflags(tp) & 0xffff0000UL)
 453                     | (tp->t_flags & 0xffff);
 454                 *(int *)data = tp->t_flags >> 16;
 455                 break;
 456
 457         case OTIOCGETD:
 458                 /*
 459                  * Get the current line discipline into the int pointed to
 460                  * by 'data'.
 461                  */
 462                 *(int *)data = tp->t_line ? tp->t_line : 2;
 463                 break;
 464
 465         case OTIOCSETD:
 466                 /*
 467                  * Set the current line discipline based on the value of the
 468                  * int pointed to by 'data'.
 469                  */
 470         {
 471                 int ldisczero = 0;
 472
 473                 return ttioctl_locked(tp, TIOCSETD,
 474                            *(int *)data == 2 ? (caddr_t)&ldisczero : data, flag, p);
 475         }
 476
 477         case OTIOCCONS:
 478                 /*
 479                  * Become the console device.
 480                  */
 481                 *(int *)data = 1;
 482                 return ttioctl_locked(tp, TIOCCONS, data, flag, p);
 483
 484         case TIOCGSID:
 485                 /*
 486                  * Get the current session ID (controlling process' PID).
 487                  */
 488                 if (tp->t_session == NULL) {
 489                         return ENOTTY;
 490                 }
 491
 492                 if (tp->t_session->s_leader == NULL) {
 493                         return ENOTTY;
 494                 }
 495
 496                 *(int *) data =  tp->t_session->s_leader->p_pid;
 497                 break;
 498
 499         default:
 500                 /*
 501                  * This ioctl is not handled at this layer.
 502                  */
 503                 return ENOTTY;
 504         }
 505
 506         /*
 507          * Successful 'get' operation.
 508          */
 509         return 0;
 510 }
 511
 512 /*
 513  * ttcompatgetflags
 514  *
 515  * Description: Get the terminal state local flags, device flags, and current
 516  *              speed code for the device (all 32 bits are returned).
 517  *
 518  * Parameters   struct tty *tp          The tty on which the operation is
 519  *                                      being performed.
 520  *
 521  * Returns:     *                       Integer value corresponding to the
 522  *                                      current terminal state local flags
 523  *                                      word.
 524  *
 525  * Notes:       Caller is responsible for breaking these bits back out into
 526  *              separate 16 bit filelds, if that's what was actually desired.
 527  */
 528 static int
 529 ttcompatgetflags(struct tty *tp)
 530 {
 531         tcflag_t iflag  = tp->t_iflag;
 532         tcflag_t lflag  = tp->t_lflag;
 533         tcflag_t oflag  = tp->t_oflag;
 534         tcflag_t cflag  = tp->t_cflag;
 535         int flags = 0;
 536
 537         if (iflag & IXOFF) {
 538                 flags |= TANDEM;
 539         }
 540         if (iflag & ICRNL || oflag & ONLCR) {
 541                 flags |= CRMOD;
 542         }
 543         if ((cflag & CSIZE) == CS8) {
 544                 flags |= PASS8;
 545                 if (iflag & ISTRIP) {
 546                         flags |= ANYP;
 547                 }
 548         } else if (cflag & PARENB) {
 549                 if (iflag & INPCK) {
 550                         if (cflag & PARODD) {
 551                                 flags |= ODDP;
 552                         } else {
 553                                 flags |= EVENP;
 554                         }
 555                 } else {
 556                         flags |= EVENP | ODDP;
 557                 }
 558         }
 559
 560         if ((lflag & ICANON) == 0) {
 561                 /* fudge */
 562                 if (iflag & (INPCK | ISTRIP | IXON) || lflag & (IEXTEN | ISIG)
 563                     || (cflag & (CSIZE | PARENB)) != CS8) {
 564                         flags |= CBREAK;
 565                 } else {
 566                         flags |= RAW;
 567                 }
 568         }
 569         if (!(flags & RAW) && !(oflag & OPOST) && (cflag & (CSIZE | PARENB)) == CS8) {
 570                 flags |= LITOUT;
 571         }
 572         if (cflag & MDMBUF) {
 573                 flags |= MDMBUF;
 574         }
 575         if ((cflag & HUPCL) == 0) {
 576                 flags |= NOHANG;
 577         }
 578         if (oflag & OXTABS) {
 579                 flags |= XTABS;
 580         }
 581         if (lflag & ECHOE) {
 582                 flags |= CRTERA | CRTBS;
 583         }
 584         if (lflag & ECHOKE) {
 585                 flags |= CRTKIL | CRTBS;
 586         }
 587         if (lflag & ECHOPRT) {
 588                 flags |= PRTERA;
 589         }
 590         if (lflag & ECHOCTL) {
 591                 flags |= CTLECH;
 592         }
 593         if ((iflag & IXANY) == 0) {
 594                 flags |= DECCTQ;
 595         }
 596         flags |= lflag & (ECHO | TOSTOP | FLUSHO | PENDIN | NOFLSH);
 597         return flags;
 598 }
 599
 600 /*
 601  * ttcompatsetflags
 602  *
 603  * Description: Given a set of compatability flags, convert the compatability
 604  *              flags in the terminal flags fields into canonical flags in the
 605  *              provided termios struct.
 606  *
 607  * Parameters:  struct tty *tp          The tty on which the operation is
 608  *                                      being performed.
 609  *              struct termios *t       The termios structure into which to
 610  *                                      return the converted flags.
 611  *
 612  * Returns:     void                    (implicit: *t, modified)
 613  */
 614 static void
 615 ttcompatsetflags(struct tty *tp, struct termios *t)
 616 {
 617         int flags = tp->t_flags;
 618         tcflag_t iflag  = t->c_iflag;
 619         tcflag_t oflag  = t->c_oflag;
 620         tcflag_t lflag  = t->c_lflag;
 621         tcflag_t cflag  = t->c_cflag;
 622
 623         if (flags & RAW) {
 624                 iflag = IGNBRK;
 625                 lflag &= ~(ECHOCTL | ISIG | ICANON | IEXTEN);
 626         } else {
 627                 iflag &= ~(PARMRK | IGNPAR | IGNCR | INLCR);
 628                 iflag |= BRKINT | IXON | IMAXBEL;
 629                 lflag |= ISIG | IEXTEN | ECHOCTL;   /* XXX was echoctl on ? */
 630                 if (flags & XTABS) {
 631                         oflag |= OXTABS;
 632                 } else {
 633                         oflag &= ~OXTABS;
 634                 }
 635                 if (flags & CBREAK) {
 636                         lflag &= ~ICANON;
 637                 } else {
 638                         lflag |= ICANON;
 639                 }
 640                 if (flags & CRMOD) {
 641                         iflag |= ICRNL;
 642                         oflag |= ONLCR;
 643                 } else {
 644                         iflag &= ~ICRNL;
 645                         oflag &= ~ONLCR;
 646                 }
 647         }
 648         if (flags & ECHO) {
 649                 lflag |= ECHO;
 650         } else {
 651                 lflag &= ~ECHO;
 652         }
 653
 654         cflag &= ~(CSIZE | PARENB);
 655         if (flags & (RAW | LITOUT | PASS8)) {
 656                 cflag |= CS8;
 657                 if (!(flags & (RAW | PASS8))
 658                     || (flags & (RAW | PASS8 | ANYP)) == (PASS8 | ANYP)) {
 659                         iflag |= ISTRIP;
 660                 } else {
 661                         iflag &= ~ISTRIP;
 662                 }
 663                 if (flags & (RAW | LITOUT)) {
 664                         oflag &= ~OPOST;
 665                 } else {
 666                         oflag |= OPOST;
 667                 }
 668         } else {
 669                 cflag |= CS7 | PARENB;
 670                 iflag |= ISTRIP;
 671                 oflag |= OPOST;
 672         }
 673         /* XXX don't set INPCK if RAW or PASS8? */
 674         if ((flags & (EVENP | ODDP)) == EVENP) {
 675                 iflag |= INPCK;
 676                 cflag &= ~PARODD;
 677         } else if ((flags & (EVENP | ODDP)) == ODDP) {
 678                 iflag |= INPCK;
 679                 cflag |= PARODD;
 680         } else {
 681                 iflag &= ~INPCK;
 682         }
 683         if (flags & TANDEM) {
 684                 iflag |= IXOFF;
 685         } else {
 686                 iflag &= ~IXOFF;
 687         }
 688         if ((flags & DECCTQ) == 0) {
 689                 iflag |= IXANY;
 690         } else {
 691                 iflag &= ~IXANY;
 692         }
 693         t->c_iflag = iflag;
 694         t->c_oflag = oflag;
 695         t->c_lflag = lflag;
 696         t->c_cflag = cflag;
 697 }
 698
 699 /*
 700  * ttcompatsetlflags
 701  *
 702  * Description: Given a set of compatability terminal state local flags,
 703  *              convert the compatability flags in the terminal flags
 704  *              fields into canonical flags in the provided termios struct.
 705  *
 706  * Parameters:  struct tty *tp          The tty on which the operation is
 707  *                                      being performed.
 708  *              struct termios *t       The termios structure into which to
 709  *                                      return the converted local flags.
 710  *
 711  * Returns:     void                    (implicit: *t, modified)
 712  */
 713 static void
 714 ttcompatsetlflags(struct tty *tp, struct termios *t)
 715 {
 716         int flags = tp->t_flags;
 717         tcflag_t iflag  = t->c_iflag;
 718         tcflag_t oflag  = t->c_oflag;
 719         tcflag_t lflag  = t->c_lflag;
 720         tcflag_t cflag  = t->c_cflag;
 721
 722         iflag &= ~(PARMRK | IGNPAR | IGNCR | INLCR);
 723         if (flags & CRTERA) {
 724                 lflag |= ECHOE;
 725         } else {
 726                 lflag &= ~ECHOE;
 727         }
 728         if (flags & CRTKIL) {
 729                 lflag |= ECHOKE;
 730         } else {
 731                 lflag &= ~ECHOKE;
 732         }
 733         if (flags & PRTERA) {
 734                 lflag |= ECHOPRT;
 735         } else {
 736                 lflag &= ~ECHOPRT;
 737         }
 738         if (flags & CTLECH) {
 739                 lflag |= ECHOCTL;
 740         } else {
 741                 lflag &= ~ECHOCTL;
 742         }
 743         if (flags & TANDEM) {
 744                 iflag |= IXOFF;
 745         } else {
 746                 iflag &= ~IXOFF;
 747         }
 748         if ((flags & DECCTQ) == 0) {
 749                 iflag |= IXANY;
 750         } else {
 751                 iflag &= ~IXANY;
 752         }
 753         if (flags & MDMBUF) {
 754                 cflag |= MDMBUF;
 755         } else {
 756                 cflag &= ~MDMBUF;
 757         }
 758         if (flags & NOHANG) {
 759                 cflag &= ~HUPCL;
 760         } else {
 761                 cflag |= HUPCL;
 762         }
 763         lflag &= ~(TOSTOP | FLUSHO | PENDIN | NOFLSH);
 764         lflag |= flags & (TOSTOP | FLUSHO | PENDIN | NOFLSH);
 765
 766         /*
 767          * The next if-else statement is copied from above so don't bother
 768          * checking it separately.  We could avoid fiddlling with the
 769          * character size if the mode is already RAW or if neither the
 770          * LITOUT bit or the PASS8 bit is being changed, but the delta of
 771          * the change is not available here and skipping the RAW case would
 772          * make the code different from above.
 773          */
 774         cflag &= ~(CSIZE | PARENB);
 775         if (flags & (RAW | LITOUT | PASS8)) {
 776                 cflag |= CS8;
 777                 if (!(flags & (RAW | PASS8))
 778                     || (flags & (RAW | PASS8 | ANYP)) == (PASS8 | ANYP)) {
 779                         iflag |= ISTRIP;
 780                 } else {
 781                         iflag &= ~ISTRIP;
 782                 }
 783                 if (flags & (RAW | LITOUT)) {
 784                         oflag &= ~OPOST;
 785                 } else {
 786                         oflag |= OPOST;
 787                 }
 788         } else {
 789                 cflag |= CS7 | PARENB;
 790                 iflag |= ISTRIP;
 791                 oflag |= OPOST;
 792         }
 793         t->c_iflag = iflag;
 794         t->c_oflag = oflag;
 795         t->c_lflag = lflag;
 796         t->c_cflag = cflag;
 797 }