![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tty.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 41BSD / 4.0.upgrade / sys / dev|
Return to tty.c CVS log | Up to [CSRG BSD Unix] / 41BSD / 4.0.upgrade / sys / dev |
1.1 root 1: /* tty.c 4.12 81/07/22 */
2:
3: /*
4: * TTY subroutines common to more than one line discipline
5: */
6: #include "../h/param.h"
7: #include "../h/systm.h"
8: #include "../h/dir.h"
9: #include "../h/user.h"
10: #include "../h/tty.h"
11: #include "../h/proc.h"
12: #include "../h/mx.h"
13: #include "../h/inode.h"
14: #include "../h/file.h"
15: #include "../h/reg.h"
16: #include "../h/conf.h"
17: #include "../h/buf.h"
18: #include "../h/dk.h"
19:
20: char partab[];
21:
22: /*
23: * Input mapping table-- if an entry is non-zero, when the
24: * corresponding character is typed preceded by "\" the escape
25: * sequence is replaced by the table value. Mostly used for
26: * upper-case only terminals.
27: */
28:
29: char maptab[] ={
30: 000,000,000,000,000,000,000,000,
31: 000,000,000,000,000,000,000,000,
32: 000,000,000,000,000,000,000,000,
33: 000,000,000,000,000,000,000,000,
34: 000,'|',000,000,000,000,000,'`',
35: '{','}',000,000,000,000,000,000,
36: 000,000,000,000,000,000,000,000,
37: 000,000,000,000,000,000,000,000,
38: 000,000,000,000,000,000,000,000,
39: 000,000,000,000,000,000,000,000,
40: 000,000,000,000,000,000,000,000,
41: 000,000,000,000,000,000,'~',000,
42: 000,'A','B','C','D','E','F','G',
43: 'H','I','J','K','L','M','N','O',
44: 'P','Q','R','S','T','U','V','W',
45: 'X','Y','Z',000,000,000,000,000,
46: };
47:
48: short tthiwat[16] =
49: { 100,100,100,100,100,100,100,200,200,400,400,400,650,650,650,650 };
50: short ttlowat[16] =
51: { 30, 30, 30, 30, 30, 30, 30, 50, 50,120,120,120,125,125,125,125 };
52:
53: #define OBUFSIZ 100
54:
55: /*
56: * set default control characters.
57: */
58: ttychars(tp)
59: register struct tty *tp;
60: {
61:
62: tun.t_intrc = CINTR;
63: tun.t_quitc = CQUIT;
64: tun.t_startc = CSTART;
65: tun.t_stopc = CSTOP;
66: tun.t_eofc = CEOT;
67: tun.t_brkc = CBRK;
68: tp->t_erase = CERASE;
69: tp->t_kill = CKILL;
70: /* begin local */
71: tlun.t_suspc = CTRL(z);
72: tlun.t_dsuspc = CTRL(y);
73: tlun.t_rprntc = CTRL(r);
74: tlun.t_flushc = CTRL(o);
75: tlun.t_werasc = CTRL(w);
76: tlun.t_lnextc = CTRL(v);
77: tp->t_local = 0;
78: tp->t_lstate = 0;
79: /* end local */
80: }
81:
82: /*
83: * Wait for output to drain, then flush input waiting.
84: */
85: wflushtty(tp)
86: register struct tty *tp;
87: {
88:
89: (void) spl5();
90: while (tp->t_outq.c_cc && tp->t_state&CARR_ON) {
91: (*tp->t_oproc)(tp);
92: tp->t_state |= ASLEEP;
93: sleep((caddr_t)&tp->t_outq, TTOPRI);
94: }
95: flushtty(tp, FREAD|FWRITE);
96: (void) spl0();
97: }
98:
99: /*
100: * flush all TTY queues
101: */
102: flushtty(tp, rw)
103: register struct tty *tp;
104: {
105: register s;
106:
107: if (tp->t_line == NETLDISC)
108: return;
109: s = spl6();
110: if (rw & FREAD) {
111: while (getc(&tp->t_canq) >= 0)
112: ;
113: wakeup((caddr_t)&tp->t_rawq);
114: }
115: if (rw & FWRITE) {
116: wakeup((caddr_t)&tp->t_outq);
117: tp->t_state &= ~TTSTOP;
118: (*cdevsw[major(tp->t_dev)].d_stop)(tp);
119: while (getc(&tp->t_outq) >= 0)
120: ;
121: }
122: if (rw & FREAD) {
123: while (getc(&tp->t_rawq) >= 0)
124: ;
125: tp->t_delct = 0;
126: tp->t_rocount = 0; /* local */
127: tp->t_rocol = 0;
128: tp->t_lstate = 0;
129: }
130: splx(s);
131: }
132:
133: /*
134: * Send stop character on input overflow.
135: */
136: ttyblock(tp)
137: register struct tty *tp;
138: {
139: register x;
140: x = tp->t_rawq.c_cc + tp->t_canq.c_cc;
141: if (tp->t_rawq.c_cc > TTYHOG) {
142: flushtty(tp, FREAD|FWRITE);
143: tp->t_state &= ~TBLOCK;
144: }
145: if (x >= TTYHOG/2) {
146: if (putc(tun.t_stopc, &tp->t_outq)==0) {
147: tp->t_state |= TBLOCK;
148: tp->t_char++;
149: ttstart(tp);
150: }
151: }
152: }
153:
154: /*
155: * Restart typewriter output following a delay
156: * timeout.
157: * The name of the routine is passed to the timeout
158: * subroutine and it is called during a clock interrupt.
159: */
160: ttrstrt(tp)
161: register struct tty *tp;
162: {
163:
164: if (tp == 0) {
165: printf("ttrstrt: arg was 0!\n");
166: return;
167: }
168: tp->t_state &= ~TIMEOUT;
169: ttstart(tp);
170: }
171:
172: /*
173: * Start output on the typewriter. It is used from the top half
174: * after some characters have been put on the output queue,
175: * from the interrupt routine to transmit the next
176: * character, and after a timeout has finished.
177: */
178: ttstart(tp)
179: register struct tty *tp;
180: {
181: register s;
182:
183: s = spl5();
184: if((tp->t_state&(TIMEOUT|TTSTOP|BUSY)) == 0)
185: (*tp->t_oproc)(tp);
186: splx(s);
187: }
188:
189: /*
190: * Common code for tty ioctls.
191: */
192: /*ARGSUSED*/
193: ttioctl(tp, com, addr, flag)
194: register struct tty *tp;
195: caddr_t addr;
196: {
197: int dev;
198: unsigned t;
199: struct sgttyb iocb;
200: struct clist tq;
201: extern int nldisp;
202: register c;
203: int temp;
204:
205: /*
206: * This is especially so that isatty() will
207: * fail when carrier is gone.
208: */
209: if ((tp->t_state&CARR_ON) == 0) {
210: u.u_error = EBADF;
211: return (1);
212: }
213:
214: dev = tp->t_dev;
215: /*
216: * If the ioctl involves modification,
217: * insist on being able to write the device,
218: * and hang if in the background.
219: */
220: switch(com) {
221:
222: case TIOCSETD:
223: case TIOCSETP:
224: case TIOCSETN:
225: case TIOCFLUSH:
226: case TIOCSETC:
227: case TIOCSLTC:
228: case TIOCSPGRP:
229: case TIOCLBIS:
230: case TIOCLBIC:
231: case TIOCLSET:
232: case TIOCSTI:
233: /* this is reasonable, but impractical...
234: if ((flag & FWRITE) == 0) {
235: u.u_error = EBADF;
236: return (1);
237: }
238: */
239: while (tp->t_line == NTTYDISC &&
240: u.u_procp->p_pgrp != tp->t_pgrp && tp == u.u_ttyp &&
241: (u.u_procp->p_flag&SVFORK) == 0 &&
242: u.u_signal[SIGTTOU] != SIG_IGN &&
243: u.u_signal[SIGTTOU] != SIG_HOLD &&
244: (u.u_procp->p_flag&SDETACH)==0) {
245: gsignal(u.u_procp->p_pgrp, SIGTTOU);
246: sleep((caddr_t)&lbolt, TTOPRI);
247: }
248: break;
249: }
250:
251: /*
252: * Process the ioctl.
253: */
254: switch(com) {
255:
256: /*
257: * Get discipline number
258: */
259: case TIOCGETD:
260: t = tp->t_line;
261: if (copyout((caddr_t)&t, addr, sizeof(t)))
262: u.u_error = EFAULT;
263: break;
264:
265: /*
266: * Set line discipline
267: */
268: case TIOCSETD:
269: if (copyin(addr, (caddr_t)&t, sizeof(t))) {
270: u.u_error = EFAULT;
271: break;
272: }
273: if (t >= nldisp) {
274: u.u_error = ENXIO;
275: break;
276: }
277: (void) spl5();
278: if (tp->t_line)
279: (*linesw[tp->t_line].l_close)(tp);
280: if (t)
281: (*linesw[t].l_open)(dev, tp, addr);
282: if (u.u_error==0)
283: tp->t_line = t;
284: (void) spl0();
285: break;
286:
287: /*
288: * Prevent more opens on channel
289: */
290: case TIOCEXCL:
291: tp->t_state |= XCLUDE;
292: break;
293:
294: case TIOCNXCL:
295: tp->t_state &= ~XCLUDE;
296: break;
297:
298: /*
299: * Set new parameters
300: */
301: case TIOCSETP:
302: case TIOCSETN:
303: if (copyin(addr, (caddr_t)&iocb, sizeof(iocb))) {
304: u.u_error = EFAULT;
305: return(1);
306: }
307: (void) spl5();
308: if (tp->t_line == 0) {
309: if (com == TIOCSETP)
310: wflushtty(tp);
311: while (canon(tp)>=0)
312: ;
313: #ifdef notdef
314: wakeup((caddr_t)&tp->t_rawq);
315: #endif
316: } else if (tp->t_line == NTTYDISC) {
317: if (tp->t_flags&RAW || iocb.sg_flags&RAW ||
318: com == TIOCSETP)
319: wflushtty(tp);
320: else if ((tp->t_flags&CBREAK) != (iocb.sg_flags&CBREAK)) {
321: if (iocb.sg_flags & CBREAK) {
322: catq(&tp->t_rawq, &tp->t_canq);
323: tq = tp->t_rawq;
324: tp->t_rawq = tp->t_canq;
325: tp->t_canq = tq;
326: } else {
327: tp->t_local |= LPENDIN;
328: if (tp->t_canq.c_cc)
329: panic("ioccom canq");
330: #ifdef notdef
331: if (tp->t_chan)
332: (void) sdata(tp->t_chan);
333: else
334: #endif
335: wakeup((caddr_t)&tp->t_rawq);
336: }
337: }
338: }
339: if ((tp->t_state&SPEEDS)==0) {
340: tp->t_ispeed = iocb.sg_ispeed;
341: tp->t_ospeed = iocb.sg_ospeed;
342: }
343: tp->t_erase = iocb.sg_erase;
344: tp->t_kill = iocb.sg_kill;
345: tp->t_flags = iocb.sg_flags;
346: if (tp->t_flags & RAW) {
347: tp->t_state &= ~TTSTOP;
348: ttstart(tp);
349: }
350: (void) spl0();
351: break;
352:
353: /*
354: * Send current parameters to user
355: */
356: case TIOCGETP:
357: iocb.sg_ispeed = tp->t_ispeed;
358: iocb.sg_ospeed = tp->t_ospeed;
359: iocb.sg_erase = tp->t_erase;
360: iocb.sg_kill = tp->t_kill;
361: iocb.sg_flags = tp->t_flags;
362: if (copyout((caddr_t)&iocb, addr, sizeof(iocb)))
363: u.u_error = EFAULT;
364: break;
365:
366: /*
367: * Hang up line on last close
368: */
369: case TIOCHPCL:
370: tp->t_state |= HUPCLS;
371: break;
372:
373: case TIOCFLUSH: {
374: int flags;
375: if (addr == 0)
376: flags = FREAD|FWRITE;
377: else if (copyin(addr, (caddr_t)&flags, sizeof (flags))) {
378: u.u_error = EFAULT;
379: return(1);
380: }
381: flushtty(tp, flags);
382: break;
383: }
384:
385: /*
386: * Set and fetch special characters
387: */
388: case TIOCSETC:
389: if (copyin(addr, (caddr_t)&tun, sizeof(struct tchars)))
390: u.u_error = EFAULT;
391: break;
392:
393: case TIOCGETC:
394: if (copyout((caddr_t)&tun, addr, sizeof(struct tchars)))
395: u.u_error = EFAULT;
396: break;
397:
398: /* local ioctls */
399: /*
400: * Set/get local special characters.
401: */
402: case TIOCSLTC:
403: if (copyin(addr, (caddr_t)&tlun, sizeof (struct ltchars)))
404: u.u_error = EFAULT;
405: break;
406:
407: case TIOCGLTC:
408: if (copyout((caddr_t)&tlun, addr, sizeof (struct ltchars)))
409: u.u_error = EFAULT;
410: break;
411:
412: /*
413: * Return number of characters immediately available.
414: */
415: case FIONREAD: {
416: off_t nread;
417:
418: switch (tp->t_line) {
419:
420: case NETLDISC:
421: nread = tp->t_rec ? tp->t_inbuf : 0;
422: break;
423:
424: case 0:
425: (void) spl5();
426: while (canon(tp)>=0)
427: ;
428: (void) spl0();
429: /* fall into ... */
430:
431: case NTTYDISC:
432: if (tp->t_local & LPENDIN)
433: ntypend(tp);
434: nread = tp->t_canq.c_cc;
435: if (tp->t_flags & (RAW|CBREAK))
436: nread += tp->t_rawq.c_cc;
437: break;
438:
439: }
440: if (copyout((caddr_t)&nread, addr, sizeof (off_t)))
441: u.u_error = EFAULT;
442: break;
443: }
444:
445: /*
446: * Should allow SPGRP and GPGRP only if tty open for reading.
447: */
448: case TIOCSPGRP:
449: if (copyin(addr, (caddr_t)&tp->t_pgrp, sizeof (tp->t_pgrp)))
450: u.u_error = EFAULT;
451: break;
452:
453: case TIOCGPGRP:
454: if (copyout((caddr_t)&tp->t_pgrp, addr, sizeof(tp->t_pgrp)))
455: u.u_error = EFAULT;
456: break;
457:
458: /*
459: * Modify local mode word.
460: */
461: case TIOCLBIS:
462: if (copyin(addr, (caddr_t)&temp, sizeof (tp->t_local)))
463: u.u_error = EFAULT;
464: else
465: tp->t_local |= temp;
466: break;
467:
468: case TIOCLBIC:
469: if (copyin(addr, (caddr_t)&temp, sizeof (tp->t_local)))
470: u.u_error = EFAULT;
471: else
472: tp->t_local &= ~temp;
473: break;
474:
475: case TIOCLSET:
476: if (copyin(addr, (caddr_t)&temp, sizeof (tp->t_local)))
477: u.u_error = EFAULT;
478: else
479: tp->t_local = temp;
480: break;
481:
482: case TIOCLGET:
483: if (copyout((caddr_t)&tp->t_local, addr, sizeof(tp->t_local)))
484: u.u_error = EFAULT;
485: break;
486:
487: /*
488: * Return number of characters in
489: * the output.
490: */
491: case TIOCOUTQ:
492: if (copyout((caddr_t)&tp->t_outq.c_cc, addr, sizeof(tp->t_outq.c_cc)))
493: u.u_error = EFAULT;
494: break;
495:
496: /*
497: * Simulate typing of a character at the terminal.
498: */
499: case TIOCSTI:
500: c = fubyte(addr);
501: if (u.u_uid && u.u_ttyp != tp || c < 0)
502: u.u_error = EFAULT;
503: else
504: (*linesw[tp->t_line].l_rint)(c, tp);
505: break;
506: /* end of locals */
507:
508: default:
509: return(0);
510: }
511: return(1);
512: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.