![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pk0.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 40BSD / cmd / uucp|
Return to pk0.c CVS log | Up to [CSRG BSD Unix] / 40BSD / cmd / uucp |
1.1 root 1: #define USER 1
2: #include <stdio.h>
3: #include <sys/pk.p>
4: #include <sys/param.h>
5: #include <sys/pk.h>
6: #include <sys/buf.h>
7:
8: /*
9: * packet driver
10: */
11:
12: char next[8] ={ 1,2,3,4,5,6,7,0}; /* packet sequence numbers */
13: char mask[8] ={ 1,2,4,010,020,040,0100,0200 };
14:
15: struct pack *pklines[NPLINES];
16:
17:
18:
19: /*
20: * receive control messages
21: */
22: pkcntl(c, pk)
23: register struct pack *pk;
24: {
25: register cntl, val;
26:
27: val = c & MOD8;
28: cntl = (c>>3) & MOD8;
29:
30: if ( ! ISCNTL(c) ) {
31: fprintf(stderr, "not cntl\n");
32: return;
33: }
34:
35: if (pk->p_mode & 02)
36: fprintf(stderr, "%o ",c);
37: switch(cntl) {
38:
39: case INITB:
40: val++;
41: pk->p_xsize = pksizes[val];
42: pk->p_lpsize = val;
43: pk->p_bits = DTOM(pk->p_xsize);
44: if (pk->p_state & LIVE) {
45: pk->p_msg |= M_INITC;
46: break;
47: }
48: pk->p_state |= INITb;
49: if ((pk->p_state & INITa)==0) {
50: break;
51: }
52: pk->p_rmsg &= ~M_INITA;
53: pk->p_msg |= M_INITC;
54: break;
55:
56: case INITC:
57: if ((pk->p_state&INITab)==INITab) {
58: pk->p_state = LIVE;
59: WAKEUP(&pk->p_state);
60: pk->p_rmsg &= ~M_INITB;
61: } else
62: pk->p_msg |= M_INITB;
63: if (val)
64: pk->p_swindow = val;
65: break;
66: case INITA:
67: if (val==0 && pk->p_state&LIVE) {
68: fprintf(stderr, "alloc change not implemented\n");
69: break;
70: }
71: if (val) {
72: pk->p_state |= INITa;
73: pk->p_msg |= M_INITB;
74: pk->p_rmsg |= M_INITB;
75: pk->p_swindow = val;
76: }
77: break;
78: case RJ:
79: pk->p_state |= RXMIT;
80: pk->p_msg |= M_RR;
81: case RR:
82: pk->p_rpr = val;
83: if (pksack(pk)==0) {
84: WAKEUP(&pk->p_ps);
85: }
86: break;
87: case SRJ:
88: fprintf(stderr, "srj not implemented\n");
89: break;
90: case CLOSE:
91: pk->p_state = DOWN+RCLOSE;
92: SIGNAL;
93: WAKEUP(&pk->p_pr);
94: WAKEUP(&pk->p_ps);
95: WAKEUP(&pk->p_state);
96: return;
97: }
98: out:
99: if (pk->p_msg)
100: pkoutput(pk);
101: }
102:
103:
104:
105: pkaccept(pk)
106: register struct pack *pk;
107: {
108: register x,seq;
109: char m, cntl, *p, imask, **bp;
110: int bad,accept,skip,s,t,h,cc;
111: unsigned short sum;
112:
113:
114: bad = accept = skip = 0;
115: /*
116: * wait for input
117: */
118: LOCK;
119: x = next[pk->p_pr];
120: while ((imask=pk->p_imap) == 0 && pk->p_rcount==0) {
121: PKGETPKT(pk);
122: SLEEP(&pk->p_pr, PKIPRI);
123: }
124: pk->p_imap = 0;
125: UNLOCK;
126:
127:
128: /*
129: * determine input window in m.
130: */
131: t = (~(-1<<pk->p_rwindow)) <<x;
132: m = t;
133: m |= t>>8;
134:
135:
136: /*
137: * mark newly accepted input buffers
138: */
139: for(x=0; x<8; x++) {
140:
141: if ((imask & mask[x]) == 0)
142: continue;
143:
144: if (((cntl=pk->p_is[x])&0200)==0) {
145: bad++;
146: free:
147: bp = (char **)pk->p_ib[x];
148: LOCK;
149: *bp = (char *)pk->p_ipool;
150: pk->p_ipool = bp;
151: pk->p_is[x] = 0;
152: UNLOCK;
153: continue;
154: }
155:
156: pk->p_is[x] = ~(B_COPY+B_MARK);
157: sum = (unsigned)chksum(pk->p_ib[x], pk->p_rsize) ^ (unsigned)(cntl&0377);
158: sum += pk->p_isum[x];
159: if (sum == CHECK) {
160: seq = (cntl>>3) & MOD8;
161: if (m & mask[seq]) {
162: if (pk->p_is[seq] & (B_COPY | B_MARK)) {
163: dup:
164: pk->p_msg |= M_RR;
165: skip++;
166: goto free;
167: }
168: if (x != seq) {
169: LOCK;
170: p = pk->p_ib[x];
171: pk->p_ib[x] = pk->p_ib[seq];
172: pk->p_is[x] = pk->p_is[seq];
173: pk->p_ib[seq] = p;
174: UNLOCK;
175: }
176: pk->p_is[seq] = B_MARK;
177: accept++;
178: cc = 0;
179: if (cntl&B_SHORT) {
180: pk->p_is[seq] = B_MARK+B_SHORT;
181: p = pk->p_ib[seq];
182: cc = (unsigned)*p++ & 0377;
183: if (cc & 0200) {
184: cc &= 0177;
185: cc |= *p << 7;
186: }
187: }
188: pk->p_isum[seq] = pk->p_rsize - cc;
189: } else {
190: goto dup;
191: }
192: } else {
193: bad++;
194: goto free;
195: }
196: }
197:
198: /*
199: * scan window again turning marked buffers into
200: * COPY buffers and looking for missing sequence
201: * numbers.
202: */
203: accept = 0;
204: for(x=next[pk->p_pr],t=h= -1; m & mask[x]; x = next[x]) {
205: if (pk->p_is[x] & B_MARK)
206: pk->p_is[x] |= B_COPY;
207: /* hole code
208: if (pk->p_is[x] & B_COPY) {
209: if (h<0 && t>=0)
210: h = x;
211: } else {
212: if (t<0)
213: t = x;
214: }
215: */
216: if (pk->p_is[x] & B_COPY) {
217: if (t >= 0) {
218: bp = (char **)pk->p_ib[x];
219: LOCK;
220: *bp = (char *)pk->p_ipool;
221: pk->p_ipool = bp;
222: pk->p_is[x] = 0;
223: UNLOCK;
224: skip++;
225: } else
226: accept++;
227: } else {
228: if (t<0)
229: t = x;
230: }
231: }
232:
233: if (bad) {
234: pk->p_msg |= M_RJ;
235: }
236:
237: if (skip) {
238: pk->p_msg |= M_RR;
239: }
240:
241: pk->p_rcount = accept;
242: return(accept);
243: }
244:
245:
246: pkread(S)
247: SDEF;
248: {
249: register struct pack *pk;
250: register x,s;
251: int is,cc,xfr,count;
252: char *cp, **bp;
253:
254: pk = PADDR;
255: xfr = 0;
256: count = 0;
257: while (pkaccept(pk)==0);
258:
259:
260: while (UCOUNT) {
261:
262: x = next[pk->p_pr];
263: is = pk->p_is[x];
264:
265: if (is & B_COPY) {
266: cc = MIN(pk->p_isum[x], UCOUNT);
267: if (cc==0 && xfr) {
268: break;
269: }
270: if (is & B_RESID)
271: cp = pk->p_rptr;
272: else {
273: cp = pk->p_ib[x];
274: if (is & B_SHORT) {
275: if (*cp++ & 0200)
276: *cp++;
277: }
278: }
279: IOMOVE(cp,cc,B_READ);
280: count += cc;
281: xfr++;
282: pk->p_isum[x] -= cc;
283: if (pk->p_isum[x] == 0) {
284: pk->p_pr = x;
285: bp = (char **)pk->p_ib[x];
286: LOCK;
287: *bp = (char *)pk->p_ipool;
288: pk->p_ipool = bp;
289: pk->p_is[x] = 0;
290: pk->p_rcount--;
291: UNLOCK;
292: pk->p_msg |= M_RR;
293: } else {
294: pk->p_rptr = cp+cc;
295: pk->p_is[x] |= B_RESID;
296: }
297: if (cc==0)
298: break;
299: } else
300: break;
301: }
302: pkoutput(pk);
303: return(count);
304: }
305:
306:
307:
308:
309: pkwrite(S)
310: SDEF;
311: {
312: register struct pack *pk;
313: register x;
314: int partial;
315: caddr_t cp;
316: int cc, s, fc, count;
317: int pktimeout();
318:
319: pk = PADDR;
320: if (pk->p_state&DOWN || !pk->p_state&LIVE) {
321: SETERROR;
322: return(-1);
323: }
324:
325: count = UCOUNT;
326: do {
327: LOCK;
328: while (pk->p_xcount>=pk->p_swindow) {
329: pkoutput(pk);
330: PKGETPKT(pk);
331: SLEEP(&pk->p_ps,PKOPRI);
332: }
333: x = next[pk->p_pscopy];
334: while (pk->p_os[x]!=B_NULL) {
335: PKGETPKT(pk);
336: SLEEP(&pk->p_ps,PKOPRI);
337: }
338: pk->p_os[x] = B_MARK;
339: pk->p_pscopy = x;
340: pk->p_xcount++;
341: UNLOCK;
342:
343: cp = pk->p_ob[x] = GETEPACK;
344: partial = 0;
345: if ((int)UCOUNT < pk->p_xsize) {
346: cc = UCOUNT;
347: fc = pk->p_xsize - cc;
348: *cp = fc&0177;
349: if (fc > 127) {
350: *cp++ |= 0200;
351: *cp++ = fc>>7;
352: } else
353: cp++;
354: partial = B_SHORT;
355: } else
356: cc = pk->p_xsize;
357: IOMOVE(cp,cc,B_WRITE);
358: pk->p_osum[x] = chksum(pk->p_ob[x], pk->p_xsize);
359: pk->p_os[x] = B_READY+partial;
360: pkoutput(pk);
361: } while (UCOUNT);
362:
363: return(count);
364: }
365:
366: pksack(pk)
367: register struct pack *pk;
368: {
369: register x, i;
370:
371: i = 0;
372: for(x=pk->p_ps; x!=pk->p_rpr; ) {
373: x = next[x];
374: if (pk->p_os[x]&B_SENT) {
375: i++;
376: pk->p_os[x] = B_NULL;
377: pk->p_state &= ~WAITO;
378: pk->p_xcount--;
379: FREEPACK(pk->p_ob[x], pk->p_bits);
380: pk->p_ps = x;
381: WAKEUP(&pk->p_ps);
382: }
383: }
384: return(i);
385: }
386:
387:
388:
389: pkoutput(pk)
390: register struct pack *pk;
391: {
392: register x,rx;
393: int s;
394: char bstate;
395: int i;
396: SDEF;
397: int flag;
398:
399: flag = 0;
400: ISYSTEM;
401: LOCK;
402: if (pk->p_obusy++ || OBUSY) {
403: pk->p_obusy--;
404: UNLOCK;
405: return;
406: }
407: UNLOCK;
408:
409:
410: /*
411: * find seq number and buffer state
412: * of next output packet
413: */
414: if (pk->p_state&RXMIT) {
415: pk->p_nxtps = next[pk->p_rpr];
416: flag++;
417: }
418: x = pk->p_nxtps;
419: bstate = pk->p_os[x];
420:
421:
422: /*
423: * Send control packet if indicated
424: */
425: if (pk->p_msg) {
426: if (pk->p_msg & ~M_RR || !(bstate&B_READY) ) {
427: x = pk->p_msg;
428: for(i=0; i<8; i++)
429: if (x&1)
430: break; else
431: x >>= 1;
432: x = i;
433: x <<= 3;
434: switch(i) {
435: case CLOSE:
436: break;
437: case RJ:
438: case RR:
439: x += pk->p_pr;
440: break;
441: case SRJ:
442: break;
443: case INITB:
444: x += pksize(pk->p_rsize);
445: break;
446: case INITC:
447: x += pk->p_rwindow;
448: break;
449: case INITA:
450: x += pk->p_rwindow;
451: break;
452: }
453:
454: pk->p_msg &= ~mask[i];
455: pkxstart(pk, x, -1);
456: goto out;
457: }
458: }
459:
460:
461: /*
462: * Don't send data packets if line is marked dead.
463: */
464: if (pk->p_state&DOWN) {
465: WAKEUP(&pk->p_ps);
466: goto out;
467: }
468: /*
469: * Start transmission (or retransmission) of data packets.
470: */
471: if (bstate & (B_READY|B_SENT)) {
472: char seq;
473:
474: bstate |= B_SENT;
475: seq = x;
476: pk->p_nxtps = next[x];
477:
478: x = 0200+pk->p_pr+(seq<<3);
479: if (bstate & B_SHORT)
480: x |= 0100;
481: pkxstart(pk, x, seq);
482: pk->p_os[seq] = bstate;
483: pk->p_state &= ~RXMIT;
484: pk->p_nout++;
485: goto out;
486: }
487: /*
488: * enable timeout if there's nothing to send
489: * and transmission buffers are languishing
490: */
491: if (pk->p_xcount) {
492: pk->p_timer = 2;
493: pk->p_state |= WAITO;
494: } else
495: pk->p_state &= ~WAITO;
496: WAKEUP(&pk->p_ps);
497: out:
498: pk->p_obusy = 0;
499: }
500:
501:
502: /*
503: * shut down line by
504: * ignoring new input
505: * letting output drain
506: * releasing space and turning off line discipline
507: */
508: pkclose(S)
509: SDEF;
510: {
511: register struct pack *pk;
512: register i,s,rbits;
513: char **bp;
514: int rcheck;
515: char *p;
516:
517:
518: pk = PADDR;
519: pk->p_state |= DRAINO;
520:
521:
522: /*
523: * try to flush output
524: */
525: i = 0;
526: LOCK;
527: pk->p_timer = 2;
528: while (pk->p_xcount && pk->p_state&LIVE) {
529: if (pk->p_state&(RCLOSE+DOWN) || ++i > 2)
530: break;
531: pkoutput(pk);
532: SLEEP(&pk->p_ps,PKOPRI);
533: }
534: pk->p_timer = 0;
535: pk->p_state |= DOWN;
536: UNLOCK;
537:
538:
539: /*
540: * try to exchange CLOSE messages
541: */
542: i = 0;
543: while ((pk->p_state&RCLOSE)==0 && i<2) {
544: pk->p_msg = M_CLOSE;
545: pk->p_timer = 2;
546: pkoutput(pk);
547: SLEEP(&pk->p_ps, PKOPRI);
548: i++;
549: }
550:
551:
552: for(i=0;i<NPLINES;i++)
553: if (pklines[i]==pk) {
554: pklines[i] = NULL;
555: }
556: TURNOFF;
557:
558:
559: /*
560: * free space
561: */
562: rbits = DTOM(pk->p_rsize);
563: rcheck = 0;
564: for (i=0;i<8;i++) {
565: if (pk->p_os[i]!=B_NULL) {
566: FREEPACK(pk->p_ob[i],pk->p_bits);
567: pk->p_xcount--;
568: }
569: if (pk->p_is[i]!=B_NULL) {
570: FREEPACK(pk->p_ib[i],rbits);
571: rcheck++;
572: }
573: }
574: LOCK;
575: while (pk->p_ipool != NULL) {
576: bp = pk->p_ipool;
577: pk->p_ipool = (char **)*bp;
578: rcheck++;
579: FREEPACK(bp, rbits);
580: }
581: UNLOCK;
582: if (rcheck != pk->p_rwindow) {
583: fprintf(stderr, "r short %d want %d\n",rcheck,pk->p_rwindow);
584: fprintf(stderr, "rcount = %d\n",pk->p_rcount);
585: fprintf(stderr, "xcount = %d\n",pk->p_xcount);
586: }
587: FREEPACK((caddr_t)pk, npbits);
588: }
589:
590:
591:
592: pkreset(pk)
593: register struct pack *pk;
594: {
595:
596: pk->p_ps = pk->p_pr = pk->p_rpr = 0;
597: pk->p_nxtps = 1;
598: }
599:
600: chksum(s,n)
601: register char *s;
602: register n;
603: {
604: register short sum;
605: register unsigned short t;
606: register short x;
607:
608: sum = -1;
609: x = 0;
610:
611: do {
612: if (sum<0) {
613: sum <<= 1;
614: sum++;
615: } else
616: sum <<= 1;
617: t = sum;
618: sum += (unsigned)*s++ & 0377;
619: x += sum^n;
620: if ((unsigned)sum <= t) {
621: sum ^= x;
622: }
623: } while (--n > 0);
624:
625: return(sum);
626: }
627:
628: pkline(pk)
629: register struct pack *pk;
630: {
631: register i;
632: for(i=0;i<NPLINES;i++) {
633: if (pklines[i]==pk)
634: return(i);
635: }
636: return(-i);
637: }
638:
639: pkzero(s,n)
640: register char *s;
641: register n;
642: {
643: while (n--)
644: *s++ = 0;
645: }
646:
647: pksize(n)
648: register n;
649: {
650: register k;
651:
652: n >>= 5;
653: for(k=0; n >>= 1; k++);
654: return(k);
655: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.