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