usr/src/uts/common/io/ptem.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, Version 1.0 only
   6  * (the "License").  You may not use this file except in compliance
   7  * with the License.
   8  *
   9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10  * or http://www.opensolaris.org/os/licensing.
  11  * See the License for the specific language governing permissions
  12  * and limitations under the License.
  13  *
  14  * When distributing Covered Code, include this CDDL HEADER in each
  15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16  * If applicable, add the following below this CDDL HEADER, with the
  17  * fields enclosed by brackets "[]" replaced with your own identifying
  18  * information: Portions Copyright [yyyy] [name of copyright owner]
  19  *
  20  * CDDL HEADER END
  21  */
  22 /*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
  23 /*        All Rights Reserved   */
  24
  25
  26 /*
  27  * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
  28  * Use is subject to license terms.
  29  */
  30
  31 #pragma ident   "%Z%%M% %I%     %E% SMI" /* from S5R4 1.13 */
  32
  33 /*
  34  * Description:
  35  *
  36  * The PTEM streams module is used as a pseudo driver emulator.  Its purpose
  37  * is to emulate the ioctl() functions of a terminal device driver.
  38  */
  39
  40 #include <sys/types.h>
  41 #include <sys/param.h>
  42 #include <sys/stream.h>
  43 #include <sys/stropts.h>
  44 #include <sys/strsun.h>
  45 #include <sys/termio.h>
  46 #include <sys/pcb.h>
  47 #include <sys/signal.h>
  48 #include <sys/cred.h>
  49 #include <sys/strtty.h>
  50 #include <sys/errno.h>
  51 #include <sys/cmn_err.h>
  52 #include <sys/jioctl.h>
  53 #include <sys/ptem.h>
  54 #include <sys/ptms.h>
  55 #include <sys/debug.h>
  56 #include <sys/kmem.h>
  57 #include <sys/ddi.h>
  58 #include <sys/sunddi.h>
  59 #include <sys/conf.h>
  60 #include <sys/modctl.h>
  61
  62 extern struct streamtab pteminfo;
  63
  64 static struct fmodsw fsw = {
  65         "ptem",
  66         &pteminfo,
  67         D_MTQPAIR | D_MP
  68 };
  69
  70 static struct modlstrmod modlstrmod = {
  71         &mod_strmodops, "pty hardware emulator", &fsw
  72 };
  73
  74 static struct modlinkage modlinkage = {
  75         MODREV_1, &modlstrmod, NULL
  76 };
  77
  78 int
  79 _init()
  80 {
  81         return (mod_install(&modlinkage));
  82 }
  83
  84 int
  85 _fini()
  86 {
  87         return (mod_remove(&modlinkage));
  88 }
  89
  90 int
  91 _info(struct modinfo *modinfop)
  92 {
  93         return (mod_info(&modlinkage, modinfop));
  94 }
  95
  96 /*
  97  * stream data structure definitions
  98  */
  99 static int ptemopen(queue_t *, dev_t  *, int, int, cred_t *);
 100 static int ptemclose(queue_t *, int, cred_t *);
 101 static void ptemrput(queue_t *, mblk_t *);
 102 static void ptemwput(queue_t *, mblk_t *);
 103 static void ptemwsrv(queue_t *);
 104
 105 static struct module_info ptem_info = {
 106         0xabcd,
 107         "ptem",
 108         0,
 109         512,
 110         512,
 111         128
 112 };
 113
 114 static struct qinit ptemrinit = {
 115         (int (*)()) ptemrput,
 116         NULL,
 117         ptemopen,
 118         ptemclose,
 119         NULL,
 120         &ptem_info,
 121         NULL
 122 };
 123
 124 static struct qinit ptemwinit = {
 125         (int (*)()) ptemwput,
 126         (int (*)()) ptemwsrv,
 127         ptemopen,
 128         ptemclose,
 129         nulldev,
 130         &ptem_info,
 131         NULL
 132 };
 133
 134 struct streamtab pteminfo = {
 135         &ptemrinit,
 136         &ptemwinit,
 137         NULL,
 138         NULL
 139 };
 140
 141 static void     ptioc(queue_t *, mblk_t *, int);
 142 static int      ptemwmsg(queue_t *, mblk_t *);
 143
 144 /*
 145  * ptemopen - open routine gets called when the module gets pushed onto the
 146  * stream.
 147  */
 148 /* ARGSUSED */
 149 static int
 150 ptemopen(
 151         queue_t    *q,          /* pointer to the read side queue */
 152         dev_t   *devp,          /* pointer to stream tail's dev */
 153         int     oflag,          /* the user open(2) supplied flags */
 154         int     sflag,          /* open state flag */
 155         cred_t *credp)          /* credentials */
 156 {
 157         struct ptem *ntp;       /* ptem entry for this PTEM module */
 158         mblk_t *mop;            /* an setopts mblk */
 159         struct stroptions *sop;
 160         struct termios *termiosp;
 161         int len;
 162
 163         if (sflag != MODOPEN)
 164                 return (EINVAL);
 165
 166         if (q->q_ptr != NULL) {
 167                 /* It's already attached. */
 168                 return (0);
 169         }
 170
 171         /*
 172          * Allocate state structure.
 173          */
 174         ntp = kmem_alloc(sizeof (*ntp), KM_SLEEP);
 175
 176         /*
 177          * Allocate a message block, used to pass the zero length message for
 178          * "stty 0".
 179          *
 180          * NOTE: it's better to find out if such a message block can be
 181          *       allocated before it's needed than to not be able to
 182          *       deliver (for possible lack of buffers) when a hang-up
 183          *       occurs.
 184          */
 185         if ((ntp->dack_ptr = allocb(4, BPRI_MED)) == NULL) {
 186                 kmem_free(ntp, sizeof (*ntp));
 187                 return (EAGAIN);
 188         }
 189
 190         /*
 191          * Initialize an M_SETOPTS message to set up hi/lo water marks on
 192          * stream head read queue and add controlling tty if not set.
 193          */
 194         mop = allocb(sizeof (struct stroptions), BPRI_MED);
 195         if (mop == NULL) {
 196                 freemsg(ntp->dack_ptr);
 197                 kmem_free(ntp, sizeof (*ntp));
 198                 return (EAGAIN);
 199         }
 200         mop->b_datap->db_type = M_SETOPTS;
 201         mop->b_wptr += sizeof (struct stroptions);
 202         sop = (struct stroptions *)mop->b_rptr;
 203         sop->so_flags = SO_HIWAT | SO_LOWAT | SO_ISTTY;
 204         sop->so_hiwat = 512;
 205         sop->so_lowat = 256;
 206
 207         /*
 208          * Cross-link.
 209          */
 210         ntp->q_ptr = q;
 211         q->q_ptr = ntp;
 212         WR(q)->q_ptr = ntp;
 213
 214         /*
 215          * Get termios defaults.  These are stored as
 216          * a property in the "options" node.
 217          */
 218         if (ddi_getlongprop(DDI_DEV_T_ANY, ddi_root_node(), 0, "ttymodes",
 219             (caddr_t)&termiosp, &len) == DDI_PROP_SUCCESS &&
 220             len == sizeof (struct termios)) {
 221
 222                 ntp->cflags = termiosp->c_cflag;
 223                 kmem_free(termiosp, len);
 224         } else {
 225                 /*
 226                  * Gack!  Whine about it.
 227                  */
 228                 cmn_err(CE_WARN, "ptem: Couldn't get ttymodes property!");
 229         }
 230         ntp->wsz.ws_row = 0;
 231         ntp->wsz.ws_col = 0;
 232         ntp->wsz.ws_xpixel = 0;
 233         ntp->wsz.ws_ypixel = 0;
 234
 235         ntp->state = 0;
 236
 237         /*
 238          * Commit to the open and send the M_SETOPTS off to the stream head.
 239          */
 240         qprocson(q);
 241         putnext(q, mop);
 242
 243         return (0);
 244 }
 245
 246
 247 /*
 248  * ptemclose - This routine gets called when the module gets popped off of the
 249  * stream.
 250  */
 251 /* ARGSUSED */
 252 static int
 253 ptemclose(queue_t *q, int flag, cred_t *credp)
 254 {
 255         struct ptem *ntp;       /* ptem entry for this PTEM module */
 256
 257         qprocsoff(q);
 258         ntp = (struct ptem *)q->q_ptr;
 259         freemsg(ntp->dack_ptr);
 260         kmem_free(ntp, sizeof (*ntp));
 261         q->q_ptr = WR(q)->q_ptr = NULL;
 262         return (0);
 263 }
 264
 265
 266 /*
 267  * ptemrput - Module read queue put procedure.
 268  *
 269  * This is called from the module or driver downstream.
 270  */
 271 static void
 272 ptemrput(queue_t *q, mblk_t *mp)
 273 {
 274         struct iocblk *iocp;    /* M_IOCTL data */
 275         struct copyresp *resp;  /* transparent ioctl response struct */
 276         int error;
 277
 278         switch (mp->b_datap->db_type) {
 279         case M_DELAY:
 280         case M_READ:
 281                 freemsg(mp);
 282                 break;
 283
 284         case M_IOCTL:
 285                 iocp = (struct iocblk *)mp->b_rptr;
 286
 287                 switch (iocp->ioc_cmd) {
 288                 case TCSBRK:
 289                         /*
 290                          * Send a break message upstream.
 291                          *
 292                          * XXX: Shouldn't the argument come into play in
 293                          *      determining whether or not so send an M_BREAK?
 294                          *      It certainly does in the write-side direction.
 295                          */
 296                         error = miocpullup(mp, sizeof (int));
 297                         if (error != 0) {
 298                                 miocnak(q, mp, 0, error);
 299                                 break;
 300                         }
 301                         if (!(*(int *)mp->b_cont->b_rptr)) {
 302                                 if (!putnextctl(q, M_BREAK)) {
 303                                         /*
 304                                          * Send an NAK reply back
 305                                          */
 306                                         miocnak(q, mp, 0, EAGAIN);
 307                                         break;
 308                                 }
 309                         }
 310                         /*
 311                          * ACK it.
 312                          */
 313                         mioc2ack(mp, NULL, 0, 0);
 314                         qreply(q, mp);
 315                         break;
 316
 317                 case JWINSIZE:
 318                 case TIOCGWINSZ:
 319                 case TIOCSWINSZ:
 320                         ptioc(q, mp, RDSIDE);
 321                         break;
 322
 323                 case TIOCSIGNAL:
 324                         /*
 325                          * The following subtle logic is due to the fact that
 326                          * `mp' may be in any one of three distinct formats:
 327                          *
 328                          *      1. A transparent M_IOCTL with an intptr_t-sized
 329                          *         payload containing the signal number.
 330                          *
 331                          *      2. An I_STR M_IOCTL with an int-sized payload
 332                          *         containing the signal number.
 333                          *
 334                          *      3. An M_IOCDATA with an int-sized payload
 335                          *         containing the signal number.
 336                          */
 337                         if (iocp->ioc_count == TRANSPARENT) {
 338                                 intptr_t sig = *(intptr_t *)mp->b_cont->b_rptr;
 339
 340                                 if (sig < 1 || sig >= NSIG) {
 341                                         /*
 342                                          * it's transparent with pointer
 343                                          * to the arg
 344                                          */
 345                                         mcopyin(mp, NULL, sizeof (int), NULL);
 346                                         qreply(q, mp);
 347                                         break;
 348                                 }
 349                         }
 350                         ptioc(q, mp, RDSIDE);
 351                         break;
 352
 353                 case TIOCREMOTE:
 354                         if (iocp->ioc_count != TRANSPARENT)
 355                                 ptioc(q, mp, RDSIDE);
 356                         else {
 357                                 mcopyin(mp, NULL, sizeof (int), NULL);
 358                                 qreply(q, mp);
 359                         }
 360                         break;
 361
 362                 default:
 363                         putnext(q, mp);
 364                         break;
 365                 }
 366                 break;
 367
 368         case M_IOCDATA:
 369                 resp = (struct copyresp *)mp->b_rptr;
 370                 if (resp->cp_rval) {
 371                         /*
 372                          * Just free message on failure.
 373                          */
 374                         freemsg(mp);
 375                         break;
 376                 }
 377
 378                 /*
 379                  * Only need to copy data for the SET case.
 380                  */
 381                 switch (resp->cp_cmd) {
 382
 383                 case TIOCSWINSZ:
 384                 case TIOCSIGNAL:
 385                 case TIOCREMOTE:
 386                         ptioc(q, mp, RDSIDE);
 387                         break;
 388
 389                 case JWINSIZE:
 390                 case TIOCGWINSZ:
 391                         mp->b_datap->db_type = M_IOCACK;
 392                         mioc2ack(mp, NULL, 0, 0);
 393                         qreply(q, mp);
 394                         break;
 395
 396                 default:
 397                         freemsg(mp);
 398                         break;
 399         }
 400         break;
 401
 402         case M_IOCACK:
 403         case M_IOCNAK:
 404                 /*
 405                  * We only pass write-side ioctls through to the master that
 406                  * we've already ACKed or NAKed to the stream head.  Thus, we
 407                  * discard ones arriving from below, since they're redundant
 408                  * from the point of view of modules above us.
 409                  */
 410                 freemsg(mp);
 411                 break;
 412
 413         case M_HANGUP:
 414                 /*
 415                  * clear blocked state.
 416                  */
 417                 {
 418                         struct ptem *ntp = (struct ptem *)q->q_ptr;
 419                         if (ntp->state & OFLOW_CTL) {
 420                                 ntp->state &= ~OFLOW_CTL;
 421                                 qenable(WR(q));
 422                         }
 423                 }
 424         default:
 425                 putnext(q, mp);
 426                 break;
 427         }
 428 }
 429
 430
 431 /*
 432  * ptemwput - Module write queue put procedure.
 433  *
 434  * This is called from the module or stream head upstream.
 435  *
 436  * XXX: This routine is quite lazy about handling allocation failures,
 437  *      basically just giving up and reporting failure.  It really ought to
 438  *      set up bufcalls and only fail when it's absolutely necessary.
 439  */
 440 static void
 441 ptemwput(queue_t *q, mblk_t *mp)
 442 {
 443         struct ptem *ntp = (struct ptem *)q->q_ptr;
 444         struct iocblk *iocp;    /* outgoing ioctl structure */
 445         struct copyresp *resp;
 446         unsigned char type = mp->b_datap->db_type;
 447
 448         if (type >= QPCTL) {
 449                 switch (type) {
 450
 451                 case M_IOCDATA:
 452                         resp = (struct copyresp *)mp->b_rptr;
 453                         if (resp->cp_rval) {
 454                                 /*
 455                                  * Just free message on failure.
 456                                  */
 457                                 freemsg(mp);
 458                                 break;
 459                         }
 460
 461                         /*
 462                          * Only need to copy data for the SET case.
 463                          */
 464                         switch (resp->cp_cmd) {
 465
 466                                 case TIOCSWINSZ:
 467                                         ptioc(q, mp, WRSIDE);
 468                                         break;
 469
 470                                 case JWINSIZE:
 471                                 case TIOCGWINSZ:
 472                                         mioc2ack(mp, NULL, 0, 0);
 473                                         qreply(q, mp);
 474                                         break;
 475
 476                                 default:
 477                                         freemsg(mp);
 478                         }
 479                         break;
 480
 481                 case M_FLUSH:
 482                         if (*mp->b_rptr & FLUSHW) {
 483                             if ((ntp->state & IS_PTSTTY) &&
 484                                         (*mp->b_rptr & FLUSHBAND))
 485                                 flushband(q, *(mp->b_rptr + 1), FLUSHDATA);
 486                             else
 487                                 flushq(q, FLUSHDATA);
 488                         }
 489                         putnext(q, mp);
 490                         break;
 491
 492                 case M_READ:
 493                         freemsg(mp);
 494                         break;
 495
 496                 case M_STOP:
 497                         /*
 498                          * Set the output flow control state.
 499                          */
 500                         ntp->state |= OFLOW_CTL;
 501                         putnext(q, mp);
 502                         break;
 503
 504                 case M_START:
 505                         /*
 506                          * Relieve the output flow control state.
 507                          */
 508                         ntp->state &= ~OFLOW_CTL;
 509                         putnext(q, mp);
 510                         qenable(q);
 511                         break;
 512                 default:
 513                         putnext(q, mp);
 514                         break;
 515                 }
 516                 return;
 517         }
 518         /*
 519          * If our queue is nonempty or flow control persists
 520          * downstream or module in stopped state, queue this message.
 521          */
 522         if (q->q_first != NULL || !bcanputnext(q, mp->b_band)) {
 523                 /*
 524                  * Exception: ioctls, except for those defined to
 525                  * take effect after output has drained, should be
 526                  * processed immediately.
 527                  */
 528                 switch (type) {
 529
 530                 case M_IOCTL:
 531                         iocp = (struct iocblk *)mp->b_rptr;
 532                         switch (iocp->ioc_cmd) {
 533                         /*
 534                          * Queue these.
 535                          */
 536                         case TCSETSW:
 537                         case TCSETSF:
 538                         case TCSETAW:
 539                         case TCSETAF:
 540                         case TCSBRK:
 541                                 break;
 542
 543                         /*
 544                          * Handle all others immediately.
 545                          */
 546                         default:
 547                                 (void) ptemwmsg(q, mp);
 548                                 return;
 549                         }
 550                         break;
 551
 552                 case M_DELAY: /* tty delays not supported */
 553                         freemsg(mp);
 554                         return;
 555
 556                 case M_DATA:
 557                         if ((mp->b_wptr - mp->b_rptr) < 0) {
 558                                 /*
 559                                  * Free all bad length messages.
 560                                  */
 561                                 freemsg(mp);
 562                                 return;
 563                         } else if ((mp->b_wptr - mp->b_rptr) == 0) {
 564                                 if (!(ntp->state & IS_PTSTTY)) {
 565                                         freemsg(mp);
 566                                         return;
 567                                 }
 568                         }
 569                 }
 570                 (void) putq(q, mp);
 571                 return;
 572         }
 573         /*
 574          * fast path into ptemwmsg to dispose of mp.
 575          */
 576         if (!ptemwmsg(q, mp))
 577                 (void) putq(q, mp);
 578 }
 579
 580 /*
 581  * ptem write queue service procedure.
 582  */
 583 static void
 584 ptemwsrv(queue_t *q)
 585 {
 586         mblk_t *mp;
 587
 588         while ((mp = getq(q)) != NULL) {
 589                 if (!bcanputnext(q, mp->b_band) || !ptemwmsg(q, mp)) {
 590                         (void) putbq(q, mp);
 591                         break;
 592                 }
 593         }
 594 }
 595
 596
 597 /*
 598  * This routine is called from both ptemwput and ptemwsrv to do the
 599  * actual work of dealing with mp.  ptmewput will have already
 600  * dealt with high priority messages.
 601  *
 602  * Return 1 if the message was processed completely and 0 if not.
 603  */
 604 static int
 605 ptemwmsg(queue_t *q, mblk_t *mp)
 606 {
 607         struct ptem *ntp = (struct ptem *)q->q_ptr;
 608         struct iocblk *iocp;    /* outgoing ioctl structure */
 609         struct termio *termiop;
 610         struct termios *termiosp;
 611         mblk_t *dack_ptr;               /* disconnect message ACK block */
 612         mblk_t *pckt_msgp;              /* message sent to the PCKT module */
 613         mblk_t *dp;                     /* ioctl reply data */
 614         tcflag_t cflags;
 615         int error;
 616
 617         switch (mp->b_datap->db_type) {
 618
 619         case M_IOCTL:
 620                 /*
 621                  * Note:  for each "set" type operation a copy
 622                  * of the M_IOCTL message is made and passed
 623                  * downstream.  Eventually the PCKT module, if
 624                  * it has been pushed, should pick up this message.
 625                  * If the PCKT module has not been pushed the master
 626                  * side stream head will free it.
 627                  */
 628                 iocp = (struct iocblk *)mp->b_rptr;
 629                 switch (iocp->ioc_cmd) {
 630
 631                 case TCSETAF:
 632                 case TCSETSF:
 633                         /*
 634                          * Flush the read queue.
 635                          */
 636                         if (putnextctl1(q, M_FLUSH, FLUSHR) == 0) {
 637                                 miocnak(q, mp, 0, EAGAIN);
 638                                 break;
 639                         }
 640                         /* FALLTHROUGH */
 641
 642                 case TCSETA:
 643                 case TCSETAW:
 644                 case TCSETS:
 645                 case TCSETSW:
 646
 647                         switch (iocp->ioc_cmd) {
 648                         case TCSETAF:
 649                         case TCSETA:
 650                         case TCSETAW:
 651                                 error = miocpullup(mp, sizeof (struct termio));
 652                                 if (error != 0) {
 653                                         miocnak(q, mp, 0, error);
 654                                         goto out;
 655                                 }
 656                                 cflags = ((struct termio *)
 657                                     mp->b_cont->b_rptr)->c_cflag;
 658                                 ntp->cflags =
 659                                     (ntp->cflags & 0xffff0000 | cflags);
 660                                 break;
 661
 662                         case TCSETSF:
 663                         case TCSETS:
 664                         case TCSETSW:
 665                                 error = miocpullup(mp, sizeof (struct termios));
 666                                 if (error != 0) {
 667                                         miocnak(q, mp, 0, error);
 668                                         goto out;
 669                                 }
 670                                 cflags = ((struct termios *)
 671                                     mp->b_cont->b_rptr)->c_cflag;
 672                                 ntp->cflags = cflags;
 673                                 break;
 674                         }
 675
 676                         if ((cflags & CBAUD) == B0) {
 677                                 /*
 678                                  * Hang-up: Send a zero length message.
 679                                  */
 680                                 dack_ptr = ntp->dack_ptr;
 681
 682                                 if (dack_ptr) {
 683                                         ntp->dack_ptr = NULL;
 684                                         /*
 685                                          * Send a zero length message
 686                                          * downstream.
 687                                          */
 688                                         putnext(q, dack_ptr);
 689                                 }
 690                         } else {
 691                                 /*
 692                                  * Make a copy of this message and pass it on
 693                                  * to the PCKT module.
 694                                  */
 695                                 if ((pckt_msgp = copymsg(mp)) == NULL) {
 696                                         miocnak(q, mp, 0, EAGAIN);
 697                                         break;
 698                                 }
 699                                 putnext(q, pckt_msgp);
 700                         }
 701                         /*
 702                          * Send ACK upstream.
 703                          */
 704                         mioc2ack(mp, NULL, 0, 0);
 705                         qreply(q, mp);
 706 out:
 707                         break;
 708
 709                 case TCGETA:
 710                         dp = allocb(sizeof (struct termio), BPRI_MED);
 711                         if (dp == NULL) {
 712                                 miocnak(q, mp, 0, EAGAIN);
 713                                 break;
 714                         }
 715                         termiop = (struct termio *)dp->b_rptr;
 716                         termiop->c_cflag = (ushort_t)ntp->cflags;
 717                         mioc2ack(mp, dp, sizeof (struct termio), 0);
 718                         qreply(q, mp);
 719                         break;
 720
 721                 case TCGETS:
 722                         dp = allocb(sizeof (struct termios), BPRI_MED);
 723                         if (dp == NULL) {
 724                                 miocnak(q, mp, 0, EAGAIN);
 725                                 break;
 726                         }
 727                         termiosp = (struct termios *)dp->b_rptr;
 728                         termiosp->c_cflag = ntp->cflags;
 729                         mioc2ack(mp, dp, sizeof (struct termios), 0);
 730                         qreply(q, mp);
 731                         break;
 732
 733                 case TCSBRK:
 734                         error = miocpullup(mp, sizeof (int));
 735                         if (error != 0) {
 736                                 miocnak(q, mp, 0, error);
 737                                 break;
 738                         }
 739
 740                         /*
 741                          * Need a copy of this message to pass it on to
 742                          * the PCKT module.
 743                          */
 744                         if ((pckt_msgp = copymsg(mp)) == NULL) {
 745                                 miocnak(q, mp, 0, EAGAIN);
 746                                 break;
 747                         }
 748                         /*
 749                          * Send a copy of the M_IOCTL to the PCKT module.
 750                          */
 751                         putnext(q, pckt_msgp);
 752
 753                         /*
 754                          * TCSBRK meaningful if data part of message is 0
 755                          * cf. termio(7).
 756                          */
 757                         if (!(*(int *)mp->b_cont->b_rptr))
 758                                 (void) putnextctl(q, M_BREAK);
 759                         /*
 760                          * ACK the ioctl.
 761                          */
 762                         mioc2ack(mp, NULL, 0, 0);
 763                         qreply(q, mp);
 764                         break;
 765
 766                 case JWINSIZE:
 767                 case TIOCGWINSZ:
 768                 case TIOCSWINSZ:
 769                         ptioc(q, mp, WRSIDE);
 770                         break;
 771
 772                 case TIOCSTI:
 773                         /*
 774                          * Simulate typing of a character at the terminal.  In
 775                          * all cases, we acknowledge the ioctl and pass a copy
 776                          * of it along for the PCKT module to encapsulate.  If
 777                          * not in remote mode, we also process the ioctl
 778                          * itself, looping the character given as its argument
 779                          * back around to the read side.
 780                          */
 781
 782                         /*
 783                          * Need a copy of this message to pass on to the PCKT
 784                          * module.
 785                          */
 786                         if ((pckt_msgp = copymsg(mp)) == NULL) {
 787                                 miocnak(q, mp, 0, EAGAIN);
 788                                 break;
 789                         }
 790                         if ((ntp->state & REMOTEMODE) == 0) {
 791                                 mblk_t *bp;
 792
 793                                 error = miocpullup(mp, sizeof (char));
 794                                 if (error != 0) {
 795                                         freemsg(pckt_msgp);
 796                                         miocnak(q, mp, 0, error);
 797                                         break;
 798                                 }
 799
 800                                 /*
 801                                  * The permission checking has already been
 802                                  * done at the stream head, since it has to be
 803                                  * done in the context of the process doing
 804                                  * the call.
 805                                  */
 806                                 if ((bp = allocb(1, BPRI_MED)) == NULL) {
 807                                         freemsg(pckt_msgp);
 808                                         miocnak(q, mp, 0, EAGAIN);
 809                                         break;
 810                                 }
 811                                 /*
 812                                  * XXX: Is EAGAIN really the right response to
 813                                  *      flow control blockage?
 814                                  */
 815                                 if (!bcanputnext(RD(q), mp->b_band)) {
 816                                         freemsg(bp);
 817                                         freemsg(pckt_msgp);
 818                                         miocnak(q, mp, 0, EAGAIN);
 819                                         break;
 820                                 }
 821                                 *bp->b_wptr++ = *mp->b_cont->b_rptr;
 822                                 qreply(q, bp);
 823                         }
 824
 825                         putnext(q, pckt_msgp);
 826                         mioc2ack(mp, NULL, 0, 0);
 827                         qreply(q, mp);
 828                         break;
 829
 830                 case PTSSTTY:
 831                         if (ntp->state & IS_PTSTTY) {
 832                                 miocnak(q, mp, 0, EEXIST);
 833                         } else {
 834                                 ntp->state |= IS_PTSTTY;
 835                                 mioc2ack(mp, NULL, 0, 0);
 836                                 qreply(q, mp);
 837                         }
 838                         break;
 839
 840                 default:
 841                         /*
 842                          * End of the line.  The slave driver doesn't see any
 843                          * ioctls that we don't explicitly pass along to it.
 844                          */
 845                         miocnak(q, mp, 0, EINVAL);
 846                         break;
 847                 }
 848                 break;
 849
 850         case M_DELAY: /* tty delays not supported */
 851                 freemsg(mp);
 852                 break;
 853
 854         case M_DATA:
 855                 if ((mp->b_wptr - mp->b_rptr) < 0) {
 856                         /*
 857                          * Free all bad length messages.
 858                          */
 859                         freemsg(mp);
 860                         break;
 861                 } else if ((mp->b_wptr - mp->b_rptr) == 0) {
 862                         if (!(ntp->state & IS_PTSTTY)) {
 863                                 freemsg(mp);
 864                                 break;
 865                         }
 866                 }
 867                 if (ntp->state & OFLOW_CTL)
 868                         return (0);
 869
 870         default:
 871                 putnext(q, mp);
 872                 break;
 873
 874         }
 875
 876         return (1);
 877 }
 878
 879 /*
 880  * Message must be of type M_IOCTL or M_IOCDATA for this routine to be called.
 881  */
 882 static void
 883 ptioc(queue_t *q, mblk_t *mp, int qside)
 884 {
 885         struct ptem *tp;
 886         struct iocblk *iocp;
 887         struct winsize *wb;
 888         struct jwinsize *jwb;
 889         mblk_t *tmp;
 890         mblk_t *pckt_msgp;      /* message sent to the PCKT module */
 891         int error;
 892
 893         iocp = (struct iocblk *)mp->b_rptr;
 894         tp = (struct ptem *)q->q_ptr;
 895
 896         switch (iocp->ioc_cmd) {
 897
 898         case JWINSIZE:
 899                 /*
 900                  * For compatibility:  If all zeros, NAK the message for dumb
 901                  * terminals.
 902                  */
 903                 if ((tp->wsz.ws_row == 0) && (tp->wsz.ws_col == 0) &&
 904                     (tp->wsz.ws_xpixel == 0) && (tp->wsz.ws_ypixel == 0)) {
 905                         miocnak(q, mp, 0, EINVAL);
 906                         return;
 907                 }
 908
 909                 tmp = allocb(sizeof (struct jwinsize), BPRI_MED);
 910                 if (tmp == NULL) {
 911                         miocnak(q, mp, 0, EAGAIN);
 912                         return;
 913                 }
 914
 915                 if (iocp->ioc_count == TRANSPARENT)
 916                         mcopyout(mp, NULL, sizeof (struct jwinsize), NULL, tmp);
 917                 else
 918                         mioc2ack(mp, tmp, sizeof (struct jwinsize), 0);
 919
 920                 jwb = (struct jwinsize *)mp->b_cont->b_rptr;
 921                 jwb->bytesx = tp->wsz.ws_col;
 922                 jwb->bytesy = tp->wsz.ws_row;
 923                 jwb->bitsx = tp->wsz.ws_xpixel;
 924                 jwb->bitsy = tp->wsz.ws_ypixel;
 925
 926                 qreply(q, mp);
 927                 return;
 928
 929         case TIOCGWINSZ:
 930                 /*
 931                  * If all zeros NAK the message for dumb terminals.
 932                  */
 933                 if ((tp->wsz.ws_row == 0) && (tp->wsz.ws_col == 0) &&
 934                     (tp->wsz.ws_xpixel == 0) && (tp->wsz.ws_ypixel == 0)) {
 935                         miocnak(q, mp, 0, EINVAL);
 936                         return;
 937                 }
 938
 939                 tmp = allocb(sizeof (struct winsize), BPRI_MED);
 940                 if (tmp == NULL) {
 941                         miocnak(q, mp, 0, EAGAIN);
 942                         return;
 943                 }
 944
 945                 mioc2ack(mp, tmp, sizeof (struct winsize), 0);
 946
 947                 wb = (struct winsize *)mp->b_cont->b_rptr;
 948                 wb->ws_row = tp->wsz.ws_row;
 949                 wb->ws_col = tp->wsz.ws_col;
 950                 wb->ws_xpixel = tp->wsz.ws_xpixel;
 951                 wb->ws_ypixel = tp->wsz.ws_ypixel;
 952
 953                 qreply(q, mp);
 954                 return;
 955
 956         case TIOCSWINSZ:
 957                 error = miocpullup(mp, sizeof (struct winsize));
 958                 if (error != 0) {
 959                         miocnak(q, mp, 0, error);
 960                         return;
 961                 }
 962
 963                 wb = (struct winsize *)mp->b_cont->b_rptr;
 964                 /*
 965                  * Send a SIGWINCH signal if the row/col information has
 966                  * changed.
 967                  */
 968                 if ((tp->wsz.ws_row != wb->ws_row) ||
 969                     (tp->wsz.ws_col != wb->ws_col) ||
 970                     (tp->wsz.ws_xpixel != wb->ws_xpixel) ||
 971                     (tp->wsz.ws_ypixel != wb->ws_xpixel)) {
 972                         /*
 973                          * SIGWINCH is always sent upstream.
 974                          */
 975                         if (qside == WRSIDE)
 976                                 (void) putnextctl1(RD(q), M_SIG, SIGWINCH);
 977                         else if (qside == RDSIDE)
 978                                 (void) putnextctl1(q, M_SIG, SIGWINCH);
 979                         /*
 980                          * Message may have come in as an M_IOCDATA; pass it
 981                          * to the master side as an M_IOCTL.
 982                          */
 983                         mp->b_datap->db_type = M_IOCTL;
 984                         if (qside == WRSIDE) {
 985                                 /*
 986                                  * Need a copy of this message to pass on to
 987                                  * the PCKT module, only if the M_IOCTL
 988                                  * orginated from the slave side.
 989                                  */
 990                                 if ((pckt_msgp = copymsg(mp)) == NULL) {
 991                                         miocnak(q, mp, 0, EAGAIN);
 992                                         return;
 993                                 }
 994                                 putnext(q, pckt_msgp);
 995                         }
 996                         tp->wsz.ws_row = wb->ws_row;
 997                         tp->wsz.ws_col = wb->ws_col;
 998                         tp->wsz.ws_xpixel = wb->ws_xpixel;
 999                         tp->wsz.ws_ypixel = wb->ws_ypixel;
1000                 }
1001
1002                 mioc2ack(mp, NULL, 0, 0);
1003                 qreply(q, mp);
1004                 return;
1005
1006         case TIOCSIGNAL: {
1007                 /*
1008                  * This ioctl can emanate from the master side in remote
1009                  * mode only.
1010                  */
1011                 int     sig;
1012
1013                 if (DB_TYPE(mp) == M_IOCTL && iocp->ioc_count != TRANSPARENT) {
1014                         error = miocpullup(mp, sizeof (int));
1015                         if (error != 0) {
1016                                 miocnak(q, mp, 0, error);
1017                                 return;
1018                         }
1019                 }
1020
1021                 if (DB_TYPE(mp) == M_IOCDATA || iocp->ioc_count != TRANSPARENT)
1022                         sig = *(int *)mp->b_cont->b_rptr;
1023                 else
1024                         sig = (int)*(intptr_t *)mp->b_cont->b_rptr;
1025
1026                 if (sig < 1 || sig >= NSIG) {
1027                         miocnak(q, mp, 0, EINVAL);
1028                         return;
1029                 }
1030
1031                 /*
1032                  * Send an M_PCSIG message up the slave's read side and
1033                  * respond back to the master with an ACK or NAK as
1034                  * appropriate.
1035                  */
1036                 if (putnextctl1(q, M_PCSIG, sig) == 0) {
1037                         miocnak(q, mp, 0, EAGAIN);
1038                         return;
1039                 }
1040
1041                 mioc2ack(mp, NULL, 0, 0);
1042                 qreply(q, mp);
1043                 return;
1044             }
1045
1046         case TIOCREMOTE: {
1047                 int     onoff;
1048                 mblk_t  *mctlp;
1049
1050                 if (DB_TYPE(mp) == M_IOCTL) {
1051                         error = miocpullup(mp, sizeof (int));
1052                         if (error != 0) {
1053                                 miocnak(q, mp, 0, error);
1054                                 return;
1055                         }
1056                 }
1057
1058                 onoff = *(int *)mp->b_cont->b_rptr;
1059
1060                 /*
1061                  * Send M_CTL up using the iocblk format.
1062                  */
1063                 mctlp = mkiocb(onoff ? MC_NO_CANON : MC_DO_CANON);
1064                 if (mctlp == NULL) {
1065                         miocnak(q, mp, 0, EAGAIN);
1066                         return;
1067                 }
1068                 mctlp->b_datap->db_type = M_CTL;
1069                 putnext(q, mctlp);
1070
1071                 /*
1072                  * ACK the ioctl.
1073                  */
1074                 mioc2ack(mp, NULL, 0, 0);
1075                 qreply(q, mp);
1076
1077                 /*
1078                  * Record state change.
1079                  */
1080                 if (onoff)
1081                         tp->state |= REMOTEMODE;
1082                 else
1083                         tp->state &= ~REMOTEMODE;
1084                 return;
1085             }
1086
1087         default:
1088                 putnext(q, mp);
1089                 return;
1090         }
1091 }