![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to prot.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 3BSD / cmd / net|
Return to prot.c CVS log | Up to [CSRG BSD Unix] / 3BSD / cmd / net |
1.1 root 1: # include "defs.h"
2: struct packet *xptr, *gptr;
3: # define PACKETLENGTH (datasize + sizeof *xptr - 1)
4: # define ACKLENGTH (sizeof *xptr - 1)
5: static int bufleft;
6: int atime = ATIME;
7: int maxbread = MAXBREAD;
8: int datasize;
9: static char savebuf[BUFSIZ], retransmit;
10: static jmp_buf env;
11: short masterseqno, lastseqno;
12: FILE *readtty,*writetty;
13: struct dumpstruc dump;
14:
15: /*
16: one problem has been character loss on
17: overloaded systems due to the daemon
18: taking too long to swap in
19: and losing characters.
20: A high priority process of small size
21: with a pipe would do the job.
22: */
23: alarmint(){
24: errno = 100;
25: signal(SIGCLK,SIG_IGN); /* alarm off */
26: longjmp(env,0); /* ugh */
27: }
28: /* returns number of bytes written, error returns WRITEFAIL (-3) */
29: xwrite(inbuf,size,amt)
30: char *inbuf;
31: {
32: struct packet *rpp;
33: int cnt, num, savetime;
34: register char *p, *b;
35: register int i;
36: if(xptr == NULL)xptr = (struct packet *)calloc((PACKETLENGTH+20)/4,4);
37: if(xptr == NULL){error("xptr NULL"); return(WRITEFAIL); }
38: amt = amt * size;
39: cnt = 0;
40: retransmit = 0;
41: savetime = atime;
42: while(amt > 0){
43: if(retransmit > maxbread){
44: debug("xwrite fail");
45: return(WRITEFAIL);
46: }
47: b = inbuf+cnt;
48: num = min(datasize,amt);
49: xptr->pcode = REQUEST;
50: xptr->seqno = masterseqno;
51: xptr->len = num;
52: p = xptr->data;
53: i = num;
54: while(i--)*p++ = *b++;
55: sendpacket(xptr);
56: rpp = getpacket();
57: if(rpp == NULL){
58: atime += 3; /* wait three more secs */
59: retransmit++;
60: dump.nretrans++;
61: continue;
62: }
63: if(rpp->chksum != 0 || rpp->pcode != ACK
64: || rpp->seqno != xptr->seqno ){
65: if(rpp->pcode == RESET){
66: error("reset");
67: return(WRITEFAIL);
68: }
69: if(rpp->seqno == 1 && rpp->pcode == REQUEST){
70: error("collision");
71: return(WRITEFAIL);
72: }
73: if(rpp->chksum != 0)
74: error("chksum %d",rpp->seqno);
75: else if(rpp->pcode != ACK)
76: error("not ack %d %d",rpp->pcode,rpp->seqno);
77: else if(rpp->seqno != xptr ->seqno)
78: error("WRSQNO got %d request %d",rpp->seqno,
79: xptr->seqno);
80: atime += 3;
81: retransmit++;
82: dump.nretrans++;
83: continue;
84: }
85: masterseqno++;
86: amt -= num;
87: retransmit = 0;
88: cnt += num;
89: }
90: atime = savetime;
91: return(cnt/size);
92: }
93: /* return the number of bytes read, or error = BROKENREAD (-2) */
94: nread(b,size,num)
95: register char *b;
96: {
97: register char *p;
98: int bcnt = 0;
99: char *q;
100: register struct packet *pp;
101: int n,j,cnt;
102: num = num * size;
103: cnt = 0;
104: if(bufleft > 0){
105: p = savebuf;
106: cnt = n = min(bufleft,num);
107: while(n--)*b++ = *p++;
108: num -= cnt;
109: bufleft -= cnt;
110: if(bufleft > 0){
111: q = savebuf;
112: n = bufleft;
113: while(n--)*q++ = *p++;
114: }
115: }
116: if(num <= 0)
117: return(cnt/size);
118: retransmit = 0;
119: for(;;){
120: pp = getpacket();
121: if(pp == NULL){
122: if(++bcnt >= maxbread){
123: debug("read timeout");
124: return(BROKENREAD);
125: }
126: continue;
127: }
128: if(pp->chksum != 0){
129: error("chksum %d",pp->seqno);
130: retransmit++;
131: continue;
132: }
133: if(pp->pcode & ~(REQUEST|RESET)){
134: error("pcode %d %d",pp->pcode,pp->seqno);
135: retransmit++;
136: continue;
137: }
138: else if(pp->pcode == RESET)break;
139: else { /* else was a REQUEST packet, no chksum errs */
140: pp->pcode = ACK;
141: n = pp->len;
142: pp->len = 0;
143: sendpacket(pp); /* send ACK */
144: pp->len = n;
145: break;
146: }
147: }
148: retransmit = 0;
149: j = n = min(num,pp->len);
150: cnt += j;
151: p = pp->data;
152: while(n--)*b++ = *p++;
153: if(pp->len > num){
154: n = bufleft = pp->len - num;
155: q = savebuf;
156: while(n--)*q++ = *p++;
157: }
158: return(cnt/size);
159: }
160: printpacket(pp,dest)
161: char *dest;
162: struct packet *pp; {
163: char *s;
164: int i;
165: char c;
166: dest[0] = 0;
167: if(pp == NULL)return;
168: if(pp->pcode == REQUEST)c='r';
169: else if(pp->pcode == ACK)c = 'a';
170: else if(pp->pcode == RESET)c = 'x';
171: else if(pp->pcode == PURGE)c = 'p';
172: else c = 'u';
173: sprintf(dest,"p:%d len:%d c:%c d:", pp->seqno, pp->len, c);
174: s = dest + strlen(dest);
175: for(i=0; i<pp->len && pp->data[i]; i++)*s++ = pp->data[i];
176: *s = 0;
177: }
178: /*
179: * A purge can always be sent -
180: * the receiver totally ignores it.
181: * It is used to push the packet terminator
182: * down the wire in case of a crash
183: * leaving the receiver half reading.
184: */
185: sendpurge()
186: {
187: if(xptr == NULL)xptr = (struct packet *)calloc((PACKETLENGTH+20)/4,4);
188: if(xptr == NULL){
189: error("bad xptr");
190: return;
191: }
192: xptr->pcode = PURGE;
193: xptr->seqno = 0;
194: xptr->len = 0;
195: debug("send purge");
196: sendpacket(xptr);
197: }
198: /*
199: * A reset is sent by the sender whenever he begins to send.
200: * It is not acknowledged.
201: * The receiver must be prepared, when he receives a reset,
202: * to receive a new transmission.
203: */
204: sendreset()
205: {
206: if(xptr == NULL)xptr = (struct packet *)calloc((PACKETLENGTH+20)/4,4);
207: if(xptr == NULL){
208: error("bad xptr");
209: return;
210: }
211: xptr->pcode = RESET;
212: xptr->seqno = 0;
213: xptr->len = 0;
214: debug("send reset");
215: sendpacket(xptr);
216: }
217: /*
218: * Getreset returns in either of two cases:
219: * 1) the read times out (return BROKENREAD)
220: * 2) a reset packet is received (return 0)
221: * all other packets received are ignored.
222: */
223: getreset() {
224: register struct packet *pp;
225: register int bcnt = 0;
226: bufleft = 0; /* if any chars are left in buffer, flush them*/
227: atime = ATIME + ((rand()>>8)%15);
228: lastseqno = -1; /* forces non-RESET pks to not be ACK-ed */
229: for(;;){
230: pp = getpacket();
231: if(pp == NULL){
232: if(++bcnt >= maxbread){
233: debug("reset timeout");
234: return(BROKENREAD);
235: }
236: continue;
237: }
238: if(pp->pcode == RESET){
239: debug("got reset");
240: addtolog(remote,"^R%c ",remote);
241: lastseqno = 0;
242: return(0);
243: }
244: }
245: }
246: /*
247: * Just sends packet pp
248: * Calculates the chksum
249: */
250: sendpacket(pp)
251: struct packet *pp; {
252: char buf[BUFSIZ];
253: int len, n, i;
254: long nt,ot;
255: register char *q, *p;
256: register int j;
257: dump.nbytesent += pp->len;
258: dump.npacksent++;
259: pp->chksum = 0;
260: n = 0;
261: p = (char *)pp;
262: len = ACKLENGTH + pp->len;
263: for(j = 0; j < len; j++)n ^= *p++;
264: pp->chksum = n;
265: p = buf;
266: q = (char *)pp;
267: len = n = (len+2)/3;
268: while(n--){
269: *p++ = (*q & 077) + INCR;
270: j = (*q++ >> 6) &03;
271: *p++ = (((*q << 2) | j) & 077) + INCR;
272: j = (*q++ >> 4) & 017;
273: *p++ = (((*q << 4) | j) & 077) + INCR;
274: *p++ = ((*q++ >> 2) & 077) + INCR;
275: }
276: *p++ = '\n';
277: *p = 0;
278: /* because of bugs in processing around erase and kill in v6 */
279: for(p=buf; *p; p++)
280: if(*p == '\\')*p = '}';
281: /*
282: debug("send %d %s",len*4+1,buf);
283: */
284: ot = gettime();
285: i = fwrite(buf,1,len*4+1, writetty);
286: nt = gettime();
287: dump.waittime += (nt - ot); /* add time writing */
288: /*
289: debug("count %d",i);
290: */
291: fflush(writetty);
292: }
293: /*
294: * returns NULL if couldn't get a packet with correct seqno
295: * chksum not checked here
296: * because other programs may want to interrogate checksum
297: */
298: struct packet *getpacket() {
299: char buf[BUFSIZ];
300: int i,n,j, len, plen;
301: int bcnt;
302: register char *q, *p;
303: long ot, nt;
304: if(gptr == NULL)gptr = (struct packet *)calloc((PACKETLENGTH+20)/4,4);
305: if(gptr == NULL){error("gptr NULL"); return(NULL); }
306: bcnt = 0;
307: errno = 0;
308: setjmp(env);
309: alarm(0);
310: signal(SIGCLK,alarmint);
311: for(;;){
312: if(bcnt++ > maxbread)errno = 100; /* give up */
313: if(errno == 100){
314: if(debugflg)putchar('^');
315: return(NULL);
316: }
317: alarm(atime);
318: ot = gettime();
319: p = fgets(buf,BUFSIZ,readtty);
320: alarm(0);
321: nt = gettime();
322: dump.waittime += (nt - ot);
323: if(p == NULL){error("getpacket fails"); return(NULL); }
324: plen = strlen(buf);
325: /*
326: debug("receive %d %s",plen,buf);
327: */
328: /* remove this loop later */
329: for(p=buf; *p; p++)
330: if(*p == '}')*p = '\\';
331: p = buf;
332: q = (char *)gptr;
333: n = (strlen(buf)+3) /4;
334: while(n--){
335: if(*p == '\n')break;
336: if(*p < INCR || *p & 0200)error("bad char %o\n",*p);
337: i = *p++ - INCR;
338: j = *p++ - INCR;
339: *q++ = ((j & 03) << 6) | (i & 077);
340: i = *p++ -INCR;
341: *q++ = ((i & 017) << 4) | ((j >> 2) & 017);
342: j = *p++ - INCR;
343: *q++ = ((j & 077) << 2) | ((i >> 4) & 03);
344: }
345: *q = 0;
346: if(plen != ((ACKLENGTH + gptr->len + 2)/3)*4 + 1){
347: error("too short %d",gptr->seqno);
348: continue;
349: }
350: if(gptr->pcode == PURGE){
351: debug("got purge");
352: continue; /* never seen */
353: }
354: if(gptr->pcode == RESET)
355: break;
356: if(gptr->seqno == lastseqno){
357: if(retransmit)break;
358: /* send ACK - it was lost first time thru */
359: len = gptr->len;
360: n = gptr->pcode;
361: gptr->len = 0;
362: gptr->pcode = ACK;
363: sendpacket(gptr);
364: gptr->len = len;
365: gptr->pcode = n;
366: error("sendlostack %d",lastseqno);
367: break;
368: }
369: if(gptr->seqno == lastseqno + 1)break;
370: error("Wrong seq no g: %d last: %d",gptr->seqno,
371: lastseqno);
372: }
373: lastseqno = gptr->seqno;
374: n = 0;
375: len = gptr->len + ACKLENGTH;
376: p = (char *)gptr;
377: for(i=0; i < len; i++)n ^= *p++;
378: gptr->chksum = n;
379: if(n != 0)dump.ncksum++;
380: dump.nbytercv += gptr->len;
381: dump.npackrcv++;
382: return(gptr);
383: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.