![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ttyld.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / sys / dev|
Return to ttyld.c CVS log | Up to [Research Unix] / researchv9 / sys / dev |
1.1 root 1: #include "../h/param.h"
2: #include "../h/stream.h"
3: #include "../h/ttyio.h"
4: #include "../h/ttyld.h"
5: #include "../h/conf.h"
6: #include "tty.h"
7:
8: extern char partab[];
9:
10: #define CANBSIZ 256 /* size of largest input line */
11:
12: struct ttyld tty[NTTY];
13:
14: char maptab[] = {
15: 000,000,000,000,000,000,000,000,
16: 000,000,000,000,000,000,000,000,
17: 000,000,000,000,000,000,000,000,
18: 000,000,000,000,000,000,000,000,
19: 000,'|',000,000,000,000,000,'`',
20: '{','}',000,000,000,000,000,000,
21: 000,000,000,000,000,000,000,000,
22: 000,000,000,000,000,000,000,000,
23: 000,000,000,000,000,000,000,000,
24: 000,000,000,000,000,000,000,000,
25: 000,000,000,000,000,000,000,000,
26: 000,000,000,000,'\\',000,'~',000,
27: 000,'A','B','C','D','E','F','G',
28: 'H','I','J','K','L','M','N','O',
29: 'P','Q','R','S','T','U','V','W',
30: 'X','Y','Z',000,000,000,000,000,
31: };
32:
33: int ttyopen(), ttyclose(), ttyldin(), ttyinsrv(), ttyosrv();
34: static struct qinit ttrinit = { ttyldin, ttyinsrv, ttyopen, ttyclose, 600, 60};
35: static struct qinit ttwinit = { putq, ttyosrv, ttyopen, ttyclose, 300, 200};
36: struct streamtab ttyinfo = { &ttrinit, &ttwinit};
37:
38: /*
39: * TTY open
40: */
41: ttyopen(qp, dev)
42: register struct queue *qp;
43: {
44: register struct ttyld *tp;
45: static struct tchars tchars = {CINTR,CQUIT,CSTART,CSTOP,CEOT,0377};
46:
47: if (qp->ptr) /* already attached */
48: return(1);
49: for (tp = tty; tp->t_state&TTUSE; tp++)
50: if (tp >= &tty[NTTY-1])
51: return(0);
52: tp->t_state = TTUSE;
53: tp->t_flags = ECHO|CRMOD;
54: tp->t_delct = 0;
55: tp->t_col = 0;
56: tp->t_erase = CERASE;
57: tp->t_kill = CKILL;
58: tp->t_chr = tchars;
59: qp->ptr = (caddr_t)tp;
60: qp->flag |= QDELIM|QNOENB;
61: WR(qp)->ptr = (caddr_t)tp;
62: return(1);
63: }
64:
65: ttyclose(qp)
66: register struct queue *qp;
67: {
68: register struct ttyld *tp = (struct ttyld *)qp->ptr;
69:
70: tp->t_state = 0;
71: }
72:
73: /*
74: * Queue put procedure for tty input
75: */
76: ttyldin(q, bp)
77: struct queue *q;
78: register struct block *bp;
79: {
80: register struct ttyld *tp;
81: register c;
82: register struct queue *wrq = WR(q); /* writer side */
83: int escape, flags;
84:
85: tp = (struct ttyld *)q->ptr;
86: flags = tp->t_flags;
87: if (bp->type!=M_DATA) {
88: switch(bp->type) {
89:
90: case M_DELIM:
91: freeb(bp);
92: return;
93:
94: case M_BREAK:
95: if (tp->t_flags&RAW) { /* speed-change hack*/
96: bp->type = M_DATA;
97: if (bp->wptr<bp->lim)
98: *bp->wptr++ = '\0';
99: break;
100: }
101: ttysig(q, SIGINT);
102: freeb(bp);
103: return;
104:
105: case M_HANGUP:
106: case M_IOCACK:
107: case M_IOCNAK:
108: (*q->next->qinfo->putp)(q->next, bp);
109: return;
110:
111: case M_IOCTL:
112: ttldioc(WR(q), bp, q, 1);
113: return;
114: }
115: flags |= RAW;
116: }
117: if (tp->t_flags&TANDEM && tp->t_state&TTBLOCK
118: && q->count <= q->qinfo->lolimit) {
119: tp->t_state &= ~TTBLOCK;
120: putd(putq, WR(q), tp->t_chr.t_startc);
121: }
122: if (flags&RAW) {
123: if ((q->next->flag&QFULL)==0 && q->count==0)
124: (*q->next->qinfo->putp)(q->next, bp);
125: else
126: putq(q, bp);
127: return;
128: }
129: while (bp->rptr<bp->wptr) {
130: c = *bp->rptr++ & 0177;
131: if (tp->t_state&TTSTOP) {
132: if (c==tp->t_chr.t_startc || c==tp->t_chr.t_intrc) {
133: tp->t_state &= ~TTSTOP;
134: putctl(wrq->next, M_START);
135: }
136: } else {
137: if (c==tp->t_chr.t_stopc) {
138: tp->t_state |= TTSTOP;
139: putctl(wrq->next, M_STOP);
140: }
141: }
142: if (c==tp->t_chr.t_stopc || c==tp->t_chr.t_startc)
143: continue;
144: if (c==tp->t_chr.t_intrc) {
145: ttysig(q, SIGINT);
146: continue;
147: }
148: if (c==tp->t_chr.t_quitc) {
149: ttysig(q, SIGQUIT);
150: continue;
151: }
152: if (c=='\r' && tp->t_flags&CRMOD)
153: c = '\n';
154: if (tp->t_flags&LCASE && c>='A' && c<='Z')
155: c += 'a'-'A';
156: escape = 0;
157: if (tp->t_flags & CBREAK) {
158: if ((q->next->flag&QFULL)==0 && q->count==0)
159: putd(q->next->qinfo->putp, q->next, c);
160: else
161: putd(putq, q, c);
162: } else {
163: if (tp->t_state&TTESC) {
164: escape = 1;
165: c |= 0200;
166: }
167: if (c == '\\')
168: tp->t_state |= TTESC;
169: else {
170: tp->t_state &= ~TTESC;
171: if (c == ('\\'|0200)) {
172: c &= 0177;
173: tp->t_state |= TTESC;
174: }
175: /* ttyhog? */
176: if (q->count<512 || (c=='\n' && tp->t_delct==0))
177: putd(putq, q, c);
178: else
179: c = '\007';
180: }
181: c &= 0177;
182: if (c=='\n'||c==tp->t_chr.t_eofc||c==tp->t_chr.t_brkc) {
183: register struct block *bp1;
184: if (bp1 = allocb(1)) {
185: bp1->type = M_DELIM;
186: putq(q, bp1);
187: tp->t_delct++;
188: }
189: qenable(q);
190: }
191: }
192: if (tp->t_flags&TANDEM && (tp->t_state&TTBLOCK) == 0
193: && q->count >= (q->qinfo->limit+q->qinfo->lolimit)/2 ) {
194: q->next->flag |= QWANTW;
195: tp->t_state |= TTBLOCK;
196: putd(putq, wrq, tp->t_chr.t_stopc);
197: }
198: if (tp->t_flags&ECHO && (wrq->flag&QFULL)==0) {
199: register c1 = c&0177;
200: if (c1!=CEOT) {
201: putd(putq, wrq, c1);
202: if(wrq->next->flag&QDELIM && bp->wptr==bp->rptr)
203: putctl(wrq, M_DELIM);
204: }
205: if (c==tp->t_kill && (tp->t_flags&CBREAK)==0
206: && !escape) {
207: putd(putq, wrq, '\n');
208: if (wrq->next->flag&QDELIM)
209: putctl(wrq, M_DELIM);
210: }
211: }
212: }
213: freeb(bp);
214: }
215:
216: /*
217: * tty input server processing. Erase-kill and escape processing;
218: * gathering into lines.
219: */
220:
221: ttyinsrv(q)
222: register struct queue *q;
223: {
224: register struct ttyld *tp;
225: register struct block *bp;
226: register char *op;
227: register c;
228: static char canonb[CANBSIZ];
229:
230: tp = (struct ttyld *)q->ptr;
231: if (q->next->flag&QFULL)
232: return;
233: if (tp->t_flags&(CBREAK|RAW)) {
234: while ((q->next->flag&QFULL)==0 && (bp = getq(q)))
235: (*q->next->qinfo->putp)(q->next, bp);
236: } else {
237: op = canonb;
238: while (tp->t_delct) {
239: bp = getq(q);
240: if (bp==NULL || bp->type!=M_DATA) {
241: if (op > canonb)
242: putcpy(q->next, canonb, op-canonb);
243: if (bp) {
244: (*q->next->qinfo->putp)(q->next, bp);
245: tp->t_delct--;
246: op = canonb;
247: continue;
248: }
249: return;
250: }
251: while (bp->rptr<bp->wptr) {
252: c = *bp->rptr++;
253: if ((c&0200) == 0) { /* not escaped */
254: if (c == tp->t_erase) {
255: if (op > canonb)
256: op--;
257: continue;
258: }
259: if (c == tp->t_kill) {
260: op = canonb;
261: continue;
262: }
263: if (c == tp->t_chr.t_eofc)
264: continue;
265: } else {
266: c &= 0177;
267: if (tp->t_flags&LCASE && maptab[c])
268: c = maptab[c];
269: else if (c==tp->t_erase || c==tp->t_kill
270: || c==tp->t_chr.t_eofc)
271: ;
272: else
273: *op++ = '\\';
274: }
275: *op++ = c;
276: if (op >= &canonb[CANBSIZ-1]) {
277: putcpy(q->next, canonb, op-canonb);
278: op = canonb;
279: }
280: }
281: freeb(bp);
282: }
283: }
284: if (tp->t_flags&TANDEM && tp->t_state&TTBLOCK
285: && q->count <= q->qinfo->lolimit) {
286: tp->t_state &= ~TTBLOCK;
287: putd(putq, WR(q), tp->t_chr.t_startc);
288: }
289: }
290:
291: /*
292: * TTY write processing: delays, tabs, CR/NL and the like.
293: */
294: ttyosrv(q)
295: register struct queue *q;
296: {
297: register struct ttyld *tp;
298: register struct block *bp;
299:
300: tp = (struct ttyld *)q->ptr;
301: while (bp = getq(q)) {
302: switch(bp->type) {
303:
304: default:
305: freeb(bp);
306: continue;
307:
308: case M_DELIM:
309: if ((q->next->flag & QDELIM) == 0) {
310: freeb(bp);
311: continue;
312: }
313: if (q->next->flag & QFULL) {
314: putbq(q, bp);
315: return;
316: }
317: (*q->next->qinfo->putp)(q->next, bp);
318: continue;
319:
320: case M_IOCTL:
321: if (q->next->flag & QFULL) {
322: putbq(q, bp);
323: return;
324: }
325: ttldioc(q, bp, RD(q), 0);
326: continue;
327:
328: case M_FLUSH:
329: flushq(q, 0);
330: case M_IOCNAK: /* flow through */
331: case M_IOCACK:
332: (*q->next->qinfo->putp)(q->next, bp);
333: continue;
334:
335: case M_DATA:
336: case M_BREAK:
337: if (q->next->flag & QFULL) {
338: putbq(q, bp);
339: return;
340: }
341: if (tp->t_flags&RAW || bp->type==M_BREAK) {
342: (*q->next->qinfo->putp)(q->next, bp);
343: } else
344: outconv(q, bp);
345: continue;
346: }
347: }
348: }
349:
350: outconv(q, ibp)
351: struct queue *q;
352: register struct block *ibp;
353: {
354: register struct ttyld *tp;
355: register struct block *obp = NULL;
356: register c;
357: register count, ctype;
358:
359: tp = (struct ttyld *)q->ptr;
360: more:
361: while (ibp->rptr < ibp->wptr) {
362: if (obp==NULL || obp->wptr >= obp->lim) {
363: if (obp)
364: (*q->next->qinfo->putp)(q->next, obp);
365: if (q->next->flag&QFULL || (obp=allocb(QBSIZE))==NULL) {
366: putbq(q, ibp);
367: return;
368: }
369: }
370: /*
371: * The following dance is an inner loop
372: */
373: count = ibp->wptr - ibp->rptr;
374: if ((c = obp->lim - obp->wptr) < count)
375: count = c;
376: while ((ctype = partab[c = *ibp->rptr++ & 0177] & 077) == 0) {
377: tp->t_col++;
378: *obp->wptr++ = c;
379: if (--count <= 0)
380: goto more;
381: }
382: if (c=='\t' && (tp->t_flags&TBDELAY)==XTABS) {
383: for (;;) {
384: *obp->wptr++ = ' ';
385: tp->t_col++;
386: if ((tp->t_col & 07) == 0) /* every 8 */
387: break;
388: if (obp->wptr >= obp->lim) {
389: ibp->rptr--;
390: break;
391: }
392: }
393: continue;
394: }
395:
396: /*
397: * turn <nl> to <cr><lf> if desired.
398: */
399: if (c=='\n' && tp->t_flags&CRMOD) {
400: if ((tp->t_state&TTCR)==0) {
401: tp->t_state |= TTCR;
402: c = '\r';
403: ctype = partab['\r'] & 077;
404: --ibp->rptr;
405: } else
406: tp->t_state &= ~TTCR;
407: }
408: /*
409: * store character
410: */
411: *obp->wptr++ = c;
412: /*
413: * Calculate delays and column movement
414: */
415: count = 0;
416: switch (ctype) {
417:
418: /* ordinary */
419: case 0:
420: tp->t_col++;
421: break;
422:
423: /* non-printing */
424: case 1:
425: break;
426:
427: /* backspace */
428: case 2:
429: if (tp->t_col)
430: tp->t_col--;
431: break;
432:
433: /* newline */
434: case 3:
435: ctype = (tp->t_flags >> 8) & 03;
436: if(ctype == 1) { /* tty 37 */
437: if (tp->t_col)
438: count = max(((unsigned)tp->t_col>>4) + 3, (unsigned)6);
439: } else if (ctype == 2) /* vt05 */
440: count = 6;
441: if ((tp->t_flags&CRMOD)==0)
442: tp->t_col = 0;
443: break;
444:
445: /* tab */
446: case 4:
447: ctype = (tp->t_flags >> 10) & 03;
448: if(ctype == 1) { /* tty 37 */
449: count = 1 - (tp->t_col | ~07);
450: if (count < 5)
451: count = 0;
452: }
453: tp->t_col |= 07;
454: tp->t_col++;
455: break;
456:
457: /* vertical motion */
458: case 5:
459: if(tp->t_flags & VTDELAY)
460: count = 127;
461: break;
462:
463: /* carriage return */
464: case 6:
465: ctype = (tp->t_flags >> 12) & 03;
466: if (ctype == 1) /* tn 300 */
467: count = 5;
468: else if (ctype == 2) /* ti 700 */
469: count = 10;
470: else if (ctype == 3)
471: count = 20;
472: tp->t_col = 0;
473: break;
474: }
475: if (count) {
476: (*q->next->qinfo->putp)(q->next, obp);
477: if (obp = allocb(1)) {
478: obp->type = M_DELAY;
479: *obp->wptr++ = count;
480: (*q->next->qinfo->putp)(q->next, obp);
481: }
482: obp = NULL;
483: }
484: }
485: if (obp)
486: (*q->next->qinfo->putp)(q->next, obp);
487: freeb(ibp);
488: }
489:
490: /*
491: * Reader generates a signal and passes it up
492: */
493: ttysig(q, sig)
494: register struct queue *q;
495: {
496: register struct ttyld *tp = (struct ttyld *)q->ptr;
497:
498: flushq(q, 0); /* flush reader */
499: flushq(WR(q), 0);
500: tp->t_state &= ~TTESC;
501: tp->t_delct = 0;
502: putctl(q->next, M_FLUSH);
503: putctl1(q->next, M_SIGNAL, sig);
504: putctl(WR(q)->next, M_FLUSH);
505: }
506:
507: ttldioc(q, bp, rdq, fromdev)
508: register struct block *bp;
509: struct queue *q, *rdq;
510: {
511: register struct ttyld *tp;
512: register union stmsg *sp;
513: int s;
514:
515: sp = (union stmsg *)bp->rptr;
516: tp = (struct ttyld *)q->ptr;
517: switch (sp->ioc0.com) {
518:
519: /*
520: * Set new parameters
521: */
522: case TIOCSETP:
523: case TIOCSETN:
524: s = spl6();
525: if (sp->ioc1.sb.sg_flags & (RAW|CBREAK)
526: && (rdq->next->flag&QFULL)==0) {
527: register struct block *bp1;
528: ttyinsrv(rdq);
529: while (bp1 = getq(rdq))
530: (*rdq->next->qinfo->putp)(rdq->next, bp1);
531: }
532: tp->t_erase = sp->ioc1.sb.sg_erase;
533: tp->t_kill = sp->ioc1.sb.sg_kill;
534: tp->t_flags = sp->ioc1.sb.sg_flags;
535: splx(s);
536: bp->type = M_IOCACK;
537: if (fromdev)
538: qreply(rdq, bp); /* reply to device side */
539: else
540: qreply(q, bp); /* reply to process side */
541: if (tp->t_flags & (RAW|CBREAK))
542: rdq->flag &= ~(QDELIM|QNOENB);
543: else
544: rdq->flag |= QDELIM|QNOENB;
545: break;
546:
547: /*
548: * Send current parameters to user
549: */
550: case TIOCGETP:
551: sp->ioc1.sb.sg_erase = tp->t_erase;
552: sp->ioc1.sb.sg_kill = tp->t_kill;
553: sp->ioc1.sb.sg_flags = tp->t_flags;
554: sp->ioc1.sb.sg_ispeed =
555: sp->ioc1.sb.sg_ospeed = B9600;
556: bp->wptr = bp->rptr+sizeof(struct ioc1);
557: bp->type = M_IOCACK;
558: if (fromdev)
559: qreply(rdq, bp); /* reply to device side */
560: else
561: qreply(q, bp); /* reply to process side */
562: break;
563:
564: /*
565: * Set and fetch special characters
566: */
567: case TIOCSETC:
568: tp->t_chr = sp->ioc2.sb;
569: bp->wptr = bp->rptr;
570: bp->type = M_IOCACK;
571: if (fromdev)
572: qreply(rdq, bp); /* reply to device side */
573: else
574: qreply(q, bp); /* reply to process side */
575: break;
576:
577: case TIOCGETC:
578: sp->ioc2.sb = tp->t_chr;
579: bp->wptr = bp->rptr+sizeof(struct ioc2);
580: bp->type = M_IOCACK;
581: if (fromdev)
582: qreply(rdq, bp); /* reply to device side */
583: else
584: qreply(q, bp); /* reply to process side */
585: break;
586:
587: default:
588: if (fromdev) {
589: bp->type = M_IOCACK;
590: qreply(rdq, bp); /* reply to device side */
591: } else
592: (*q->next->qinfo->putp)(q->next, bp); /* pass to device */
593: break;
594:
595: }
596: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.