usr/src/uts/common/io/ttcompat.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  * Copyright 2018 OmniOS Community Edition (OmniOSce) Association.
  25  */
  26
  27 /*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
  28 /*        All Rights Reserved   */
  29
  30 /*
  31  * University Copyright- Copyright (c) 1982, 1986, 1988
  32  * The Regents of the University of California
  33  * All Rights Reserved
  34  *
  35  * University Acknowledgment- Portions of this document are derived from
  36  * software developed by the University of California, Berkeley, and its
  37  * contributors.
  38  */
  39
  40 /*
  41  * Module to intercept old V7 and 4BSD "ioctl" calls.
  42  */
  43
  44 #include <sys/types.h>
  45 #include <sys/param.h>
  46 #include <sys/signal.h>
  47 #include <sys/file.h>
  48 #include <sys/termios.h>
  49 #include <sys/ttold.h>
  50 #include <sys/cmn_err.h>
  51 #include <sys/stream.h>
  52 #include <sys/stropts.h>
  53 #include <sys/strsubr.h>
  54 #include <sys/strsun.h>
  55 #include <sys/errno.h>
  56 #include <sys/debug.h>
  57 #include <sys/ttcompat.h>
  58 #include <sys/ddi.h>
  59 #include <sys/sunddi.h>
  60 #include <sys/kmem.h>
  61 #include <sys/policy.h>
  62
  63 /*
  64  * This is the loadable module wrapper.
  65  */
  66 #include <sys/conf.h>
  67 #include <sys/modctl.h>
  68
  69 /* See os/streamio.c */
  70 extern int sgttyb_handling;
  71
  72 static struct streamtab ttcoinfo;
  73
  74 static struct fmodsw fsw = {
  75         "ttcompat",
  76         &ttcoinfo,
  77         D_MTQPAIR | D_MP | _D_SINGLE_INSTANCE
  78 };
  79
  80 /*
  81  * Module linkage information for the kernel.
  82  */
  83
  84 static struct modlstrmod modlstrmod = {
  85         &mod_strmodops,
  86         "alt ioctl calls",
  87         &fsw
  88 };
  89
  90 static struct modlinkage modlinkage = {
  91         MODREV_1, &modlstrmod, NULL
  92 };
  93
  94 int
  95 _init(void)
  96 {
  97         return (mod_install(&modlinkage));
  98 }
  99
 100 int
 101 _fini(void)
 102 {
 103         return (mod_remove(&modlinkage));
 104 }
 105
 106 int
 107 _info(struct modinfo *modinfop)
 108 {
 109         return (mod_info(&modlinkage, modinfop));
 110 }
 111
 112 static int ttcompatopen(queue_t *, dev_t *, int, int, cred_t *);
 113 static int ttcompatclose(queue_t *, int, cred_t *);
 114 static void ttcompatrput(queue_t *, mblk_t *);
 115 static void ttcompatwput(queue_t *, mblk_t *);
 116
 117 static struct module_info ttycompatmiinfo = {
 118         0,
 119         "ttcompat",
 120         0,
 121         INFPSZ,
 122         2048,
 123         128
 124 };
 125
 126 static struct qinit ttycompatrinit = {
 127         (int (*)())ttcompatrput,
 128         NULL,
 129         ttcompatopen,
 130         ttcompatclose,
 131         NULL,
 132         &ttycompatmiinfo
 133 };
 134
 135 static struct module_info ttycompatmoinfo = {
 136         42,
 137         "ttcompat",
 138         0,
 139         INFPSZ,
 140         300,
 141         200
 142 };
 143
 144 static struct qinit ttycompatwinit = {
 145         (int (*)())ttcompatwput,
 146         NULL,
 147         ttcompatopen,
 148         ttcompatclose,
 149         NULL,
 150         &ttycompatmoinfo
 151 };
 152
 153 static struct streamtab ttcoinfo = {
 154         &ttycompatrinit,
 155         &ttycompatwinit,
 156         NULL,
 157         NULL
 158 };
 159
 160 static void ttcompat_do_ioctl(ttcompat_state_t *, queue_t *, mblk_t *);
 161 static void ttcompat_ioctl_ack(queue_t *, mblk_t *);
 162 static void ttcopyout(queue_t *, mblk_t *);
 163 static void ttcompat_ioctl_nak(queue_t *, mblk_t *);
 164 static void from_compat(compat_state_t *, struct termios *);
 165 static void to_compat(struct termios *, compat_state_t *);
 166
 167 /*
 168  * Open - get the current modes and translate them to the V7/4BSD equivalent.
 169  */
 170 /*ARGSUSED*/
 171 static int
 172 ttcompatopen(queue_t *q, dev_t *devp, int oflag, int sflag, cred_t *crp)
 173 {
 174         ttcompat_state_t *tp;
 175
 176         if (q->q_ptr != NULL)  {
 177                 tp = (ttcompat_state_t *)q->q_ptr;
 178                 /* fail open if TIOCEXCL was done and its not privileged */
 179                 if ((tp->t_new_lflags & XCLUDE) &&
 180                     secpolicy_excl_open(crp) != 0) {
 181                         return (EBUSY);
 182                 }
 183                 return (0);             /* already attached */
 184         }
 185         tp = kmem_zalloc(sizeof (ttcompat_state_t), KM_SLEEP);
 186         q->q_ptr = tp;
 187         WR(q)->q_ptr = tp;
 188         qprocson(q);
 189
 190         return (0);
 191 }
 192
 193 /* ARGSUSED1 */
 194 static int
 195 ttcompatclose(queue_t *q, int flag, cred_t *crp)
 196 {
 197         ttcompat_state_t *tp = (ttcompat_state_t *)q->q_ptr;
 198         mblk_t *mp;
 199
 200         /* Dump the state structure, then unlink it */
 201         qprocsoff(q);
 202         if (tp->t_bufcallid != 0) {
 203                 qunbufcall(q, tp->t_bufcallid);
 204                 tp->t_bufcallid = 0;
 205         }
 206         if ((mp = tp->t_iocpending) != NULL)
 207                 freemsg(mp);
 208         kmem_free(tp, sizeof (ttcompat_state_t));
 209         q->q_ptr = NULL;
 210
 211         return (0);
 212 }
 213
 214 /*
 215  * Put procedure for input from driver end of stream (read queue).
 216  * Most messages just get passed to the next guy up; we intercept
 217  * "ioctl" replies, and if it's an "ioctl" whose reply we plan to do
 218  * something with, we do it.
 219  */
 220 static void
 221 ttcompatrput(queue_t *q, mblk_t *mp)
 222 {
 223         switch (mp->b_datap->db_type) {
 224
 225         case M_IOCACK:
 226                 ttcompat_ioctl_ack(q, mp);
 227                 break;
 228
 229         case M_IOCNAK:
 230                 ttcompat_ioctl_nak(q, mp);
 231                 break;
 232
 233         default:
 234                 putnext(q, mp);
 235                 break;
 236         }
 237 }
 238
 239 /*
 240  * Line discipline output queue put procedure: speeds M_IOCTL
 241  * messages.
 242  */
 243 static void
 244 ttcompatwput(queue_t *q, mblk_t *mp)
 245 {
 246         ttcompat_state_t *tp;
 247         struct copyreq *cqp;
 248         struct copyresp *csp;
 249         struct iocblk *iocbp;
 250
 251         tp = (ttcompat_state_t *)q->q_ptr;
 252
 253         /*
 254          * Process some M_IOCTL messages here; pass everything else down.
 255          */
 256         switch (mp->b_datap->db_type) {
 257
 258         default:
 259                 putnext(q, mp);
 260                 return;
 261
 262         case M_IOCTL:
 263                 iocbp = (struct iocblk *)mp->b_rptr;
 264
 265                 switch (iocbp->ioc_cmd) {
 266
 267                 default:
 268         /* these are ioctls with no arguments or are known to stream head */
 269         /* process them right away */
 270                         ttcompat_do_ioctl(tp, q, mp);
 271                         return;
 272                 case TIOCSETN:
 273                 case TIOCSLTC:
 274                 case TIOCSETC:
 275                 case TIOCLBIS:
 276                 case TIOCLBIC:
 277                 case TIOCLSET:
 278                 case TIOCFLUSH:
 279                         if (iocbp->ioc_count != TRANSPARENT) {
 280                                 putnext(q, mp);
 281                                 return;
 282                         }
 283
 284                         mp->b_datap->db_type = M_COPYIN;
 285                         cqp = (struct copyreq *)mp->b_rptr;
 286                         cqp->cq_addr = (caddr_t)*(intptr_t *)mp->b_cont->b_rptr;
 287                         switch (iocbp->ioc_cmd) {
 288                                 case TIOCSETN:
 289                                         cqp->cq_size = sizeof (struct sgttyb);
 290                                         break;
 291                                 case TIOCSLTC:
 292                                         cqp->cq_size = sizeof (struct ltchars);
 293                                         break;
 294                                 case TIOCSETC:
 295                                         cqp->cq_size = sizeof (struct tchars);
 296                                         break;
 297                                 case TIOCLBIS:
 298                                 case TIOCLBIC:
 299                                 case TIOCLSET:
 300                                 case TIOCFLUSH:
 301                                         cqp->cq_size = sizeof (int);
 302                                         break;
 303                                 default:
 304                                         break;
 305                         }
 306                         cqp->cq_flag = 0;
 307                         cqp->cq_private = NULL;
 308                         freemsg(mp->b_cont);
 309                         mp->b_cont = NULL;
 310                         mp->b_wptr = mp->b_rptr + sizeof (struct copyreq);
 311                         tp->t_ioccmd = iocbp->ioc_cmd;
 312                         tp->t_state |= TS_W_IN;
 313                         qreply(q, mp);
 314                         return;
 315
 316                 } /* switch ioc_cmd */
 317         case M_IOCDATA:
 318                 csp = (struct copyresp *)mp->b_rptr;
 319
 320                 switch (csp->cp_cmd) {
 321
 322                 default:
 323                         putnext(q, mp);
 324                         return;
 325
 326                 case TIOCSETN:
 327                 case TIOCSLTC:
 328                 case TIOCSETC:
 329                 case TIOCLBIS:
 330                 case TIOCLBIC:
 331                 case TIOCLSET:
 332                 case TIOCFLUSH:
 333                         tp->t_state &= ~TS_W_IN;
 334                         if (csp->cp_rval != 0) {        /* failure */
 335                                 freemsg(mp);
 336                                 return;
 337                         }
 338
 339                         /* make it look like an ioctl */
 340                         mp->b_datap->db_type = M_IOCTL;
 341                         mp->b_wptr = mp->b_rptr + sizeof (struct iocblk);
 342                         iocbp = (struct iocblk *)mp->b_rptr;
 343                         iocbp->ioc_count = MBLKL(mp->b_cont);
 344                         iocbp->ioc_error = 0;
 345                         iocbp->ioc_rval = 0;
 346                         ttcompat_do_ioctl(tp, q, mp);
 347                         return;
 348
 349                 case TIOCGLTC:
 350                 case TIOCLGET:
 351                 case TIOCGETC:
 352                         tp->t_state &= ~TS_W_OUT;
 353                         if (csp->cp_rval != 0) {        /* failure */
 354                                 freemsg(mp);
 355                                 return;
 356                         }
 357
 358                         iocbp = (struct iocblk *)mp->b_rptr;
 359                         iocbp->ioc_count = 0;
 360                         iocbp->ioc_error = 0;
 361                         iocbp->ioc_rval = 0;
 362                         mp->b_datap->db_type = M_IOCACK;
 363                         qreply(q, mp);
 364                         return;
 365
 366                 } /* switch cp_cmd */
 367         } /* end message switch */
 368 }
 369
 370 /*
 371  * Retry an "ioctl", now that "bufcall" claims we may be able to allocate
 372  * the buffer we need.
 373  */
 374 static void
 375 ttcompat_reioctl(void *arg)
 376 {
 377         queue_t *q = arg;
 378         ttcompat_state_t *tp;
 379         mblk_t *mp;
 380
 381         tp = (ttcompat_state_t *)q->q_ptr;
 382         tp->t_bufcallid = 0;
 383
 384         if ((mp = tp->t_iocpending) != NULL) {
 385                 tp->t_iocpending = NULL;        /* not pending any more */
 386                 ttcompat_do_ioctl(tp, q, mp);
 387         }
 388 }
 389
 390 /*
 391  * Handle old-style "ioctl" messages; pass the rest down unmolested.
 392  */
 393 static void
 394 ttcompat_do_ioctl(ttcompat_state_t *tp, queue_t *q, mblk_t *mp)
 395 {
 396         struct iocblk *iocp;
 397         int error;
 398
 399         /*
 400          * Most of the miocpullup()'s below aren't needed because the
 401          * ioctls in question are actually transparent M_IOCDATA messages
 402          * dummied to look like M_IOCTL messages.  However, for clarity and
 403          * robustness against future changes, we've included them anyway.
 404          */
 405
 406         iocp = (struct iocblk *)mp->b_rptr;
 407         switch (iocp->ioc_cmd) {
 408
 409         /*
 410          * "get"-style calls that get translated data from the "termios"
 411          * structure.  Save the existing code and pass it down as a TCGETS.
 412          */
 413         case TIOCGETC:
 414         case TIOCLGET:
 415         case TIOCGLTC:
 416                 if (iocp->ioc_count != TRANSPARENT) {
 417                         miocnak(q, mp, 0, EINVAL);
 418                         return;
 419                 }
 420
 421                 /*
 422                  * We can get here with t_arg != 0, iff the stream head
 423                  * has for some reason given up on the ioctl in progress.
 424                  * The most likely cause is an interrupted ioctl syscall.
 425                  * We will behave robustly because (given our perimeter)
 426                  * the ttcompat_state_t will get set up for the new ioctl,
 427                  * and when the response we were waiting for appears it
 428                  * will be passed on to the stream head which will discard
 429                  * it as non-current.
 430                  */
 431                 ASSERT(mp->b_cont != NULL);
 432                 tp->t_arg = *(intptr_t *)mp->b_cont->b_rptr;
 433                 /* free the data buffer - it might not be sufficient */
 434                 /* driver will allocate one for termios size */
 435                 freemsg(mp->b_cont);
 436                 mp->b_cont = NULL;
 437                 iocp->ioc_count = 0;
 438                 /* FALLTHRU */
 439         case TIOCGETP:
 440                 goto dogets;
 441
 442         /*
 443          * "set"-style calls that set translated data into a "termios"
 444          * structure.  Set our idea of the new state from the value
 445          * given to us.  We then have to get the current state, so we
 446          * turn this guy into a TCGETS and pass it down.  When the
 447          * ACK comes back, we modify the state we got back and shove it
 448          * back down as the appropriate type of TCSETS.
 449          */
 450         case TIOCSETP:
 451         case TIOCSETN:
 452                 error = miocpullup(mp, sizeof (struct sgttyb));
 453                 if (error != 0) {
 454                         miocnak(q, mp, 0, error);
 455                         return;
 456                 }
 457                 tp->t_new_sgttyb = *((struct sgttyb *)mp->b_cont->b_rptr);
 458                 goto dogets;
 459
 460         case TIOCSETC:
 461                 error = miocpullup(mp, sizeof (struct tchars));
 462                 if (error != 0) {
 463                         miocnak(q, mp, 0, error);
 464                         return;
 465                 }
 466                 tp->t_new_tchars = *((struct tchars *)mp->b_cont->b_rptr);
 467                 goto dogets;
 468
 469         case TIOCSLTC:
 470                 error = miocpullup(mp, sizeof (struct ltchars));
 471                 if (error != 0) {
 472                         miocnak(q, mp, 0, error);
 473                         return;
 474                 }
 475                 tp->t_new_ltchars = *((struct ltchars *)mp->b_cont->b_rptr);
 476                 goto dogets;
 477
 478         case TIOCLBIS:
 479         case TIOCLBIC:
 480         case TIOCLSET:
 481                 error = miocpullup(mp, sizeof (int));
 482                 if (error != 0) {
 483                         miocnak(q, mp, 0, error);
 484                         return;
 485                 }
 486                 tp->t_new_lflags = *(int *)mp->b_cont->b_rptr;
 487                 goto dogets;
 488
 489         /*
 490          * "set"-style call that sets a particular bit in a "termios"
 491          * structure.  We then have to get the current state, so we
 492          * turn this guy into a TCGETS and pass it down.  When the
 493          * ACK comes back, we modify the state we got back and shove it
 494          * back down as the appropriate type of TCSETS.
 495          */
 496         case TIOCHPCL:
 497         dogets:
 498                 tp->t_ioccmd = iocp->ioc_cmd;
 499                 tp->t_iocid = iocp->ioc_id;
 500                 tp->t_state |= TS_IOCWAIT;
 501                 iocp->ioc_cmd = TCGETS;
 502                 iocp->ioc_count = 0;    /* no data returned unless we say so */
 503                 break;
 504
 505         /*
 506          * "set"-style call that sets DTR.  Pretend that it was a TIOCMBIS
 507          * with TIOCM_DTR set.
 508          */
 509         case TIOCSDTR: {
 510                 mblk_t *datap;
 511
 512                 if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL)
 513                         goto allocfailure;
 514                 *(int *)datap->b_wptr = TIOCM_DTR;
 515                 datap->b_wptr += sizeof (int);
 516                 iocp->ioc_cmd = TIOCMBIS;       /* turn it into a TIOCMBIS */
 517                 if (mp->b_cont != NULL)
 518                         freemsg(mp->b_cont);
 519                 mp->b_cont = datap;     /* attach the data */
 520                 iocp->ioc_count = sizeof (int); /* in case driver checks */
 521                 break;
 522         }
 523
 524         /*
 525          * "set"-style call that clears DTR.  Pretend that it was a TIOCMBIC
 526          * with TIOCM_DTR set.
 527          */
 528         case TIOCCDTR: {
 529                 mblk_t *datap;
 530
 531                 if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL)
 532                         goto allocfailure;
 533                 *(int *)datap->b_wptr = TIOCM_DTR;
 534                 datap->b_wptr += sizeof (int);
 535                 iocp->ioc_cmd = TIOCMBIC;       /* turn it into a TIOCMBIC */
 536                 if (mp->b_cont != NULL)
 537                         freemsg(mp->b_cont);
 538                 mp->b_cont = datap;     /* attach the data */
 539                 iocp->ioc_count = sizeof (int); /* in case driver checks */
 540                 break;
 541         }
 542
 543         /*
 544          * Translate into the S5 form of TCFLSH.
 545          */
 546         case TIOCFLUSH: {
 547                 int flags;
 548
 549                 error = miocpullup(mp, sizeof (int));
 550                 if (error != 0) {
 551                         miocnak(q, mp, 0, error);
 552                         return;
 553                 }
 554                 flags = *(int *)mp->b_cont->b_rptr;
 555
 556                 switch (flags&(FREAD|FWRITE)) {
 557
 558                 case 0:
 559                 case FREAD|FWRITE:
 560                         flags = 2;      /* flush 'em both */
 561                         break;
 562
 563                 case FREAD:
 564                         flags = 0;      /* flush read */
 565                         break;
 566
 567                 case FWRITE:
 568                         flags = 1;      /* flush write */
 569                         break;
 570                 }
 571                 iocp->ioc_cmd = TCFLSH; /* turn it into a TCFLSH */
 572                 *(int *)mp->b_cont->b_rptr = flags;     /* fiddle the arg */
 573                 break;
 574         }
 575
 576         /*
 577          * Turn into a TCXONC.
 578          */
 579         case TIOCSTOP: {
 580                 mblk_t *datap;
 581
 582                 if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL)
 583                         goto allocfailure;
 584                 *(int *)datap->b_wptr = 0;      /* stop */
 585                 datap->b_wptr += sizeof (int);
 586                 iocp->ioc_cmd = TCXONC; /* turn it into a XONC */
 587                 iocp->ioc_count = sizeof (int);
 588                 if (mp->b_cont != NULL)
 589                         freemsg(mp->b_cont);
 590                 mp->b_cont = datap;     /* attach the data */
 591                 break;
 592         }
 593
 594         case TIOCSTART: {
 595                 mblk_t *datap;
 596
 597                 if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL)
 598                         goto allocfailure;
 599                 *(int *)datap->b_wptr = 1;      /* start */
 600                 datap->b_wptr += sizeof (int);
 601                 iocp->ioc_cmd = TCXONC; /* turn it into a XONC */
 602                 iocp->ioc_count = sizeof (int);
 603                 if (mp->b_cont != NULL)
 604                         freemsg(mp->b_cont);
 605                 mp->b_cont = datap;     /* attach the data */
 606                 break;
 607         }
 608         case TIOCSETD:
 609         case TIOCGETD:
 610         case DIOCSETP:
 611         case DIOCGETP:
 612         case LDOPEN:
 613         case LDCLOSE:
 614         case LDCHG:
 615         case LDSETT:
 616         case LDGETT:
 617                 /*
 618                  * All of these ioctls are just ACK'd, except for
 619                  * TIOCSETD, which must be for line discipline zero.
 620                  */
 621                 mp->b_datap->db_type = M_IOCACK;
 622                 if (iocp->ioc_cmd == TIOCSETD) {
 623                         iocp->ioc_error = miocpullup(mp, sizeof (uchar_t));
 624                         if (iocp->ioc_error == 0 && (*mp->b_cont->b_rptr != 0))
 625                                 mp->b_datap->db_type = M_IOCNAK;
 626                 }
 627
 628                 iocp->ioc_error = 0;
 629                 iocp->ioc_count = 0;
 630                 iocp->ioc_rval = 0;
 631                 qreply(q, mp);
 632                 return;
 633         case IOCTYPE:
 634                 mp->b_datap->db_type = M_IOCACK;
 635                 iocp->ioc_error = 0;
 636                 iocp->ioc_count = 0;
 637                 iocp->ioc_rval = TIOC;
 638                 qreply(q, mp);
 639                 return;
 640         case TIOCEXCL:
 641                 /* check for binary value of XCLUDE flag ???? */
 642                 tp->t_new_lflags |= XCLUDE;
 643                 mp->b_datap->db_type = M_IOCACK;
 644                 iocp->ioc_error = 0;
 645                 iocp->ioc_count = 0;
 646                 iocp->ioc_rval = 0;
 647                 qreply(q, mp);
 648                 return;
 649         case TIOCNXCL:
 650                 tp->t_new_lflags &= ~XCLUDE;
 651                 mp->b_datap->db_type = M_IOCACK;
 652                 iocp->ioc_error = 0;
 653                 iocp->ioc_count = 0;
 654                 iocp->ioc_rval = 0;
 655                 qreply(q, mp);
 656                 return;
 657         }
 658
 659         /*
 660          * We don't reply to most calls, we just pass them down,
 661          * possibly after modifying the arguments.
 662          */
 663         putnext(q, mp);
 664         return;
 665
 666 allocfailure:
 667         /*
 668          * We needed to allocate something to handle this "ioctl", but
 669          * couldn't; save this "ioctl" and arrange to get called back when
 670          * it's more likely that we can get what we need.
 671          * If there's already one being saved, throw it out, since it
 672          * must have timed out.
 673          */
 674         if (tp->t_iocpending != NULL)
 675                 freemsg(tp->t_iocpending);
 676         tp->t_iocpending = mp;  /* hold this ioctl */
 677         if (tp->t_bufcallid != 0)
 678                 qunbufcall(q, tp->t_bufcallid);
 679
 680         tp->t_bufcallid = qbufcall(q, sizeof (struct iocblk), BPRI_HI,
 681             ttcompat_reioctl, q);
 682 }
 683
 684 /*
 685  * Called when an M_IOCACK message is seen on the read queue; if this
 686  * is the response we were waiting for, we either:
 687  *    modify the data going up (if the "ioctl" read data); since in all
 688  *    cases, the old-style returned information is smaller than or the same
 689  *    size as the new-style returned information, we just overwrite the old
 690  *    stuff with the new stuff (beware of changing structure sizes, in case
 691  *    you invalidate this)
 692  * or
 693  *    take this data, modify it appropriately, and send it back down (if
 694  *    the "ioctl" wrote data).
 695  * In either case, we cancel the "wait"; the final response to a "write"
 696  * ioctl goes back up to the user.
 697  * If this wasn't the response we were waiting for, just pass it up.
 698  */
 699 static void
 700 ttcompat_ioctl_ack(queue_t *q,  mblk_t *mp)
 701 {
 702         ttcompat_state_t *tp;
 703         struct iocblk *iocp;
 704         mblk_t *datap;
 705
 706         tp = (ttcompat_state_t *)q->q_ptr;
 707         iocp = (struct iocblk *)mp->b_rptr;
 708
 709         if (!(tp->t_state&TS_IOCWAIT) || iocp->ioc_id != tp->t_iocid) {
 710                 /*
 711                  * This isn't the reply we're looking for.  Move along.
 712                  */
 713                 putnext(q, mp);
 714                 return;
 715         }
 716
 717         datap = mp->b_cont;     /* mblk containing data going up */
 718
 719         switch (tp->t_ioccmd) {
 720
 721         case TIOCGETP: {
 722                 struct sgttyb *cb;
 723
 724                 to_compat((struct termios *)datap->b_rptr, &tp->t_curstate);
 725                 datap->b_rptr = datap->b_wptr = datap->b_datap->db_base;
 726                         /* recycle the reply's buffer */
 727                 cb = (struct sgttyb *)datap->b_wptr;
 728                 /*
 729                  * This is used for TIOCGETP handling of sg_ispeed and
 730                  * sg_ospeed.  If the current speed is over 38400 (the
 731                  * sgttyb limit), then we report 38400.  Note that
 732                  * when "compatibility with old releases" is enabled
 733                  * (sgttyb_handling == 0), then t_[io]speed will have
 734                  * garbled nonsense, as in prior releases.  (See
 735                  * to_compat() below).
 736                  */
 737                 cb->sg_ispeed = tp->t_curstate.t_ispeed > B38400 ? B38400 :
 738                     tp->t_curstate.t_ispeed;
 739                 cb->sg_ospeed = tp->t_curstate.t_ospeed > B38400 ? B38400 :
 740                     tp->t_curstate.t_ospeed;
 741                 cb->sg_erase = tp->t_curstate.t_erase;
 742                 cb->sg_kill = tp->t_curstate.t_kill;
 743                 cb->sg_flags = tp->t_curstate.t_flags;
 744                 datap->b_wptr += sizeof (struct sgttyb);
 745                 iocp->ioc_count = sizeof (struct sgttyb);
 746
 747                 /* you are lucky - stream head knows how to copy you out */
 748
 749                 tp->t_state &= ~TS_IOCWAIT;     /* we got what we wanted */
 750                 iocp->ioc_rval = 0;
 751                 iocp->ioc_cmd =  tp->t_ioccmd;
 752                 putnext(q, mp);
 753                 return;
 754         }
 755
 756         case TIOCGETC:
 757                 to_compat((struct termios *)datap->b_rptr, &tp->t_curstate);
 758                 datap->b_rptr = datap->b_wptr = datap->b_datap->db_base;
 759                         /* recycle the reply's buffer */
 760                 bcopy(&tp->t_curstate.t_intrc, datap->b_wptr,
 761                     sizeof (struct tchars));
 762                 datap->b_wptr += sizeof (struct tchars);
 763                 break;
 764
 765         case TIOCGLTC:
 766                 to_compat((struct termios *)datap->b_rptr, &tp->t_curstate);
 767                 datap->b_rptr = datap->b_wptr = datap->b_datap->db_base;
 768                         /* recycle the reply's buffer */
 769                 bcopy(&tp->t_curstate.t_suspc, datap->b_wptr,
 770                     sizeof (struct ltchars));
 771                 datap->b_wptr += sizeof (struct ltchars);
 772                 break;
 773
 774         case TIOCLGET:
 775                 to_compat((struct termios *)datap->b_rptr, &tp->t_curstate);
 776                 datap->b_rptr = datap->b_wptr = datap->b_datap->db_base;
 777                         /* recycle the reply's buffer */
 778                 *(int *)datap->b_wptr =
 779                     ((unsigned)tp->t_curstate.t_flags) >> 16;
 780                 datap->b_wptr += sizeof (int);
 781                 break;
 782
 783         case TIOCSETP:
 784         case TIOCSETN:
 785                 /*
 786                  * Get the current state from the GETS data, and
 787                  * update it.
 788                  */
 789                 to_compat((struct termios *)datap->b_rptr, &tp->t_curstate);
 790                 tp->t_curstate.t_erase = tp->t_new_sgttyb.sg_erase;
 791                 tp->t_curstate.t_kill = tp->t_new_sgttyb.sg_kill;
 792                 /*
 793                  * For new-style handling, we ignore requests to set
 794                  * B38400 when the current speed is over B38400.  This
 795                  * means that we change the speed as requested if:
 796                  *      old style (sgttyb_handling == 0) is requested
 797                  *      the requested new speed isn't B38400
 798                  *      the current speed is at or below B38400
 799                  * Note that when old style is requested, both speeds
 800                  * in t_curstate are set to <= B38400 by to_compat, so
 801                  * the first test isn't needed here.
 802                  * Also note that we silently allow the user to set
 803                  * speeds above B38400 through this interface,
 804                  * regardless of the style setting.  This allows
 805                  * greater compatibility with current BSD releases.
 806                  */
 807                 if (tp->t_new_sgttyb.sg_ispeed != B38400 ||
 808                     tp->t_curstate.t_ispeed <= B38400)
 809                         tp->t_curstate.t_ispeed = tp->t_new_sgttyb.sg_ispeed;
 810                 if (tp->t_new_sgttyb.sg_ospeed != B38400 ||
 811                     tp->t_curstate.t_ospeed <= B38400)
 812                         tp->t_curstate.t_ospeed = tp->t_new_sgttyb.sg_ospeed;
 813                 tp->t_curstate.t_flags =
 814                     (tp->t_curstate.t_flags & 0xffff0000) |
 815                     (tp->t_new_sgttyb.sg_flags & 0xffff);
 816
 817                 /*
 818                  * Replace the data that came up with the updated data.
 819                  */
 820                 from_compat(&tp->t_curstate, (struct termios *)datap->b_rptr);
 821
 822                 /*
 823                  * Send it back down as a TCSETS or TCSETSF.
 824                  */
 825                 iocp->ioc_cmd = (tp->t_ioccmd == TIOCSETP) ? TCSETSF : TCSETS;
 826                 goto senddown;
 827
 828         case TIOCSETC:
 829                 /*
 830                  * Get the current state from the GETS data, and
 831                  * update it.
 832                  */
 833                 to_compat((struct termios *)datap->b_rptr, &tp->t_curstate);
 834                 bcopy(&tp->t_new_tchars,
 835                     &tp->t_curstate.t_intrc, sizeof (struct tchars));
 836
 837                 /*
 838                  * Replace the data that came up with the updated data.
 839                  */
 840                 from_compat(&tp->t_curstate, (struct termios *)datap->b_rptr);
 841
 842                 /*
 843                  * Send it back down as a TCSETS.
 844                  */
 845                 iocp->ioc_cmd = TCSETS;
 846                 goto senddown;
 847
 848         case TIOCSLTC:
 849                 /*
 850                  * Get the current state from the GETS data, and
 851                  * update it.
 852                  */
 853                 to_compat((struct termios *)datap->b_rptr, &tp->t_curstate);
 854                 bcopy(&tp->t_new_ltchars,
 855                     &tp->t_curstate.t_suspc, sizeof (struct ltchars));
 856
 857                 /*
 858                  * Replace the data that came up with the updated data.
 859                  */
 860                 from_compat(&tp->t_curstate, (struct termios *)datap->b_rptr);
 861
 862                 /*
 863                  * Send it back down as a TCSETS.
 864                  */
 865                 iocp->ioc_cmd = TCSETS;
 866                 goto senddown;
 867
 868         case TIOCLBIS:
 869                 /*
 870                  * Get the current state from the GETS data, and
 871                  * update it.
 872                  */
 873                 to_compat((struct termios *)datap->b_rptr, &tp->t_curstate);
 874                 tp->t_curstate.t_flags |= (tp->t_new_lflags << 16);
 875
 876                 /*
 877                  * Replace the data that came up with the updated data.
 878                  */
 879                 from_compat(&tp->t_curstate, (struct termios *)datap->b_rptr);
 880
 881                 /*
 882                  * Send it back down as a TCSETS.
 883                  */
 884                 iocp->ioc_cmd = TCSETS;
 885                 goto senddown;
 886
 887         case TIOCLBIC:
 888                 /*
 889                  * Get the current state from the GETS data, and
 890                  * update it.
 891                  */
 892                 to_compat((struct termios *)datap->b_rptr, &tp->t_curstate);
 893                 tp->t_curstate.t_flags &= ~(tp->t_new_lflags << 16);
 894
 895                 /*
 896                  * Replace the data that came up with the updated data.
 897                  */
 898                 from_compat(&tp->t_curstate, (struct termios *)datap->b_rptr);
 899
 900                 /*
 901                  * Send it back down as a TCSETS.
 902                  */
 903                 iocp->ioc_cmd = TCSETS;
 904                 goto senddown;
 905
 906         case TIOCLSET:
 907                 /*
 908                  * Get the current state from the GETS data, and
 909                  * update it.
 910                  */
 911                 to_compat((struct termios *)datap->b_rptr, &tp->t_curstate);
 912                 tp->t_curstate.t_flags &= 0xffff;
 913                 tp->t_curstate.t_flags |= (tp->t_new_lflags << 16);
 914
 915                 /*
 916                  * Replace the data that came up with the updated data.
 917                  */
 918                 from_compat(&tp->t_curstate, (struct termios *)datap->b_rptr);
 919
 920                 /*
 921                  * Send it back down as a TCSETS.
 922                  */
 923                 iocp->ioc_cmd = TCSETS;
 924                 goto senddown;
 925
 926         case TIOCHPCL:
 927                 /*
 928                  * Replace the data that came up with the updated data.
 929                  */
 930                 ((struct termios *)datap->b_rptr)->c_cflag |= HUPCL;
 931
 932                 /*
 933                  * Send it back down as a TCSETS.
 934                  */
 935                 iocp->ioc_cmd = TCSETS;
 936                 goto senddown;
 937
 938         case TCSETSF:
 939                 /*
 940                  * We're acknowledging the terminal reset ioctl that we sent
 941                  * when the module was opened.
 942                  */
 943                 tp->t_state &= ~(TS_IOCWAIT | TS_TIOCNAK);
 944                 freemsg(mp);
 945                 return;
 946
 947         default:
 948                 cmn_err(CE_WARN, "ttcompat: Unexpected ioctl acknowledgment\n");
 949         }
 950
 951         /*
 952          * All the calls that return something return 0.
 953          */
 954         tp->t_state &= ~TS_IOCWAIT;     /* we got what we wanted */
 955         iocp->ioc_rval = 0;
 956
 957         /* copy out the data - ioctl transparency */
 958         iocp->ioc_cmd =  tp->t_ioccmd;
 959         ttcopyout(q, mp);
 960         return;
 961
 962 senddown:
 963         /*
 964          * Send a "get state" reply back down, with suitably-modified
 965          * state, as a "set state" "ioctl".
 966          */
 967         tp->t_state &= ~TS_IOCWAIT;
 968         mp->b_datap->db_type = M_IOCTL;
 969         mp->b_wptr = mp->b_rptr + sizeof (struct iocblk);
 970         putnext(WR(q), mp);
 971 }
 972 /* Called from ttcompatrput M_IOCACK processing. */
 973 /* Copies out the data using M_COPYOUT messages */
 974
 975 static void
 976 ttcopyout(queue_t *q, mblk_t *mp)
 977 {
 978         struct copyreq *cqp;
 979         ttcompat_state_t *tp;
 980
 981         tp = (ttcompat_state_t *)q->q_ptr;
 982
 983         mp->b_datap->db_type = M_COPYOUT;
 984         cqp = (struct copyreq *)mp->b_rptr;
 985         cqp->cq_addr = (caddr_t)tp->t_arg; /* retrieve the 3rd argument */
 986         tp->t_arg = 0; /* clear it since we don't need it anymore */
 987         switch (tp->t_ioccmd) {
 988                 case TIOCGLTC:
 989                         cqp->cq_size = sizeof (struct ltchars);
 990                         break;
 991                 case TIOCGETC:
 992                         cqp->cq_size = sizeof (struct tchars);
 993                         break;
 994                 case TIOCLGET:
 995                         cqp->cq_size = sizeof (int);
 996                         break;
 997                 default:
 998                         cmn_err(CE_WARN,
 999                             "ttcompat: Unknown ioctl to copyout\n");
1000                         break;
1001                 }
1002         cqp->cq_flag = 0;
1003         cqp->cq_private = NULL;
1004         tp->t_state |= TS_W_OUT;
1005         putnext(q, mp);
1006 }
1007
1008
1009 /*
1010  * Called when an M_IOCNAK message is seen on the read queue; if this is
1011  * the response we were waiting for, cancel the wait.  Pass the reply up;
1012  * if we were waiting for this response, we can't complete the "ioctl" and
1013  * the NAK will tell that to the guy above us.
1014  * If this wasn't the response we were waiting for, just pass it up.
1015  */
1016 static void
1017 ttcompat_ioctl_nak(queue_t *q, mblk_t *mp)
1018 {
1019         ttcompat_state_t *tp;
1020         struct iocblk *iocp;
1021
1022         iocp = (struct iocblk *)mp->b_rptr;
1023         tp = (ttcompat_state_t *)q->q_ptr;
1024
1025         if (tp->t_state&TS_IOCWAIT && iocp->ioc_id == tp->t_iocid) {
1026                 tp->t_state &= ~TS_IOCWAIT; /* this call isn't going through */
1027                 tp->t_arg = 0;  /* we may have stashed the 3rd argument */
1028         }
1029         putnext(q, mp);
1030 }
1031
1032 #define FROM_COMPAT_CHAR(to, from) { if ((to = from) == 0377) to = 0; }
1033
1034 static void
1035 from_compat(compat_state_t *csp, struct termios *termiosp)
1036 {
1037         termiosp->c_iflag = 0;
1038         termiosp->c_oflag &= (ONLRET|ONOCR);
1039
1040         termiosp->c_cflag = (termiosp->c_cflag &
1041             (CRTSCTS|CRTSXOFF|PAREXT|LOBLK|HUPCL)) | CREAD;
1042
1043         if (csp->t_ospeed > CBAUD) {
1044                 termiosp->c_cflag |= ((csp->t_ospeed - CBAUD - 1) & CBAUD) |
1045                     CBAUDEXT;
1046         } else {
1047                 termiosp->c_cflag |= csp->t_ospeed & CBAUD;
1048         }
1049
1050         if (csp->t_ospeed != csp->t_ispeed) {
1051                 if (csp->t_ispeed > (CIBAUD >> IBSHIFT)) {
1052                         termiosp->c_cflag |= CIBAUDEXT |
1053                             (((csp->t_ispeed - (CIBAUD >> IBSHIFT) - 1) <<
1054                             IBSHIFT) & CIBAUD);
1055                 } else {
1056                         termiosp->c_cflag |= (csp->t_ispeed << IBSHIFT) &
1057                             CIBAUD;
1058                 }
1059                 /* hang up if ispeed=0 */
1060                 if (csp->t_ispeed == 0)
1061                         termiosp->c_cflag &= ~CBAUD & ~CBAUDEXT;
1062         }
1063         if (csp->t_ispeed == B110 || csp->t_xflags & STOPB)
1064                 termiosp->c_cflag |= CSTOPB;
1065         termiosp->c_lflag = ECHOK;
1066         FROM_COMPAT_CHAR(termiosp->c_cc[VERASE], csp->t_erase);
1067         FROM_COMPAT_CHAR(termiosp->c_cc[VKILL], csp->t_kill);
1068         FROM_COMPAT_CHAR(termiosp->c_cc[VINTR], csp->t_intrc);
1069         FROM_COMPAT_CHAR(termiosp->c_cc[VQUIT], csp->t_quitc);
1070         FROM_COMPAT_CHAR(termiosp->c_cc[VSTART], csp->t_startc);
1071         FROM_COMPAT_CHAR(termiosp->c_cc[VSTOP], csp->t_stopc);
1072         termiosp->c_cc[VEOL2] = 0;
1073         FROM_COMPAT_CHAR(termiosp->c_cc[VSUSP], csp->t_suspc);
1074         /* is this useful? */
1075         FROM_COMPAT_CHAR(termiosp->c_cc[VDSUSP], csp->t_dsuspc);
1076         FROM_COMPAT_CHAR(termiosp->c_cc[VREPRINT], csp->t_rprntc);
1077         FROM_COMPAT_CHAR(termiosp->c_cc[VDISCARD], csp->t_flushc);
1078         FROM_COMPAT_CHAR(termiosp->c_cc[VWERASE], csp->t_werasc);
1079         FROM_COMPAT_CHAR(termiosp->c_cc[VLNEXT], csp->t_lnextc);
1080         termiosp->c_cc[VSTATUS] = 0;
1081         if (csp->t_flags & O_TANDEM)
1082                 termiosp->c_iflag |= IXOFF;
1083         if (csp->t_flags & O_LCASE) {
1084                 termiosp->c_iflag |= IUCLC;
1085                 termiosp->c_oflag |= OLCUC;
1086                 termiosp->c_lflag |= XCASE;
1087         }
1088         if (csp->t_flags & O_ECHO)
1089                 termiosp->c_lflag |= ECHO;
1090         if (csp->t_flags & O_CRMOD) {
1091                 termiosp->c_iflag |= ICRNL;
1092                 termiosp->c_oflag |= ONLCR;
1093                 switch (csp->t_flags & O_CRDELAY) {
1094
1095                 case O_CR1:
1096                         termiosp->c_oflag |= CR2;
1097                         break;
1098
1099                 case O_CR2:
1100                         termiosp->c_oflag |= CR3;
1101                         break;
1102                 }
1103         } else {
1104                 if ((csp->t_flags & O_NLDELAY) == O_NL1)
1105                         termiosp->c_oflag |= ONLRET|CR1;        /* tty37 */
1106         }
1107         if ((csp->t_flags & O_NLDELAY) == O_NL2)
1108                 termiosp->c_oflag |= NL1;
1109         /*
1110          * When going into RAW mode, the special characters controlled by the
1111          * POSIX IEXTEN bit no longer apply; when leaving, they do.
1112          */
1113         if (csp->t_flags & O_RAW) {
1114                 termiosp->c_cflag |= CS8;
1115                 termiosp->c_iflag &= ~(ICRNL|IUCLC);
1116                 termiosp->c_lflag &= ~(XCASE|IEXTEN);
1117         } else {
1118                 termiosp->c_iflag |= IMAXBEL|BRKINT|IGNPAR;
1119                 if (termiosp->c_cc[VSTOP] != 0 && termiosp->c_cc[VSTART] != 0)
1120                         termiosp->c_iflag |= IXON;
1121                 if (csp->t_flags & O_LITOUT)
1122                         termiosp->c_cflag |= CS8;
1123                 else {
1124                         if (csp->t_flags & O_PASS8)
1125                                 termiosp->c_cflag |= CS8;
1126                                 /* XXX - what about 8 bits plus parity? */
1127                         else {
1128                                 switch (csp->t_flags & (O_EVENP|O_ODDP)) {
1129
1130                                 case 0:
1131                                         termiosp->c_iflag |= ISTRIP;
1132                                         termiosp->c_cflag |= CS8;
1133                                         break;
1134
1135                                 case O_EVENP:
1136                                         termiosp->c_iflag |= INPCK|ISTRIP;
1137                                         termiosp->c_cflag |= CS7|PARENB;
1138                                         break;
1139
1140                                 case O_ODDP:
1141                                         termiosp->c_iflag |= INPCK|ISTRIP;
1142                                         termiosp->c_cflag |= CS7|PARENB|PARODD;
1143                                         break;
1144
1145                                 case O_EVENP|O_ODDP:
1146                                         termiosp->c_iflag |= ISTRIP;
1147                                         termiosp->c_cflag |= CS7|PARENB;
1148                                         break;
1149                                 }
1150                         }
1151                         if (!(csp->t_xflags & NOPOST))
1152                                 termiosp->c_oflag |= OPOST;
1153                 }
1154                 termiosp->c_lflag |= IEXTEN;
1155                 if (!(csp->t_xflags & NOISIG))
1156                         termiosp->c_lflag |= ISIG;
1157                 if (!(csp->t_flags & O_CBREAK))
1158                         termiosp->c_lflag |= ICANON;
1159                 if (csp->t_flags & O_CTLECH)
1160                         termiosp->c_lflag |= ECHOCTL;
1161         }
1162         switch (csp->t_flags & O_TBDELAY) {
1163
1164         case O_TAB1:
1165                 termiosp->c_oflag |= TAB1;
1166                 break;
1167
1168         case O_TAB2:
1169                 termiosp->c_oflag |= TAB2;
1170                 break;
1171
1172         case O_XTABS:
1173                 termiosp->c_oflag |= TAB3;
1174                 break;
1175         }
1176         if (csp->t_flags & O_VTDELAY)
1177                 termiosp->c_oflag |= FFDLY;
1178         if (csp->t_flags & O_BSDELAY)
1179                 termiosp->c_oflag |= BSDLY;
1180         if (csp->t_flags & O_PRTERA)
1181                 termiosp->c_lflag |= ECHOPRT;
1182         if (csp->t_flags & O_CRTERA)
1183                 termiosp->c_lflag |= ECHOE;
1184         if (csp->t_flags & O_TOSTOP)
1185                 termiosp->c_lflag |= TOSTOP;
1186         if (csp->t_flags & O_FLUSHO)
1187                 termiosp->c_lflag |= FLUSHO;
1188         if (csp->t_flags & O_NOHANG)
1189                 termiosp->c_cflag |= CLOCAL;
1190         if (csp->t_flags & O_CRTKIL)
1191                 termiosp->c_lflag |= ECHOKE;
1192         if (csp->t_flags & O_PENDIN)
1193                 termiosp->c_lflag |= PENDIN;
1194         if (!(csp->t_flags & O_DECCTQ))
1195                 termiosp->c_iflag |= IXANY;
1196         if (csp->t_flags & O_NOFLSH)
1197                 termiosp->c_lflag |= NOFLSH;
1198         if (termiosp->c_lflag & ICANON) {
1199                 FROM_COMPAT_CHAR(termiosp->c_cc[VEOF], csp->t_eofc);
1200                 FROM_COMPAT_CHAR(termiosp->c_cc[VEOL], csp->t_brkc);
1201         } else {
1202                 termiosp->c_cc[VMIN] = 1;
1203                 termiosp->c_cc[VTIME] = 0;
1204         }
1205 }
1206
1207 #define TO_COMPAT_CHAR(to, from) { if ((to = from) == 0) to = (uchar_t)0377; }
1208
1209 static void
1210 to_compat(struct termios *termiosp, compat_state_t *csp)
1211 {
1212         csp->t_xflags &= (NOISIG|NOPOST);
1213         csp->t_ospeed = termiosp->c_cflag & CBAUD;
1214         csp->t_ispeed = (termiosp->c_cflag & CIBAUD) >> IBSHIFT;
1215         if (sgttyb_handling > 0) {
1216                 if (termiosp->c_cflag & CBAUDEXT)
1217                         csp->t_ospeed += CBAUD + 1;
1218                 if (termiosp->c_cflag & CIBAUDEXT)
1219                         csp->t_ispeed += (CIBAUD >> IBSHIFT) + 1;
1220         }
1221         if (csp->t_ispeed == 0)
1222                 csp->t_ispeed = csp->t_ospeed;
1223         if ((termiosp->c_cflag & CSTOPB) && csp->t_ispeed != B110)
1224                 csp->t_xflags |= STOPB;
1225         TO_COMPAT_CHAR(csp->t_erase, termiosp->c_cc[VERASE]);
1226         TO_COMPAT_CHAR(csp->t_kill, termiosp->c_cc[VKILL]);
1227         TO_COMPAT_CHAR(csp->t_intrc, termiosp->c_cc[VINTR]);
1228         TO_COMPAT_CHAR(csp->t_quitc, termiosp->c_cc[VQUIT]);
1229         TO_COMPAT_CHAR(csp->t_startc, termiosp->c_cc[VSTART]);
1230         TO_COMPAT_CHAR(csp->t_stopc, termiosp->c_cc[VSTOP]);
1231         TO_COMPAT_CHAR(csp->t_suspc, termiosp->c_cc[VSUSP]);
1232         TO_COMPAT_CHAR(csp->t_dsuspc, termiosp->c_cc[VDSUSP]);
1233         TO_COMPAT_CHAR(csp->t_rprntc, termiosp->c_cc[VREPRINT]);
1234         TO_COMPAT_CHAR(csp->t_flushc, termiosp->c_cc[VDISCARD]);
1235         TO_COMPAT_CHAR(csp->t_werasc, termiosp->c_cc[VWERASE]);
1236         TO_COMPAT_CHAR(csp->t_lnextc, termiosp->c_cc[VLNEXT]);
1237         csp->t_flags &= (O_CTLECH|O_LITOUT|O_PASS8|O_ODDP|O_EVENP);
1238         if (termiosp->c_iflag & IXOFF)
1239                 csp->t_flags |= O_TANDEM;
1240         if (!(termiosp->c_iflag &
1241             (IMAXBEL|BRKINT|IGNPAR|PARMRK|INPCK|ISTRIP|
1242             INLCR|IGNCR|ICRNL|IUCLC|IXON)) &&
1243             !(termiosp->c_oflag & OPOST) &&
1244             (termiosp->c_cflag & (CSIZE|PARENB)) == CS8 &&
1245             !(termiosp->c_lflag & (ISIG|ICANON|XCASE|IEXTEN)))
1246                 csp->t_flags |= O_RAW;
1247         else {
1248                 if (!(termiosp->c_iflag & IXON)) {
1249                         csp->t_startc = (uchar_t)0377;
1250                         csp->t_stopc = (uchar_t)0377;
1251                 }
1252                 if ((termiosp->c_cflag & (CSIZE|PARENB)) == CS8 &&
1253                     !(termiosp->c_oflag & OPOST))
1254                         csp->t_flags |= O_LITOUT;
1255                 else {
1256                         csp->t_flags &= ~O_LITOUT;
1257                         if ((termiosp->c_cflag & (CSIZE|PARENB)) == CS8) {
1258                                 if (!(termiosp->c_iflag & ISTRIP))
1259                                         csp->t_flags |= O_PASS8;
1260                         } else {
1261                                 csp->t_flags &= ~(O_ODDP|O_EVENP|O_PASS8);
1262                                 if (termiosp->c_cflag & PARODD)
1263                                         csp->t_flags |= O_ODDP;
1264                                 else if (termiosp->c_iflag & INPCK)
1265                                         csp->t_flags |= O_EVENP;
1266                                 else
1267                                         csp->t_flags |= O_ODDP|O_EVENP;
1268                         }
1269                         if (!(termiosp->c_oflag & OPOST))
1270                                 csp->t_xflags |= NOPOST;
1271                         else
1272                                 csp->t_xflags &= ~NOPOST;
1273                 }
1274                 if (!(termiosp->c_lflag & ISIG))
1275                         csp->t_xflags |= NOISIG;
1276                 else
1277                         csp->t_xflags &= ~NOISIG;
1278                 if (!(termiosp->c_lflag & ICANON))
1279                         csp->t_flags |= O_CBREAK;
1280                 if (termiosp->c_lflag & ECHOCTL)
1281                         csp->t_flags |= O_CTLECH;
1282                 else
1283                         csp->t_flags &= ~O_CTLECH;
1284         }
1285         if (termiosp->c_oflag & OLCUC)
1286                 csp->t_flags |= O_LCASE;
1287         if (termiosp->c_lflag&ECHO)
1288                 csp->t_flags |= O_ECHO;
1289         if (termiosp->c_oflag & ONLCR) {
1290                 csp->t_flags |= O_CRMOD;
1291                 switch (termiosp->c_oflag & CRDLY) {
1292
1293                 case CR2:
1294                         csp->t_flags |= O_CR1;
1295                         break;
1296
1297                 case CR3:
1298                         csp->t_flags |= O_CR2;
1299                         break;
1300                 }
1301         } else {
1302                 if ((termiosp->c_oflag & CR1) &&
1303                     (termiosp->c_oflag & ONLRET))
1304                         csp->t_flags |= O_NL1;  /* tty37 */
1305         }
1306         if ((termiosp->c_oflag & ONLRET) && (termiosp->c_oflag & NL1))
1307                 csp->t_flags |= O_NL2;
1308         switch (termiosp->c_oflag & TABDLY) {
1309
1310         case TAB1:
1311                 csp->t_flags |= O_TAB1;
1312                 break;
1313
1314         case TAB2:
1315                 csp->t_flags |= O_TAB2;
1316                 break;
1317
1318         case XTABS:
1319                 csp->t_flags |= O_XTABS;
1320                 break;
1321         }
1322         if (termiosp->c_oflag & FFDLY)
1323                 csp->t_flags |= O_VTDELAY;
1324         if (termiosp->c_oflag & BSDLY)
1325                 csp->t_flags |= O_BSDELAY;
1326         if (termiosp->c_lflag & ECHOPRT)
1327                 csp->t_flags |= O_PRTERA;
1328         if (termiosp->c_lflag & ECHOE)
1329                 csp->t_flags |= (O_CRTERA|O_CRTBS);
1330         if (termiosp->c_lflag & TOSTOP)
1331                 csp->t_flags |= O_TOSTOP;
1332         if (termiosp->c_lflag & FLUSHO)
1333                 csp->t_flags |= O_FLUSHO;
1334         if (termiosp->c_cflag & CLOCAL)
1335                 csp->t_flags |= O_NOHANG;
1336         if (termiosp->c_lflag & ECHOKE)
1337                 csp->t_flags |= O_CRTKIL;
1338         if (termiosp->c_lflag & PENDIN)
1339                 csp->t_flags |= O_PENDIN;
1340         if (!(termiosp->c_iflag & IXANY))
1341                 csp->t_flags |= O_DECCTQ;
1342         if (termiosp->c_lflag & NOFLSH)
1343                 csp->t_flags |= O_NOFLSH;
1344         if (termiosp->c_lflag & ICANON) {
1345                 TO_COMPAT_CHAR(csp->t_eofc, termiosp->c_cc[VEOF]);
1346                 TO_COMPAT_CHAR(csp->t_brkc, termiosp->c_cc[VEOL]);
1347         } else {
1348                 termiosp->c_cc[VMIN] = 1;
1349                 termiosp->c_cc[VTIME] = 0;
1350         }
1351 }