![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mux.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / jerq / src / mux|
Return to mux.c CVS log | Up to [Research Unix] / researchv9 / jerq / src / mux |
1.1 root 1: #if TRACING | PSTATISTICS
2: #include <stdio.h>
3: #endif
4:
5: #include <sys/param.h>
6: #include <sys/types.h>
7: #include <sys/stream.h>
8: #include <sys/ttyio.h>
9: #include <sys/filio.h>
10: #include <signal.h>
11: #include <errno.h>
12: #include <jioctl.h>
13: #include <tty.h>
14:
15: #include "msgs.h"
16: #include "pconfig.h"
17: #include "proto.h"
18: #include "packets.h"
19: #include "pstats.h"
20:
21: /*
22: * One layer structure per file-descriptor
23: */
24: struct layer {
25: char chan; /* jerq protocol channel */
26: char busy;
27: char dx, dy; /* Window size in characters */
28: short bitsx, bitsy; /* Window size in bits */
29: int more;
30: struct ttychars ttychars;
31: char ptfile[14]; /* file name of slave */
32: char bchan; /* holding area for blocked data */
33: char bcount;
34: char bbuf[MAXPKTDSIZE];
35: };
36:
37: #define NLAYERS 16 /* Same as in jerq itself */
38: #define NSELFD 20 /* Maximum file descriptors for 'select' */
39: #define SELTIMO (1000*3) /* 'select' timeout in millisecs */
40: #define CDSIZE (sizeof(struct sgttyb)-1)
41:
42: char *jerqprog;
43: char *jerqstart;
44: char umesgf[]= "/dev/pt/pt109";
45: char *progname;
46: char *shell;
47: int quitflag;
48: fd_set rdfd;
49: int enabled=1;
50: int blocked=0;
51: struct layer layer[NSELFD];
52: char buf[MAXPKTDSIZE+MSGHLEN];
53: struct sgttyb sttymodes;
54: struct sgttyb sttysave;
55: struct ttydevb devmodes;
56: struct ttydevb devsave;
57: struct tchars tcharssave;
58: struct ttychars ttychars;
59: struct ttychars zerochars;
60: short booted;
61: extern int receive();
62: extern int creceive();
63: void dosig();
64: int twrite();
65: void wrmesgb();
66: extern char *sys_errlist[];
67: extern char *getenv();
68: extern char *itoa();
69: extern char *strcpy();
70: extern char *strcat();
71: extern int tty_ld;
72: extern int mesg_ld;
73: extern int errno;
74: extern int sys_nerr;
75: extern int strlen();
76: extern int write();
77:
78: struct{
79: short speed;
80: short bytes;
81: } speeds[] = {
82: EXTA, 1920,
83: B9600, 960,
84: B4800, 480,
85: B1200, 120,
86: B300, 30,
87: 0, 960, /* default */
88: };
89: #define NSPEEDS ((sizeof speeds)/(sizeof speeds[0]))
90: #define max(A,B) (((A)>(B))?(A):(B))
91:
92: struct Pchannel pconvs[NLAYERS];
93: struct Pconfig pconfig = {
94: # ifndef TRACING
95: write,
96: # else
97: twrite,
98: # endif
99: receive,
100: (void(*)())creceive,
101: };
102:
103: #ifdef TRACING
104: int twrite();
105: FILE *tracefd;
106: void trace();
107: void tread();
108: #define ifdeftracing(a) a
109: #else
110: #define trace(a, b)
111: #define tread(a, b)
112: #define ifdeftracing(a)
113: #endif
114:
115: #if TRACING==1 || PDEBUG==1
116: char tracefile[]="traces";
117: #define _exit exit
118: #endif
119:
120: main(argc, argv)
121: char *argv[];
122: {
123: register int n;
124: char cmdline[64];
125: progname=argv[0];
126: for(n=1; n<argc; n++) {
127: if(strcmp(argv[n], "-L")==0)
128: jerqstart=argv[++n];
129: else if(strcmp(argv[n], "-l")==0){
130: register fd; char jfd[32];
131: fd = creat(mktemp(strcpy(jfd, "/tmp/.muxXXXXXX")), 0744);
132: ++n, write(fd, argv[n], strlen(argv[n]));
133: close(fd);
134: strcpy(cmdline, jfd);
135: strcat(strcat(strcat(cmdline, "; rm "), jfd), "; exit");
136: jerqstart = cmdline;
137: }else{
138: n=argc+1; break;
139: }
140: }
141: if(n!=argc)
142: return service(argc-1, argv+1);
143: if((jerqprog=getenv("MUXTERM")) == 0)
144: jerqprog="/usr/jerq/lib/muxterm";
145: if((shell=getenv("SHELL")) == 0)
146: shell="sh";
147: ioctl(0, TIOCGETP, &sttymodes);
148: sttysave=sttymodes;
149: if(ioctl(0, TIOCGDEV, &devmodes)>=0) /* band-aid for old systems */
150: devsave=devmodes;
151: else {
152: devsave.ispeed=devmodes.ispeed=sttymodes.sg_ispeed;
153: devsave.ospeed=devmodes.ospeed=sttymodes.sg_ospeed;
154: }
155: ioctl(0, TIOCGETC, &tcharssave);
156: setmodes(&ttychars, &sttymodes);
157: settchars(&ttychars, &tcharssave);
158: sttymodes.sg_flags|=RAW;
159: sttymodes.sg_flags&=~ECHO;
160: ioctl(0, TIOCSETP, &sttymodes);
161: devmodes.flags|=F8BIT;
162: ioctl(0, TIOCSDEV, &devmodes);
163: signal(SIGPIPE, (int (*)())1);
164: #ifdef TRACING
165: tracefd=fopen(tracefile, "w");
166: #ifdef PDEBUG
167: ptracefd = tracefd;
168: #endif
169: #endif
170: #if TRACING!=1 && PDEBUG==1
171: ptracefd=fopen(tracefile, "w");
172: #endif
173: if(boot(jerqprog))
174: quit("can't boot terminal program");
175: booted++;
176: ioctl(0, TIOCEXCL, 0);
177: trace(0, 0);
178: trace("start\n", 0);
179: for(n=0; n<NSPEEDS; n++)
180: if(speeds[n].speed<=devmodes.ospeed)
181: break;
182: n=speeds[n].bytes;
183: Pxtimeout=max((((NLAYERS-2)*sizeof(struct Packet)*NPCBUFS+n-1)/n), 3);
184: Prtimeout=max(((sizeof(struct Packet)+n-1)/n), 2);
185: Pscanrate=1;
186: trace("speed = %d", n);
187: trace(" xtimo = %d", Pxtimeout);
188: trace(" rtimo = %d\n", Prtimeout);
189: Pxfdesc=1;
190: if(pinit(NLAYERS)==-1)
191: quit("bad protocol initialization");
192: buf[0]=JTIMO;
193: buf[1]=Prtimeout;
194: buf[2]=Pxtimeout;
195: if (jerqstart && (n = strlen(jerqstart)) <= MAXPKTDSIZE-3) {
196: strncpy(&buf[3], jerqstart, n);
197: n += 3;
198: } else
199: n = 3;
200: (void)psend(0, buf, n);
201: while(scan()!=-1){
202: if(quitflag)
203: quit(NULL);
204: ifdeftracing(fflush(tracefd));
205: }
206: trace("errno = %d\n", errno);
207: quit("select");
208: }
209: scan()
210: {
211: register fd, bit, n, ret=0;
212:
213: trace(0, 0);
214: trace("enabled %o\n", enabled);
215: if(blocked){ /* try to clear blocked channels */
216: for(fd=0, bit=1; fd<NSELFD; fd++, bit<<=1)
217: if((bit&blocked) &&
218: psend(layer[fd].bchan, layer[fd].bbuf, layer[fd].bcount)!=-1){
219: blocked&=~bit;
220: return 0;
221: }
222: }
223: rdfd.fds_bits[0]=enabled&~blocked;
224: while(select(NSELFD, &rdfd, (fd_set *)0, SELTIMO)==-1){
225: if(errno!=EINTR)
226: return -1;
227: ret++;
228: }
229: trace(0, 0);
230: trace("selected %o\n", rdfd.fds_bits[0]);
231: if(rdfd.fds_bits[0]==0) {
232: if(Ptflag)
233: ptimeout(SIGALRM);
234: }else for(fd=0, bit=1; fd<NSELFD; fd++, bit<<=1)
235: if(bit&rdfd.fds_bits[0]){
236: while((n=read(fd, buf, sizeof buf))==-1)
237: if(errno!=EINTR)
238: return -1;
239: else{
240: trace("read error, errno=%d\n", errno);
241: return 0;
242: }
243: ifdeftracing(if(n==0) trace("0 byte read", 0));
244: if(fd==0){
245: if(n==0)
246: quit("EOF on jerq");
247: tread(buf, n);
248: precv(buf, n);
249: } else if(unpack(fd, buf, n))
250: enabled&=~bit;
251: }
252: return ret; /* used in quit */
253: }
254: psend_hold(chan, bufp, count, fd)
255: int chan;
256: register char *bufp;
257: int count;
258: register fd;
259: {
260: int ret;
261: register i;
262: if((ret=psend(chan, bufp, count))==-1){
263: trace("psend hold on fd %d\n", fd);
264: layer[fd].bchan=chan;
265: layer[fd].bcount=count;
266: for(i=0; i<count; i++)
267: layer[fd].bbuf[i]=bufp[i];
268: blocked|=1<<fd;
269: }
270: return ret;
271: }
272: quit(s)
273: register char *s;
274: {
275: register l, i;
276:
277: ifdeftracing(trace("\nmux: %s\n", s); trace(0, 0); fflush(tracefd));
278: if(booted){
279: for(i=0; i<NSELFD; i++)
280: if(layer[i].busy)
281: (void)close(i);
282: layer[0].chan=0;
283: sendioctl(0, JTERM); /* kill demux ==> boot terminal */
284: for(i=Pxtimeout+1; Ptflag && i>0;){
285: enabled=1;
286: if((l=scan())==-1)
287: break;
288: i-=l;
289: }
290: alarm(0);
291: }
292: ioctl(0, TIOCSDEV, &devsave);
293: ioctl(0, TIOCSETP, &sttysave);
294: ioctl(0, TIOCNXCL, 0);
295: sleep(2);
296: if (s) {
297: write(2, progname, strlen(progname));
298: write(2, ": ", 2);
299: write(2, s, strlen(s));
300: write(2, "\n", 1);
301: }
302: #ifdef PSTATISTICS
303: for(i=0, l=0; i<PS_NSTATS; i++)
304: if (pstats[i].count) {
305: if(l++==0)
306: fprintf(stderr, "\nPacket protocol statistics:\n");
307: fprintf(stderr, "%6ld %s\n"
308: ,pstats[i].count
309: #ifdef PSTATSDESC
310: ,pstats[i].descp
311: #else
312: ,""
313: #endif
314: );
315: trace("%6ld ", pstats[i].count);
316: trace("%s\n", pstats[i].descp);
317: }
318: fflush(stderr);
319: #endif
320: #if TRACING == 1 || PDEBUG == 1
321: fprintf(stderr, "\nThere are traces in '%s'\n", tracefile);
322: #endif
323: ifdeftracing(fflush(tracefd); abort());
324: #ifdef MONITOR
325: monitor(0);
326: #endif
327: _exit(0);
328: }
329: /*
330: * Unpack a message buffer bp of length n.
331: */
332: unpack(fd, bp, n)
333: register int fd;
334: char *bp;
335: int n;
336: {
337: register struct mesg *mp;
338: struct ttychars tempchars;
339: static char cdbuf[256];
340: char *s;
341: register int size;
342: mp = (struct mesg *)bp;
343: size = mp->losize + (mp->hisize<<8);
344: trace("unpack fd %d", fd);
345: trace(" size %d", n);
346: trace(" count %d\n", size);
347: if(n<=0)
348: mp->type=M_HANGUP;
349: else if(layer[fd].more>0){
350: layer[fd].more-=n;
351: return sendchars(fd, bp, n);
352: }
353: switch (mp->type) {
354: case M_HANGUP:
355: trace("shell died\n", 0);
356: wait((int *)0);
357: if(layer[fd].busy){
358: sendioctl(fd, JDELETE);
359: /*(void)psend(layer[fd].chan, "Shell died.\n", 12);*/
360: }
361: layer[fd].busy = 0;
362: close(fd);
363: enabled &= ~(1<<fd);
364: return 1;
365: case M_DELAY:
366: default:
367: trace("ignore type 0%o\n", mp->type);
368: return 0;
369: case M_DELIM:
370: case M_DATA:
371: if(size==0){
372: trace("size 0 %s ignored\n", mp->type==M_DELIM? "delim" : "data");
373: return 0;
374: }
375: break;
376: case M_IOCTL:
377: mp->type = M_IOCACK;
378: switch (*(int *)(bp+MSGHLEN)) {
379: case TIOCSETP:
380: case TIOCSETN:
381: tempchars=layer[fd].ttychars;
382: setmodes(&tempchars, (struct sgttyb *)(bp+MSGHLEN+sizeof(int)));
383: ttyset(fd, &tempchars);
384: size = 0;
385: break;
386: case TIOCGETP:
387: tempchars=layer[fd].ttychars;
388: getmodes(&tempchars, (struct sgttyb *)(bp+MSGHLEN+sizeof(int)));
389: size=sizeof(struct sgttyb)+sizeof(int);
390: ttyset(fd, &tempchars);
391: break;
392: case TIOCSETC:
393: tempchars=layer[fd].ttychars;
394: settchars(&tempchars, (struct tchars *)(bp+MSGHLEN+sizeof(int)));
395: ttyset(fd, &tempchars);
396: size=0;
397: break;
398: case TIOCGETC:
399: gettchars(&layer[fd].ttychars, (struct tchars *)(bp+MSGHLEN+sizeof(int)));
400: size=sizeof (struct tchars) + sizeof (int);
401: break;
402: case TIOCSDEV:
403: size=0;
404: break;
405: case TIOCGDEV:
406: size=sizeof(devsave)+sizeof(int);
407: *(struct ttydevb *)(bp+MSGHLEN+sizeof(int))=devsave;
408: break;
409: case JMUX:
410: size=0;
411: break;
412: case JWINSIZE:
413: *((int *)(bp+MSGHLEN))=JWINSIZE; /* answering JWINSIZE ioctl */
414: #define BP ((struct winsize *)(bp+MSGHLEN+sizeof(int)))
415: BP->bytesx=layer[fd].dx;
416: BP->bytesy=layer[fd].dy;
417: BP->bitsx=layer[fd].bitsx;
418: BP->bitsy=layer[fd].bitsy;
419: size=sizeof(struct winsize)+sizeof(int);
420: break;
421: case JTERM:
422: case JBOOT:
423: case JZOMBOOT:
424: sendioctl(fd, *(int *)(bp+MSGHLEN));
425: size=0;
426: break;
427: case JEXIT:
428: sendioctl(fd, *(int *)(bp+MSGHLEN));
429: size=0;
430: break;
431: case JCHDIR:
432: s=bp+MSGHLEN+sizeof(int);
433: if(*s==0){
434: if(chdir(cdbuf)!=0)
435: mp->type = M_IOCNAK;
436: cdbuf[0]=0;
437: }else
438: strcat(cdbuf, s);
439: size = 0;
440: break;
441: default:
442: mp->type = M_IOCNAK;
443: size = 0;
444: }
445: mp->magic = MSGMAGIC; /* safety net */
446: mp->losize = size;
447: mp->hisize = size>>8;
448: write(fd, bp, MSGHLEN+size);
449: trace("unpack ioctl type '%c'", *(int *)(bp+MSGHLEN)>>8);
450: trace(" %d\n", *(int *)(bp+MSGHLEN)&0xff);
451: return 0;
452: }
453: if(size>MAXPKTDSIZE){
454: layer[fd].more=size-MAXPKTDSIZE;
455: size=MAXPKTDSIZE;
456: }
457: return sendchars(fd, bp+MSGHLEN, size);
458: }
459: getmodes(tp, bp)
460: register struct ttychars *tp;
461: register struct sgttyb *bp;
462: {
463: bp->sg_ispeed=sttysave.sg_ispeed;
464: bp->sg_ospeed=sttysave.sg_ospeed;
465: bp->sg_flags=(tp->flags1<<8)|(tp->flags0&0xFF);
466: bp->sg_erase=tp->erase;
467: bp->sg_kill=tp->kill;
468: }
469: setmodes(tp, bp)
470: register struct ttychars *tp;
471: register struct sgttyb *bp;
472: {
473: tp->flags0=bp->sg_flags;
474: tp->flags1=bp->sg_flags>>8;
475: tp->erase=bp->sg_erase;
476: tp->kill=bp->sg_kill;
477: }
478: gettchars(tp, bp)
479: register struct ttychars *tp;
480: register struct tchars *bp;
481: {
482: bp->t_intrc=tp->intrc;
483: bp->t_quitc=tp->quitc;
484: bp->t_startc=tp->startc;
485: bp->t_stopc=tp->stopc;
486: bp->t_eofc=tp->eofc;
487: bp->t_brkc=tp->brkc;
488: }
489: settchars(tp, bp)
490: register struct ttychars *tp;
491: register struct tchars *bp;
492: {
493: tp->intrc=bp->t_intrc;
494: tp->quitc=bp->t_quitc;
495: tp->startc=bp->t_startc;
496: tp->stopc=bp->t_stopc;
497: tp->eofc=bp->t_eofc;
498: tp->brkc=bp->t_brkc;
499: }
500: ttyset(fd, tp)
501: struct ttychars *tp;
502: {
503: register char *p, *q;
504: register i;
505: static struct ttycmesg m={JTTYC};
506: for(i=0, p=(char *)tp, q=(char *)&layer[fd].ttychars; *p++==*q++; i++)
507: if(i>=sizeof(struct ttychars))
508: return; /* no need to send; they're identical */
509: m.chan=layer[fd].chan;
510: layer[fd].ttychars = *tp;
511: m.ttychars = *tp;
512: (void)psend_hold(0, (char *)&m, sizeof m, fd);
513: }
514: sendioctl(fd, cmd)
515: {
516: char ioctlvec[2];
517: ioctlvec[0]=cmd;
518: ioctlvec[1]=layer[fd].chan;
519: if(psend_hold(0, ioctlvec, sizeof ioctlvec, fd)!=-1)
520: unblock(fd);
521: }
522: int
523: sendchars(fd, s, cc)
524: char *s;
525: int cc;
526: {
527: register int l=layer[fd].chan;
528: register int n;
529:
530: # ifdef TRACING
531: char buf[256];
532: trace("write %d chars ", cc);
533: trace("to layer %d\n", l);
534: strncpy(buf, s, cc);
535: buf[cc]=0;
536: trace("<%s>\n", buf);
537: # endif
538: if(fd!=0 && layer[fd].busy==0)
539: return 0; /* layer was deleted, but there's still data */
540: if(cc>0)
541: do{
542: if((n=cc)>MAXPKTDSIZE)
543: n=MAXPKTDSIZE;
544: if(psend(l, s, n)==-1){
545: trace("layer %d blocked\n", l);
546: return fd; /* BUG */
547: }
548: }while(s+=n, (cc-=n)>0);
549: unblock(fd);
550: return 0;
551: }
552: unblock(fd)
553: int fd;
554: {
555: register Pch_p pcp= &pconvs[layer[fd].chan];
556:
557: trace("unblock for layer %d", layer[fd].chan);
558: trace(" freepkts=%d\n", pcp->freepkts);
559: if(fd==0)
560: return;
561: if(pcp->freepkts>=1)
562: enabled|=1<<fd;
563: else
564: enabled&=~(1<<fd);
565: }
566: void
567: lerror(l, s, t)
568: int l;
569: char *s, t;
570: {
571: char ebuf[128];
572: int busy;
573: strcpy(ebuf, s);
574: if(errno){
575: strcat(ebuf, ": ");
576: if(errno < sys_nerr)
577: strcat(ebuf, sys_errlist[errno]);
578: else{
579: strcat(ebuf, "error ");
580: strcat(ebuf, itoa(errno));
581: }
582: errno=0;
583: }
584: strcat(ebuf, "\n");
585: trace("lerror type %d", t);
586: trace(" for layer %d", l);
587: trace(" %s\n", ebuf);
588: layer[0].chan=l;
589: sendchars(0, ebuf, strlen(ebuf));
590: }
591: int
592: creceive(l, s, n)
593: char *s;
594: {
595: if(s[0]!=C_UNBLK || n!=1)
596: quit("bad control type");
597: (void)receive(l, s, n);
598: }
599: int
600: receive(l, s, cc)
601: int l;
602: register char *s;
603: register int cc;
604: {
605: register int i;
606: struct mesg hupmsg;
607: if((i=ltofd(l))==-1)
608: switch(*s){
609: case C_NEW:
610: case C_EXIT:
611: break;
612: default:
613: errno = 0;
614: lerror(l, "inactive layer", *s);
615: case C_UNBLK:
616: return 0;
617: }
618: while(cc--){
619: trace("receive C type %d", *s);
620: trace(" for layer %d", l);
621: trace(" fd %d\n", i);
622: switch(*s++){
623: case C_SENDCHAR: /* send layer char */
624: wrmesgb(i, s++, 1);
625: delim(i);
626: cc--;
627: break;
628: case C_DELIM: /* send delimiter */
629: delim(i);
630: break;
631: case C_NEW: /* make layer */
632: if((i=doshell())==-1){
633: lerror(l, umesgf, C_NEW);
634: trace("can't open %s\n", umesgf);
635: cc-=6;
636: break;
637: }
638: layer[i].busy=1;
639: layer[i].chan=l;
640: ttyset(i, &ttychars);
641: trace("new fd %d ", i);
642: trace("layer %d ", l);
643: enabled |= (1<<i);
644: case C_RESHAPE:
645: layer[i].dx= *s++;
646: trace("x wid %d ", layer[i].dx);
647: layer[i].dy= *s++;
648: trace("y wid %d\n", layer[i].dy);
649: layer[i].bitsx=(unsigned char)*s++;
650: layer[i].bitsx|=(*s++)<<8;
651: layer[i].bitsy=(unsigned char)*s++;
652: layer[i].bitsy|=(*s++)<<8;
653: cc-=6;
654: break;
655: case C_UNBLK: /* unblock layer */
656: unblock(i);
657: break;
658: case C_PUSHLD: /* push ld onto stream */
659: pushld(i);
660: break;
661: case C_POPLD: /* pop ld from stream */
662: popld(i);
663: break;
664: case C_DELETE: /* delete layer */
665: hupmsg.losize=0;
666: hupmsg.hisize=0;
667: hupmsg.magic=MSGMAGIC;
668: hupmsg.type=M_HANGUP;
669: write(i, (char *)&hupmsg, MSGHLEN);
670: layer[i].busy=0;
671: pconvs[layer[i].chan].freepkts=1; /* hack */
672: unblock(i);
673: layer[i].ttychars=zerochars;
674: break;
675: case C_EXIT: /* exit */
676: quitflag++;
677: return 0;
678: case C_SENDNCHARS: /* send cc characters */
679: wrmesgb(i, s, cc);
680: return 0;
681: case C_KILL: /* send layer signal */
682: dosig(i, *s++);
683: cc--;
684: break;
685: default:
686: quit("unknown state incase 0");
687: }
688: ifdeftracing(if(cc<0) quit("bad count in receive"));
689: }
690: return 0;
691: }
692: int
693: ltofd(l)
694: {
695: register i;
696: if(l==0)
697: return 0;
698: for(i=1; i<NSELFD; i++)
699: if(layer[i].busy && layer[i].chan==l)
700: return i;
701: trace("unknown layer %d\n", l);
702: return -1;
703: }
704: void
705: dosig(fd, sig) /* Interrupt shell */
706: {
707: char sigbuf[MSGHLEN+1];
708: register struct mesg *mp;
709:
710: mp = (struct mesg *)sigbuf;
711: mp->type=M_SIGNAL;
712: mp->magic=MSGMAGIC;
713: mp->losize=sizeof(char);
714: mp->hisize=0;
715: sigbuf[MSGHLEN]=sig;
716: write(fd, sigbuf, MSGHLEN+1);
717: mp->type=M_FLUSH;
718: mp->magic=MSGMAGIC;
719: mp->losize=0;
720: mp->hisize=0;
721: write(fd, sigbuf, MSGHLEN);
722: }
723: void
724: wrmesgb(fd, cp, n)
725: register char *cp;
726: int n;
727: {
728: char wrbuf[MAXPKTDSIZE+MSGHLEN];
729: register char *bp;
730: register struct mesg *mp;
731: register int i;
732:
733: ifdeftracing(fprintf(tracefd, "mesg to fd %d: <%.*s>\n", fd, n, cp));
734: mp = (struct mesg *)wrbuf;
735: mp->type=M_DATA;
736: mp->magic=MSGMAGIC;
737: mp->losize=n;
738: mp->hisize=n>>8;
739: bp=wrbuf+MSGHLEN;
740: i=n;
741: while(i--)
742: *bp++= *cp++;
743: write(fd, wrbuf, MSGHLEN+n);
744: }
745: delim(fd)
746: {
747: struct mesg delbuf;
748:
749: ifdeftracing(fprintf(tracefd, "delim fd %d\n", fd));
750: delbuf.type=M_DELIM;
751: delbuf.magic=MSGMAGIC;
752: delbuf.losize=0;
753: delbuf.hisize=0;
754: write(fd, (char *)&delbuf, MSGHLEN);
755: }
756: popld(fd)
757: {
758: register f, i;
759: struct ttychars tempchars;
760: struct sgttyb tb;
761: struct tchars tc;
762: errno=0;
763: if((f=open(layer[fd].ptfile, 2))>0){
764: if((i=ioctl(f, FIOLOOKLD, 0))==tty_ld) {
765: i=0;
766: if(ioctl(f, TIOCGETP, &tb)<0
767: || ioctl(f, TIOCGETC, &tc)<0)
768: i=1; /* hack for old systems */
769: ioctl(f, FIOPOPLD, (struct sgttyb *)0);
770: if(i==0){
771: setmodes(&tempchars, &tb);
772: settchars(&tempchars, &tc);
773: ttyset(fd, &tempchars);
774: }
775: }
776: else if(i>=0)
777: lerror(layer[fd].chan, "mux warning: unknown line discipline", 0);
778: }
779: close(f);
780: trace("popld file %s\n", layer[fd].ptfile);
781: trace("popld file descriptor %d\n", f);
782: }
783: pushld(fd)
784: {
785: register f, i;
786: int tty;
787: struct tchars tc;
788: struct sgttyb tb;
789: if((f=open(layer[fd].ptfile, 2))>0){
790: if((i=ioctl(f, FIOLOOKLD, 0))==-1){
791: ioctl(f, FIOPUSHLD, (struct sgttyb *)&tty_ld);
792: getmodes(&layer[fd].ttychars, &tb);
793: gettchars(&layer[fd].ttychars, &tc);
794: ioctl(f, TIOCSETP, &tb);
795: ioctl(f, TIOCSETC, &tc);
796: }else
797: ; /* can't warn; program could be e.g. jim! */
798: }
799: trace("pushld errno file %d\n", errno);
800: close(f);
801: trace("pushld file descriptor file %s\n", layer[fd].ptfile);
802: }
803: int
804: doshell()
805: {
806: register fd, slave;
807: trace("do shell\n", 0);
808: if((fd=ptopen(umesgf))<0){
809: trace("can't open %s\n", umesgf);
810: return -1;
811: }
812: if((slave=open(umesgf, 2))==-1){
813: trace("can't open %s\n", umesgf);
814: close(fd);
815: return -1;
816: }
817: trace("opened %s\n", umesgf);
818: strcpy(layer[fd].ptfile, umesgf);
819: if(ioctl(fd, FIOPUSHLD, &mesg_ld) == -1){
820: trace("FIOPUSHLD fails, errno=%d\n", errno);
821: close(fd);
822: return -1;
823: }
824: switch(fork()){
825: case 0:
826: /* close every file descriptor in sight, and then some */
827: for(fd=0; fd<5+NLAYERS; fd++)
828: if(fd!=slave)
829: close(fd);
830: dup(slave); dup(slave); dup(slave); dup(slave);
831: close(slave);
832: ioctl(0, TIOCSPGRP, 0);
833: signal(SIGPIPE, (int (*)())0);
834: execlp(shell, shell, 0);
835: perror(shell);
836: exit(1);
837: break;
838: case -1:
839: close(fd);
840: return -1;
841: }
842: trace("doshell succeeds\n", 0);
843: close(slave);
844: return fd;
845: }
846: int
847: boot(s)
848: char *s;
849: {
850: if(system("/usr/jerq/bin/32ld", "32ld", s))
851: return 1;
852: sleep(2);
853: return 0;
854: }
855: int
856: system(s, t, u)
857: char *s, *t, *u;
858: {
859: int status, pid, l;
860:
861: if ((pid=fork())==0){
862: execl(s, t, u, 0);
863: _exit(127);
864: }
865: while ((l = wait(&status)) != pid && l != -1)
866: ;
867: if (l == -1)
868: status = -1;
869: return(status);
870: }
871: char *
872: itoa(i)
873: register int i;
874: {
875: static char str[11];
876: register char * sp = &str[sizeof str];
877:
878: *--sp = '\0';
879: if(i>0){
880: do
881: *--sp=i%10+'0';
882: while((i/=10)>0);
883: }else
884: *--sp='0';
885: return sp;
886: }
887: service(argc, argv)
888: char *argv[];
889: {
890: if(strcmp(argv[0], "cd")==0){
891: char *where=argv[1];
892: char buf[CDSIZE+1];
893: buf[CDSIZE]=0;
894: if(where==0 && (where=getenv("HOME"))==0){
895: write(2, "cd: no HOME set\n", 16);
896: return 1;
897: }
898: while(*where){
899: strncpy(buf, where, CDSIZE);
900: ioctl(0, JCHDIR, buf);
901: where+=strlen(buf);
902: }
903: if(ioctl(0, JCHDIR, where)!=0){
904: write(2, "cd: bad directory\n", 18);
905: return 1;
906: }
907: return 0;
908: }
909: if(strcmp(argv[0], "exit")==0)
910: return ioctl(0, JEXIT, 0);
911: write(2, "mux: no such command ", 21);
912: write(2, argv[0], strlen(argv[0]));
913: write(2, "\n", 1);
914: return 1;
915: }
916: #ifdef TRACING
917: /*VARARGS1*/
918: void
919: trace(s, a)
920: char *s, *a;
921: {
922: long t;
923: extern long time();
924: extern char *ctime();
925:
926: if(s)
927: fprintf(tracefd, s, a);
928: else{
929: (void)time(&t);
930: fprintf(tracefd, "%.9s", ctime(&t)+11);
931: }
932: }
933: int
934: twrite(fd, s, n)
935: unsigned char * s;
936: {
937: register i;
938: fprintf(tracefd, "to jerq: ");
939: for(i=0; i<n; i++)
940: fprintf(tracefd, "<%o>", s[i]);
941: fprintf(tracefd, "\n");
942: return write(fd, s, n);
943: }
944: void
945: tread(s, n)
946: unsigned char * s;
947: {
948: register i;
949: fprintf(tracefd, "from jerq: ");
950: for(i=0; i<n; i++)
951: fprintf(tracefd, "<%o>", s[i]);
952: fprintf(tracefd, "\n");
953: }
954: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.