![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mx2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 41BSD / 4.0.upgrade / sys / dev|
Return to mx2.c CVS log | Up to [CSRG BSD Unix] / 41BSD / 4.0.upgrade / sys / dev |
1.1 root 1: /* mx2.c 4.7 81/09/11 */
2:
3: #include "../h/param.h"
4: #include "../h/systm.h"
5: #include "../h/dir.h"
6: #include "../h/user.h"
7: #include "../h/proc.h"
8: #include "../h/tty.h"
9: #include "../h/inode.h"
10: #include "../h/mx.h"
11: #include "../h/file.h"
12: #include "../h/conf.h"
13: #include "../h/buf.h"
14: /*
15: * multiplexor driver
16: */
17: struct chan chans[NCHANS];
18: struct group *groups[NGROUPS];
19: int mpxline;
20:
21: short cmask[16] ={
22: 01, 02, 04,
23: 010, 020, 040,
24: 0100, 0200, 0400,
25: 01000, 02000, 04000,
26: 010000, 020000, 040000, 0100000
27: };
28:
29: #define IOMOVE iomove
30: struct chan *xcp(),*addch(),*nextcp();
31:
32: #define HIQ 100
33: #define LOQ 20
34: #define FP ((struct file *)cp)
35:
36: char mcdebugs[NDEBUGS];
37:
38: struct group *
39: getmpx(dev)
40: dev_t dev;
41: {
42: register d;
43:
44: d = minor(dev);
45: if (d >= NGROUPS) {
46: u.u_error = ENXIO;
47: return(NULL);
48: }
49: return(groups[d]);
50: }
51:
52:
53: /*ARGSUSED*/
54: mxopen(dev, flag)
55: {
56: register struct group *gp;
57: register struct file *fp;
58: register struct chan *cp;
59: int msg;
60:
61: if ((gp=getmpx(dev)) == NULL) {
62: return;
63: }
64: if (!(gp->g_state&INUSE)) {
65: u.u_error = ENXIO;
66: return;
67: }
68: fp = u.u_ofile[u.u_r.r_val1];
69: if (fp->f_inode != gp->g_inode) {
70: u.u_error = ENXIO;
71: return;
72: }
73: if ((cp=addch(gp->g_inode,0)) == NULL) {
74: u.u_error = ENXIO;
75: return;
76: }
77:
78: cp->c_flags = XGRP;
79: cp->c_ottyp = cp->c_ttyp = (struct tty *)cp;
80: cp->c_line = cp->c_oline = mpxline;
81:
82: fp->f_flag |= FMPY;
83: fp->f_flag |= FREAD+FWRITE;
84: fp->f_un.f_chan = cp;
85:
86: if (gp->g_inode == mpxip) {
87: plock(mpxip);
88: mpxname(cp);
89: msg = M_OPEN;
90: } else
91: msg = M_WATCH;
92:
93: scontrol(cp, msg+(cp->c_index<<8), u.u_uid);
94: sleep((caddr_t)cp,TTIPRI);
95: if (cp->c_flags&NMBUF)
96: prele(mpxip);
97: if (cp->c_flags & WCLOSE) {
98: chdrain(cp);
99: chfree(cp);
100: u.u_error = ENXIO;
101: return;
102: }
103: cp->c_fy = fp;
104: cp->c_pgrp = u.u_procp->p_pgrp;
105: }
106:
107:
108: char mxnmbuf[NMSIZE];
109: int nmsize;
110:
111: mpxname(cp)
112: register struct chan *cp;
113: {
114: register char *np;
115: register c;
116:
117: np = mxnmbuf;
118: u.u_dirp = (caddr_t)u.u_arg[0];
119:
120: while (np < &mxnmbuf[NMSIZE]) {
121: c = uchar();
122: if (c <= 0)
123: break;
124: *np++ = c;
125: }
126: *np++ = '\0';
127: nmsize = np - mxnmbuf;
128:
129: cp->c_flags |= NMBUF;
130: }
131:
132:
133: mxclose(dev, flag, fp)
134: dev_t dev;
135: register struct file *fp;
136: {
137: register struct chan *cp = fp->f_un.f_chan;
138: register struct group *gp;
139: register struct inode *ip;
140: int i, fmp;
141:
142: fmp = flag&FMP;
143: if ((gp=getmpx(dev)) == NULL)
144: return;
145:
146: ip = gp->g_inode;
147: if (ip==NULL || (ip->i_mode&IFMT)!=IFMPC) {
148: return;
149: }
150:
151: /*
152: * close a channel
153: */
154: if (cp!=NULL && fmp && fmp!=FMP) {
155: for(fp=file; fp< fileNFILE; fp++)
156: if(fp->f_count && fp->f_flag&FMP && fp->f_un.f_chan==cp){
157: return;
158: }
159: chdrain(cp);
160: if ((cp->c_flags&WCLOSE)==0) {
161: scontrol(cp, M_CLOSE, 0);
162: cp->c_flags |= WCLOSE;
163: } else {
164: chfree(cp);
165: }
166: goto out;
167: }
168:
169:
170: for(fp=file; fp < fileNFILE; fp++) {
171: if (fp->f_count && (fp->f_flag&FMP)==FMP && fp->f_inode==ip)
172: return;
173: }
174:
175: if (ip == mpxip) {
176: mpxip = NULL;
177: prele(ip);
178: }
179:
180: for(i=0;i<NINDEX;i++)
181: (void) detach(gp->g_chans[i]);
182:
183: out:
184: plock(ip);
185: if (ip->i_count == 1) {
186: groups[minor(dev)] = NULL;
187: zero((caddr_t)gp, sizeof (struct group));
188: ip->i_mode = IFREG + 0666;
189: ip->i_un.i_rdev = 0;
190: ip->i_flag |= IUPD|ICHG;
191: iput(ip);
192: return;
193: }
194: prele(ip);
195: }
196:
197: zero(s, cc)
198: register char *s;
199: register cc;
200: {
201: while (cc--)
202: *s++ = 0;
203: }
204:
205: char m_eot[] ={ M_EOT, 0, 0, 0};
206:
207: /*
208: * Mxread + mxwrite are entered from cdevsw
209: * for all read/write calls. Operations on
210: * an mpx file are handled here.
211: * Calls are made through linesw to handle actual
212: * data movement.
213: */
214: mxread(dev)
215: {
216: register struct group *gp;
217: register struct chan *cp;
218: register esc;
219: struct rh h;
220: caddr_t base;
221: unsigned count;
222: int s, xfr, more, fmp;
223:
224: if ((gp=getmpx(dev))==NULL || (FP=getf(u.u_arg[0]))==NULL) {
225: u.u_error = ENXIO;
226: return;
227: }
228:
229: fmp = FP->f_flag & FMP;
230: if (fmp != FMP) {
231: if (u.u_count == 0)
232: return;
233: msread(fmp, FP->f_un.f_chan);
234: return;
235: }
236:
237: if ((int)u.u_base & 1) {
238: u.u_error = ENXIO;
239: return;
240: }
241:
242: s = spl6();
243: if (u.u_count == 0)
244: {
245: if (gp->g_datq == 0)
246: u.u_error = ENXIO;
247: splx(s);
248: return;
249: }
250: while (gp->g_datq == 0) {
251: sleep((caddr_t)&gp->g_datq, TTIPRI);
252: }
253: splx(s);
254:
255: while (gp->g_datq && u.u_count >= CNTLSIZ + 2) {
256: esc = 0;
257: cp = nextcp(gp);
258: if (cp==NULL) {
259: continue;
260: }
261: h.index = cpx(cp);
262: if (count = cp->c_ctlx.c_cc) {
263: count += CNTLSIZ;
264: if (cp->c_flags&NMBUF)
265: count += nmsize;
266: if (count > u.u_count) {
267: (void) sdata(cp);
268: return;
269: }
270: esc++;
271: }
272: base = u.u_base;
273: count = u.u_count;
274: u.u_base += sizeof h;
275: u.u_count -= sizeof h;
276: xfr = u.u_count;
277: if (esc) {
278: more = mcread(cp);
279: } else {
280: more = (*linesw[cp->c_line].l_read)(cp->c_ttyp);
281: }
282: if (more > 0)
283: (void) sdata(cp);
284: if (more < 0)
285: scontrol(cp, M_CLOSE, 0);
286: (void) spl0();
287: if (xfr == u.u_count) {
288: esc++;
289: IOMOVE((caddr_t)m_eot, sizeof m_eot, B_READ);
290: }
291: xfr -= u.u_count;
292: if (esc) {
293: h.count = 0;
294: h.ccount = xfr;
295: } else {
296: h.count = xfr;
297: h.ccount = 0;
298: mxrstrt(cp, &cp->cx.datq, BLOCK|ALT);
299: }
300: if (u.u_count && (xfr&1)) {
301: u.u_base++;
302: u.u_count--;
303: }
304: (void) copyout((caddr_t)&h, base, sizeof h);
305:
306: }
307: }
308:
309:
310: mxwrite(dev)
311: {
312: register struct chan *cp;
313: struct wh h;
314: struct group *gp;
315: int ucount, esc, fmp, burpcount;
316: caddr_t ubase, hbase;
317:
318: if ((gp=getmpx(dev))==NULL || (FP=getf(u.u_arg[0]))==NULL) {
319: return;
320: }
321: fmp = FP->f_flag & FMP;
322: if (fmp != FMP) {
323: mswrite(fmp, FP->f_un.f_chan);
324: return;
325: }
326:
327: burpcount = 0;
328: while (u.u_count >= sizeof h) {
329: hbase = u.u_base;
330: IOMOVE((caddr_t)&h, sizeof h, B_WRITE);
331: if (u.u_error)
332: return;
333: esc = 0;
334: if (h.count==0) {
335: esc++;
336: h.count = h.ccount;
337: }
338: cp = xcp(gp, h.index);
339: if (cp==NULL || cp->c_flags&ISGRP) {
340: u.u_error = ENXIO;
341: return;
342: }
343: ucount = u.u_count;
344: ubase = u.u_base;
345: u.u_count = h.count;
346: u.u_base = h.data;
347:
348: if (esc==0) {
349: struct tty *tp;
350: caddr_t waddr;
351: int line;
352:
353: if (cp->c_flags&PORT) {
354: line = cp->c_line;
355: tp = cp->c_ttyp;
356: } else {
357: line = cp->c_oline;
358: tp = cp->c_ottyp;
359: }
360: loop:
361: waddr = (caddr_t)(*linesw[line].l_write)(tp);
362: if (u.u_count) {
363: if (gp->g_state&ENAMSG) {
364: burpcount++;
365: cp->c_flags |= BLKMSG;
366: /*
367: scontrol(cp, M_BLK, u.u_count);
368: */
369: h.ccount = -1;
370: h.count = u.u_count;
371: h.data = u.u_base;
372: (void) copyout((caddr_t)&h, hbase, sizeof h);
373: } else {
374: if(waddr == 0) {
375: u.u_error = ENXIO;
376: return;
377: }
378: sleep(waddr, TTOPRI);
379: goto loop;
380: }
381: }
382: } else {
383: mxwcontrol(cp);
384: }
385: u.u_count = ucount;
386: u.u_base = ubase;
387: }
388: u.u_count = burpcount;
389: }
390:
391:
392:
393: /*
394: * Mcread and mcwrite move data on an mpx file.
395: * Transfer addr and length is controlled by mxread/mxwrite.
396: * Kernel-to-Kernel and other special transfers are not
397: * yet in.
398: */
399: mcread(cp)
400: register struct chan *cp;
401: {
402: register struct clist *q;
403: register char *np;
404:
405:
406: q = (cp->c_ctlx.c_cc) ? &cp->c_ctlx : &cp->cx.datq;
407: (void) mxmove(q, B_READ);
408:
409: if (cp->c_flags&NMBUF && q == &cp->c_ctlx) {
410: np = mxnmbuf;
411: while (nmsize--)
412: (void) passc(*np++);
413: cp->c_flags &= ~NMBUF;
414: prele(mpxip);
415: }
416: if (cp->c_flags&PORT)
417: return(cp->c_ctlx.c_cc + cp->c_ttyp->t_rawq.c_cc); else
418: return(cp->c_ctlx.c_cc + cp->cx.datq.c_cc);
419:
420: }
421:
422:
423: caddr_t
424: mcwrite(cp)
425: register struct chan *cp;
426: {
427: register struct clist *q;
428: int s;
429:
430: q = &cp->cy.datq;
431: while (u.u_count) {
432: s = spl6();
433: if (q->c_cc > HIQ || (cp->c_flags&EOTMARK)) {
434: cp->c_flags |= SIGBLK;
435: splx(s);
436: break;
437: }
438: splx(s);
439: (void) mxmove(q, B_WRITE);
440: }
441: wakeup((caddr_t)q);
442: return((caddr_t)q);
443: }
444:
445:
446: /*
447: * Msread and mswrite move bytes
448: * between user and non-multiplexed channel.
449: */
450: msread(fmp, cp)
451: register struct chan *cp;
452: {
453: register struct clist *q;
454: int s;
455:
456: q = (fmp&FMPX) ? &cp->cx.datq : &cp->cy.datq;
457: s = spl6();
458: while (q->c_cc == 0) {
459: if (cp->c_flags&WCLOSE) {
460: u.u_error = ENXIO;
461: goto out;
462: }
463: if (cp->c_flags & EOTMARK) {
464: cp->c_flags &= ~EOTMARK;
465: if(msgenab(cp))
466: scontrol(cp, M_UBLK, 0);
467: else {
468: wakeup((caddr_t)cp);
469: wakeup((caddr_t)q);
470: }
471: goto out;
472: }
473: sleep((caddr_t)q,TTIPRI);
474: }
475: if (cp->c_flags&WCLOSE) {
476: u.u_error = ENXIO;
477: goto out;
478: }
479: splx(s);
480: while (mxmove(q, B_READ) > 0)
481: ;
482: mxrstrt(cp, q, SIGBLK);
483: return;
484: out:
485: splx(s);
486: }
487:
488:
489: mswrite(fmp, cp)
490: register struct chan *cp;
491: {
492: register struct clist *q;
493: register int cc;
494:
495: q = (fmp&FMPX) ? &cp->cy.datq : &cp->cx.datq;
496: while (u.u_count) {
497: (void) spl6();
498: if (cp->c_flags&WCLOSE) {
499: gsignal(cp->c_pgrp, SIGPIPE);
500: (void) spl0();
501: return;
502: }
503: if (q->c_cc>= HIQ || cp->c_flags&FBLOCK) {
504: if (cp->c_flags&WCLOSE) {
505: gsignal(cp->c_pgrp, SIGPIPE);
506: (void) spl0();
507: return;
508: }
509: (void) sdata(cp);
510: cp->c_flags |= BLOCK;
511: sleep((caddr_t)q+1,TTOPRI);
512: (void) spl0();
513: continue;
514: }
515: (void) spl0();
516: cc = mxmove(q, B_WRITE);
517: if (cc < 0)
518: break;
519: }
520: if (fmp&FMPX) {
521: if (cp->c_flags&YGRP) (void) sdata(cp);
522: else wakeup((caddr_t)q);
523: } else {
524: if (cp->c_flags&XGRP) (void) sdata(cp);
525: else wakeup((caddr_t)q);
526: }
527: }
528:
529:
530: /*
531: * move chars between clist and user space.
532: */
533:
534: mxmove(q, dir)
535: register struct clist *q;
536: register dir;
537: {
538: register cc;
539: char cbuf[HIQ];
540:
541: cc = MIN(u.u_count, sizeof cbuf);
542: if (dir == B_READ)
543: cc = q_to_b(q, cbuf, cc);
544: if (cc <= 0)
545: return(cc);
546: IOMOVE((caddr_t)cbuf, (unsigned)cc, dir);
547: if (dir == B_WRITE)
548: cc = b_to_q(cbuf, cc, q);
549: return(cc);
550: }
551:
552:
553:
554: mxrstrt(cp, q, b)
555: register struct chan *cp;
556: register struct clist *q;
557: register b;
558: {
559: int s;
560:
561: s = spl6();
562: if (cp->c_flags&b && q->c_cc<LOQ) {
563: cp->c_flags &= ~b;
564: if (b&ALT)
565: wakeup((caddr_t)q+1); else
566: if (b&(BLKMSG))
567: scontrol(cp, M_UBLK, 0); else
568: wakeup((caddr_t)q);
569: }
570: if (cp->c_flags&WFLUSH)
571: wakeup((caddr_t)q+2);
572: splx(s);
573: }
574:
575:
576:
577: /*
578: * called from driver start or xint routines
579: * to wakeup output sleeper.
580: */
581: mcstart(cp, q)
582: register struct chan *cp;
583: register caddr_t q;
584: {
585:
586: if (cp->c_flags&(BLKMSG)) {
587: cp->c_flags &= ~BLKMSG;
588: scontrol(cp, M_UBLK, 0);
589: } else
590: wakeup((caddr_t)q);
591: }
592:
593:
594: mxwcontrol(cp)
595: register struct chan *cp;
596: {
597: short cmd;
598: struct sgttyb vec;
599: int s;
600:
601: IOMOVE((caddr_t)&cmd, sizeof cmd, B_WRITE);
602: if (u.u_error)
603: return;
604: switch(cmd) {
605: /*
606: * not ready to queue this up yet.
607: */
608: case M_EOT:
609: s = spl6();
610: while (cp->c_flags & EOTMARK)
611: if(msgenab(cp)){
612: scontrol(cp, M_BLK, 0);
613: goto out;
614: } else
615: sleep((caddr_t)cp, TTOPRI);
616: cp->c_flags |= EOTMARK;
617: out:
618: wakeup((caddr_t)&cp->cy.datq);
619: splx(s);
620: break;
621: case M_IOCTL:
622: break;
623: case M_IOANS:
624: if (cp->c_flags&SIOCTL) {
625: IOMOVE((caddr_t)&vec, sizeof vec, B_WRITE);
626: (void) b_to_q((caddr_t)&vec, sizeof vec, &cp->c_ctly);
627: cp->c_flags &= ~SIOCTL;
628: wakeup((caddr_t)cp);
629: }
630: break;
631: case M_BLK:
632: cp->c_flags |= FBLOCK;
633: break;
634: case M_UBLK:
635: cp->c_flags &= ~FBLOCK;
636: chwake(cp);
637: break;
638: default:
639: u.u_error = ENXIO;
640: }
641: }
642:
643:
644:
645: /*ARGSUSED*/
646: mxioctl(dev, cmd, addr, flag)
647: caddr_t addr;
648: {
649: struct group *gp;
650: int fmp;
651: struct file *fp;
652: struct {
653: short c_ctl;
654: short c_cmd;
655: struct sgttyb c_vec;
656: } ctlbuf;
657:
658: if ((gp=getmpx(dev))==NULL || (fp=getf(u.u_arg[0]))==NULL) {
659: return;
660: }
661:
662: fmp = fp->f_flag & FMP;
663: if (fmp == FMP) {
664: switch(cmd) {
665:
666: case MXLSTN:
667: if (mpxip == NULL) {
668: mpxip = gp->g_inode;
669: } else {
670: u.u_error = ENXIO;
671: return;
672: }
673: break;
674:
675: case MXNBLK:
676: gp->g_state |= ENAMSG;
677: break;
678:
679: default:
680: u.u_error = ENXIO;
681: return;
682: }
683: } else {
684: ctlbuf.c_ctl = M_IOCTL;
685: ctlbuf.c_cmd = cmd;
686: (void) copyin(addr, (caddr_t)&ctlbuf.c_vec, sizeof (struct sgttyb));
687: sioctl(fp->f_un.f_chan, (char *)&ctlbuf, sizeof ctlbuf);
688: (void) copyout((caddr_t)&ctlbuf, addr, sizeof (struct sgttyb));
689: }
690: }
691:
692:
693: chdrain(cp)
694: register struct chan *cp;
695: {
696: register struct tty *tp;
697: int wflag;
698:
699: chwake(cp);
700:
701: wflag = (cp->c_flags&WCLOSE)==0;
702: tp = cp->c_ttyp;
703: if (tp == NULL) /* prob not required */
704: return;
705: if (cp->c_flags&PORT && tp->t_chan == cp) {
706: cp->c_ttyp = NULL;
707: tp->t_chan = NULL;
708: return;
709: }
710: if (wflag)
711: wflush(cp,&cp->cx.datq); else
712: flush(&cp->cx.datq);
713: if (!(cp->c_flags&YGRP)) {
714: flush(&cp->cy.datq);
715: }
716: }
717:
718: chwake(cp)
719: register struct chan *cp;
720: {
721: register char *p;
722:
723: wakeup((caddr_t)cp);
724: flush(&cp->c_ctlx);
725: p = (char *)&cp->cx.datq;
726: wakeup((caddr_t)p); wakeup((caddr_t)++p); wakeup((caddr_t)++p);
727: p = (char *)&cp->cy.datq;
728: wakeup((caddr_t)p); wakeup((caddr_t)++p); wakeup((caddr_t)++p);
729: }
730:
731:
732: chfree(cp)
733: register struct chan *cp;
734: {
735: register struct group *gp;
736: register i;
737:
738: gp = cp->c_group;
739: if (gp==NULL)
740: return;
741: i = cp->c_index;
742: if (cp == gp->g_chans[i]) {
743: gp->g_chans[i] = NULL;
744: }
745: cp->c_group = NULL;
746: wakeup((caddr_t)gp);
747: }
748:
749:
750: flush(q)
751: register struct clist *q;
752: {
753:
754: while(q->c_cc)
755: (void) getc(q);
756: }
757:
758:
759: wflush(cp,q)
760: register struct chan *cp;
761: register struct clist *q;
762: {
763: register s;
764:
765: s = spl6();
766: if(q->c_cc && (cp->c_flags&WCLOSE) == 0) {
767: cp->c_flags |= WFLUSH;
768: (void) sdata(cp);
769: (void) tsleep((caddr_t)q+2, TTOPRI, 30);
770: }
771: flush(q);
772: cp->c_flags &= ~WFLUSH;
773: splx(s);
774: }
775:
776:
777: scontrol(cp,event,value)
778: register struct chan *cp;
779: short event,value;
780: {
781: register struct clist *q;
782: int s;
783:
784: q = &cp->c_ctlx;
785: s = spl6();
786: if (sdata(cp) == NULL)
787: return;
788: (void) putw(event,q);
789: (void) putw(value,q);
790: splx(s);
791: }
792:
793:
794:
795: sioctl(cp, vec, cc)
796: register struct chan *cp;
797: char *vec;
798: {
799: register s;
800: register struct clist *q;
801:
802: s = spl6();
803: q = &cp->cx.datq;
804: while (q->c_cc) {
805: cp->c_flags |= BLOCK;
806: if (sdata(cp)==NULL) {
807: u.u_error = ENXIO;
808: return;
809: }
810: sleep((caddr_t)q+1, TTOPRI);
811: }
812: (void) b_to_q(vec, cc, &cp->c_ctlx);
813: cp->c_flags |= SIOCTL;
814: while (cp->c_flags&SIOCTL) {
815: if (cp->c_ctlx.c_cc)
816: if (sdata(cp)==NULL) {
817: u.u_error = ENXIO;
818: return;
819: }
820: sleep((caddr_t)cp, TTOPRI);
821: }
822: (void) q_to_b(&cp->c_ctly, vec, cp->c_ctly.c_cc);
823: splx(s);
824: }
825:
826: sdata(cp)
827: struct chan *cp;
828: {
829: register struct group *gp = (struct group *)cp;
830: register struct group *ngp;
831: register int s;
832:
833: ngp = gp->g_group;
834: if (ngp==NULL || (ngp->g_state&ISGRP)==0)
835: return(NULL);
836:
837: s = spl6();
838: do {
839: ngp->g_datq |= cmask[gp->g_index];
840: wakeup((caddr_t)&ngp->g_datq);
841: gp = ngp;
842: } while(ngp=ngp->g_group);
843: splx(s);
844: return((int)gp);
845: }
846:
847:
848:
849: struct chan *
850: xcp(gp, x)
851: register struct group *gp;
852: register short x;
853: {
854: register int i;
855:
856: while (gp->g_group) gp=gp->g_group;
857: for (i=0;i<NLEVELS;i++) {
858: if ((x&017) >= NINDEX)
859: break;
860: if (gp==NULL || (gp->g_state&ISGRP)==0)
861: return((struct chan *)NULL);
862: gp = (struct group *)gp->g_chans[x&017];
863: x >>= 4;
864: }
865: return((struct chan *)gp);
866: }
867:
868: cpx(cp)
869: register struct chan *cp;
870: {
871: register x;
872: register struct group *gp;
873:
874: x = (-1<<4) + cp->c_index;
875: gp = cp->c_group;
876: while (gp->g_group) {
877: x <<= 4;
878: x |= gp->g_index;
879: gp = gp->g_group;
880: }
881: return(x);
882: }
883:
884:
885: struct chan *
886: nextcp(gp)
887: register struct group *gp;
888: {
889: register struct group *lgp, *ngp;
890:
891: do {
892: while ((gp->g_datq & cmask[gp->g_rot]) == 0) {
893: gp->g_rot = (gp->g_rot+1)%NINDEX;
894: }
895: lgp = gp;
896: gp = (struct group *)gp->g_chans[gp->g_rot];
897: } while (gp!=NULL && gp->g_state&ISGRP);
898:
899: lgp->g_datq &= ~cmask[lgp->g_rot];
900: lgp->g_rot = (lgp->g_rot+1)%NINDEX;
901:
902: while (ngp=lgp->g_group) {
903: ngp->g_datq &= ~cmask[lgp->g_index];
904: if (ngp->g_datq)
905: break;
906: lgp = ngp;
907: }
908: return((struct chan *)gp);
909: }
910:
911:
912:
913: msgenab(cp)
914: register struct chan *cp;
915: {
916: register struct group *gp;
917:
918: for(gp=cp->c_group;gp;gp=gp->g_group)
919: if(gp->g_state & ENAMSG)return(1);
920: return(0);
921: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.