![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to nttyld.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 nttyld.c CVS log | Up to [Research Unix] / researchv8dc / sys / dev |
1.1 root 1: #include "ntty.h"
2: #if NNTTY > 0
3: #include "../h/param.h"
4: #include "../h/stream.h"
5: #include "../h/ioctl.h"
6: #include "../h/ttyld.h"
7: #include "../h/nttyld.h"
8: #include "../h/conf.h"
9: #include "../h/file.h"
10:
11:
12: extern char maptab[], /* see dev/ttyld.c */
13: partab[]; /* see sys/partab.c */
14:
15: extern int tk_nin, tk_nout;
16:
17:
18: struct nttyld ntty[NNTTY];
19:
20: int ntclose(), /* queue close routine */
21: ntin(), /* reader queue put routine */
22: ntinsrv(), /* reader queue service routine */
23: ntopen(), /* queue open routine */
24: ntout(), /* writer queue put routine */
25: ntoutsrv(); /* writer queue service routine */
26:
27: static struct qinit rinit = { ntin, ntinsrv, ntopen, ntclose, 300, 0 },
28: winit = { ntout, ntoutsrv, ntopen, ntclose, 300, 200 };
29: struct streamtab nttyinfo = { &rinit, &winit };
30:
31:
32: /*
33: * Backspace over "n" characters, perhaps erasing them.
34: * Called from ntrubout().
35: */
36:
37: ntbs (nt, n)
38: register struct nttyld *nt;
39: register int n;
40: {
41: while (--n >= 0)
42: if (putd (putq, nt->nt_outq, '\b')) {
43: nt->nt_state |= NT_ECHO;
44: if (nt->nt_local & LCRTERA) {
45: (void) putd (putq, nt->nt_outq, ' ');
46: (void) putd (putq, nt->nt_outq, '\b');
47: }
48: }
49: return;
50: }
51:
52:
53: /*
54: * Set default control characters.
55: * Called by ntopen().
56: */
57:
58: ntchars (nt)
59: register struct nttyld *nt;
60: {
61: static struct tchars tchars = { CINTR, CQUIT, CSTART, CSTOP, CEOT,
62: 0377 };
63: static struct ltchars ltchars = { CSUSP, CDSUSP, CRPRNT, CFLUSH,
64: CWERAS, CLNEXT };
65:
66: nt->nt_erase = CERASE;
67: nt->nt_kill = CKILL;
68: nt->nt_tchr = tchars;
69: nt->nt_ltchr = ltchars;
70: return;
71: }
72:
73:
74: ntclose (q)
75: register struct queue *q;
76: {
77: register struct nttyld *nt = (struct nttyld *) q->ptr;
78:
79: nt->nt_state = 0;
80: return;
81: }
82:
83:
84: /*
85: * Put input buffer on read queue followed by a delimiter.
86: * Called from ntinc() when a line break character is read,
87: * and from ntioctl() when switching from cooked to raw or cbreak mode.
88: */
89:
90: ntcooked (nt)
91: register struct nttyld *nt;
92: {
93: register char *s, *t;
94: register struct block *b;
95: register struct queue *q = RD (nt->nt_outq);
96:
97: if (!(q->flag & QFULL) && (b = allocb (1))) {
98: for (t = (s = nt->nt_in) + nt->nt_nin; s < t; s++)
99: (void) putd (putq, q, *s);
100: b->type = M_DELIM;
101: putq (q, b);
102: nt->nt_delct++;
103: }
104: qenable (q);
105: nt->nt_nin = 0;
106: nt->nt_trash = 0;
107: return;
108: }
109:
110:
111: /*
112: * Echo a typed character to a terminal.
113: */
114:
115: ntecho (c, nt)
116: register int c;
117: register struct nttyld *nt;
118: {
119: register struct queue *echoq = nt->nt_outq;
120:
121: nt->nt_local &= ~LFLUSHO;
122: if (!(nt->nt_flags & ECHO) || echoq->flag & QFULL)
123: return;
124: c &= 0377;
125: if (nt->nt_flags & RAW)
126: goto out;
127: if (c == '\r' && nt->nt_flags & CRMOD)
128: c = '\n';
129: if (c != '\n' && c != '\t' && nt->nt_local & LCTLECH)
130: if ((c &= 0177) <= 037 || c == 0177) {
131: (void) putd (putq, echoq, '^');
132: if (c == 0177)
133: c = '?';
134: else if (nt->nt_flags & LCASE)
135: c += 'a' - 1;
136: else c += 'A' - 1;
137: goto out;
138: }
139:
140: if ((c &= 0177) == CEOT) /* terminals don't like it */
141: return;
142:
143: out:
144: if (putd (putq, echoq, c))
145: nt->nt_state |= NT_ECHO;
146: return;
147: }
148:
149:
150: /*
151: * Flush all input and/or all output tty queues.
152: */
153:
154: ntflush (nt, rw)
155: struct nttyld *nt;
156: int rw;
157: {
158: struct queue *wrq = nt->nt_outq,
159: *rdq = RD (wrq);
160:
161: if (rw & FREAD) {
162: flushq (rdq, 0);
163: (void) putctl (rdq->next, M_FLUSH);
164: nt->nt_delct = 0;
165: nt->nt_nin = 0;
166: nt->nt_trash = 0;
167: nt->nt_lstate = 0;
168: }
169: if (rw & FWRITE) {
170: flushq (wrq, 0);
171: (void) putctl (wrq->next, M_FLUSH);
172: }
173: return;
174: }
175:
176:
177: /*
178: * Reader queue (input from tty) put routine.
179: */
180:
181: ntin (q, b)
182: struct queue *q;
183: register struct block *b;
184: {
185: register struct nttyld *nt = (struct nttyld *) q->ptr;
186:
187: switch (b->type) {
188: case M_DATA:
189: if (nt->nt_flags & RAW && !(nt->nt_flags & ECHO))
190: break;
191: nt->nt_state &= ~NT_ECHO;
192: while (b->rptr < b->wptr)
193: ntinc ((int) *b->rptr++, nt);
194: freeb (b);
195: if (nt->nt_state & NT_ECHO && nt->nt_outq->next->flag & QDELIM)
196: (void) putctl (nt->nt_outq, M_DELIM);
197: return;
198: case M_DELIM:
199: freeb (b);
200: return;
201: case M_BREAK:
202: if (nt->nt_flags & RAW) { /* speed-change hack */
203: b->type = M_DATA;
204: if (b->wptr < b->lim)
205: *b->wptr++ = '\0';
206: break;
207: }
208: (void) putctl1 (q->next, M_SIGNAL, SIGINT);
209: ntflush (nt, FREAD | FWRITE);
210: freeb (b);
211: return;
212: case M_HANGUP:
213: (*q->next->qinfo->putp)(q->next, b);
214: return;
215: }
216:
217: if (q->next->flag & QFULL)
218: freeb (b);
219: else (*q->next->qinfo->putp)(q->next, b);
220: return;
221: }
222:
223:
224: /*
225: * Process a single input character.
226: * Called (at interrupt level) by ntin().
227: */
228:
229: ntinc (c, nt)
230: register c;
231: register struct nttyld *nt;
232: {
233: register int t_flags;
234:
235: tk_nin++;
236: c &= 0377;
237: t_flags = nt->nt_flags;
238:
239: if (t_flags & RAW) {
240: if (!(nt->nt_readq->next->flag & QFULL))
241: if (putd (nt->nt_readq->next->qinfo->putp, nt->nt_readq->next, c))
242: ntecho (c, nt);
243: return;
244: }
245:
246: if (!(nt->nt_lstate & LSTYPEN))
247: c &= 0177;
248:
249: /*
250: * Interpret literal-next-character control character (^V).
251: */
252: if (nt->nt_lstate & LSLNCH) {
253: c |= 0200;
254: nt->nt_lstate &= ~LSLNCH;
255: }
256: if (c == nt->nt_lnextc) {
257: nt->nt_lstate |= LSLNCH;
258: if (nt->nt_flags & ECHO)
259: if (putd (putq, nt->nt_outq, '^')) {
260: nt->nt_state |= NT_ECHO;
261: (void) putd (putq, nt->nt_outq, '\b');
262: }
263: return;
264: }
265:
266: if (ntstst (c, nt) || /* start, stop */
267: ntoflush (c, nt) || /* flush output */
268: ntsigc (c, nt)) /* interrupt/quit/stop */
269: return;
270:
271: if (c == '\r' && t_flags & CRMOD)
272: c = '\n';
273: if (t_flags & LCASE && c >= 'A' && c <= 'Z')
274: c += 'a' - 'A';
275:
276: if (t_flags & CBREAK) {
277: if (nt->nt_readq->next->flag & QFULL) {
278: if (putd (putq, nt->nt_outq, CTRL(g)))
279: nt->nt_state |= NT_ECHO;
280: }
281: #ifdef notdef
282: else if (c == nt->nt_dsuspc)
283: (void) putctl1 (nt->nt_readq->next, M_SSIGNAL, SIGTSTP);
284: #endif
285: else if (putd (nt->nt_readq->next->qinfo->putp, nt->nt_readq->next, c&0177))
286: ntecho (c, nt);
287: return;
288: }
289:
290: if (nt->nt_lstate & LSQUOT) {
291: nt->nt_lstate &= ~LSQUOT;
292: if (c == nt->nt_erase || c == nt->nt_kill) {
293: c |= 0200;
294: ntrubout (nt);
295: }
296: }
297: if (c == '\\')
298: nt->nt_lstate |= LSQUOT;
299:
300: if (c == nt->nt_erase)
301: ntrubout (nt); /* erase character */
302: else if (c == nt->nt_kill)
303: ntkill (nt); /* erase line */
304: else if (c == nt->nt_werasc)
305: ntwerase (nt); /* erase word */
306: else if (c == nt->nt_rprntc)
307: ntreprint (nt); /* reprint line */
308: else {
309: if (nt->nt_nin < NT_NIN) {
310: if (nt->nt_nin == 0)
311: nt->nt_rocol = nt->nt_col;
312: nt->nt_in[nt->nt_nin++] = c;
313: }
314: else {
315: if (putd (putq, nt->nt_outq, CTRL(g)))
316: nt->nt_state |= NT_ECHO;
317: return;
318: }
319:
320: if (c == '\n' || c == nt->nt_eofc || c == nt->nt_brkc ||
321: c == '\r' && (nt->nt_flags & CRMOD))
322: ntcooked (nt);
323:
324: if (nt->nt_lstate & LSERASE) {
325: nt->nt_lstate &= ~LSERASE;
326: if (putd (putq, nt->nt_outq, '/'))
327: nt->nt_state |= NT_ECHO;
328: }
329:
330: ntecho (c, nt);
331: if (c == nt->nt_eofc && nt->nt_flags & ECHO &&
332: nt->nt_local & LCTLECH)
333: if (putd (putq, nt->nt_outq, '\b')) {
334: nt->nt_state |= NT_ECHO;
335: (void) putd (putq, nt->nt_outq, '\b');
336: }
337: }
338: return;
339: }
340:
341:
342: /*
343: * Reader queue (tty input) service routine.
344: * Only cooked mode data and delimiters come through here, via ntcooked().
345: */
346:
347: ntinsrv (q)
348: register struct queue *q;
349: {
350: register struct nttyld *nt;
351: register struct block *b;
352: register char *op;
353: register int c;
354: static char canonb[CANBSIZ];
355:
356: if (q->next->flag & QFULL)
357: return;
358: nt = (struct nttyld *) q->ptr;
359: op = canonb;
360: while (nt->nt_delct) {
361: b = getq(q);
362: if (b == NULL || b->type != M_DATA) {
363: if (op > canonb)
364: putcpy (q->next, canonb, op - canonb);
365: if (b) {
366: (*q->next->qinfo->putp)(q->next, b);
367: nt->nt_delct--;
368: op = canonb;
369: continue;
370: }
371: return;
372: }
373: while (b->rptr < b->wptr) {
374: c = *b->rptr++;
375: if (c & 0200) { /* escaped */
376: c &= 0177;
377: if (nt->nt_flags & LCASE && maptab[c])
378: c = maptab[c];
379: else if (c != nt->nt_erase &&
380: c != nt->nt_kill && c != nt->nt_eofc)
381: *op++ = '\\';
382: }
383: else {
384: #ifdef notdef
385: /*
386: * Interpret delayed stop process
387: * control character (^Y).
388: */
389: if (c == nt->nt_dsuspc) {
390: putcpy (q->next, canonb, op - canonb);
391: op = canonb;
392: (void) putctl1 (q->next, M_SSIGNAL,
393: SIGTSTP);
394: continue;
395: }
396: #endif
397: if (c == nt->nt_eofc)
398: continue;
399: }
400: *op++ = c;
401: if (op >= &canonb[CANBSIZ-1]) {
402: putcpy (q->next, canonb, op - canonb);
403: op = canonb;
404: }
405: }
406: freeb (b);
407: }
408:
409: return;
410: }
411:
412:
413: /*
414: * Acknowledge ioctl message.
415: * Called by ntioctl().
416: */
417:
418: ntiocack (q, b, n)
419: register struct queue *q;
420: register struct block *b;
421: register int n;
422: {
423: if (n > 0)
424: n += sizeof (int); /* for ioctl command */
425: b->wptr = b->rptr + n;
426: b->type = M_IOCACK;
427: qreply (q, b);
428: return;
429: }
430:
431:
432: /*
433: * Terminal I/O control operations.
434: * Called by ntoutsrv().
435: */
436:
437: ntioctl (q, b)
438: register struct queue *q;
439: register struct block *b;
440: {
441: register struct nttyld *nt = (struct nttyld *) q->ptr;
442: register struct ntioc *ioc = (struct ntioc *) b->rptr;
443: int s;
444:
445: switch (ioc->command) {
446:
447: /*
448: * Set new parameters
449: */
450: case TIOCSETP:
451: case TIOCSETN:
452: s = spl6();
453: if (ioc->arg.sg.sg_flags & (RAW|CBREAK) &&
454: !(nt->nt_flags & (RAW|CBREAK))) {
455: /*
456: * Before leaving cooked mode, push through
457: * any characters that made it to ntin().
458: */
459: if (nt->nt_nin > 0)
460: ntcooked (nt);
461: ntinsrv (RD (nt->nt_outq));
462: }
463: nt->nt_erase = ioc->arg.sg.sg_erase;
464: nt->nt_kill = ioc->arg.sg.sg_kill;
465: nt->nt_flags = ioc->arg.sg.sg_flags;
466: nt->nt_readq->flag &= ~QDELIM;
467: if ((nt->nt_flags & (RAW|CBREAK))==0)
468: nt->nt_readq->flag |= QDELIM;
469: splx (s);
470:
471: (*q->next->qinfo->putp)(q->next, b); /* send it on down */
472: break;
473:
474: /*
475: * Send current parameters to user
476: */
477: case TIOCGETP:
478: ioc->arg.sg.sg_erase = nt->nt_erase;
479: ioc->arg.sg.sg_kill = nt->nt_kill;
480: ioc->arg.sg.sg_flags = nt->nt_flags;
481:
482: b->wptr = b->rptr + sizeof (int) + sizeof (struct sgttyb);
483: b->wptr = 2 + b->rptr + sizeof (int) + sizeof (struct sgttyb);
484: (*q->next->qinfo->putp)(q->next, b);
485: break;
486:
487: /*
488: * Set/get special characters
489: */
490: case TIOCSETC:
491: nt->nt_tchr = ioc->arg.tchr;
492: ntiocack (q, b, 0);
493: break;
494:
495: case TIOCGETC:
496: ioc->arg.tchr = nt->nt_tchr;
497: ntiocack (q, b, sizeof (struct tchars));
498: break;
499:
500: /*
501: * Set/get local special characters.
502: */
503: case TIOCSLTC:
504: nt->nt_ltchr = ioc->arg.ltchr;
505: ntiocack (q, b, 0);
506: break;
507:
508: case TIOCGLTC:
509: ioc->arg.ltchr = nt->nt_ltchr;
510: ntiocack (q, b, sizeof (struct ltchars));
511: break;
512:
513: /*
514: * Modify local mode word.
515: */
516: case TIOCLBIS:
517: nt->nt_local |= ioc->arg.local;
518: ntiocack (q, b, 0);
519: break;
520:
521: case TIOCLBIC:
522: nt->nt_local &= ~ioc->arg.local;
523: ntiocack (q, b, 0);
524: break;
525:
526: case TIOCLSET:
527: nt->nt_local = ioc->arg.local;
528: ntiocack (q, b, 0);
529: break;
530:
531: case TIOCLGET:
532: ioc->arg.local = nt->nt_local;
533: ntiocack (q, b, sizeof (short));
534: break;
535:
536: /*
537: * Return number of characters in the output.
538: */
539: case TIOCOUTQ:
540:
541: default:
542: (*q->next->qinfo->putp)(q->next, b);
543: break;
544: }
545:
546: return;
547: }
548:
549:
550: /*
551: * Erase entire input buffer.
552: * Called by ntinc().
553: */
554:
555: ntkill (nt)
556: register struct nttyld *nt;
557: {
558: if (nt->nt_local & LCRTKIL && !nt->nt_trash) {
559: while (nt->nt_nin > 0)
560: ntrubout (nt);
561: }
562: else {
563: ntecho (nt->nt_kill, nt);
564: ntecho ('\n', nt);
565: nt->nt_nin = 0;
566: nt->nt_trash = 0;
567: }
568: nt->nt_lstate = 0;
569: return;
570: }
571:
572:
573: /*
574: * Interpret the flush-output (^O) control character.
575: * Called by ntinc().
576: */
577:
578: int
579: ntoflush (c, nt)
580: register int c;
581: register struct nttyld *nt;
582: {
583: if (nt->nt_local & LFLUSHO) {
584: nt->nt_local &= ~LFLUSHO;
585: if (c == nt->nt_flushc)
586: return (1);
587: }
588: else if (c == nt->nt_flushc) {
589: ntflush (nt, FWRITE);
590: ntecho (c, nt);
591: ntreprint (nt);
592: nt->nt_local |= LFLUSHO;
593: return (1);
594: }
595:
596: return (0);
597: }
598:
599:
600: /*ARGSUSED*/
601:
602: int
603: ntopen (q, dev)
604: register struct queue *q;
605: int dev;
606: {
607: register struct nttyld *nt;
608:
609: if (q->ptr)
610: return (1); /* already attached */
611:
612: for (nt = ntty; nt->nt_state & NT_USE; nt++)
613: if (nt >= &ntty[NNTTY-1])
614: return (0);
615:
616: WR (q)->ptr = q->ptr = (caddr_t) nt;
617: nt->nt_outq = WR (q);
618: nt->nt_readq = q;
619: nt->nt_nin = 0;
620: nt->nt_state = NT_USE;
621: nt->nt_flags = ECHO | CRMOD;
622: nt->nt_col = 0;
623: nt->nt_delct = 0;
624: ntchars (nt); /* set default control characters */
625: nt->nt_trash = 0;
626: nt->nt_local = 0;
627: nt->nt_lstate = 0;
628: q->flag |= QDELIM;
629: return (1);
630: }
631:
632:
633: /*
634: * Writer queue (output to tty) put routine.
635: */
636:
637: ntout (wrq, b)
638: register struct queue *wrq;
639: register struct block *b;
640: {
641: if (b->type == M_DATA)
642: b->type = M_CTL; /* see ntoutsrv() */
643: putq (wrq, b);
644: return;
645: }
646:
647:
648: /*
649: * Output a block of data to a terminal.
650: * Handle tab expansion, case conversion, turning CR to CRLF, delays, etc.
651: * Called from ntoutsrv().
652: */
653:
654: ntoutb (nt, ib)
655: register struct nttyld *nt;
656: register struct block *ib;
657: {
658: register struct block *ob = 0;
659: register struct queue *q = nt->nt_outq;
660: register int c, delay, ctype;
661: char *colp;
662:
663: while (ib->rptr < ib->wptr) {
664: if (!ob || ob->wptr >= ob->lim) {
665: if (ob) {
666: if (nt->nt_local & LFLUSHO)
667: break;
668: tk_nout += ob->wptr - ob->rptr;
669: (*q->next->qinfo->putp)(q->next, ob);
670: }
671: if (q->next->flag & QFULL || !(ob = allocb (QBSIZE))) {
672: putbq (q, ib);
673: return;
674: }
675: }
676:
677: switch (c = *ib->rptr++ & 0177) {
678: case '\t':
679: if ((nt->nt_flags & TBDELAY) != XTABS)
680: break;
681:
682: /*
683: * Expand tabs to spaces.
684: */
685: for (;;) {
686: *ob->wptr++ = ' ';
687: nt->nt_col++;
688: if ((nt->nt_col & 07) == 0) /* every 8 */
689: break;
690: if (ob->wptr >= ob->lim) {
691: ib->rptr--;
692: break;
693: }
694: }
695: continue;
696: case '\n':
697: if (!(nt->nt_flags & CRMOD))
698: break;
699:
700: /*
701: * Turn <nl> to <cr><lf>.
702: */
703: if (nt->nt_state & NT_CR)
704: nt->nt_state &= ~NT_CR;
705: else {
706: nt->nt_state |= NT_CR;
707: c = '\r';
708: ib->rptr--;
709: }
710: break;
711: case '~':
712: if (nt->nt_local & LTILDE)
713: c = '`';
714: /* no break */
715: default:
716: if (!(nt->nt_flags & LCASE))
717: break;
718:
719: /*
720: * Generate escapes for upper-case-only terminals.
721: */
722: if (nt->nt_state & NT_CASE) {
723: nt->nt_state &= ~NT_CASE;
724: break;
725: }
726:
727: for (colp = "{(})|!~^`'"; *colp && c != *colp;
728: colp += 2);
729:
730: if (*colp || c >= 'A' && c <= 'Z') {
731: *--ib->rptr = *colp ? colp[1] : c;
732: nt->nt_state |= NT_CASE;
733: c = '\\';
734: }
735: else if (c >= 'a' && c <= 'z')
736: c += 'A' - 'a';
737: break;
738: }
739:
740: /*
741: * Store character.
742: */
743: *ob->wptr++ = c;
744:
745: /*
746: * Calculate delays and column movement.
747: * The delay values are in clock ticks and aren't
748: * necessarily optimal for all terminals.
749: */
750: delay = 0;
751:
752: switch (ctype = partab[c] & 077) {
753: case ORDINARY:
754: nt->nt_col++;
755: break;
756: case CONTROL:
757: break;
758: case BACKSPACE:
759: if (nt->nt_col)
760: nt->nt_col--;
761: break;
762: case NEWLINE:
763: ctype = (nt->nt_flags >> 8) & 03;
764: if (ctype == 1) { /* tty 37 */
765: if (nt->nt_col)
766: if ((delay = nt->nt_col >> 4) < 6)
767: delay = 6;
768: }
769: else if (ctype == 2) /* vt05 */
770: delay = 6;
771: if (!(nt->nt_flags & CRMOD))
772: nt->nt_col = 0;
773: break;
774: case TAB:
775: ctype = (nt->nt_flags >> 10) & 03;
776: if (ctype == 1) /* tty 37 */
777: if ((delay = 1 - (nt->nt_col | ~07)) < 5)
778: delay = 0;
779: nt->nt_col |= 07;
780: nt->nt_col++;
781: break;
782: case VTAB:
783: if (nt->nt_flags & VTDELAY)
784: delay = 127;
785: break;
786: case RETURN:
787: ctype = (nt->nt_flags >> 12) & 03;
788: if (ctype == 1) /* tn 300 */
789: delay = 5;
790: else if (ctype == 2) /* ti 700 */
791: delay = 10;
792: else if (ctype == 3) /* concept 100 */
793: if ((delay = 9 - nt->nt_col) < 0)
794: delay = 0;
795: nt->nt_col = 0;
796: break;
797: }
798:
799: if (delay) {
800: if (nt->nt_local & LFLUSHO)
801: break;
802: tk_nout += ob->wptr - ob->rptr;
803: (*q->next->qinfo->putp)(q->next, ob);
804: if (ob = allocb(1)) {
805: ob->type = M_DELAY;
806: *ob->wptr++ = delay;
807: (*q->next->qinfo->putp)(q->next, ob);
808: }
809: ob = 0;
810: }
811: }
812:
813: freeb (ib);
814: if (ob)
815: if (nt->nt_local & LFLUSHO)
816: freeb (ob);
817: else {
818: tk_nout += ob->wptr - ob->rptr;
819: (*q->next->qinfo->putp)(q->next, ob);
820: }
821: return;
822: }
823:
824:
825: /*
826: * Writer queue (tty output) service routine.
827: * All tty output comes through here. Upstream data comes in M_CTL
828: * blocks via ntout(); echoed data comes in M_DATA blocks.
829: */
830:
831: ntoutsrv (q)
832: register struct queue *q;
833: {
834: register struct nttyld *nt = (struct nttyld *) q->ptr;
835: register struct block *b;
836:
837: while (b = getq (q))
838: switch (b->type) {
839: default:
840: freeb (b);
841: continue;
842: case M_BREAK:
843: if (q->next->flag & QFULL) {
844: putbq (q, b);
845: return;
846: }
847: (*q->next->qinfo->putp)(q->next, b);
848: continue;
849: case M_DELIM:
850: if (!(q->next->flag & QDELIM)) {
851: freeb (b);
852: continue;
853: }
854: if (nt->nt_local & LFLUSHO) {
855: freeb (b);
856: continue;
857: }
858: if (q->next->flag & QFULL) {
859: putbq (q, b);
860: return;
861: }
862: (*q->next->qinfo->putp)(q->next, b);
863: continue;
864: case M_IOCTL:
865: if (q->next->flag & QFULL) {
866: putbq (q, b);
867: return;
868: }
869: ntioctl (q, b);
870: continue;
871: case M_FLUSH:
872: flushq (q, 0);
873: /* no break */
874: case M_IOCNAK:
875: case M_IOCACK:
876: (*q->next->qinfo->putp)(q->next, b);
877: continue;
878: case M_CTL:
879: case M_DATA:
880: if (nt->nt_local & LFLUSHO) {
881: freeb (b);
882: continue;
883: }
884: if (q->next->flag & QFULL) {
885: putbq (q, b);
886: return;
887: }
888: if (b->type == M_CTL) {
889: b->type = M_DATA;
890: nt->nt_trash = nt->nt_nin;
891: }
892: if (nt->nt_flags & RAW || nt->nt_local & LLITOUT) {
893: tk_nout += b->wptr - b->rptr;
894: (*q->next->qinfo->putp)(q->next, b);
895: }
896: else ntoutb (nt, b);
897: continue;
898: }
899:
900: return;
901: }
902:
903:
904: /*
905: * Reprint input buffer.
906: */
907:
908: ntreprint (nt)
909: register struct nttyld *nt;
910: {
911: register char *in;
912: register int nin;
913:
914: if (nt->nt_rprntc != 0377)
915: ntecho ((int) nt->nt_rprntc, nt);
916: (void) putd (putq, nt->nt_outq, '\n');
917: for (in = nt->nt_in, nin = nt->nt_nin; nin > 0; in++, nin--)
918: ntecho (*in, nt);
919: nt->nt_lstate &= ~LSERASE;
920: nt->nt_trash = 0;
921: return;
922: }
923:
924:
925: /*
926: * Rubout the last character of the input buffer.
927: */
928:
929: ntrubout (nt)
930: register struct nttyld *nt;
931: {
932: register int c, cc, col, i;
933:
934: if (nt->nt_nin <= 0)
935: return;
936: c = nt->nt_in[--nt->nt_nin];
937:
938: if (!(nt->nt_flags & ECHO))
939: return;
940:
941: nt->nt_local &= ~LFLUSHO;
942:
943: if (nt->nt_local & LPRTERA) {
944: if (!(nt->nt_lstate & LSERASE)) {
945: (void) putd (putq, nt->nt_outq, '\\');
946: nt->nt_lstate |= LSERASE;
947: }
948: ntecho (c, nt);
949: return;
950: }
951:
952: if (!(nt->nt_local & LCRTBS)) {
953: ntecho (nt->nt_erase, nt);
954: return;
955: }
956:
957: if (nt->nt_trash > nt->nt_nin) {
958: ntreprint (nt);
959: return;
960: }
961:
962: if (c == ('\t'|0200) || c == ('\n'|0200)) {
963: ntbs (nt, 2);
964: return;
965: }
966:
967: switch (partab[c&=0177] & 0177) {
968: case ORDINARY:
969: if (nt->nt_flags&LCASE && c >= 'A' && c <= 'Z')
970: ntbs (nt, 2);
971: else ntbs (nt, 1);
972: break;
973: case TAB:
974: for (col = nt->nt_rocol, i = 0; i < nt->nt_nin; i++) {
975: cc = nt->nt_in[i];
976: if (cc == ('\t'|0200) || cc == ('\n'|0200)) {
977: col += 2;
978: continue;
979: }
980: switch (partab[cc&=0177] & 0177) {
981: case ORDINARY:
982: if (nt->nt_flags&LCASE && cc>='A' && cc<='Z')
983: col += 2;
984: else col++;
985: break;
986: case TAB:
987: col = (col + 8) & ~7;
988: break;
989: default:
990: if (nt->nt_local & LCTLECH)
991: col += 2;
992: break;
993: }
994: }
995: ntbs (nt, 8 - (col & 7));
996: break;
997: default:
998: if (nt->nt_local & LCTLECH)
999: ntbs (nt, 2);
1000: break;
1001: }
1002:
1003: return;
1004: }
1005:
1006:
1007: /*
1008: * Interpret the control characters that cause signals to be generated
1009: * immediately: interrupt (^?), quit (^\), stop (^Z).
1010: * Called from ntinc().
1011: */
1012:
1013: int
1014: ntsigc (c, nt)
1015: register c;
1016: register struct nttyld *nt;
1017: {
1018: if (c == nt->nt_intrc) {
1019: ntflush (nt, FREAD | FWRITE);
1020: (void) putctl1 (nt->nt_readq->next, M_SIGNAL, SIGINT);
1021: }
1022: else if (c == nt->nt_quitc) {
1023: ntflush (nt, FREAD | FWRITE);
1024: (void) putctl1 (nt->nt_readq->next, M_SIGNAL, SIGQUIT);
1025: }
1026: else if (c == nt->nt_suspc) {
1027: ntflush (nt, FREAD);
1028: (void) putctl1 (nt->nt_readq->next, M_SIGNAL, SIGTSTP);
1029: }
1030: else return (0);
1031:
1032: ntecho (c, nt);
1033: return (1);
1034: }
1035:
1036:
1037: /*
1038: * Interpret the start (^S) and stop (^Q) control characters.
1039: * Called from ntinc().
1040: */
1041:
1042: int
1043: ntstst (c, nt)
1044: register int c;
1045: register struct nttyld *nt;
1046: {
1047: if (nt->nt_state & NT_STOP) {
1048: if (c == nt->nt_startc ||
1049: !(nt->nt_local & LDECCTQ) &&
1050: (c != nt->nt_stopc || nt->nt_stopc == nt->nt_startc)) {
1051: if (putctl (nt->nt_outq->next, M_START))
1052: nt->nt_state &= ~NT_STOP;
1053: }
1054: }
1055: else if (c == nt->nt_stopc) {
1056: if (putctl (nt->nt_outq->next, M_STOP))
1057: nt->nt_state |= NT_STOP;
1058: }
1059:
1060: return (c == nt->nt_startc || c == nt->nt_stopc);
1061: }
1062:
1063:
1064: /*
1065: * Erase the last word of the input buffer.
1066: * Called from ntinc().
1067: */
1068:
1069: ntwerase (nt)
1070: register struct nttyld *nt;
1071: {
1072: register char *s;
1073:
1074: for (s = nt->nt_in + nt->nt_nin - 1; s >= nt->nt_in; s--)
1075: if (*s == ' ' || *s == '\t')
1076: ntrubout (nt);
1077: else break;
1078:
1079: for (; s >= nt->nt_in; s--)
1080: if (*s == ' ' || *s == '\t')
1081: break;
1082: else ntrubout (nt);
1083:
1084: return;
1085: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.