]> git.saurik.com Git - apple/xnu.git/blob - bsd/kern/tty_pty.c
projects / apple / xnu.git / blob
? search:


05931c126011222e4ae0caa6259fa343e0873170
[apple/xnu.git] / bsd / kern / tty_pty.c
1 /*
2 * Copyright (c) 1997-2006 Apple Computer, Inc. All rights reserved.
3 *
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
5 *
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. The rights granted to you under the License
10 * may not be used to create, or enable the creation or redistribution of,
11 * unlawful or unlicensed copies of an Apple operating system, or to
12 * circumvent, violate, or enable the circumvention or violation of, any
13 * terms of an Apple operating system software license agreement.
14 *
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
17 *
18 * The Original Code and all software distributed under the License are
19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
23 * Please see the License for the specific language governing rights and
24 * limitations under the License.
25 *
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
27 */
28 /*
29 * Copyright (c) 1982, 1986, 1989, 1993
30 * The Regents of the University of California. All rights reserved.
31 *
32 * Redistribution and use in source and binary forms, with or without
33 * modification, are permitted provided that the following conditions
34 * are met:
35 * 1. Redistributions of source code must retain the above copyright
36 * notice, this list of conditions and the following disclaimer.
37 * 2. Redistributions in binary form must reproduce the above copyright
38 * notice, this list of conditions and the following disclaimer in the
39 * documentation and/or other materials provided with the distribution.
40 * 3. All advertising materials mentioning features or use of this software
41 * must display the following acknowledgement:
42 * This product includes software developed by the University of
43 * California, Berkeley and its contributors.
44 * 4. Neither the name of the University nor the names of its contributors
45 * may be used to endorse or promote products derived from this software
46 * without specific prior written permission.
47 *
48 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
49 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
50 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
51 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
52 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
53 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
54 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
55 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
56 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
57 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
58 * SUCH DAMAGE.
59 *
60 * @(#)tty_pty.c 8.4 (Berkeley) 2/20/95
61 */
62
63 /*
64 * Pseudo-teletype Driver
65 * (Actually two drivers, requiring two entries in 'cdevsw')
66 */
67 #include "pty.h" /* XXX */
68
69 #include <sys/param.h>
70 #include <sys/systm.h>
71 #include <sys/ioctl.h>
72 #include <sys/proc_internal.h>
73 #include <sys/kauth.h>
74 #include <sys/tty.h>
75 #include <sys/conf.h>
76 #include <sys/file_internal.h>
77 #include <sys/uio_internal.h>
78 #include <sys/kernel.h>
79 #include <sys/vnode.h>
80 #include <sys/user.h>
81 #include <sys/signalvar.h>
82
83 #define d_devtotty_t struct tty **
84
85 #ifdef d_stop_t
86 #undef d_stop_t
87 #endif
88 typedef void d_stop_t(struct tty *tp, int rw);
89
90 /* XXX function should be removed??? */
91 int pty_init(int n_ptys);
92
93 /* XXX should be a devfs function */
94 int _devfs_setattr(void * handle, unsigned short mode, uid_t uid, gid_t gid);
95
96 static void ptsstart(struct tty *tp);
97 static void ptcwakeup(struct tty *tp, int flag);
98
99 __XNU_PRIVATE_EXTERN d_open_t ptsopen;
100 __XNU_PRIVATE_EXTERN d_close_t ptsclose;
101 __XNU_PRIVATE_EXTERN d_read_t ptsread;
102 __XNU_PRIVATE_EXTERN d_write_t ptswrite;
103 __XNU_PRIVATE_EXTERN d_ioctl_t ptyioctl;
104 __XNU_PRIVATE_EXTERN d_stop_t ptsstop;
105 __XNU_PRIVATE_EXTERN d_devtotty_t ptydevtotty;
106 __XNU_PRIVATE_EXTERN d_open_t ptcopen;
107 __XNU_PRIVATE_EXTERN d_close_t ptcclose;
108 __XNU_PRIVATE_EXTERN d_read_t ptcread;
109 __XNU_PRIVATE_EXTERN d_write_t ptcwrite;
110 __XNU_PRIVATE_EXTERN d_select_t ptcselect;
111
112 #if NPTY == 1
113 #undef NPTY
114 #define NPTY 32 /* crude XXX */
115 #warning You have only one pty defined, redefining to 32.
116 #endif
117
118 #define BUFSIZ 100 /* Chunk size iomoved to/from user */
119
120 /*
121 * pts == /dev/tty[pqrsPQRS][0123456789abcdefghijklmnopqrstuv]
122 * ptc == /dev/pty[pqrsPQRS][0123456789abcdefghijklmnopqrstuv]
123 */
124 /* All references to have been changed to indirections in the file */
125 __private_extern__ struct tty *pt_tty[NPTY] = { NULL };
126
127 static struct pt_ioctl {
128 int pt_flags;
129 struct selinfo pt_selr, pt_selw;
130 u_char pt_send;
131 u_char pt_ucntl;
132 void *pt_devhandle; /* slave device handle for grantpt() */
133 } pt_ioctl[NPTY]; /* XXX */
134 static int npty = NPTY; /* for pstat -t */
135
136 #define PF_PKT 0x08 /* packet mode */
137 #define PF_STOPPED 0x10 /* user told stopped */
138 #define PF_REMOTE 0x20 /* remote and flow controlled input */
139 #define PF_NOSTOP 0x40
140 #define PF_UCNTL 0x80 /* user control mode */
141
142 #ifndef DEVFS
143 int
144 pty_init(__unused int n_ptys)
145 {
146 return 0;
147 }
148 #else
149 #include <miscfs/devfs/devfs.h>
150 #define START_CHAR 'p'
151 #define HEX_BASE 16
152 int
153 pty_init(int n_ptys)
154 {
155 int i;
156 int j;
157
158 /* create the pseudo tty device nodes */
159 for (j = 0; j < 10; j++) {
160 for (i = 0; i < HEX_BASE; i++) {
161 int m = j * HEX_BASE + i;
162 if (m == n_ptys)
163 goto done;
164 pt_ioctl[m].pt_devhandle = devfs_make_node(makedev(4, m),
165 DEVFS_CHAR, UID_ROOT, GID_WHEEL, 0666,
166 "tty%c%x", j + START_CHAR, i);
167 (void)devfs_make_node(makedev(5, m),
168 DEVFS_CHAR, UID_ROOT, GID_WHEEL, 0666,
169 "pty%c%x", j + START_CHAR, i);
170 }
171 }
172 done:
173 return (0);
174 }
175 #endif /* DEVFS */
176
177 __private_extern__ int
178 ptsopen(dev_t dev, int flag, __unused int devtype, __unused struct proc *p)
179 {
180 struct tty *tp;
181 int error;
182
183 /*
184 * You will see this sort of code coming up in diffs later both
185 * the ttymalloc and the tp indirection.
186 */
187 if (minor(dev) >= npty) {
188 error = ENXIO;
189 goto err;
190 }
191 if (!pt_tty[minor(dev)]) {
192 /*
193 * If we can't allocate a new one, act as if we had run out
194 * of device nodes.
195 */
196 if ((tp = pt_tty[minor(dev)] = ttymalloc()) == NULL) {
197 error = ENXIO;
198 goto err;
199 }
200 } else
201 tp = pt_tty[minor(dev)];
202
203 tty_lock(tp);
204
205 if ((tp->t_state & TS_ISOPEN) == 0) {
206 termioschars(&tp->t_termios); /* Set up default chars */
207 tp->t_iflag = TTYDEF_IFLAG;
208 tp->t_oflag = TTYDEF_OFLAG;
209 tp->t_lflag = TTYDEF_LFLAG;
210 tp->t_cflag = TTYDEF_CFLAG;
211 tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED;
212 ttsetwater(tp); /* would be done in xxparam() */
213 } else if (tp->t_state&TS_XCLUDE && suser(kauth_cred_get(), NULL)) {
214 error = EBUSY;
215 goto out;
216 }
217 if (tp->t_oproc) /* Ctrlr still around. */
218 (void)(*linesw[tp->t_line].l_modem)(tp, 1);
219 while ((tp->t_state & TS_CARR_ON) == 0) {
220 if (flag&FNONBLOCK)
221 break;
222 error = ttysleep(tp, TSA_CARR_ON(tp), TTIPRI | PCATCH,
223 "ptsopn", 0);
224 if (error)
225 goto out;
226 }
227 error = (*linesw[tp->t_line].l_open)(dev, tp);
228 if (error == 0)
229 ptcwakeup(tp, FREAD|FWRITE);
230
231 out:
232 tty_unlock(tp);
233 err:
234 return (error);
235 }
236
237 __private_extern__ int
238 ptsclose(dev_t dev, int flag, __unused int mode, __unused proc_t p)
239 {
240 struct tty *tp;
241 int err;
242
243 /*
244 * This is temporary until the VSX conformance tests
245 * are fixed. They are hanging with a deadlock
246 * where close(pts) will not complete without t_timeout set
247 */
248 #define FIX_VSX_HANG 1
249 #ifdef FIX_VSX_HANG
250 int save_timeout;
251 #endif
252
253 tp = pt_tty[minor(dev)];
254 tty_lock(tp);
255 #ifdef FIX_VSX_HANG
256 save_timeout = tp->t_timeout;
257 tp->t_timeout = 60;
258 #endif
259 err = (*linesw[tp->t_line].l_close)(tp, flag);
260 ptsstop(tp, FREAD|FWRITE);
261 (void) ttyclose(tp);
262 #ifdef FIX_VSX_HANG
263 tp->t_timeout = save_timeout;
264 #endif
265 tty_unlock(tp);
266 return (err);
267 }
268
269 __private_extern__ int
270 ptsread(dev_t dev, struct uio *uio, int flag)
271 {
272 struct proc *p = current_proc();
273 struct tty *tp = pt_tty[minor(dev)];
274 struct pt_ioctl *pti = &pt_ioctl[minor(dev)];
275 int error = 0;
276 struct uthread *ut;
277 struct pgrp *pg;
278
279 tty_lock(tp);
280
281 ut = (struct uthread *)get_bsdthread_info(current_thread());
282 again:
283 if (pti->pt_flags & PF_REMOTE) {
284 while (isbackground(p, tp)) {
285 if ((p->p_sigignore & sigmask(SIGTTIN)) ||
286 (ut->uu_sigmask & sigmask(SIGTTIN)) ||
287 p->p_lflag & P_LPPWAIT) {
288 error = EIO;
289 goto out;
290 }
291
292
293 pg = proc_pgrp(p);
294 if (pg == PGRP_NULL) {
295 error = EIO;
296 goto out;
297 }
298 /*
299 * SAFE: We about to drop the lock ourselves by
300 * SAFE: erroring out or sleeping anyway.
301 */
302 tty_unlock(tp);
303 if (pg->pg_jobc == 0) {
304 pg_rele(pg);
305 tty_lock(tp);
306 error = EIO;
307 goto out;
308 }
309 pgsignal(pg, SIGTTIN, 1);
310 pg_rele(pg);
311 tty_lock(tp);
312
313 error = ttysleep(tp, &ptsread, TTIPRI | PCATCH | PTTYBLOCK, "ptsbg",
314 hz);
315 if (error)
316 goto out;
317 }
318 if (tp->t_canq.c_cc == 0) {
319 if (flag & IO_NDELAY) {
320 error = EWOULDBLOCK;
321 goto out;
322 }
323 error = ttysleep(tp, TSA_PTS_READ(tp), TTIPRI | PCATCH,
324 "ptsin", 0);
325 if (error)
326 goto out;
327 goto again;
328 }
329 while (tp->t_canq.c_cc > 1 && uio_resid(uio) > 0) {
330 int cc;
331 char buf[BUFSIZ];
332
333 cc = min(uio_resid(uio), BUFSIZ);
334 // Don't copy the very last byte
335 cc = min(cc, tp->t_canq.c_cc - 1);
336 cc = q_to_b(&tp->t_canq, (u_char *)buf, cc);
337 error = uiomove(buf, cc, uio);
338 if (error)
339 break;
340 }
341 if (tp->t_canq.c_cc == 1)
342 (void) getc(&tp->t_canq);
343 if (tp->t_canq.c_cc)
344 goto out;
345 } else
346 if (tp->t_oproc)
347 error = (*linesw[tp->t_line].l_read)(tp, uio, flag);
348 ptcwakeup(tp, FWRITE);
349 out:
350 tty_unlock(tp);
351 return (error);
352 }
353
354 /*
355 * Write to pseudo-tty.
356 * Wakeups of controlling tty will happen
357 * indirectly, when tty driver calls ptsstart.
358 */
359 __private_extern__ int
360 ptswrite(dev_t dev, struct uio *uio, int flag)
361 {
362 struct tty *tp;
363 int error;
364
365 tp = pt_tty[minor(dev)];
366
367 tty_lock(tp);
368
369 if (tp->t_oproc == 0)
370 error = EIO;
371 else
372 error = (*linesw[tp->t_line].l_write)(tp, uio, flag);
373
374 tty_unlock(tp);
375
376 return (error);
377 }
378
379 /*
380 * Start output on pseudo-tty.
381 * Wake up process selecting or sleeping for input from controlling tty.
382 *
383 * t_oproc for this driver; called from within the line discipline
384 *
385 * Locks: Assumes tp is locked on entry, remains locked on exit
386 */
387 static void
388 ptsstart(struct tty *tp)
389 {
390 struct pt_ioctl *pti = &pt_ioctl[minor(tp->t_dev)];
391
392 if (tp->t_state & TS_TTSTOP)
393 goto out;
394 if (pti->pt_flags & PF_STOPPED) {
395 pti->pt_flags &= ~PF_STOPPED;
396 pti->pt_send = TIOCPKT_START;
397 }
398 ptcwakeup(tp, FREAD);
399 out:
400 return;
401 }
402
403 /*
404 * Locks: Assumes tty_lock() is held over this call.
405 */
406 static void
407 ptcwakeup(struct tty *tp, int flag)
408 {
409 struct pt_ioctl *pti = &pt_ioctl[minor(tp->t_dev)];
410
411 if (flag & FREAD) {
412 selwakeup(&pti->pt_selr);
413 wakeup(TSA_PTC_READ(tp));
414 }
415 if (flag & FWRITE) {
416 selwakeup(&pti->pt_selw);
417 wakeup(TSA_PTC_WRITE(tp));
418 }
419 }
420
421 __private_extern__ int
422 ptcopen(dev_t dev, __unused int flag, __unused int devtype, __unused proc_t p)
423 {
424 struct tty *tp;
425 struct pt_ioctl *pti;
426 int error = 0;
427
428 if (minor(dev) >= npty) {
429 error = ENXIO;
430 goto out;
431 }
432 if(!pt_tty[minor(dev)]) {
433 tp = pt_tty[minor(dev)] = ttymalloc();
434 } else
435 tp = pt_tty[minor(dev)];
436
437 tty_lock(tp);
438
439 /* If master is open OR slave is still draining, pty is still busy */
440 if (tp->t_oproc || (tp->t_state & TS_ISOPEN)) {
441 error = EBUSY;
442 } else {
443 tp->t_oproc = ptsstart;
444 CLR(tp->t_state, TS_ZOMBIE);
445 #ifdef sun4c
446 tp->t_stop = ptsstop;
447 #endif
448 (void)(*linesw[tp->t_line].l_modem)(tp, 1);
449 tp->t_lflag &= ~EXTPROC;
450 pti = &pt_ioctl[minor(dev)];
451 pti->pt_flags = 0;
452 pti->pt_send = 0;
453 pti->pt_ucntl = 0;
454 }
455
456 tty_unlock(tp);
457
458 out:
459 return (error);
460 }
461
462 __private_extern__ int
463 ptcclose(dev_t dev, __unused int flags, __unused int fmt, __unused proc_t p)
464 {
465 struct tty *tp = pt_tty[minor(dev)];
466
467 tty_lock(tp);
468
469 (void)(*linesw[tp->t_line].l_modem)(tp, 0);
470
471 /*
472 * XXX MDMBUF makes no sense for ptys but would inhibit the above
473 * l_modem(). CLOCAL makes sense but isn't supported. Special
474 * l_modem()s that ignore carrier drop make no sense for ptys but
475 * may be in use because other parts of the line discipline make
476 * sense for ptys. Recover by doing everything that a normal
477 * ttymodem() would have done except for sending a SIGHUP.
478 */
479 if (tp->t_state & TS_ISOPEN) {
480 tp->t_state &= ~(TS_CARR_ON | TS_CONNECTED);
481 tp->t_state |= TS_ZOMBIE;
482 ttyflush(tp, FREAD | FWRITE);
483 }
484
485 tp->t_oproc = 0; /* mark closed */
486
487 tty_unlock(tp);
488
489 return (0);
490 }
491
492 __private_extern__ int
493 ptcread(dev_t dev, struct uio *uio, int flag)
494 {
495 struct tty *tp = pt_tty[minor(dev)];
496 struct pt_ioctl *pti = &pt_ioctl[minor(dev)];
497 char buf[BUFSIZ];
498 int error = 0, cc;
499
500 tty_lock(tp);
501
502 /*
503 * We want to block until the slave
504 * is open, and there's something to read;
505 * but if we lost the slave or we're NBIO,
506 * then return the appropriate error instead.
507 */
508 for (;;) {
509 if (tp->t_state&TS_ISOPEN) {
510 if (pti->pt_flags&PF_PKT && pti->pt_send) {
511 error = ureadc((int)pti->pt_send, uio);
512 if (error)
513 goto out;
514 if (pti->pt_send & TIOCPKT_IOCTL) {
515 cc = min(uio_resid(uio),
516 sizeof(tp->t_termios));
517 uiomove((caddr_t)&tp->t_termios, cc,
518 uio);
519 }
520 pti->pt_send = 0;
521 goto out;
522 }
523 if (pti->pt_flags&PF_UCNTL && pti->pt_ucntl) {
524 error = ureadc((int)pti->pt_ucntl, uio);
525 if (error)
526 goto out;
527 pti->pt_ucntl = 0;
528 goto out;
529 }
530 if (tp->t_outq.c_cc && (tp->t_state&TS_TTSTOP) == 0)
531 break;
532 }
533 if ((tp->t_state & TS_CONNECTED) == 0)
534 goto out; /* EOF */
535 if (flag & IO_NDELAY) {
536 error = EWOULDBLOCK;
537 goto out;
538 }
539 error = ttysleep(tp, TSA_PTC_READ(tp), TTIPRI | PCATCH, "ptcin", 0);
540 if (error)
541 goto out;
542 }
543 if (pti->pt_flags & (PF_PKT|PF_UCNTL))
544 error = ureadc(0, uio);
545 while (uio_resid(uio) > 0 && error == 0) {
546 cc = q_to_b(&tp->t_outq, (u_char *)buf, min(uio_resid(uio), BUFSIZ));
547 if (cc <= 0)
548 break;
549 error = uiomove(buf, cc, uio);
550 }
551 (*linesw[tp->t_line].l_start)(tp);
552
553 out:
554 tty_unlock(tp);
555
556 return (error);
557 }
558
559 /*
560 * Line discipline callback
561 *
562 * Locks: tty_lock() is assumed held on entry and exit.
563 */
564 __private_extern__ void
565 ptsstop(struct tty *tp, int flush)
566 {
567 struct pt_ioctl *pti;
568 int flag;
569
570 pti = &pt_ioctl[minor(tp->t_dev)];
571
572 /* note: FLUSHREAD and FLUSHWRITE already ok */
573 if (flush == 0) {
574 flush = TIOCPKT_STOP;
575 pti->pt_flags |= PF_STOPPED;
576 } else
577 pti->pt_flags &= ~PF_STOPPED;
578 pti->pt_send |= flush;
579 /* change of perspective */
580 flag = 0;
581 if (flush & FREAD)
582 flag |= FWRITE;
583 if (flush & FWRITE)
584 flag |= FREAD;
585 ptcwakeup(tp, flag);
586 }
587
588 __private_extern__ int
589 ptcselect(dev_t dev, int rw, void *wql, struct proc *p)
590 {
591 struct tty *tp = pt_tty[minor(dev)];
592 struct pt_ioctl *pti = &pt_ioctl[minor(dev)];
593 int retval = 0;
594
595 tty_lock(tp);
596
597 if ((tp->t_state & TS_CONNECTED) == 0) {
598 retval = 1;
599 goto out;
600 }
601 switch (rw) {
602
603 case FREAD:
604 /*
605 * Need to block timeouts (ttrstart).
606 */
607 if ((tp->t_state&TS_ISOPEN) &&
608 tp->t_outq.c_cc && (tp->t_state&TS_TTSTOP) == 0) {
609 retval = 1;
610 goto out;
611 }
612 /* FALLTHROUGH */
613
614 case 0: /* exceptional */
615 if ((tp->t_state&TS_ISOPEN) &&
616 ((pti->pt_flags&PF_PKT && pti->pt_send) ||
617 (pti->pt_flags&PF_UCNTL && pti->pt_ucntl))) {
618 retval = 1;
619 goto out;
620 }
621 selrecord(p, &pti->pt_selr, wql);
622 break;
623
624
625 case FWRITE:
626 if (tp->t_state&TS_ISOPEN) {
627 if (pti->pt_flags & PF_REMOTE) {
628 if (tp->t_canq.c_cc == 0) {
629 retval = 1;
630 goto out;
631 }
632 } else {
633 if (tp->t_rawq.c_cc + tp->t_canq.c_cc < TTYHOG-2) {
634 retval = 1;
635 goto out;
636 }
637 if (tp->t_canq.c_cc == 0 && (tp->t_lflag&ICANON)) {
638 retval = 1;
639 goto out;
640 }
641 }
642 }
643 selrecord(p, &pti->pt_selw, wql);
644 break;
645
646 }
647 out:
648 tty_unlock(tp);
649
650 return (retval);
651 }
652
653 __private_extern__ int
654 ptcwrite(dev_t dev, struct uio *uio, int flag)
655 {
656 struct tty *tp = pt_tty[minor(dev)];
657 u_char *cp = NULL;
658 int cc = 0;
659 u_char locbuf[BUFSIZ];
660 int wcnt = 0;
661 struct pt_ioctl *pti = &pt_ioctl[minor(dev)];
662 int error = 0;
663
664 tty_lock(tp);
665
666 again:
667 if ((tp->t_state&TS_ISOPEN) == 0)
668 goto block;
669 if (pti->pt_flags & PF_REMOTE) {
670 if (tp->t_canq.c_cc)
671 goto block;
672 while ((uio_resid(uio) > 0 || cc > 0) &&
673 tp->t_canq.c_cc < TTYHOG - 1) {
674 if (cc == 0) {
675 cc = min(uio_resid(uio), BUFSIZ);
676 cc = min(cc, TTYHOG - 1 - tp->t_canq.c_cc);
677 cp = locbuf;
678 error = uiomove((caddr_t)cp, cc, uio);
679 if (error)
680 goto out;
681 /* check again for safety */
682 if ((tp->t_state & TS_ISOPEN) == 0) {
683 /* adjust as usual */
684 uio_setresid(uio, (uio_resid(uio) + cc));
685 error = EIO;
686 goto out;
687 }
688 }
689 if (cc > 0) {
690 cc = b_to_q((u_char *)cp, cc, &tp->t_canq);
691 /*
692 * XXX we don't guarantee that the canq size
693 * is >= TTYHOG, so the above b_to_q() may
694 * leave some bytes uncopied. However, space
695 * is guaranteed for the null terminator if
696 * we don't fail here since (TTYHOG - 1) is
697 * not a multiple of CBSIZE.
698 */
699 if (cc > 0)
700 break;
701 }
702 }
703 /* adjust for data copied in but not written */
704 uio_setresid(uio, (uio_resid(uio) + cc));
705 (void) putc(0, &tp->t_canq);
706 ttwakeup(tp);
707 wakeup(TSA_PTS_READ(tp));
708 goto out;
709 }
710 while (uio_resid(uio) > 0 || cc > 0) {
711 if (cc == 0) {
712 cc = min(uio_resid(uio), BUFSIZ);
713 cp = locbuf;
714 error = uiomove((caddr_t)cp, cc, uio);
715 if (error)
716 goto out;
717 /* check again for safety */
718 if ((tp->t_state & TS_ISOPEN) == 0) {
719 /* adjust for data copied in but not written */
720 uio_setresid(uio, (uio_resid(uio) + cc));
721 error = EIO;
722 goto out;
723 }
724 }
725 while (cc > 0) {
726 if ((tp->t_rawq.c_cc + tp->t_canq.c_cc) >= TTYHOG - 2 &&
727 (tp->t_canq.c_cc > 0 || !(tp->t_lflag&ICANON))) {
728 wakeup(TSA_HUP_OR_INPUT(tp));
729 goto block;
730 }
731 (*linesw[tp->t_line].l_rint)(*cp++, tp);
732 wcnt++;
733 cc--;
734 }
735 cc = 0;
736 }
737 out:
738 tty_unlock(tp);
739
740 return (error);
741
742 block:
743 /*
744 * Come here to wait for slave to open, for space
745 * in outq, or space in rawq, or an empty canq.
746 */
747 if ((tp->t_state & TS_CONNECTED) == 0) {
748 /* adjust for data copied in but not written */
749 uio_setresid(uio, (uio_resid(uio) + cc));
750 error = EIO;
751 goto out;
752 }
753 if (flag & IO_NDELAY) {
754 /* adjust for data copied in but not written */
755 uio_setresid(uio, (uio_resid(uio) + cc));
756 if (wcnt == 0)
757 error = EWOULDBLOCK;
758 goto out;
759 }
760 error = ttysleep(tp, TSA_PTC_WRITE(tp), TTOPRI | PCATCH, "ptcout", 0);
761 if (error) {
762 /* adjust for data copied in but not written */
763 uio_setresid(uio, (uio_resid(uio) + cc));
764 goto out;
765 }
766 goto again;
767 }
768
769 __private_extern__ int
770 ptyioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)
771 {
772 struct tty *tp = pt_tty[minor(dev)];
773 struct pt_ioctl *pti = &pt_ioctl[minor(dev)];
774 u_char *cc = tp->t_cc;
775 int stop, error = 0;
776
777 tty_lock(tp);
778
779 /*
780 * IF CONTROLLER STTY THEN MUST FLUSH TO PREVENT A HANG.
781 * ttywflush(tp) will hang if there are characters in the outq.
782 */
783 if (cmd == TIOCEXT) {
784 /*
785 * When the EXTPROC bit is being toggled, we need
786 * to send an TIOCPKT_IOCTL if the packet driver
787 * is turned on.
788 */
789 if (*(int *)data) {
790 if (pti->pt_flags & PF_PKT) {
791 pti->pt_send |= TIOCPKT_IOCTL;
792 ptcwakeup(tp, FREAD);
793 }
794 tp->t_lflag |= EXTPROC;
795 } else {
796 if ((tp->t_lflag & EXTPROC) &&
797 (pti->pt_flags & PF_PKT)) {
798 pti->pt_send |= TIOCPKT_IOCTL;
799 ptcwakeup(tp, FREAD);
800 }
801 tp->t_lflag &= ~EXTPROC;
802 }
803 goto out;
804 } else
805 if (cdevsw[major(dev)].d_open == ptcopen)
806 switch (cmd) {
807
808 case TIOCGPGRP:
809 /*
810 * We aviod calling ttioctl on the controller since,
811 * in that case, tp must be the controlling terminal.
812 */
813 *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : 0;
814 goto out;
815
816 case TIOCPKT:
817 if (*(int *)data) {
818 if (pti->pt_flags & PF_UCNTL) {
819 error = EINVAL;
820 goto out;
821 }
822 pti->pt_flags |= PF_PKT;
823 } else
824 pti->pt_flags &= ~PF_PKT;
825 goto out;
826
827 case TIOCUCNTL:
828 if (*(int *)data) {
829 if (pti->pt_flags & PF_PKT) {
830 error = EINVAL;
831 goto out;
832 }
833 pti->pt_flags |= PF_UCNTL;
834 } else
835 pti->pt_flags &= ~PF_UCNTL;
836 goto out;
837
838 case TIOCREMOTE:
839 if (*(int *)data)
840 pti->pt_flags |= PF_REMOTE;
841 else
842 pti->pt_flags &= ~PF_REMOTE;
843 ttyflush(tp, FREAD|FWRITE);
844 goto out;
845
846 case TIOCSETP:
847 case TIOCSETN:
848 case TIOCSETD:
849 case TIOCSETA_32:
850 case TIOCSETAW_32:
851 case TIOCSETAF_32:
852 case TIOCSETA_64:
853 case TIOCSETAW_64:
854 case TIOCSETAF_64:
855 ndflush(&tp->t_outq, tp->t_outq.c_cc);
856 break;
857
858 case TIOCSIG:
859 if (*(unsigned int *)data >= NSIG ||
860 *(unsigned int *)data == 0) {
861 error = EINVAL;
862 goto out;
863 }
864 if ((tp->t_lflag&NOFLSH) == 0)
865 ttyflush(tp, FREAD|FWRITE);
866 if ((*(unsigned int *)data == SIGINFO) &&
867 ((tp->t_lflag&NOKERNINFO) == 0))
868 ttyinfo_locked(tp);
869 /*
870 * SAFE: All callers drop the lock on return and
871 * SAFE: the linesw[] will short circut this call
872 * SAFE: if the ioctl() is eaten before the lower
873 * SAFE: level code gets to see it.
874 */
875 tty_unlock(tp);
876 tty_pgsignal(tp, *(unsigned int *)data, 1);
877 tty_lock(tp);
878 goto out;
879
880 case TIOCPTYGRANT: /* grantpt(3) */
881 /*
882 * Change the uid of the slave to that of the calling
883 * thread, change the gid of the slave to GID_TTY,
884 * change the mode to 0620 (rw--w----).
885 */
886 {
887 _devfs_setattr(pti->pt_devhandle, 0620, kauth_getuid(), GID_TTY);
888 goto out;
889 }
890
891 case TIOCPTYGNAME: /* ptsname(3) */
892 /*
893 * Report the name of the slave device in *data
894 * (128 bytes max.). Use the same derivation method
895 * used for calling devfs_make_node() to create it.
896 */
897 snprintf(data, 128, "/dev/tty%c%x",
898 START_CHAR + (minor(dev) / HEX_BASE),
899 minor(dev) % HEX_BASE);
900 error = 0;
901 goto out;
902
903 case TIOCPTYUNLK: /* unlockpt(3) */
904 /*
905 * Unlock the slave device so that it can be opened.
906 */
907 error = 0;
908 goto out;
909 }
910 error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, p);
911 if (error == ENOTTY) {
912 error = ttioctl_locked(tp, cmd, data, flag, p);
913 if (error == ENOTTY) {
914 if (pti->pt_flags & PF_UCNTL && (cmd & ~0xff) == UIOCCMD(0)) {
915 /* Process the UIOCMD ioctl group */
916 if (cmd & 0xff) {
917 pti->pt_ucntl = (u_char)cmd;
918 ptcwakeup(tp, FREAD);
919 }
920 error = 0;
921 goto out;
922 } else if (cmd == TIOCSBRK || cmd == TIOCCBRK) {
923 /*
924 * POSIX conformance; rdar://3936338
925 *
926 * Clear ENOTTY in the case of setting or
927 * clearing a break failing because pty's
928 * don't support break like real serial
929 * ports.
930 */
931 error = 0;
932 goto out;
933 }
934 }
935 }
936
937 /*
938 * If external processing and packet mode send ioctl packet.
939 */
940 if ((tp->t_lflag&EXTPROC) && (pti->pt_flags & PF_PKT)) {
941 switch(cmd) {
942 case TIOCSETA_32:
943 case TIOCSETAW_32:
944 case TIOCSETAF_32:
945 case TIOCSETA_64:
946 case TIOCSETAW_64:
947 case TIOCSETAF_64:
948 case TIOCSETP:
949 case TIOCSETN:
950 case TIOCSETC:
951 case TIOCSLTC:
952 case TIOCLBIS:
953 case TIOCLBIC:
954 case TIOCLSET:
955 pti->pt_send |= TIOCPKT_IOCTL;
956 ptcwakeup(tp, FREAD);
957 default:
958 break;
959 }
960 }
961 stop = (tp->t_iflag & IXON) && CCEQ(cc[VSTOP], CTRL('s'))
962 && CCEQ(cc[VSTART], CTRL('q'));
963 if (pti->pt_flags & PF_NOSTOP) {
964 if (stop) {
965 pti->pt_send &= ~TIOCPKT_NOSTOP;
966 pti->pt_send |= TIOCPKT_DOSTOP;
967 pti->pt_flags &= ~PF_NOSTOP;
968 ptcwakeup(tp, FREAD);
969 }
970 } else {
971 if (!stop) {
972 pti->pt_send &= ~TIOCPKT_DOSTOP;
973 pti->pt_send |= TIOCPKT_NOSTOP;
974 pti->pt_flags |= PF_NOSTOP;
975 ptcwakeup(tp, FREAD);
976 }
977 }
978 out:
979 tty_unlock(tp);
980
981 return (error);
982 }
mirror of XNU