![[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] / researchv8dc / sys / dev|
Return to ttyld.c CVS log | Up to [Research Unix] / researchv8dc / sys / dev |
1.1 root 1: #include "../h/param.h"
2: #include "../h/stream.h"
3: #include "../h/ioctl.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_stopc
133: || tp->t_chr.t_stopc==tp->t_chr.t_startc) {
134: tp->t_state &= ~TTSTOP;
135: putctl(wrq->next, M_START);
136: }
137: } else {
138: if (c==tp->t_chr.t_stopc) {
139: tp->t_state |= TTSTOP;
140: putctl(wrq->next, M_STOP);
141: }
142: }
143: if (c==tp->t_chr.t_stopc || c==tp->t_chr.t_startc)
144: continue;
145: if (c==tp->t_chr.t_intrc) {
146: ttysig(q, SIGINT);
147: continue;
148: }
149: if (c==tp->t_chr.t_quitc) {
150: ttysig(q, SIGQUIT);
151: continue;
152: }
153: if (c=='\r' && tp->t_flags&CRMOD)
154: c = '\n';
155: if (tp->t_flags&LCASE && c>='A' && c<='Z')
156: c += 'a'-'A';
157: escape = 0;
158: if (tp->t_flags & CBREAK) {
159: if ((q->next->flag&QFULL)==0 && q->count==0)
160: putd(q->next->qinfo->putp, q->next, c);
161: else
162: putd(putq, q, c);
163: } else {
164: if (tp->t_state&TTESC) {
165: escape = 1;
166: c |= 0200;
167: }
168: if (c == '\\')
169: tp->t_state |= TTESC;
170: else {
171: tp->t_state &= ~TTESC;
172: if (c == ('\\'|0200)) {
173: c &= 0177;
174: tp->t_state |= TTESC;
175: }
176: /* ttyhog? */
177: if (q->count<512 || (c=='\n' && tp->t_delct==0))
178: putd(putq, q, c);
179: else
180: c = '\007';
181: }
182: c &= 0177;
183: if (c=='\n'||c==tp->t_chr.t_eofc||c==tp->t_chr.t_brkc) {
184: register struct block *bp1;
185: if (bp1 = allocb(1)) {
186: bp1->type = M_DELIM;
187: putq(q, bp1);
188: tp->t_delct++;
189: }
190: qenable(q);
191: }
192: }
193: if (tp->t_flags&TANDEM && (tp->t_state&TTBLOCK) == 0
194: && q->count >= (q->qinfo->limit+q->qinfo->lolimit)/2 ) {
195: q->next->flag |= QWANTW;
196: tp->t_state |= TTBLOCK;
197: putd(putq, wrq, tp->t_chr.t_stopc);
198: }
199: if (tp->t_flags&ECHO && (wrq->flag&QFULL)==0) {
200: register c1 = c&0177;
201: if (c1!=CEOT) {
202: putd(putq, wrq, c1);
203: if(wrq->next->flag&QDELIM && bp->wptr==bp->rptr)
204: putctl(wrq, M_DELIM);
205: }
206: if (c==tp->t_kill && (tp->t_flags&CBREAK)==0
207: && !escape) {
208: putd(putq, wrq, '\n');
209: if (wrq->next->flag&QDELIM)
210: putctl(wrq, M_DELIM);
211: }
212: }
213: }
214: freeb(bp);
215: }
216:
217: /*
218: * tty input server processing. Erase-kill and escape processing;
219: * gathering into lines.
220: */
221:
222: ttyinsrv(q)
223: register struct queue *q;
224: {
225: register struct ttyld *tp;
226: register struct block *bp;
227: register char *op;
228: register c;
229: static char canonb[CANBSIZ];
230:
231: tp = (struct ttyld *)q->ptr;
232: if (q->next->flag&QFULL)
233: return;
234: if (tp->t_flags&(CBREAK|RAW)) {
235: while ((q->next->flag&QFULL)==0 && (bp = getq(q)))
236: (*q->next->qinfo->putp)(q->next, bp);
237: } else {
238: op = canonb;
239: while (tp->t_delct) {
240: bp = getq(q);
241: if (bp==NULL || bp->type!=M_DATA) {
242: if (op > canonb)
243: putcpy(q->next, canonb, op-canonb);
244: if (bp) {
245: (*q->next->qinfo->putp)(q->next, bp);
246: tp->t_delct--;
247: op = canonb;
248: continue;
249: }
250: return;
251: }
252: while (bp->rptr<bp->wptr) {
253: c = *bp->rptr++;
254: if ((c&0200) == 0) { /* not escaped */
255: if (c == tp->t_erase) {
256: if (op > canonb)
257: op--;
258: continue;
259: }
260: if (c == tp->t_kill) {
261: op = canonb;
262: continue;
263: }
264: if (c == tp->t_chr.t_eofc)
265: continue;
266: } else {
267: c &= 0177;
268: if (tp->t_flags&LCASE && maptab[c])
269: c = maptab[c];
270: else if (c==tp->t_erase || c==tp->t_kill
271: || c==tp->t_chr.t_eofc)
272: ;
273: else
274: *op++ = '\\';
275: }
276: *op++ = c;
277: if (op >= &canonb[CANBSIZ-1]) {
278: putcpy(q->next, canonb, op-canonb);
279: op = canonb;
280: }
281: }
282: freeb(bp);
283: }
284: }
285: if (tp->t_flags&TANDEM && tp->t_state&TTBLOCK
286: && q->count <= q->qinfo->lolimit) {
287: tp->t_state &= ~TTBLOCK;
288: putd(putq, WR(q), tp->t_chr.t_startc);
289: }
290: }
291:
292: /*
293: * TTY write processing: delays, tabs, CR/NL and the like.
294: */
295: ttyosrv(q)
296: register struct queue *q;
297: {
298: register struct ttyld *tp;
299: register struct block *bp;
300:
301: tp = (struct ttyld *)q->ptr;
302: while (bp = getq(q)) {
303: switch(bp->type) {
304:
305: default:
306: freeb(bp);
307: continue;
308:
309: case M_DELIM:
310: if ((q->next->flag & QDELIM) == 0) {
311: freeb(bp);
312: continue;
313: }
314: if (q->next->flag & QFULL) {
315: putbq(q, bp);
316: return;
317: }
318: (*q->next->qinfo->putp)(q->next, bp);
319: continue;
320:
321: case M_IOCTL:
322: if (q->next->flag & QFULL) {
323: putbq(q, bp);
324: return;
325: }
326: ttldioc(q, bp, RD(q), 0);
327: continue;
328:
329: case M_FLUSH:
330: flushq(q, 0);
331: case M_IOCNAK: /* flow through */
332: case M_IOCACK:
333: (*q->next->qinfo->putp)(q->next, bp);
334: continue;
335:
336: case M_DATA:
337: case M_BREAK:
338: if (q->next->flag & QFULL) {
339: putbq(q, bp);
340: return;
341: }
342: if (tp->t_flags&RAW || bp->type==M_BREAK) {
343: (*q->next->qinfo->putp)(q->next, bp);
344: } else
345: outconv(q, bp);
346: continue;
347: }
348: }
349: }
350:
351: outconv(q, ibp)
352: struct queue *q;
353: register struct block *ibp;
354: {
355: register struct ttyld *tp;
356: register struct block *obp = NULL;
357: register c;
358: register count, ctype;
359:
360: tp = (struct ttyld *)q->ptr;
361: more:
362: while (ibp->rptr < ibp->wptr) {
363: if (obp==NULL || obp->wptr >= obp->lim) {
364: if (obp)
365: (*q->next->qinfo->putp)(q->next, obp);
366: if (q->next->flag&QFULL || (obp=allocb(QBSIZE))==NULL) {
367: putbq(q, ibp);
368: return;
369: }
370: }
371: /*
372: * The following dance is an inner loop
373: */
374: count = ibp->wptr - ibp->rptr;
375: if ((c = obp->lim - obp->wptr) < count)
376: count = c;
377: while ((ctype = partab[c = *ibp->rptr++ & 0177] & 077) == 0) {
378: tp->t_col++;
379: *obp->wptr++ = c;
380: if (--count <= 0)
381: goto more;
382: }
383: if (c=='\t' && (tp->t_flags&TBDELAY)==XTABS) {
384: for (;;) {
385: *obp->wptr++ = ' ';
386: tp->t_col++;
387: if ((tp->t_col & 07) == 0) /* every 8 */
388: break;
389: if (obp->wptr >= obp->lim) {
390: ibp->rptr--;
391: break;
392: }
393: }
394: continue;
395: }
396:
397: /*
398: * turn <nl> to <cr><lf> if desired.
399: */
400: if (c=='\n' && tp->t_flags&CRMOD) {
401: if ((tp->t_state&TTCR)==0) {
402: tp->t_state |= TTCR;
403: c = '\r';
404: ctype = partab['\r'] & 077;
405: --ibp->rptr;
406: } else
407: tp->t_state &= ~TTCR;
408: }
409: /*
410: * store character
411: */
412: *obp->wptr++ = c;
413: /*
414: * Calculate delays and column movement
415: */
416: count = 0;
417: switch (ctype) {
418:
419: /* ordinary */
420: case 0:
421: tp->t_col++;
422: break;
423:
424: /* non-printing */
425: case 1:
426: break;
427:
428: /* backspace */
429: case 2:
430: if (tp->t_col)
431: tp->t_col--;
432: break;
433:
434: /* newline */
435: case 3:
436: ctype = (tp->t_flags >> 8) & 03;
437: if(ctype == 1) { /* tty 37 */
438: if (tp->t_col)
439: count = max(((unsigned)tp->t_col>>4) + 3, (unsigned)6);
440: } else if (ctype == 2) /* vt05 */
441: count = 6;
442: if ((tp->t_flags&CRMOD)==0)
443: tp->t_col = 0;
444: break;
445:
446: /* tab */
447: case 4:
448: ctype = (tp->t_flags >> 10) & 03;
449: if(ctype == 1) { /* tty 37 */
450: count = 1 - (tp->t_col | ~07);
451: if (count < 5)
452: count = 0;
453: }
454: tp->t_col |= 07;
455: tp->t_col++;
456: break;
457:
458: /* vertical motion */
459: case 5:
460: if(tp->t_flags & VTDELAY)
461: count = 127;
462: break;
463:
464: /* carriage return */
465: case 6:
466: ctype = (tp->t_flags >> 12) & 03;
467: if (ctype == 1) /* tn 300 */
468: count = 5;
469: else if (ctype == 2) /* ti 700 */
470: count = 10;
471: else if (ctype == 3)
472: count = 20;
473: tp->t_col = 0;
474: break;
475: }
476: if (count) {
477: (*q->next->qinfo->putp)(q->next, obp);
478: if (obp = allocb(1)) {
479: obp->type = M_DELAY;
480: *obp->wptr++ = count;
481: (*q->next->qinfo->putp)(q->next, obp);
482: }
483: obp = NULL;
484: }
485: }
486: if (obp)
487: (*q->next->qinfo->putp)(q->next, obp);
488: freeb(ibp);
489: }
490:
491: /*
492: * Reader generates a signal and passes it up
493: */
494: ttysig(q, sig)
495: register struct queue *q;
496: {
497: register struct ttyld *tp = (struct ttyld *)q->ptr;
498:
499: flushq(q, 0); /* flush reader */
500: flushq(WR(q), 0);
501: tp->t_state &= ~TTESC;
502: tp->t_delct = 0;
503: putctl1(q->next, M_FLUSH);
504: putctl1(q->next, M_SIGNAL, sig);
505: putctl(WR(q)->next, M_FLUSH);
506: }
507:
508: ttldioc(q, bp, rdq, fromdev)
509: register struct block *bp;
510: struct queue *q, *rdq;
511: {
512: register struct ttyld *tp;
513: register union stmsg *sp;
514: register rawcb;
515: int s;
516:
517: sp = (union stmsg *)bp->rptr;
518: tp = (struct ttyld *)q->ptr;
519: switch (sp->ioc0.com) {
520:
521: /*
522: * Set new parameters
523: */
524: case TIOCSETP:
525: case TIOCSETN:
526: s = spl6();
527: if (sp->ioc1.sb.sg_flags & (RAW|CBREAK)
528: && (rdq->next->flag&QFULL)==0) {
529: register struct block *bp1;
530: ttyinsrv(rdq);
531: while (bp1 = getq(rdq))
532: (*rdq->next->qinfo->putp)(rdq->next, bp1);
533: }
534: tp->t_erase = sp->ioc1.sb.sg_erase;
535: tp->t_kill = sp->ioc1.sb.sg_kill;
536: tp->t_flags = sp->ioc1.sb.sg_flags;
537: splx(s);
538: if (fromdev) {
539: bp->type = M_IOCACK;
540: qreply(rdq, bp); /* reply to device side */
541: } else
542: (*q->next->qinfo->putp)(q->next, bp); /* pass to device */
543: if (tp->t_flags & (RAW|CBREAK))
544: rdq->flag &= ~(QDELIM|QNOENB);
545: else
546: rdq->flag |= QDELIM|QNOENB;
547: break;
548:
549: /*
550: * Send current parameters to user
551: */
552: case TIOCGETP:
553: sp->ioc1.sb.sg_erase = tp->t_erase;
554: sp->ioc1.sb.sg_kill = tp->t_kill;
555: sp->ioc1.sb.sg_flags = tp->t_flags;
556: bp->wptr = bp->rptr+sizeof(struct ioc1);
557: if (fromdev) {
558: bp->type = M_IOCACK;
559: qreply(rdq, bp); /* reply to device side */
560: } else
561: (*q->next->qinfo->putp)(q->next, bp); /* pass to device */
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.