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