![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pk.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv8dc / sys / dev|
Return to pk.c CVS log | Up to [Research Unix] / researchv8dc / sys / dev |
1.1 root 1: /*
2: * Packet protocol processor
3: */
4:
5: #include "../h/param.h"
6: #include "../h/stream.h"
7: #include "../h/conf.h"
8: #include "../h/ioctl.h"
9: #include "../h/ttyld.h"
10: #include "pk.h"
11:
12: struct pack {
13: u_char istate;
14: u_char ostate;
15: u_char xlogseg; /* code for xmit segment size */
16: u_char S; /* current output seqno */
17: u_char SN; /* next output seqno */
18: u_char XW; /* size of output window */
19: u_char R; /* current input seqno */
20: u_char timer;
21: short xsegment; /* output segment size */
22: short iwant; /* # chars needed before i q enable */
23: struct block *xpacks[8]; /* waiting output blocks */
24: struct {
25: u_char k; /* packet size */
26: u_char c0; /* low checksum byte */
27: u_char c1; /* high checksum byte */
28: u_char C; /* control byte */
29: u_char x; /* header check */
30: } hdr; /* copy of header of received segment */
31: struct queue *rdq; /* associated read queue */
32: };
33:
34: #define PK_TYPE 0xC0
35: #define PKCNTL 0x00
36: #define PKDATA 0x80
37: #define PKSDATA 0xC0
38:
39: #define PK_CLOSE 010
40: #define PK_RJ 020
41: #define PK_RR 040
42: #define PK_INITC 050
43: #define PK_INITB 060
44: #define PK_INITA 070
45:
46: #define CHECK 0125252
47:
48: #define WDATA 01
49: #define PKDELIM 02
50: #define PKREJ 04
51:
52: #define SYN 020 /* sic */
53:
54: #define SINITA 1
55: #define SINITB 2
56: #define SINITC 3
57: #define OPEN 4
58: #define LCLOSE 5
59: #define RCLOSE 6
60:
61: #define PKPRI 28
62: #define DKDATA 0400
63:
64: #define RWINSIZE 3
65: #define RSEGSIZE 1 /* 64 bytes */
66:
67: #define PKTIME 5
68:
69: struct pack packs[NPK];
70: short pksizes[] = { 16, 32, 64, 128, 256, 512, 1024, 2048, 4096 };
71: u_short pkc_sum;
72: u_short pkc_x;
73: int pkc_size;
74:
75: int pkiput(), pkisrv(), pkoput(), pkosrv(), pkopen(), pkclose();
76: static struct qinit pkrinit = { pkiput, pkisrv, pkopen, pkclose, 512, 64 };
77: static struct qinit pkwinit = { pkoput, pkosrv, pkopen, pkclose, 128, 65 };
78: struct streamtab pkinfo = { &pkrinit, &pkwinit };
79:
80: pkopen(q)
81: register struct queue *q;
82: {
83: register struct pack *pkp;
84: register s;
85: static timer = 0;
86: int pktimer();
87:
88: if (q->ptr) {
89: pkp = (struct pack *)q->ptr;
90: if (pkp->ostate != OPEN)
91: return(0); /* don't reopen half-open chans */
92: return(1);
93: } else {
94: for (pkp = packs; pkp->ostate!=0; pkp++)
95: if (pkp >= &packs[NPK])
96: return(0);
97: pkp->rdq = q;
98: q->ptr = (caddr_t)pkp;
99: WR(q)->ptr = (caddr_t)pkp;
100: pkp->S = 1;
101: pkp->SN = 1;
102: pkp->R = 0;
103: putctl(q->next, M_FLUSH);
104: pkp->ostate = SINITA;
105: pkp->istate = 0;
106: pkp->timer = 2;
107: pkscntl(pkp, PK_INITA+RWINSIZE);
108: }
109: if (timer == 0) {
110: timer = 1;
111: timeout(pktimer, (caddr_t)NULL, 60);
112: }
113: s = spl5();
114: while (pkp->ostate != OPEN) {
115: switch (tsleep((caddr_t)pkp, PKPRI, 15)) {
116: case TS_OK:
117: continue;
118: case TS_SIG:
119: case TS_TIME:
120: pkp->ostate = 0;
121: splx(s);
122: return(0);
123: }
124: }
125: q->flag |= QDELIM;
126: splx(s);
127: return(1);
128: }
129:
130: /*
131: * Shut it down.
132: * The problem is to dispose of unacked stuff in the window.
133: * -- no real solution; the receiver might hang on for hours.
134: * Give it 15 seconds.
135: */
136: pkclose(q)
137: register struct queue *q;
138: {
139: register struct pack *pkp;
140: register s = spl5();
141: register i;
142:
143: pkp = (struct pack *)q->ptr;
144: pkp->ostate = LCLOSE;
145: flushq(q, 1);
146: for (i=0; pkp->S < pkp->SN && i<15; i++)
147: tsleep((caddr_t)pkp, PKPRI, 1);
148: splx(s);
149: flushq(WR(q), 1);
150: pkrack(pkp, pkp->SN-1, 0);
151: pkscntl(pkp, PK_CLOSE);
152: pkp->ostate = 0;
153: }
154:
155:
156: /*
157: * Process a bunch of input
158: */
159: pkisrv(q)
160: register struct queue *q;
161: {
162: register struct pack *pkp = (struct pack *)q->ptr;
163: register struct block *bp;
164: register segsize, msgsize;
165: int R, OK;
166: u_char c;
167:
168: more:
169: while ((pkp->istate & WDATA) == 0) {
170: if (pkwant(pkp, 6)==0)
171: return;
172: pkgetb(q, &c, 1);
173: if (c != SYN)
174: continue;
175: pkgetb(q, (u_char *)&pkp->hdr, 5);
176: if (pkp->hdr.x != (pkp->hdr.k ^ pkp->hdr.c0 ^
177: pkp->hdr.c1 ^ pkp->hdr.C)) { /* bad header? */
178: continue;
179: }
180: switch (pkp->hdr.C & PK_TYPE) {
181: case PKCNTL:
182: pkp->istate &= ~PKREJ;
183: pkcntl(pkp);
184: continue;
185:
186: case PKDATA:
187: case PKSDATA:
188: if (pkp->ostate==SINITC) {
189: pkp->ostate = OPEN;
190: wakeup((caddr_t)pkp);
191: }
192: if (pkp->S != pkp->SN) /* if need an ack */
193: pkrack(pkp, pkp->hdr.C&07, 0);
194: if (pkp->hdr.k<1 || pkp->hdr.k>8) {
195: continue;
196: }
197: pkp->istate |= WDATA;
198: break;
199:
200: default:
201: continue;
202: }
203: break;
204: }
205: if (q->next->flag&QFULL)
206: return;
207: msgsize = segsize = pksizes[pkp->hdr.k];
208: if (pkwant(pkp, segsize) == 0)
209: return;
210: /*
211: * Now have a segment's worth of data; if in window, compute checksum
212: * and accept if all is OK
213: */
214: R = (pkp->hdr.C>>3) & 07;
215: if (R <= pkp->R)
216: R += 8;
217: /* compute checksum */
218: OK = 0;
219: pkc_sum = -1;
220: pkc_x = 0;
221: pkc_size = segsize;
222: for (bp = q->first; segsize>0; bp = bp->next) {
223: register sz = bp->wptr - bp->rptr;
224: pkcksum(bp->rptr, sz);
225: segsize -= sz;
226: }
227: segsize = msgsize;
228: pkc_sum ^= pkp->hdr.C;
229: pkc_sum += (pkp->hdr.c1<<8) + pkp->hdr.c0;
230: if (pkc_sum != CHECK || R != pkp->R+1) { /* Bad? */
231: if (R < pkp->R+RWINSIZE) {
232: flushq(q, 0);
233: if ((pkp->istate & PKREJ) == 0)
234: pkscntl(pkp, PK_RJ+pkp->R);
235: pkp->istate &= ~WDATA;
236: pkp->istate |= PKREJ;
237: goto more;
238: }
239: msgsize = -1; /* duplicate; just ignore */
240: } else { /* It's good */
241: pkp->R = (pkp->R+1)&07;
242: OK = 1;
243: if ((pkp->hdr.C&PK_TYPE) == PKSDATA) {
244: pkgetb(q, &c, 1);
245: msgsize -= c & 0x7F;
246: segsize -= 1;
247: if (c&0x80) {
248: pkgetb(q, &c, 1);
249: msgsize -= c << 7;
250: segsize -= 1;
251: }
252: }
253: }
254: pkp->istate &= ~PKREJ;
255: pkscntl(pkp, PK_RR+pkp->R);
256: while (segsize > 0) {
257: register i;
258: bp = getq(q);
259: i = bp->wptr - bp->rptr;
260: if (i <= msgsize) {
261: (*q->next->qinfo->putp)(q->next, bp);
262: msgsize -= i;
263: segsize -= i;
264: continue;
265: }
266: if (msgsize>0) {
267: register struct block *bp1 = allocb(msgsize);
268: if (bp1) {
269: bcopy(bp->rptr, bp1->wptr, msgsize);
270: bp->rptr += msgsize;
271: bp1->wptr += msgsize;
272: (*q->next->qinfo->putp)(q->next, bp1);
273: segsize -= msgsize;
274: msgsize = 0;
275: putbq(q, bp);
276: continue;
277: } else
278: panic("pk alloc\n");
279: }
280: if (i <= segsize) {
281: freeb(bp);
282: segsize -= i;
283: continue;
284: }
285: bp->rptr += segsize;
286: putbq(q, bp);
287: break;
288: }
289: if (OK)
290: putctl(q->next, M_DELIM);
291: pkp->istate &= ~WDATA;
292: goto more;
293: }
294:
295: /*
296: * Packet arrives.
297: */
298: pkiput(q, bp)
299: struct queue *q;
300: register struct block *bp;
301: {
302: register struct pack *pkp;
303: register c;
304:
305: if ((pkp = (struct pack *)q->ptr)==NULL || pkp->ostate==LCLOSE) {
306: freeb(bp);
307: return;
308: }
309: switch (bp->type) {
310:
311: case M_DATA:
312: if (q->flag&QFULL) {
313: freeb(bp);
314: return;
315: }
316: if ((pkp->iwant -= bp->wptr - bp->rptr) <= 0) {
317: pkp->iwant = 0;
318: qenable(q);
319: }
320: putq(q, bp);
321: return;
322:
323: case M_HANGUP:
324: pkp->ostate = RCLOSE;
325: flushq(WR(q), 0);
326: pkrack(pkp, pkp->SN-1, 0);
327: qenable(q);
328: freeb(bp);
329: return;
330:
331: case M_IOCACK:
332: case M_IOCNAK:
333: (*q->next->qinfo->putp)(q->next, bp);
334: return;
335:
336: default:
337: freeb(bp);
338: return;
339: }
340: }
341:
342: /*
343: * --- Output processor
344: */
345:
346: /*
347: * accept data from writer
348: * -- handle all non-data messages
349: */
350: pkoput(q, bp)
351: register struct queue *q;
352: register struct block *bp;
353: {
354: register struct pack *pkp = (struct pack *)q->ptr;
355: register union stmsg *sp;
356:
357: if (pkp->ostate == RCLOSE) {
358: freeb(bp);
359: return;
360: }
361: switch (bp->type) {
362:
363: case M_DELIM:
364: if (pkp->istate & PKDELIM)
365: goto isdata;
366: pkp->istate |= PKDELIM;
367: /* flow through */
368: case M_FLUSH:
369: freeb(bp);
370: return;
371:
372: case M_IOCTL:
373: sp = (union stmsg *)bp->rptr;
374: switch (sp->ioc0.com) {
375:
376: case TIOCGETP:
377: sp->ioc1.sb.sg_erase = 0;
378: sp->ioc1.sb.sg_kill = 0;
379: sp->ioc1.sb.sg_flags = RAW;
380: bp->wptr = bp->rptr+sizeof(struct ioc1);
381: bp->type = M_IOCACK;
382: qreply(q, bp);
383: break;
384:
385: default:
386: (*q->next->qinfo->putp)(q->next, bp);
387: break;
388: }
389: return;
390:
391: default:
392: freeb(bp);
393: return;
394:
395: case M_DATA:
396: pkp->istate &= ~PKDELIM;
397: isdata:
398: putq(q, bp);
399: if (pkp->SN < pkp->S + pkp->XW)
400: qenable(q);
401: return;
402: }
403: }
404:
405: /*
406: * PK out server:
407: * if space in window, process queue
408: * take care of splitting packets bigger than segment size
409: * if timer has expired, retransmit
410: */
411: pkosrv(q)
412: register struct queue *q;
413: {
414: register struct pack *pkp = (struct pack *)q->ptr;
415: register struct block *bp, *xbp;
416:
417: if (pkp->timer==0 && pkp->S != pkp->SN)
418: pkxmit(q, pkp->xpacks[pkp->S], pkp->S);
419: while (pkp->SN < pkp->S + pkp->XW) {
420: if ((bp = getq(q)) == NULL)
421: break;
422: if (bp->wptr-bp->rptr > pkp->xsegment) {
423: if ((xbp = allocb(pkp->xsegment)) == NULL) {
424: putbq(q, bp);
425: return;
426: }
427: bcopy(bp->rptr, xbp->wptr, pkp->xsegment);
428: bp->rptr += pkp->xsegment;
429: xbp->wptr += pkp->xsegment;
430: putbq(q, bp);
431: bp = xbp;
432: }
433: bp->type = M_DATA; /* M_DELIM -> 0-length write */
434: pkp->xpacks[pkp->SN & 07] = bp;
435: pkxmit(q, bp, pkp->SN);
436: pkp->SN++;
437: }
438: }
439:
440: /*
441: * Send out a packet, with header.
442: * -- only a "pointer" to the data is sent; the original
443: * is kept.
444: */
445: pkxmit(q, bp, pkno)
446: struct queue *q;
447: register struct block *bp;
448: unsigned pkno;
449: {
450: register struct block *hbp;
451: register size;
452: register seg;
453: register struct pack *pkp = (struct pack *)q->ptr;
454: register struct block *sbp = NULL;
455: register sizeadjust = 0;
456: static u_char zero[64];
457:
458: if (bp == (struct block *)NULL) {
459: printf("0 bp in pkxmit\n");
460: return;
461: }
462: pkp->timer = PKTIME;
463: if ((hbp = allocb(8)) == NULL)
464: return; /* hope timeouts will recover */
465: pkno &= 07;
466: size = bp->wptr - bp->rptr;
467: /* compute header */
468: hbp->wptr += 6; /* header size */
469: hbp->rptr[0] = SYN;
470: hbp->rptr[1] = pkp->xlogseg;
471: seg = pkp->xsegment;
472: pkc_sum = -1;
473: pkc_x = 0;
474: pkc_size = seg;
475: if (size < seg) {
476: hbp->rptr[4] = PKSDATA | (pkno << 3) | pkp->R;
477: if ((sbp = allocb(2)) == NULL) {
478: freeb(hbp);
479: return;
480: }
481: /* hack in the size bytes */
482: if ((seg - size) <= 127) {
483: *sbp->wptr++ = seg - size;
484: sizeadjust = 1;
485: } else {
486: *sbp->wptr++ = 0x80 + ((seg - size) & 0x7F);
487: *sbp->wptr++ = (seg - size) >> 7;
488: sizeadjust = 2;
489: }
490: pkcksum(sbp->rptr, sizeadjust);
491: pkcksum(bp->rptr, size);
492: seg -= size;
493: while (seg>0) {
494: pkcksum(zero, 64);
495: seg -= 64;
496: }
497: } else {
498: if (size > seg) {
499: printf("pk size botch\n");
500: return;
501: }
502: hbp->rptr[4] = PKDATA | (pkno<<3) | pkp->R;
503: pkcksum(bp->rptr, size);
504: }
505: pkc_sum = CHECK - (pkc_sum ^ hbp->rptr[4]);
506: hbp->rptr[2] = pkc_sum;
507: hbp->rptr[3] = pkc_sum>>8;
508: hbp->rptr[5] = hbp->rptr[1]^hbp->rptr[2]^hbp->rptr[3]^hbp->rptr[4];
509: /* send header */
510: (*q->next->qinfo->putp)(q->next, hbp);
511: /* send size */
512: if (sbp)
513: (*q->next->qinfo->putp)(q->next, sbp);
514: /* send data ptr */
515: if (hbp = allocb(0)) { /* if fail, pray for timeout */
516: hbp->rptr = bp->rptr; /* copy ptrs */
517: hbp->wptr = bp->wptr;
518: (*q->next->qinfo->putp)(q->next, hbp); /* send data */
519: }
520: /* send padding */
521: seg = pkp->xsegment - sizeadjust;
522: while (size < seg) {
523: register deficit = seg - size;
524: if (deficit > 64)
525: deficit = 64;
526: if (hbp = allocb(deficit)) {
527: hbp->rptr = zero;
528: hbp->wptr = zero + deficit;
529: (*q->next->qinfo->putp)(q->next, hbp);
530: }
531: size += deficit;
532: }
533: }
534:
535: /*
536: * Receive an ack for a transmitted packet.
537: * Advance the window. Retransmit stacked up stuff if required.
538: */
539: pkrack(pkp, packno, rxmit)
540: register unsigned packno;
541: register struct pack *pkp;
542: {
543: register struct block **bpp;
544: register s = spl5();
545:
546: packno &= 07;
547: if (packno < pkp->S)
548: packno += 8;
549: pkp->timer = PKTIME;
550: if (packno < pkp->SN)
551: while (pkp->S <= packno) {
552: bpp = &pkp->xpacks[pkp->S & 07];
553: if (*bpp) {
554: freeb(*bpp);
555: *bpp = NULL;
556: }
557: pkp->S++;
558: }
559: if (WR(pkp->rdq)->count)
560: qenable(WR(pkp->rdq));
561: if (rxmit) {
562: for (packno = pkp->S; packno < pkp->SN; packno++)
563: pkxmit(WR(pkp->rdq), pkp->xpacks[packno&07], packno);
564: }
565: if (pkp->S >= 8) {
566: pkp->S -= 8;
567: pkp->SN -= 8;
568: }
569: splx(s);
570: }
571:
572: /*
573: * If n bytes are available, return 1, else 0.
574: */
575: pkwant(pkp, n)
576: register n;
577: register struct pack *pkp;
578: {
579: register int navail = 0;
580: register struct block *bp;
581: int s = spl5();
582:
583: for (bp = pkp->rdq->first; bp; bp = bp->next) {
584: navail += bp->wptr - bp->rptr;
585: if (navail >= n) {
586: splx(s);
587: return(1);
588: }
589: }
590: if (pkp->ostate==RCLOSE)
591: putctl(pkp->rdq->next, M_HANGUP);
592: pkp->iwant = n - navail;
593: splx(s);
594: return(0);
595: }
596:
597: /*
598: * Copy n bytes from the front of the queue.
599: */
600: pkgetb(q, cp, n)
601: register struct queue *q;
602: register u_char *cp;
603: register n;
604: {
605: register struct block *bp;
606:
607: while (n) {
608: if ((bp = q->first) == NULL) {
609: printf("pkgetb fail\n");
610: return;
611: }
612: if (bp->rptr >= bp->wptr) {
613: freeb(getq(q));
614: continue;
615: }
616: *cp++ = *bp->rptr++;
617: --n;
618: }
619: if (bp->rptr >= bp->wptr)
620: freeb(getq(q));
621: }
622:
623: /*
624: * The very strange checksum
625: */
626: pkcksum(cp, nbytes)
627: register u_char *cp;
628: register nbytes;
629: {
630: register sum, t, x;
631:
632: if (nbytes > pkc_size)
633: nbytes = pkc_size;
634: sum = pkc_sum;
635: x = pkc_x;
636: while (--nbytes >= 0) {
637: sum <<= 1;
638: if (sum & 0x10000)
639: sum++;
640: t = sum & 0xFFFF;
641: sum += *cp++;
642: sum &= 0xFFFF;
643: x += sum ^ pkc_size;
644: pkc_size--;
645: if (sum <= t)
646: sum ^= x;
647: }
648: pkc_x = x;
649: pkc_sum = sum;
650: }
651:
652: /*
653: * Send a control packet
654: */
655: pkscntl(pkp, cmd)
656: struct pack *pkp;
657: {
658: register struct block *bp;
659: register u_char *cp;
660: register struct queue *q;
661:
662: if ((bp = allocb(6)) == NULL)
663: return; /* what else to do? */
664: bp->wptr += 6;
665: cp = bp->rptr;
666: *cp++ = SYN;
667: *cp++ = 9; /* ctl pack marker */
668: *cp++ = cmd;
669: *cp++ = 0;
670: *cp++ = cmd;
671: *cp++ = 9; /* xor of hdr[1..4] */
672: q = WR(pkp->rdq);
673: (*q->next->qinfo->putp)(q->next, bp);
674: }
675:
676: /*
677: * Receive a control packet
678: */
679: pkcntl(pkp)
680: register struct pack *pkp;
681: {
682: register val;
683: register reject = 0;
684:
685: if (pkp->hdr.k != 9) {
686: return;
687: }
688: val = pkp->hdr.C & 07;
689: switch (pkp->hdr.C & 0370) {
690:
691: case PK_INITA:
692: pkp->timer = 2;
693: pkp->XW = val;
694: if (pkp->ostate==SINITA || pkp->ostate==SINITB) {
695: pkscntl(pkp, PK_INITA+RWINSIZE);
696: pkscntl(pkp, PK_INITB+RSEGSIZE);
697: pkp->ostate = SINITB;
698: return;
699: }
700: return;
701:
702: case PK_INITB:
703: pkp->timer = 2;
704: pkp->xsegment = pksizes[val+1];
705: pkp->xlogseg = val + 1;
706: if (pkp->ostate==SINITB) {
707: pkp->ostate = SINITC;
708: pkscntl(pkp, PK_INITB+RSEGSIZE);
709: pkscntl(pkp, PK_INITC+RWINSIZE);
710: return;
711: }
712: return;
713:
714: case PK_INITC:
715: if (pkp->ostate>=SINITB) {
716: if (pkp->ostate==SINITB)
717: pkscntl(pkp, PK_INITC+RWINSIZE);
718: pkp->ostate = OPEN;
719: wakeup((caddr_t)pkp);
720: return;
721: }
722: return;
723:
724: case PK_RJ:
725: reject = 1;
726: case PK_RR:
727: pkrack(pkp, val, reject);
728: return;
729:
730: case PK_CLOSE:
731: pkp->ostate = RCLOSE;
732: flushq(WR(pkp->rdq), 0);
733: pkrack(pkp, pkp->SN-1, 0);
734: qenable(pkp->rdq);
735: return;
736:
737: default:
738: return;
739: }
740: }
741:
742: pktimer()
743: {
744: register struct pack *pkp;
745:
746: for (pkp = packs; pkp < &packs[NPK]; pkp++) {
747: if (pkp->timer) {
748: pkp->timer--;
749: continue;
750: }
751: switch (pkp->ostate) {
752:
753: case 0:
754: continue;
755:
756: case OPEN:
757: case LCLOSE:
758: qenable(WR(pkp->rdq));
759: continue;
760:
761: case SINITA:
762: pkscntl(pkp, PK_INITA+RWINSIZE);
763: pkp->timer = 2;
764: continue;
765:
766: case SINITB:
767: pkscntl(pkp, PK_INITA+RWINSIZE);
768: pkscntl(pkp, PK_INITB+RSEGSIZE);
769: pkp->timer = 2;
770: continue;
771: }
772: }
773: timeout(pktimer, (caddr_t)NULL, 60);
774: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.