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