![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gpkt.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / a / usr / bob / uusrc / dcp|
Return to gpkt.c CVS log | Up to [MW Coherent from dump] / coherent / a / usr / bob / uusrc / dcp |
1.1 root 1: /*
2: * gpkt.c
3: *
4: * author: Peter S. Housel
5: *
6: * The |cksum()| routine is taken from UUPC, Copyright 1985, 1986, 1987 by
7: * Richard H. Lamb, with (possible) changes Copyright 1987 by Stuart Lynne
8: *
9: * All other code is Copyright 1989 by Peter S. Housel.
10: * Redistribution for any purpose is permitted provided this message
11: * is included intact. No warranty of any sort is provided.
12: *
13: * gpkt version 1.1 7/21/89
14: */
15:
16: /* This program was written based on the original UUPC 'g' driver,
17: * John Gilmore's version of uuslave, and Greg Chesson's protocol
18: * description article. The last was especially helpful.
19: *
20: * This code was written around a severely hacked version of UUPC.
21: * The call interface is almost identical to the original, but
22: * the internal implementation is quite different. Also, many
23: * functions are called that were not available in the original
24: * UUPC support functions. It should serve as an adequate framework.
25: *
26: * The framing strategy requires that a |read()| be interruptable
27: * by a |SIGALRM|. No "busy wait" or nonblocking read is required.
28: */
29: extern int bad_count;
30: extern int total_errors;
31:
32: #include "dcp.h"
33: #include "alarm.h"
34:
35: #define MAXPKT 64 /* incredibly conservative... actually 4096 */
36: #define SWINDOW 3 /* initial send window size */
37: #define RWINDOW 7 /* window size we want to recieve */
38: #define SPKTSIZE 64 /* initial send packet size */
39: #define RPKTSIZE 64 /* window size we want to receive */
40:
41: #define MAXLOST 5 /* max lost packets (closes or such) */
42: #define TIMEOUT 5 /* max seconds of before timeout */
43:
44: #define LOSTPKT -1 /* packet lost, got timeout */
45: #define BADPKT -2 /* bad checksum, or data read timed out */
46:
47: #define ENV_DLE 0 /* framing char at start of envelope */
48: #define ENV_K 1 /* packet length specifier */
49: #define ENV_C0 2 /* low-order checksum */
50: #define ENV_C1 3 /* high-order checksum */
51: #define ENV_C 4 /* control byte */
52: #define ENV_X 5 /* xor check byte */
53: #define ENV_LEN 6 /* overall envelope length */
54:
55: #define TT_CTRL 0 /* control packet */
56: #define TT_DATA 2 /* data packet */
57: #define TT_SDATA 3 /* short data packet */
58: #define TT_ALTCHAN 1 /* 'alternate channel' - invalid */
59:
60: #define X_CLOSE 1 /* close down protocol */
61: #define X_RJ 2 /* reject recieved packet */
62: #define X_SRJ 3 /* selectively reject packet - invalid */
63: #define X_RR 4 /* reciever ready */
64: #define X_INITC 5 /* third init packet */
65: #define X_INITB 6 /* second init packet */
66: #define X_INITA 7 /* first init packet */
67:
68: #define OP_OPEN 1 /* request to open/init protocol */
69: #define OP_CLOSE 2 /* request to close protocol */
70: #define OP_WRITE 3 /* request to send packet */
71: #define OP_READ 4 /* request to read packet */
72:
73: #define MAGIC (unsigned) 0xAAAA /* checksum magic value */
74:
75: /* from original dcp - determinie if a <= b < c, for mod 8 seq numbers */
76: #define between(a,b,c) (((a)<=(b) && (b)<(c)) \
77: || ((c)<(a) && (a)<=(b)) \
78: || ((b)<(c) && (c)<(a)))
79:
80: unsigned cksum(/* unsigned char *data, int len */);
81:
82: struct {
83: short sdata; /* 'is this a short data packet' flag */
84: unsigned length; /* length of this packet */
85: unsigned char *bufloc; /* location of this data pkt's buffer */
86: }
87: inpbufs[8], outbufs[8]; /* input/output queues */
88:
89: static int needack; /* do we need to acknowledge a rcv'd pkt? */
90: static int neednack; /* do we need to reject a recieved pkt? */
91: static int recv; /* seq. number of last correctly rcv'd pkt */
92: static int lastread; /* seq. number of last pkt ret. to caller */
93: static int send; /* first packet in output window */
94: static int next; /* next pkt to send send <= next < nstuff */
95: static int nstuff; /* next loc. to stuff a pkt in output queue */
96: /* (last pkt in output window) + 1 */
97: static int initpk; /* current init sequence send packet */
98: static int skipping; /* skipping out-of-seq packets after RJ */
99: static int spktsize; /* send data size (requested by other end) */
100: static int swindow; /* send output window size (ditto) */
101: static int nlost; /* number of consecutive timeouts */
102: static int chanopen = 0; /* 'channel open' flag */
103:
104: static unsigned char buf[ENV_LEN + RPKTSIZE+ BUFSIZ]; /* packet framing buffer */
105: static unsigned char *low, *high; /* framing buffer limits */
106:
107: static unsigned char *ibufset, *obufset; /* i/o packet buffer sets */
108:
109: /* |gopenpk()| opens the 'g' packet protocol on the serial line. It
110: * initializes its state variables, allocates buffers, etc., then calls
111: * |gmachine()| to do the actual protocol negotiation/initialization.
112: */
113: gopenpk()
114: {
115: int i; /* index */
116: unsigned char *p, *q; /* pointers into buffer set */
117:
118: high = low = buf; /* empty input buffer */
119: needack = neednack = 0; /* don't need to accept or reject anything */
120: initpk = X_INITA; /* send INITA during initialization */
121: recv = lastread = 0; /* initial empty read queue, seq=0 */
122: send = next = nstuff = 1; /* first in output queue, seq=1 */
123: skipping = nlost = 0; /* nothing lost yet, not skipping */
124:
125: if (gmachine(OP_OPEN) < 0) /* do the open */
126: return -1;
127: /* allocate send and recieve buffers */
128: if (NULL == (p = ibufset = (unsigned char *)malloc(8 * RPKTSIZE)))
129: return -1;
130: if (NULL == (q = obufset = (unsigned char *)malloc(8 * spktsize)))
131: return -1;
132: for(i = 0; i < 8; ++i) {
133: inpbufs[i].bufloc = p;
134: p += RPKTSIZE;
135: outbufs[i].bufloc = q;
136: q += spktsize;
137: }
138:
139: pktsize = spktsize; /* for dcp compatibility */
140: return 0;
141: }
142:
143: /* |gclosepk()| closes down the packet protocol using the |OP_CLOSE| operation
144: * of |gmachine()|.
145: */
146: gclosepk()
147: {
148: return gmachine(OP_CLOSE);
149: }
150:
151: /* |ggetpkt()| reads one packet and returns it. The data is stored in
152: * the buffer pointed to by |cdata|, and the length is stored in |*lenp|.
153: * It calls |gmachine()| to get the data, and copies it from the proper input
154: * buffer to the user's buffer area. "Short data" packets are handled here,
155: * as opposed to within |gmachine()|.
156: */
157: int
158: ggetpkt(cdata, lenp)
159: unsigned char *cdata;
160: int *lenp;
161: {
162: int i;
163: int nextread;
164: unsigned char *bufp;
165:
166: if (!chanopen)
167: return -1;
168: nextread = (lastread + 1) & 7;
169: printmsg(M_HIGHPROTO, "waiting for input pkt seq=%d", nextread);
170: if (gmachine(OP_READ) < 0)
171: return -1;
172: *lenp = inpbufs[nextread].length;
173: bufp = inpbufs[nextread].bufloc;
174: printmsg(M_HIGHPROTO, " lenp starts out at %d, and *bufp is %d",
175: *lenp, *bufp);
176: if (inpbufs[nextread].sdata) {
177: if (*bufp < 128) {
178: /* less than 128 bytes shorter than packet length */
179: printmsg(M_HIGHPROTO, "decrementing lenp once");
180: *lenp -= *bufp++;
181: } else { /* more than 128 bytes shorter */
182: printmsg(M_HIGHPROTO, "decrementing lenp twice");
183: *lenp -= (*bufp++ & 127) * 256;
184: *lenp -= *bufp++;
185: }
186: }
187: printmsg(M_HIGHPROTO,
188: "about to call memcpy, cdata %04x, bufp %04x, lenp %04x, *lenp %d",
189: cdata, bufp, lenp, *lenp);
190: i = *lenp;
191: memcpy(cdata, bufp, i);
192: lastread = nextread;
193: return 0;
194: }
195:
196: /* |gsendpkt()| queues the packet pointed to by |cdata| of length |len|
197: * into the packet driver output buffer, and calls |gmachine()| to send
198: * it. (|gmachine()| will return when the packet has been transmitted but
199: * not necessarily acknowledged, with window size greater than 1.) If
200: * |flag| is nonzero, |cdata| is considered a null-terminated string
201: * which will be null-padded to the packet size and transmitted.
202: */
203: int
204: gsendpkt(cdata, len, flag)
205: unsigned char *cdata;
206: int len, flag;
207: {
208: unsigned char *destp;
209: unsigned diff;
210:
211: if (!chanopen)
212: return -1;
213:
214: outbufs[nstuff].sdata = 0;
215: destp = outbufs[nstuff].bufloc;
216: if (flag && len < spktsize) {
217: printmsg(M_HIGHPROTO, "Padded message packet |%s|", cdata);
218: strncpy(destp, cdata, spktsize);
219: } else {
220: if ((diff = spktsize - len) > 127) { /* really short packet? */
221: *destp++ = (diff >> 8) | 128;
222: *destp++ = diff & 255;
223: outbufs[nstuff].sdata = 1;
224: } else if (diff > 0) { /* short packet */
225: *destp++ = diff;
226: outbufs[nstuff].sdata = 1;
227: } else
228: outbufs[nstuff].sdata = 0;
229: memcpy(destp, cdata, len); /* copy into buffer */
230: }
231: printmsg(M_HIGHPROTO, "queued data packet seq=%d len=%d", nstuff, len);
232: outbufs[nstuff].length = spktsize;
233: nstuff = (nstuff + 1) & 7;
234:
235: return gmachine(OP_WRITE);
236: }
237:
238: /* |gmachine()| is the heart of the 'g' packet driver. Its basic strategy
239: * is:
240: * - transmit a packet if necessary
241: * - return if possible,
242: * - else read a packet and act on it
243: * - repeat
244: *
245: * |OP_OPEN| requests that the channel be opened, and |OP_CLOSE| requests that
246: * it be closed. If |why| is |OP_WRITE|, |gmachine()| will return when the
247: * last packet in the output queue has been transmitted (but not necessarily
248: * acknowledged). |OP_READ| requests will return as soon as a new packet
249: * arrives.
250: */
251: int gmachine(why)
252: int why;
253: {
254: int xxx, yyy, len;
255: unsigned char *bufp;
256: int shortdat;
257: int i;
258: while(1) {
259: if (OP_CLOSE == why) {
260: gspack(TT_CTRL, X_CLOSE, 0, (unsigned char *)NULL, 0);
261: chanopen = 0;
262: printmsg(M_MEDPROTO, "Sending CLOSE request...");
263: } else if (neednack) {
264: gspack(TT_CTRL, X_RJ, recv, (unsigned char *)NULL, 0);
265: neednack = 0;
266: printmsg(M_MEDPROTO, "Sending RJ... recv=%d", recv);
267: } else if (send != nstuff /* nonzero output queue? */
268: && between(send, next, nstuff) /* 'next' in queue? */
269: && between(send, next, (send + swindow) & 7)) {
270: /* in out win. */
271: printmsg(M_MEDPROTO, "Sending data packet %d", next);
272: gspack(outbufs[next].sdata ? TT_SDATA : TT_DATA,
273: next, recv, outbufs[next].bufloc, outbufs[next].length);
274: needack = 0;
275: next = (next + 1) & 7;
276: if (OP_WRITE == why && next == nstuff)
277: /* go back for more */
278: return 0;
279: } else if (needack) {
280: gspack(TT_CTRL, X_RR, recv, (unsigned char *)NULL, 0);
281: needack = 0;
282: printmsg(M_MEDPROTO, "Sending RR... recv=%d", recv);
283: } else if (OP_OPEN == why) {
284: if (X_INITB == initpk)
285: i = ilog2(RPKTSIZE) - 5;
286: /* INITB contains packet size, */
287: else
288: i = RWINDOW;
289: /* INITA, INITC contain window size */
290: printmsg(M_MEDPROTO, "inita/b pkt/wndow i = %d", i);
291: /* ??? examine for INITC */
292: gspack(TT_CTRL, initpk, i, (unsigned char *)NULL, 0);
293: }
294: if (OP_READ == why && recv != lastread) {
295: return 0;
296: }
297: shortdat = 0;
298: bufp = buf + ENV_LEN;
299: switch(grpack(&xxx, &yyy, &len)) {
300: case LOSTPKT:
301: printmsg(M_MEDPROTO, "Lost packet...");
302: if (nlost > MAXLOST) {
303: plog(M_DATA, "Lost packets from other side");
304: return -1;
305: }
306: next = send; /* retransmit last un-ack'ed pkt, */
307: if (OP_READ == why) /* request retransmit */
308: neednack = 1;
309: skipping = 0;
310: break;
311: case BADPKT:
312: printmsg(M_MEDPROTO, "Bad packet...");
313: bad_count++;
314: total_errors ++;
315: neednack = 1; /* reject! */
316: skipping = 1; /* ignore the rest of the 'window' */
317: if (bad_count > 20) {
318: plog(M_DATA, "Too many errors");
319: return -1;
320: }
321: break;
322: case TT_SDATA:
323: shortdat = 1;
324: /* fall through */
325: case TT_DATA:
326: bad_count = 0;
327: send = (yyy + 1) & 7; /* recieve acknowledgement */
328: if (xxx != ((recv + 1) & 7)) {
329: printmsg(M_MEDPROTO,
330: "Recieved data out of sequence (%d != %d)",
331: xxx, (recv + 1) & 7);
332: if (!skipping) {
333: neednack = 1; /* we must have missed one */
334: skipping = 1;
335: } else
336: printmsg(M_MEDPROTO, "(Ignoring)");
337: } else {
338: recv = xxx;
339: /* this is most recent correct pkt */
340: needack = 1; /* we will ack it */
341: skipping = 0;
342: inpbufs[xxx].length = len;
343: inpbufs[xxx].sdata = shortdat;
344: memcpy(inpbufs[xxx].bufloc, bufp, len);
345: }
346: break;
347: case TT_CTRL:
348: bad_count = 0;
349: skipping = 0;
350: switch(xxx) {
351: case X_CLOSE:
352: printmsg(M_MEDPROTO, "* CLOSE *");
353: gspack(TT_CTRL, X_CLOSE, 0, NULL, 0);
354: chanopen = 0;
355: if (OP_CLOSE == why) /* expected? */
356: return 0;
357: else
358: return -1; /* nope */
359: case X_RJ:
360: printmsg(M_MEDPROTO, "got RJ yyy=%d", yyy);
361: next = send = (yyy + 1) & 7;
362: break;
363: case X_RR:
364: printmsg(M_MEDPROTO, "got RR yyy=%d", yyy);
365: send = (yyy + 1) & 7;
366: break;
367: case X_INITC:
368: printmsg(M_MEDPROTO, "* INITC *");
369: swindow = yyy;
370: if (X_INITC == initpk) {
371: chanopen = 1;
372: return 0;
373: }
374: break;
375: case X_INITB:
376: spktsize = 32 << yyy;
377: printmsg(M_MEDPROTO, "* INITB *, spktsz %d",
378: spktsize);
379: if (X_INITB == initpk)
380: initpk = X_INITC;
381: break;
382: case X_INITA:
383: printmsg(M_MEDPROTO, "* INITA *");
384: swindow = yyy;
385: initpk = X_INITB;
386: break;
387: default:
388: printmsg(M_MEDPROTO,
389: "bad control packet: xxx=%d", xxx);
390: }
391: break;
392: default:
393: break;
394: }
395: }
396: }
397:
398: /*
399: * |grpack()| is responsible for reading one 'g'-protocol packet from the
400: * input communications channel. This includes framing, detecting timeouts,
401: * and checksum validation.
402: * The basic strategy is to keep a count of how many bytes have currently
403: * been read and how many are needed. When enough bytes for a packet header
404: * ("envelope") have been read, it is validated. If it is valid, and it
405: * has a nonzero data segment, the data portion is read. When it has
406: * everything, it does a checksum test and returns, with the control
407: * information stored in |*xxxp|, |*yyyp|, and the data segment length stored
408: * in |*lenp|.
409: */
410: int grpack(xxxp, yyyp, lenp)
411: int *xxxp, *yyyp;
412: int *lenp;
413: {
414: int need; /* need how many bytes? */
415: int env; /* 'have pkt envelope' flag */
416: int gotdle; /* do we have envelope hdr? */
417: int tt; /* packet type */
418: unsigned sum; /* checksum */
419: int remain; /* bytes which we stil need */
420: int i;
421:
422: env = gotdle = 0;
423: need = ENV_LEN; /* initially, need a header */
424:
425: SETALRM(TIMEOUT); /* time out if we don't have a packet */
426:
427: while(1) {
428: if (low == high) /* prevent framebuffer overruns */
429: low = high = buf;
430: printmsg(M_LOWPROTO, "=> l=%d h=%d g=%d", (int)(low - buf),
431: (int)(high - buf), gotdle);
432: while((remain = need - (high - low)) > 0) {
433: if (timedout || (i = sread2(high, remain)) < 0) {
434: CLRALRM();
435: ++nlost;
436: low = high = buf;
437: /* empty out partial packet, if any */
438: return env ? BADPKT : LOSTPKT;
439: }
440: high += i; /* got some data - move upper limit up */
441: }
442: if (!gotdle) {
443: while(low < high) { /* look for header 'DLE' prefix */
444: if (DLE == *low) {
445: gotdle = 1;
446: break;
447: } else
448: ++low;
449: }
450: continue;
451: } else if (!env) {
452: /* found DLE, but haven't found header yet */
453: if (low > buf) { /* move envelope to buf beginning */
454: register unsigned char *dst = buf;
455: while(low < high)
456: *dst++ = *low++;
457: low = buf;
458: high = dst;
459: }
460: if (buf[ENV_X] != (buf[ENV_K]^buf[ENV_C0]^
461: buf[ENV_C1]^buf[ENV_C]) ||
462: buf[ENV_K] < 1 || buf[ENV_K] > 9) {
463: /* valid? */
464: ++low;
465: gotdle = 0;
466: printmsg(M_LOWPROTO,
467: "grpack: rejecting an envelope");
468: continue;
469: }
470: env = 1; /* we have an envelope */
471: /* store away control info */
472: tt = (buf[ENV_C] >> 6) & 3;
473: *xxxp = (buf[ENV_C] >> 3) & 7;
474: *yyyp = (buf[ENV_C] ) & 7;
475: if (buf[ENV_K] == 9) /* does it have data? */
476: *lenp = 0;
477: else
478: *lenp = 16 << buf[ENV_K];
479: /* size = 32 * 2^(k-1) */
480: need += *lenp; /* now need that many more */
481: printmsg(M_LOWPROTO,
482: "grpack: tt=%d, xxx=%d, yyy=%d, need=%d",
483: tt, *xxxp, *yyyp, need);
484: continue;
485: } else { /* have everything we need */
486: if (*lenp)
487: sum = MAGIC - (cksum(buf + ENV_LEN, *lenp) ^
488: buf[ENV_C]);
489: else {
490: sum = MAGIC - buf[ENV_C];
491: printmsg(M_LOWPROTO,
492: "0 length data, data %x, %x, %x", buf[ENV_C],
493: buf[ENV_C0], buf[ENV_C1]);
494: }
495: if (((sum >> 8) & 0xFF) != buf[ENV_C1]
496: || (sum & 0xFF) != buf[ENV_C0]) {
497: CLRALRM();
498: nlost = 0;
499: printmsg(M_LOWPROTO,
500: "grpack: bad check, sum is %x", sum);
501: low += ENV_LEN;
502: /* we will search bad data seg for a header */
503: return BADPKT;
504: } else {
505: CLRALRM(); /* got it all... return */
506: nlost = 0;
507: low += need;
508: if (*lenp)
509: printmsg(M_DATA, "|%s|",
510: visbuf(buf + ENV_LEN, *lenp));
511: return tt;
512: }
513: }
514: }
515: }
516:
517: /*
518: * gspack simply sends out a packet, by assembling an envelope and writing
519: * it, and the data segment, to the communications channel.
520: */
521: gspack(tt, xxx, yyy, data, size)
522: int tt, xxx, yyy;
523: unsigned char *data;
524: int size;
525: {
526: unsigned char envelope[ENV_LEN]; /* packet envelope */
527: unsigned sum; /* checksum */
528: unsigned char ctrl; /* header control byte */
529: int k; /* size = 32 * 2^(k-1) */
530:
531: ctrl = ((tt & 3) << 6) | ((xxx & 7) << 3) | (yyy & 7);
532: if (0 == size) {
533: k = 9; /* no data seg */
534: sum = MAGIC - ctrl;
535: } else {
536: int tmp = size;
537: for(k = -5; tmp != 0; ++k) /* find k */
538: tmp >>= 1;
539: sum = MAGIC - (cksum(data, size) ^ ctrl);
540: }
541: envelope[ENV_DLE] = DLE;
542: envelope[ENV_K] = k;
543: envelope[ENV_C1] = (sum >> 8) & 0xFF;
544: envelope[ENV_C0] = sum & 0xFF;
545: envelope[ENV_C] = ctrl;
546: envelope[ENV_X] = k ^ envelope[ENV_C0] ^ envelope[ENV_C1] ^ ctrl;
547: swrite(envelope, ENV_LEN); /* send envelope */
548: if (0 != size)
549: swrite(data, size); /* send data segment */
550: printmsg(M_LOWPROTO, "gspack: tt=%d xxx=%d yyy=%d k=%d sum=%x",
551: tt, xxx, yyy, k, sum);
552: if (0 != size)
553: printmsg(M_DATA, "|%s|", visbuf(data, size));
554: }
555:
556: /*
557: * chksum(data, len) came directly from dcp. It checksums the given data
558: * area using the g protocol algorithm.
559: */
560: unsigned cksum(data, len)
561: int len;
562: unsigned char *data;
563: {
564: unsigned int i, j, tmp, chk1, chk2;
565: chk1 = 0xffff;
566: chk2 = 0;
567: j = len;
568: for (i = 0; i < len; i++) {
569: if (chk1 & 0x8000) {
570: chk1 <<= 1;
571: chk1++;
572: } else
573: chk1 <<= 1;
574: tmp = chk1;
575: chk1 += (data[i] & 0xff);
576: chk2 += chk1 ^ j;
577: if ((chk1 & 0xffff) <= (tmp & 0xffff))
578: chk1 ^= chk2;
579: j--;
580: }
581: return (chk1 & 0xffff);
582: }
583:
584: /* |ilog2(value)| returns (int)floor(log2(value)).
585: */
586: int ilog2(value)
587: unsigned value;
588: {
589: int i;
590:
591: if (value == 0)
592: return -1;
593: for(i = 0; value > 1; ++i)
594: value >>= 1;
595: return i;
596: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.