![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ckcfn2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / e / bin / cku179|
Return to ckcfn2.c CVS log | Up to [MW Coherent from dump] / coherent / e / bin / cku179 |
1.1 root 1: /* C K C F N 2 -- System-independent Kermit protocol support functions... */
2:
3: /* ...Part 2 (continued from ckcfns.c) */
4:
5: /*
6: Author: Frank da Cruz ([email protected], [email protected]),
7: Columbia University Center for Computing Activities.
8: First released January 1985.
9: Copyright (C) 1985, 1992, Trustees of Columbia University in the City of New
10: York. Permission is granted to any individual or institution to use, copy, or
11: redistribute this software so long as it is not sold for profit, provided this
12: copyright notice is retained.
13: */
14: /*
15: Note -- if you change this file, please amend the version number and date at
16: the top of ckcfns.c accordingly.
17: */
18:
19: #include "ckcsym.h"
20: #include "ckcdeb.h"
21: #include "ckcasc.h"
22: #include "ckcker.h"
23: #include "ckcxla.h"
24:
25: #ifdef DYNAMIC
26: extern struct pktinfo *s_pkt; /* array of pktinfo structures */
27: extern struct pktinfo *r_pkt; /* array of pktinfo structures */
28: #else
29: extern struct pktinfo s_pkt[]; /* array of pktinfo structures */
30: extern struct pktinfo r_pkt[]; /* array of pktinfo structures */
31: #endif /* DYNAMIC */
32:
33: extern int sseqtbl[], rseqtbl[], sbufuse[], sacktbl[], wslots, winlo, sbufnum;
34:
35: extern int ttprty; /* from ckutio.c */
36: extern int autopar;
37:
38: extern int spsiz, spmax, rpsiz, timint, npad, ebq, ebqflg, pkttim, rtimo,
39: rpt, rptq, rptflg, capas, spsizf, en_fin, tsecs, network, flow;
40: extern int pktnum, sndtyp, bctr, bctu, rsn, rln, maxtry, size;
41: extern int osize, maxsize, spktl, nfils, stdouf, warn, timef, parity;
42: extern int turn, turnch, delay, displa, pktlog, tralog, seslog, xflg, mypadn;
43: extern int hcflg, binary, local, server, cxseen, czseen;
44: extern int nakstate, quiet, success, xitsta, what;
45: extern int spackets, rpackets, timeouts, retrans, crunched, wmax;
46: extern long filcnt, ffc, flci, flco, tlci, tlco, tfc, fsize, speed;
47: extern char *cmarg, *cmarg2, filnam[], *hlptxt;
48: extern CHAR padch, mypadc, eol, seol, ctlq, myctlq, sstate;
49: extern CHAR *recpkt, *data, encbuf[];
50: extern CHAR *srvptr, stchr, mystch, *rdatap;
51: extern CHAR padbuf[];
52: #ifdef DYNAMIC
53: extern CHAR *srvcmd;
54: #else
55: extern CHAR srvcmd[];
56: #endif /* DYNAMIC */
57:
58: int numerrs = 0; /* (PWP) total number packet errors so far */
59:
60: static CHAR partab[] = { /* Even parity table for dopar(). */
61: (CHAR) '\000', /* ANSI C casts '\ooo' constants */
62: (CHAR) '\201', /* to signed char, so we have to */
63: (CHAR) '\202', /* cast back to unsigned char... */
64: (CHAR) '\003',
65: (CHAR) '\204',
66: (CHAR) '\005',
67: (CHAR) '\006',
68: (CHAR) '\207',
69: (CHAR) '\210',
70: (CHAR) '\011',
71: (CHAR) '\012',
72: (CHAR) '\213',
73: (CHAR) '\014',
74: (CHAR) '\215',
75: (CHAR) '\216',
76: (CHAR) '\017',
77: (CHAR) '\220',
78: (CHAR) '\021',
79: (CHAR) '\022',
80: (CHAR) '\223',
81: (CHAR) '\024',
82: (CHAR) '\225',
83: (CHAR) '\226',
84: (CHAR) '\027',
85: (CHAR) '\030',
86: (CHAR) '\231',
87: (CHAR) '\232',
88: (CHAR) '\033',
89: (CHAR) '\234',
90: (CHAR) '\035',
91: (CHAR) '\036',
92: (CHAR) '\237',
93: (CHAR) '\240',
94: (CHAR) '\041',
95: (CHAR) '\042',
96: (CHAR) '\243',
97: (CHAR) '\044',
98: (CHAR) '\245',
99: (CHAR) '\246',
100: (CHAR) '\047',
101: (CHAR) '\050',
102: (CHAR) '\251',
103: (CHAR) '\252',
104: (CHAR) '\053',
105: (CHAR) '\254',
106: (CHAR) '\055',
107: (CHAR) '\056',
108: (CHAR) '\257',
109: (CHAR) '\060',
110: (CHAR) '\261',
111: (CHAR) '\262',
112: (CHAR) '\063',
113: (CHAR) '\264',
114: (CHAR) '\065',
115: (CHAR) '\066',
116: (CHAR) '\267',
117: (CHAR) '\270',
118: (CHAR) '\071',
119: (CHAR) '\072',
120: (CHAR) '\273',
121: (CHAR) '\074',
122: (CHAR) '\275',
123: (CHAR) '\276',
124: (CHAR) '\077',
125: (CHAR) '\300',
126: (CHAR) '\101',
127: (CHAR) '\102',
128: (CHAR) '\303',
129: (CHAR) '\104',
130: (CHAR) '\305',
131: (CHAR) '\306',
132: (CHAR) '\107',
133: (CHAR) '\110',
134: (CHAR) '\311',
135: (CHAR) '\312',
136: (CHAR) '\113',
137: (CHAR) '\314',
138: (CHAR) '\115',
139: (CHAR) '\116',
140: (CHAR) '\317',
141: (CHAR) '\120',
142: (CHAR) '\321',
143: (CHAR) '\322',
144: (CHAR) '\123',
145: (CHAR) '\324',
146: (CHAR) '\125',
147: (CHAR) '\126',
148: (CHAR) '\327',
149: (CHAR) '\330',
150: (CHAR) '\131',
151: (CHAR) '\132',
152: (CHAR) '\333',
153: (CHAR) '\134',
154: (CHAR) '\335',
155: (CHAR) '\336',
156: (CHAR) '\137',
157: (CHAR) '\140',
158: (CHAR) '\341',
159: (CHAR) '\342',
160: (CHAR) '\143',
161: (CHAR) '\344',
162: (CHAR) '\145',
163: (CHAR) '\146',
164: (CHAR) '\347',
165: (CHAR) '\350',
166: (CHAR) '\151',
167: (CHAR) '\152',
168: (CHAR) '\353',
169: (CHAR) '\154',
170: (CHAR) '\355',
171: (CHAR) '\356',
172: (CHAR) '\157',
173: (CHAR) '\360',
174: (CHAR) '\161',
175: (CHAR) '\162',
176: (CHAR) '\363',
177: (CHAR) '\164',
178: (CHAR) '\365',
179: (CHAR) '\366',
180: (CHAR) '\167',
181: (CHAR) '\170',
182: (CHAR) '\371',
183: (CHAR) '\372',
184: (CHAR) '\173',
185: (CHAR) '\374',
186: (CHAR) '\175',
187: (CHAR) '\176',
188: (CHAR) '\377'
189: };
190:
191: /* CRC generation tables */
192:
193: static long crcta[16] = { 0L, 010201L, 020402L, 030603L, 041004L,
194: 051205L, 061406L, 071607L, 0102010L, 0112211L, 0122412L, 0132613L, 0143014L,
195: 0153215L, 0163416L, 0173617L };
196:
197: static long crctb[16] = { 0L, 010611L, 021422L, 031233L, 043044L,
198: 053655L, 062466L, 072277L, 0106110L, 0116701L, 0127532L, 0137323L, 0145154L,
199: 0155745L, 0164576L, 0174367L };
200:
201:
202: /* I N P U T -- Attempt to read packet number 'pktnum'. */
203:
204: /*
205: This is the function that feeds input to Kermit's finite state machine,
206: in the form of a character in the range 32-126, normally a packet type
207: (uppercase letter) or pseudo-packet-type (lowercase letter).
208:
209: If a special start state is in effect, that state is returned as if it were
210: the type of an incoming packet. Otherwise:
211:
212: (fill in...)
213: */
214:
215: int
216: input() {
217: int type;
218: int x = 0, y, k;
219:
220: debug(F101,"input sstate","",sstate);
221: debug(F101," nakstate","",nakstate);
222: debug(F000," sndtyp","",sndtyp);
223:
224: while (1) { /* Big loop... */
225:
226: if (sstate != 0) { /* If a start state is in effect, */
227: type = sstate; /* return it like a packet type, */
228: sstate = 0; /* and then nullify it. */
229: numerrs = 0; /* (PWP) no errors so far */
230: return(type);
231: }
232:
233: if (nakstate) { /* This section for file receiver. */
234:
235: if (wslots > 1) { /* If we're doing windows, */
236: x = rseqtbl[winlo]; /* see if desired packet already in. */
237: debug(F101," winlo","",winlo);
238: debug(F101," rseqtbl[winlo]","",rseqtbl[winlo]);
239: if (x > -1) { /* Already there? */
240: if (r_pkt[x].pk_seq == winlo) { /* (double check) */
241: rsn = winlo; /* Yes, return its info */
242: debug(F101,"input return pre-stashed packet","",rsn);
243: dumprbuf();
244: rdatap = r_pkt[x].pk_adr; /* like rpack would do. */
245: rln = (int)strlen((char *) rdatap);
246: type = r_pkt[x].pk_typ;
247: break;
248: }
249: }
250: }
251: type = rpack(); /* Try to read a packet. */
252: debug(F111,"input",(char *) rdatap,(int) type);
253: while (type == sndtyp) { /* Handle echoes */
254: debug(F000,"echo discarded","",type);
255: freerbuf(rseqtbl[rsn]);
256: type = rpack();
257: }
258: if (type < -1) return('q'); /* Ctrl-C */
259: if (type < 0) { /* Receive window full */
260: /* Another thing to do here would be to delete */
261: /* the highest packet and NAK winlo. But that */
262: /* shouldn't be necessary since the other Kermit */
263: /* should not have sent a packet outside the window. */
264: debug(F101,"rpack receive window full","",0);
265: dumprbuf();
266: errpkt((CHAR *)"Receive window full.");
267: strcpy((char *)recpkt,"Receive window full.");
268: type = 'E';
269: break;
270: }
271: dumprbuf();
272:
273: if (chkint() < 0) { /* Check for console interrupts. */
274: errpkt((CHAR *)"User cancelled.");
275: strcpy((char *)recpkt,"User cancelled.");
276: type = 'E';
277: break;
278: }
279: if (type == 'E') {
280: debug(F101,"input got E, nakstate","",nakstate);
281: break; /* Error packet */
282: }
283: if (type == 'Q') { /* Crunched packet. */
284: crunched++;
285: numerrs++;
286: if (nack(winlo) < 0) { /* Request resend of window-low.. */
287: debug(F101,"input sent too many naks","",winlo);
288: errpkt((CHAR *)"Too many retries.");
289: strcpy((char *)recpkt,"Sent too many NAKs.");
290: type = 'E';
291: break;
292: } else continue;
293: }
294: if (type == 'T') { /* Timeout */
295: #ifdef BULKNAKS
296: int z;
297: #endif
298: timeouts++;
299: debug(F101,"input receive-state timeout, winlo","",winlo);
300: #ifdef BULKNAKS
301: z = winlo + wslots; /* NAK all unACK'd packets */
302: if (z > 63) z -= 64;
303: debug(F101,"input sending bulk NAKs, winlo","",winlo);
304: for (x = winlo; (x != z) && ttchk() == 0; x++) {
305: if (x < 0 || x > 63) break;
306: if (rseqtbl[x] < 0) {
307: if (nack(x) < 0) {
308: debug(F101,"input sent too many naks","",winlo);
309: errpkt((CHAR *)"Too many retries.");
310: strcpy(recpkt,"Sent too many NAKs.");
311: type = 'E';
312: break;
313: }
314: }
315: }
316: #else /* NAK only the packet at window-low */
317: debug(F101,"input sending NAK for winlo","",winlo);
318: if (nack(winlo) < 0) {
319: debug(F101,"input sent too many naks","",winlo);
320: errpkt((CHAR *)"Too many retries.");
321: strcpy((char *)recpkt,"Sent too many NAKs.");
322: type = 'E';
323: break;
324: }
325: #endif /* BULKNAKS */
326: continue;
327: }
328:
329: /* Got the packet we want, done. */
330:
331: if (rsn == winlo) {
332: debug(F101,"input rsn=winlo","",rsn);
333: break;
334: }
335:
336: /* Got a packet out of order. */
337:
338: debug(F101,"input got data packet out of order","",rsn);
339: k = rseqtbl[rsn]; /* Get window slot of this packet. */
340: debug(F101,"input rseqtbl[rsn]","",k);
341: if (k < 0) {
342: debug(F101,"input can't find index for rcvd pkt","",rsn);
343: errpkt((CHAR *)"internal error number 21");
344: strcpy((char *)recpkt,"S/W Protocol Error.");
345: type = 'E';
346: break;
347: }
348: y = chkwin(rsn,winlo,wslots); /* See what window it's in. */
349: debug(F101,"input chkwin","",y);
350: if (y == 1) { /* Previous window. */
351: ackn(rsn); /* Send empty ACK */
352: freerpkt(rsn); /* Get rid of received packet */
353: continue;
354: } else { /* In this window or out of range */
355: if (y < 0) /* If out of range entirely, */
356: freerpkt(rsn); /* release its buffer */
357: /*
358: We have received a packet, but not the one we want. If we do nothing,
359: we could be in for a lengthy timeout/retry cycle. It would seem to
360: make sense to send a NAK for the most desired packet (winlo). But
361: consider this scenario: a packet arrived damaged so we NAK'd it above;
362: then packets winlo+1, winlo+2, ... winlo+n arrive, each one making us
363: send a NAK for winlo, so the other Kermit gets n NAKs for winlo, and
364: either would have to resend it n times, or if n > retry limit, give up
365: because of too many retries. So we compromise: If a packet arrives
366: that is not the most desired packet (winlo), we NAK winlo, BUT ONLY IF
367: it has not be NAK'd before.
368: */
369: if (s_pkt[k].pk_rtr == 0) { /* Have we been here before? */
370: if (nack(winlo) < 0) { /* No, NAK winlo. */
371: errpkt((CHAR *)"Too many retries."); /* Too many */
372: strcpy((char *)recpkt,"Timed out."); /* Give up */
373: type = 'E';
374: break;
375: } else continue;
376: } else continue;
377: }
378: /*!!!*/
379: } else { /* Otherwise file sender... */
380:
381: if (wslots > 1) { /* Packet at winlo already ACK'd? */
382: #ifdef COMMENT
383: x = sseqtbl[winlo];
384: if (x > -1) {
385: if (s_pkt[x].pk_flg) { /* If so, */
386: freesbuf(winlo); /* Free its buffer */
387:
388: #else
389: if (sacktbl[winlo]) { /* If so, */
390: sacktbl[winlo] = 0; /* Turn off the ACK'd flag */
391: #endif
392: winlo = (winlo + 1) % 64; /* Rotate the window */
393: type = 'Y'; /* And return ACK */
394: debug(F101,
395: "input returning pre-stashed ACK","",winlo-1);
396: break;
397: }
398: #ifdef COMMENT
399: }
400: #endif /* COMMENT */
401: }
402:
403: type = rpack(); /* Try to read an ack. */
404: debug(F111,"input",rdatap,type);
405: while (type == sndtyp) { /* Handle echoes */
406: debug(F000,"echo discarded","",type);
407: freerbuf(rseqtbl[rsn]);
408: type = rpack();
409: }
410: if (type == -2) return('q');
411: if (type == -1) {
412: errpkt((CHAR *)"Internal error number 18");
413: debug(F101," wslots","",wslots);
414: debug(F101," winlo","",winlo);
415: debug(F101," pktnum","",pktnum);
416: dumprbuf();
417: strcpy((char *)recpkt,"Can't allocate receive buffer");
418: type = 'E';
419: break;
420: }
421: dumprbuf(); /* debugging */
422:
423: if (chkint() < 0) { /* Check for console interrupts. */
424: errpkt((CHAR *)"User cancelled.");
425: strcpy((char *)recpkt,"User cancelled.");
426: return(type = 'E');
427: }
428:
429: /* got a packet */
430:
431: if (type == 'E') {
432: debug(F101,"input got E, nakstate","",nakstate);
433: break; /* Error packet */
434: }
435: if (type == 'Q') { /* Crunched packet */
436: crunched++; /* For statistics */
437: numerrs++; /* For packet resizing */
438: x = resend(winlo); /* Resend window-low */
439: if (x < 0) {
440: type = 'E';
441: errpkt(recpkt);
442: break;
443: }
444: continue;
445: }
446: if (type == 'T') { /* Timeout waiting for ACKs. */
447: #ifdef BULKNAKS
448: int z; /* Resend all un-ACK'd packets. */
449: #endif
450: timeouts++;
451: numerrs++;
452: debug(F101,"input send-state timeout, winlo","",winlo);
453: #ifdef BULKNAKS
454: /* Retransmit all un-ACK'd packets. */
455: z = (pktnum+1)%64;
456: debug(F101,"input resending unack'd packets, winlo","",winlo);
457: debug(F101," pktnum","",pktnum);
458: for (x = winlo; (x != z) && (ttchk() == 0); (x = (x+1)%64)) {
459: if (x < 0 || x > 63) {
460: debug(F101,"input resend invalid packet","",x);
461: continue;
462: }
463: if ((k = sseqtbl[x]) > -1) {
464: if (k > 31) {
465: debug(F101,"input resend invalid slot","",k);
466: continue;
467: }
468: /* If formed and unack'd, resend */
469:
470: if (
471: #ifdef COMMENT
472: s_pkt[k].pk_flg == 0
473: #else
474: sacktbl[x] == 0
475: #endif
476: && s_pkt[k].pk_typ != SP) {
477: if (resend(x) < 0) { /* Check retries */
478: debug(F101,"input resend max","",maxtry);
479: errpkt(recpkt);
480: return(type = 'E');
481: }
482: } else { /* Already ACK'd, don't retransmit */
483: debug(F101,"input resend pkt already ack'd","",x);
484: }
485: } else { /* Shouldn't happen */
486: debug(F101,"input resend can't find pkt","",x);
487: }
488: }
489: #else
490: /* Just retransmit the oldest un-ACK'd packet. */
491: debug(F101,"input resending winlo","",winlo);
492: if (resend(winlo) < 0) { /* Check retries */
493: debug(F101,"input too many resends","",maxtry);
494: errpkt(recpkt);
495: return(type = 'E');
496: }
497: #endif /* BULKNAKS */
498: continue;
499: }
500:
501: /* Got an actual normal packet */
502:
503: y = chkwin(rsn,winlo,wslots); /* Is it in the window? */
504: debug(F101,"input rsn","",rsn);
505: debug(F101,"input winlo","",winlo);
506: debug(F101,"input chkwin","",y);
507: if (type == 'Y') { /* Got an ACK */
508: if (y == 0) { /* In current window */
509: x = sseqtbl[rsn]; /* Mark the packet as ACK'd */
510: if (x > -1) s_pkt[x].pk_flg++; /* (old way) */
511: sacktbl[rsn]++; /* (new way) */
512: /*
513: NOTE: The following statement frees the buffer of the ACK we just got.
514: But the upper layers still need the data, like if it's the ACK to an I,
515: S, F, D, Z, or just about any kind of packet. So for now, freerbuf()
516: deallocates the buffer, but does not erase the data or destroy the pointer
517: to it. There's no other single place where these receive buffers can be
518: correctly freed (?) ...
519: */
520: freerpkt(rsn); /* Free the ACK's buffer */
521: freesbuf(rsn); /* *** Free the sent packet's buffer */
522: if (rsn == winlo) { /* Got the one we want */
523: sacktbl[winlo] = 0;
524: winlo = (winlo + 1) % 64;
525: debug(F101,"input rotated send window","",winlo);
526: break; /* Return the ACK */
527: } else {
528: debug(F101,"input mark pkt","",rsn);
529: continue; /* Otherwise go read another packet */
530: }
531: } else { /* ACK not in window, ignore */
532: debug(F101,"input ACK out of window","",rsn);
533: freerpkt(rsn);
534: continue;
535: }
536: }
537: if (type == 'N') { /* NAK */
538: numerrs++; /* Count an error */
539: debug(F101,"input NAK","",rsn);
540: if (y == 0) { /* In current window */
541: debug(F100," in window","",0);
542: freerpkt(rsn); /* Free buffer where NAK lies. */
543: k = sseqtbl[rsn]; /* Get pointer to NAK'd packet. */
544: x = 0;
545: if (k < 0 || (k > -1 && s_pkt[k].pk_typ == ' ')) {
546: x = resend(winlo); /* Packet we haven't sent yet. */
547: } else {
548: x = resend(rsn); /* Resend requested packet. */
549: }
550: if (x < 0) { /* Resend error is fatal. */
551: type = 'E';
552: errpkt(recpkt);
553: break;
554: } else continue; /* Resend ok, go read another packet */
555: } else if ((rsn == (pktnum + 1) % 64)) { /* NAK for next pkt */
556: if (wslots > 1) {
557: debug( F101,"NAK for next packet, windowing","",rsn);
558: x = resend(winlo); /* Resend window-low */
559: if (x < 0) {
560: type = 'E';
561: errpkt(recpkt);
562: break;
563: }
564: freerpkt(rsn);
565: continue; /* Go back and read another pkt */
566: }
567: debug(F101," NAK for next packet, no windowing","",rsn);
568: freerpkt(rsn);
569: x = (rsn - 1) % 64;
570: if ((x = sseqtbl[x]) > -1) {
571: sacktbl[x]++; /* (new way) */
572: s_pkt[x].pk_flg++; /* (old way) */
573: }
574: type = 'Y'; /* Treat it as ACK for current pkt */
575: break;
576: } else if (y > 0) { /* NAK for pkt we can't resend */
577: debug(F101," NAK out of window","",rsn); /* bad... */
578: type = 'E';
579: errpkt((CHAR *)"NAK out of window");
580: strcpy((char *)recpkt,"NAK out of window.");
581: break;
582: } else continue; /* Ignore other NAKs */
583: } /* End of file-sender NAK handler */
584:
585: if (rsn == winlo) { /* Not ACK, NAK, timeout, etc. */
586: debug(F000,"input unexpected type","",type);
587: break;
588: }
589: } /* End of file-sender section */
590: } /* End of input() loop */
591: if (wslots == 1) {
592: debug(F100,"input about to flush","",0);
593: ttflui(); /* Got what we want, clear input buffer. */
594: }
595: #ifdef COMMENT
596: /* Old complicated and slow method */
597: if (spktl && !spsizf && !(pktnum & 007)) /* should we recalc pack len? */
598: rcalcpsz(); /* (PWP) recalc every 8 packets */
599: #else
600: /* New simple and fast method */
601: if (!nakstate) /* When sending */
602: rcalcpsz(); /* recalculate size every packet */
603: #endif
604: debug(F000,"input returning type","",type);
605: return(type); /* Success, return packet type. */
606: }
607:
608: /* D O P A R -- Add an appropriate parity bit to a character */
609:
610: /*
611: (PWP) this is still used in the Mac terminal emulator, so we have to keep it
612: */
613: CHAR
614: #ifdef CK_ANSIC
615: dopar(register CHAR ch)
616: #else
617: dopar(ch) register CHAR ch;
618: #endif /* CK_ANSIC */
619: {
620: register unsigned int a;
621: if (!parity) return((CHAR) (ch & 255)); else a = ch & 127;
622: switch (parity) {
623: case 'e': return(partab[a]); /* Even */
624: case 'm': return((CHAR) (a | 128)); /* Mark */
625: case 'o': return((CHAR) (partab[a] ^ 128)); /* Odd */
626: case 's': return((CHAR) a); /* Space */
627: default: return((CHAR) a); /* Something illegal */
628: }
629: }
630:
631: #ifdef PARSENSE
632: /* P A R C H K -- Check if Kermit packet has parity */
633:
634: /*
635: Call with s = pointer to packet, start = packet start character, n = length.
636: Returns 0 if packet has no parity, -1 on error, or, if packet has parity:
637: 'e' for even, 'o' for odd, 'm' for mark. Space parity cannot be sensed.
638: So a return value of 0 really means either space or none.
639: */
640: int
641: #ifdef CK_ANSIC
642: parchk(CHAR *s, CHAR start, int n)
643: #else
644: parchk(s,start,n) CHAR *s, start; int n;
645: #endif /* CK_ANSIC */
646: /* parchk */ {
647: CHAR s0, s1, s2, s3;
648:
649: debug(F101,"parchk n","",n);
650: debug(F101,"parchk start","",start);
651:
652: s0 = s[0] & 0x7f; /* Mark field (usually Ctrl-A) */
653:
654: if (s0 != start || n < 5) return(-1); /* Not a valid packet */
655:
656: /* Look at packet control fields, which never have 8th bit set */
657: /* First check for no parity, most common case. */
658:
659: if (((s[0] | s[1] | s[2] | s[3]) & 0x80) == 0)
660: return(0); /* No parity */
661:
662: /* Check for mark parity */
663:
664: if (((s[0] & s[1] & s[2] & s[3]) & 0x80) == 0x80)
665: return('m'); /* Mark parity */
666:
667: /* Packet has some kind of parity */
668: /* Make 7-bit copies of control fields */
669:
670: s1 = s[1] & 0x7f; /* LEN */
671: s2 = s[2] & 0x7f; /* SEQ */
672: s3 = s[3] & 0x7f; /* TYPE */
673:
674: /* Check for even parity */
675:
676: if ((s[0] == partab[s0]) &&
677: (s[1] == partab[s1]) &&
678: (s[2] == partab[s2]) &&
679: (s[3] == partab[s3]))
680: return('e');
681:
682: /* Check for odd parity */
683:
684: if ((s[0] != partab[s0]) &&
685: (s[1] != partab[s1]) &&
686: (s[2] != partab[s2]) &&
687: (s[3] != partab[s3]))
688: return('o');
689:
690: /* Otherwise it's probably line noise. Let checksum calculation catch it. */
691:
692: return(-1);
693: }
694: #endif /* PARSENSE */
695:
696: /*
697: Check to make sure timeout intervals are long enough to allow maximum
698: length packets to get through before the timer goes off.
699: */
700: VOID
701: chktimo() {
702: int cps; long z;
703: speed = ttgspd(); /* Get latest speed */
704: if (speed > 0L && !network) {
705: cps = speed / 10L;
706: if (cps > 0) {
707: z = (long) cps * (long) timint; /* Chars per timeout interval */
708: if (z < spmax) {
709: rtimo = timint = pkttim = (spmax / cps) + 2;
710: debug(F101,"chktimo spmax","",timint);
711: }
712: if (z < rpsiz && rpsiz > spmax) {
713: rtimo = timint = pkttim = (rpsiz / cps) + 2;
714: debug(F101,"chktimo rpsiz","",timint);
715: }
716: }
717: }
718: }
719:
720: /* S P A C K -- Construct and send a packet */
721:
722: /*
723: spack() sends a packet of the given type, sequence number n, with len data
724: characters pointed to by d, in either a regular or extended- length packet,
725: depending on len. Returns the number of bytes actually sent, or else -1
726: upon failure. Uses global npad, padch, mystch, bctu, data. Leaves packet
727: fully built and null-terminated for later retransmission by resend().
728: Updates global sndpktl (send-packet length).
729:
730: NOTE: The global pointer "data" is assumed to point into the 7th position
731: of a character array (presumably in packet buffer for the current packet).
732: It was used by getpkt() to build the packet data field. spack() fills in
733: the header to the left of the data pointer (the data pointer is defined
734: in getsbuf() in ckcfn3.c). If the address "d" is the same as "data", then
735: the packet's data field has been built "in place" and need not be copied.
736: */
737: int
738: #ifdef CK_ANSIC
739: spack(char pkttyp, int n, int len, CHAR *d)
740: #else
741: spack(pkttyp,n,len,d) char pkttyp; int n, len; CHAR *d;
742: #endif /* CK_ANSIC */
743: /* spack */ {
744: register int i;
745: int j, k, lp, longpkt, copy;
746: register CHAR *cp, *mydata;
747: unsigned crc;
748:
749: debug(F101,"spack n","",n);
750: debug(F101," data","",data);
751: debug(F101," d","",d);
752:
753: copy = (d != data); /* Flag whether data must be copied */
754: longpkt = (len + bctu + 2) > 94; /* Decide whether it's a long packet */
755: mydata = data - 7 + (longpkt ? 0 : 3); /* Starting position of header */
756: debug(F101," mydata","",mydata);
757:
758: k = sseqtbl[n]; /* Packet structure info for pkt n */
759: debug(F101," sseqtbl[n]","",k);
760: if (k < 0) {
761: debug(F101,"spack sending packet out of window","",n);
762: } else { /* Record packet info */
763: s_pkt[k].pk_adr = mydata; /* Remember address of packet. */
764: s_pkt[k].pk_seq = n; /* Record sequence number */
765: s_pkt[k].pk_typ = pkttyp; /* Record packet type */
766: }
767:
768: spktl = 0; /* Initialize length of this packet */
769: i = 0; /* and position in packet. */
770:
771: /* Now fill the packet */
772:
773: mydata[i++] = mystch; /* MARK */
774: lp = i++; /* Position of LEN, fill in later */
775:
776: mydata[i++] = tochar(n); /* SEQ field */
777: mydata[i++] = pkttyp; /* TYPE field */
778: sndtyp = pkttyp; /* Keep a copy */
779: j = len + bctu; /* Length of data + block check */
780: if (longpkt) { /* Long packet? */
781: int x; /* Work around SCO Xenix/286 */
782: x = 95; /* compiler bug... */
783: x = j / 95;
784: mydata[lp] = tochar(0); /* Yes, set LEN to zero */
785: mydata[i++] = tochar(x); /* High part */
786: mydata[i++] = tochar(j % 95); /* Low part */
787: mydata[i] = '\0'; /* Header checksum */
788: mydata[i++] = tochar(chk1(mydata+lp));
789: } else mydata[lp] = tochar(j+2); /* Normal LEN */
790:
791: if (copy) /* Data field built in place? */
792: for ( ; len--; i++) mydata[i] = *d++; /* No, must copy. */
793: else /* Otherwise, */
794: i += len; /* Just skip past data field. */
795: mydata[i] = '\0'; /* Null-terminate for checksum calc. */
796:
797: switch (bctu) { /* Block check */
798: case 1: /* 1 = 6-bit chksum */
799: mydata[i++] = tochar(chk1(mydata+lp));
800: break;
801: case 2: /* 2 = 12-bit chksum */
802: j = chk2(mydata+lp);
803: mydata[i++] = (unsigned)tochar((j >> 6) & 077);
804: mydata[i++] = (unsigned)tochar(j & 077);
805: break;
806: case 3: /* 3 = 16-bit CRC */
807: crc = chk3(mydata+lp);
808: mydata[i++] = (unsigned)tochar(((crc & 0170000)) >> 12);
809: mydata[i++] = (unsigned)tochar((crc >> 6) & 077);
810: mydata[i++] = (unsigned)tochar(crc & 077);
811: break;
812: }
813: mydata[i++] = seol; /* End of line (packet terminator) */
814: mydata[i] = '\0'; /* Terminate string */
815: logpkt('s',n,mydata); /* Log packet */
816:
817: /* (PWP) add the parity quickly at the end */
818: switch (parity) {
819: case 'e': /* Even */
820: for (cp = &mydata[i-1]; cp >= mydata; cp--)
821: *cp = partab[*cp];
822: break;
823: case 'm': /* Mark */
824: for (cp = &mydata[i-1]; cp >= mydata; cp--)
825: *cp |= 128;
826: break;
827: case 'o': /* Odd */
828: for (cp = &mydata[i-1]; cp >= mydata; cp--)
829: *cp = partab[*cp] ^ 128;
830: break;
831: case 's': /* Space */
832: for (cp = &mydata[i-1]; cp >= mydata; cp--)
833: *cp &= 127;
834: break;
835: }
836: if (npad) ttol(padbuf,npad); /* Send any padding */
837: spktl = i; /* Remember packet length */
838: s_pkt[k].pk_len = spktl; /* also in packet info structure */
839: if (ttol(mydata,spktl) < 0) return(-1); /* Send the packet */
840: spackets++; /* Count it. */
841: flco += spktl; /* Count the characters */
842: tlco += spktl; /* for statistics... */
843: dumpsbuf(); /* Dump send buffers to debug log */
844: screen(SCR_PT,pkttyp,(long)n,(char *)mydata); /* Update screen */
845: return(spktl); /* Return length */
846: }
847:
848: /* C H K 1 -- Compute a type-1 Kermit 6-bit checksum. */
849:
850: int
851: chk1(pkt) register CHAR *pkt; {
852: register unsigned int chk;
853: chk = chk2(pkt);
854: chk = (((chk & 0300) >> 6) + chk) & 077;
855: return((int) chk);
856: }
857:
858: /* C H K 2 -- Compute the numeric sum of all the bytes in the packet. */
859:
860: unsigned int
861: chk2(pkt) register CHAR *pkt; {
862: register long chk; register unsigned int m;
863: m = (parity) ? 0177 : 0377;
864: for (chk = 0; *pkt != '\0'; pkt++)
865: chk += *pkt & m;
866: return((unsigned int) (chk & 07777));
867: }
868:
869:
870: /* C H K 3 -- Compute a type-3 Kermit block check. */
871: /*
872: Calculate the 16-bit CRC-CCITT of a null-terminated string using a lookup
873: table. Assumes the argument string contains no embedded nulls.
874: */
875: unsigned int
876: chk3(pkt) register CHAR *pkt; {
877: register long c, crc;
878: register unsigned int m;
879: m = (parity) ? 0177 : 0377;
880: for (crc = 0; *pkt != '\0'; pkt++) {
881: c = crc ^ (long)(*pkt & m);
882: crc = (crc >> 8) ^ (crcta[(c & 0xF0) >> 4] ^ crctb[c & 0x0F]);
883: }
884: return((unsigned int) (crc & 0xFFFF));
885: }
886:
887: int
888: nxtpkt() { /* Called by file sender */
889: int j, n;
890:
891: debug(F101,"nxtpkt pktnum","",pktnum);
892: debug(F101,"nxtpkt winlo ","",winlo);
893: n = (pktnum + 1) % 64; /* Increment packet number mod 64 */
894: #ifdef COMMENT
895: /*
896: Suggested by Alan Grieg. A packet can be sent out of window in
897: circumstances involving acks received out of order, ... Have to think
898: about this...
899: */
900: if (chkwin(n,winlo,wslots)) {
901: debug(F101,"nxtpkt n not in window","",n);
902: return(-1);
903: }
904: #endif
905: j = getsbuf(n); /* Get a buffer for packet n */
906: if (j < 0) {
907: debug(F101,"nxtpkt can't getsbuf","",j);
908: return(-1);
909: }
910: pktnum = n;
911: debug(F101,"nxtpkt bumped pktnum to","",pktnum);
912: return(0);
913: }
914:
915: /* Functions for sending ACKs and NAKs */
916:
917: /* Note, we should only ACK the packet at window-low (winlo) */
918: /* However, if an old packet arrives again (e.g. because the ACK we sent */
919: /* earlier was lost), we ACK it again. */
920:
921: int
922: ack() { /* Acknowledge the current packet. */
923: return(ackns(winlo,(CHAR *)""));
924: }
925:
926: int
927: ackns(n,s) int n; CHAR *s; { /* Acknowledge packet n */
928: int j, k;
929: debug(F111,"ackns",s,n);
930:
931: k = rseqtbl[n]; /* First find received packet n. */
932: debug(F101,"ackns k","",k);
933: #ifdef COMMENT
934: /* No need to set ACK'd bit, because we're gonna free the buffer now */
935: if (k > -1) /* If in window */
936: s_pkt[k].pk_flg++; /* mark the ack'd bit. */
937: else
938: debug(F101,"ackns can't set ack'd bit","",k);
939: #endif
940: freesbuf(n); /* Free current send-buffer, if any */
941: if ((j = getsbuf(n)) < 0) {
942: /* This can happen if we have to re-ACK an old packet that has */
943: /* already left the window. It does no harm. */
944: debug(F101,"ackns can't getsbuf","",n);
945: }
946: spack('Y',n,(int)strlen((char *)s),s); /* Now send it. */
947: debug(F101,"ackns winlo","",winlo);
948: debug(F101,"ackns n","",n);
949: if (n == winlo) { /* If we're acking winlo */
950: if (k > -1)
951: freerbuf(k); /* don't need it any more */
952: if (j > -1)
953: freesbuf(j); /* and don't need to keep ACK either */
954: winlo = (winlo + 1) % 64;
955: }
956: return(0);
957: }
958:
959: int
960: ackn(n) int n; { /* Send ACK for packet number n */
961: return(ackns(n,(CHAR *)""));
962: }
963:
964: int
965: ack1(s) CHAR *s; { /* Send an ACK with data. */
966: debug(F110,"ack1",(char *) s,0);
967: return(ackns(winlo, s));
968: }
969:
970: /* N A C K -- Send a Negative ACKnowledgment. */
971: /*
972: Call with the packet number, n, to be NAK'd.
973: Returns -1 if that packet has been NAK'd too many times, otherwise 0.
974: Btw, it is not right to return 0 under error conditions. This is
975: done because the -1 code is used for cancelling the file transfer.
976: More work is needed here.
977: */
978: int
979: nack(n) int n; {
980: int i;
981:
982: if (n < 0 || n > 63) {
983: debug(F101,"nack bad pkt num","",n);
984: return(0);
985: } else debug(F101,"nack","",n);
986: if ((i = sseqtbl[n]) < 0) { /* If necessary */
987: if (getsbuf(n) < 0) { /* get a buffer for this NAK */
988: debug(F101,"nack can't getsbuf","",n);
989: return(0);
990: } else i = sseqtbl[n]; /* New slot number */
991: }
992: if (s_pkt[i].pk_rtr++ > maxtry) /* How many times have we done this? */
993: return(-1); /* Too many... */
994:
995: /* Note, don't free this buffer. Eventually an ACK will come, and that */
996: /* will set it free. If not, well, it's back to ground zero anyway... */
997:
998: spack('N',n,0,(CHAR *) ""); /* NAKs never have data. */
999: return(0);
1000: }
1001:
1002: /*
1003: * (PWP) recalculate the optimal packet length in the face of errors.
1004: * This is a modified version of the algorithm by John Chandler in Kermit/370,
1005: * see "Dynamic Packet Size Control", Kermit News, V2 #1, June 1988.
1006: *
1007: * This implementation minimizes the total overhead equation, which is
1008: *
1009: * Total chars = file_chars + (header_len * num_packs)
1010: * + (errors * (header_len + packet_len))
1011: *
1012: * Differentiate with respect to number of chars, solve for packet_len, get:
1013: *
1014: * packet_len = sqrt (file_chars * header_len / errors)
1015: */
1016:
1017: /*
1018: (FDC) New super-simple algorithm. If there was an error in the most recent
1019: packet exchange, cut the send-packet size in half, down to a minimum of 20.
1020: If there was no error, increase the size by 5/4, up to the maximum negotiated
1021: length. Seems to be much more responsive than previous algorithm, which took
1022: forever to recover the original packet length, and it also went crazy under
1023: certain conditions.
1024:
1025: Here's another idea for packet length resizing that keeps a history of the
1026: last n packets. Push a 1 into the left end of an n-bit shift register if the
1027: current packet is good, otherwise push a zero. The current n-bit value, w, of
1028: this register is a weighted sum of the noise hits for the last n packets, with
1029: the most recent weighing the most. The current packet length is some function
1030: of w and the negotiated packet length, like:
1031:
1032: (2^n - 1 - w) / (2^n - 1) * (negotiated length)
1033:
1034: If the present resizing method causes problems, think about this one a little
1035: more.
1036: */
1037: VOID
1038: rcalcpsz() {
1039:
1040: #ifdef COMMENT
1041: /* Old way */
1042: register long x, q;
1043: if (numerrs == 0) return; /* bounds check just in case */
1044:
1045: /* overhead on a data packet is npad+5+bctr, plus 3 if extended packet */
1046: /* an ACK is 5+bctr */
1047:
1048: /* first set x = per packet overhead */
1049: if (wslots > 1)
1050: x = (long) (npad+5+bctr); /* only the packet, don't count the ack */
1051: else
1052: x = (long) (npad+5+3+bctr+5+bctr);
1053:
1054: /* then set x = packet length ** 2 */
1055: x = x * ( ffc / (long) numerrs); /* careful of overflow */
1056:
1057: /* calculate the long integer sqrt(x) quickly */
1058: q = 500;
1059: q = (q + x/q) >> 1;
1060: q = (q + x/q) >> 1;
1061: q = (q + x/q) >> 1;
1062: q = (q + x/q) >> 1; /* should converge in about 4 steps */
1063: if ((q > 94) && (q < 130)) /* break-even point for long packets */
1064: q = 94;
1065: if (q > spmax) q = spmax; /* maximum bounds */
1066: if (q < 10) q = 10; /* minimum bounds */
1067: spsiz = q; /* set new send packet size */
1068: debug(F101,"rcalcpsiz","",q);
1069: #else
1070: /* New way */
1071: if (spackets < 3) return;
1072: debug(F101,"rcalcpsiz numerrs","",numerrs);
1073: debug(F101,"rcalcpsiz spsiz","",spsiz);
1074: if (numerrs)
1075: spsiz = spsiz / 2;
1076: else
1077: spsiz = (spsiz / 4) * 5;
1078: if (spsiz < 20) spsiz = 20;
1079: if (spsiz > spmax) spsiz = spmax;
1080: debug(F101,"rcalcpsiz new spsiz","",spsiz);
1081: numerrs = 0;
1082: return;
1083: #endif
1084: }
1085:
1086: /* R E S E N D -- Retransmit packet n. */
1087:
1088: /* Returns 0 or positive on success. */
1089: /* On failure, returns a negative number, and an error message is placed */
1090: /* in recpkt. All errors are considered fatal. */
1091:
1092: #ifdef IOFATAL
1093: #undef IOFATAL
1094: #endif
1095: /*
1096: Let's try something new... I/O errors are not fatal. Let retry mechanisms
1097: take care of giving up (edit 159).
1098: */
1099: int
1100: resend(n) int n; { /* Send packet n again. */
1101: int k;
1102:
1103: debug(F101,"resend seq","",n);
1104: if ((k = chkwin(n,winlo,wslots)) != 0) { /* Check if it's in the window */
1105: debug(F101,"resend pkt not in win","",k);
1106: if (nakstate && k == 1) { /* Take a chance... */
1107: #ifdef IOFATAL
1108: if (spack('Y',n,0,(CHAR *) "") < 0) { /* Send an ACK... */
1109: debug(F100,"resend spack fails","",0);
1110: sprintf((char *)recpkt,
1111: "resend i/o error: SPF, n=%d, k=%d.",n,k);
1112: return(-2);
1113: }
1114: debug(F101,"resent ACK from prev window ok","",n);
1115: #else
1116: spack('Y',n,0,(CHAR *) ""); /* Just send the ACK... */
1117: #endif /* IOFATAL */
1118: retrans++;
1119: return(0);
1120: } else {
1121: debug(F100,"resend pkt not in window","",0);
1122: sprintf((char *)recpkt,"resend error: NIW, n=%d, k=%d.",n,k);
1123: return(-2);
1124: }
1125: }
1126: k = sseqtbl[n]; /* OK, it's in the window. */
1127: debug(F101,"resend pktinfo index","",k);
1128: if (k < 0) { /* But I can't find it! */
1129: debug(F101,"resend sseqtbl failure for pkt","",n);
1130: sprintf((char *)recpkt,"resend logic error: BPX, n=%d, k=%d.",n,k);
1131: return(-2);
1132: }
1133: if (s_pkt[k].pk_rtr++ > maxtry) { /* Found it but over retry limit */
1134: strcpy((char *)recpkt,"Too many retries.");
1135: return(-1);
1136: }
1137: debug(F101," retry","",s_pkt[k].pk_rtr); /* OK so far */
1138: dumpsbuf();
1139: if (s_pkt[k].pk_typ == ' ') { /* Incompletely formed packet */
1140: if (nakstate) { /* (This shouldn't happen any more) */
1141: nack(n);
1142: retrans++;
1143: return(s_pkt[k].pk_rtr);
1144: } else { /* No packet to resend! */
1145: sprintf((char *)recpkt,
1146: "resend logic error: NPS, n=%d, k=%d.",n,k);
1147: return(-2);
1148: }
1149: }
1150: #ifdef IOFATAL
1151: if (ttol(s_pkt[k].pk_adr,s_pkt[k].pk_len) < 0) {
1152: debug(F100,"resend ttol failed","",0);
1153: sprintf((char *)recpkt,"resend i/o error: TIO, n=%d, k=%d.",n,k);
1154: return(-2);
1155: }
1156: #else
1157: ttol(s_pkt[k].pk_adr,s_pkt[k].pk_len);
1158: #endif /* IOFATAL */
1159: retrans++;
1160: screen(SCR_PT,'%',(long)pktnum,"(resend)"); /* Say resend occurred */
1161: logpkt('S',n,s_pkt[k].pk_adr); /* Log packet */
1162: return(s_pkt[k].pk_rtr); /* Return retries. */
1163: }
1164:
1165: int
1166: errpkt(reason) CHAR *reason; { /* Send an error packet. */
1167: int x, y;
1168: encstr(reason);
1169: y = spack('E',pktnum,size,encbuf+7);
1170: x = quiet; quiet = 1; /* Close files silently. */
1171: clsif(); clsof(1);
1172: quiet = x;
1173: screen(SCR_TC,0,0l,"");
1174: if (what < W_CONNECT)
1175: xitsta |= what; /* Remember what failed. */
1176: success = 0;
1177: return(y);
1178: }
1179:
1180: /* scmd() -- Send a packet of the given type */
1181:
1182: int
1183: #ifdef CK_ANSIC
1184: scmd(char t, CHAR *dat)
1185: #else
1186: scmd(t,dat) char t; CHAR *dat;
1187: #endif /* CK_ANSIC */
1188: /* scmd */ {
1189: encstr(dat); /* Encode the command string */
1190: spack(t,pktnum,size,(CHAR *)(encbuf+7));
1191: return(0);
1192: }
1193:
1194: VOID
1195: srinit() { /* Send R (GET) packet */
1196: encstr((CHAR *)cmarg); /* Encode the filename. */
1197: spack('R',pktnum,size,encbuf+7); /* Send the packet. */
1198: }
1199:
1200: /* R P A C K -- Read a Packet */
1201:
1202: /*
1203: rpack reads a packet and returns the packet type, or else Q if the
1204: packet was invalid, or T if a timeout occurred. Upon successful return, sets
1205: the values of global rsn (received sequence number), rln (received
1206: data length), and rdatap (pointer to null-terminated data field).
1207: */
1208: int
1209: rpack() {
1210: register int i, j, x, lp; /* Local variables */
1211: int k, type, chklen;
1212: unsigned crc;
1213: CHAR pbc[4]; /* Packet block check */
1214: CHAR *sohp; /* Pointer to SOH */
1215: CHAR e; /* Packet end character */
1216:
1217: debug(F101,"entering rpack, pktnum","",pktnum);
1218: k = getrbuf(); /* Get a new packet input buffer. */
1219: debug(F101,"rpack getrbuf","",k);
1220: if (k < 0) return(-1); /* Return like this if none free. */
1221: recpkt = r_pkt[k].bf_adr;
1222: *recpkt = '\0'; /* Clear receive buffer. */
1223: sohp = recpkt; /* Initialize pointers to it. */
1224: rdatap = recpkt;
1225: rsn = rln = -1; /* In case of failure. */
1226: e = (turn) ? turnch : eol; /* Use any handshake char for eol */
1227:
1228: /* Try to get a "line". */
1229:
1230: #ifdef PARSENSE
1231: #ifdef UNIX
1232: /*
1233: So far the final turn argument is only ckutio.c. Should be added
1234: to the others too.
1235: */
1236: j = ttinl(recpkt,r_pkt[k].bf_len - 1,timint,e,stchr,turn);
1237: #else
1238: j = ttinl(recpkt,r_pkt[k].bf_len - 1,timint,e,stchr);
1239: #endif /* UNIX */
1240: if (parity != ttprty) autopar = 1;
1241: parity = ttprty;
1242: #else
1243: j = ttinl(recpkt,r_pkt[k].bf_len - 1,timint,e);
1244: #endif
1245: if (j < 0) {
1246: debug(F101,"rpack: ttinl fails","",j); /* Otherwise, */
1247: freerbuf(k); /* Free this buffer */
1248: if (j < -1) { /* Bail out if ^C^C typed. */
1249: debug(F101,"rpack ^C server","",server);
1250: debug(F101,"rpack ^C en_fin","",en_fin);
1251: if (server == 0) return(j); /* But not if in server mode */
1252: else if (en_fin) return(j); /* with DISABLE FINISH */
1253: }
1254: if (nakstate) /* call it a timeout. */
1255: screen(SCR_PT,'T',(long)winlo,"");
1256: else
1257: screen(SCR_PT,'T',(long)pktnum,"");
1258: logpkt('r',-1,(CHAR *)"<timeout>");
1259: if (flow == 1) ttoc(XON); /* In case of Xoff blockage. */
1260: return('T');
1261: }
1262: tlci += j; /* All OK, Count the characters. */
1263: flci += j;
1264:
1265: #ifndef PARSENSE
1266: /* THEN eliminate this loop... */
1267: for (i = 0; (recpkt[i] != stchr) && (i < j); i++)
1268: sohp++; /* Find mark */
1269: if (i++ >= j) { /* Didn't find it. */
1270: logpkt('r',-1,"<timeout>");
1271: freerbuf(k);
1272: return('T');
1273: }
1274: #else
1275: i = 1;
1276: #endif /* PARSENSE */
1277:
1278: rpackets++;
1279: lp = i; /* Remember LEN position. */
1280: if ((j = xunchar(recpkt[i++])) == 0) {
1281: if ((j = lp+5) > MAXRP) return('Q'); /* Long packet */
1282: x = recpkt[j]; /* Header checksum. */
1283: recpkt[j] = '\0'; /* Calculate & compare. */
1284: if (xunchar(x) != chk1(recpkt+lp)) {
1285: freerbuf(k);
1286: logpkt('r',-1,(CHAR *)"<crunched:hdr>");
1287: return('Q');
1288: }
1289: recpkt[j] = x; /* Checksum ok, put it back. */
1290: rln = xunchar(recpkt[j-2]) * 95 + xunchar(recpkt[j-1]) - bctu;
1291: j = 3; /* Data offset. */
1292: } else if (j < 3) {
1293: debug(F101,"rpack packet length less than 3","",j);
1294: freerbuf(k);
1295: logpkt('r',-1,(CHAR *)"<crunched:len>");
1296: return('Q');
1297: } else {
1298: rln = j - bctu - 2; /* Regular packet */
1299: j = 0; /* No extended header */
1300: }
1301: rsn = xunchar(recpkt[i++]); /* Sequence number */
1302: logpkt('r',rsn,sohp);
1303: if (rsn < 0 || rsn > 63) {
1304: debug(F101,"rpack bad sequence number","",rsn);
1305: freerbuf(k);
1306: logpkt('r',rsn,(CHAR *)"<crunched:seq>");
1307: return('Q');
1308: }
1309: type = recpkt[i++]; /* Packet type */
1310: #define XXX
1311: #ifdef XXX
1312: /*
1313: Heuristics to adjust for old block-check type on retransmitted packet
1314: after block check has switched.
1315: */
1316: if (type == 'I' || type == 'S') { /* These always have type 1 */
1317: chklen = 1;
1318: rln = rln + bctu - 1;
1319: } else if (type == 'N') { /* NAK never has data */
1320: chklen = xunchar(recpkt[lp]) - 2;
1321: rln = rln + bctu - chklen;
1322: } else chklen = bctu;
1323: #else
1324: chklen = bctu;
1325: #endif /* XXX */
1326: i += j; /* Where data begins */
1327: rdatap = recpkt+i; /* The data itself */
1328: if ((j = rln + i) > r_pkt[k].bf_len ) {
1329: debug(F101,"packet sticks out too far","",j);
1330: freerbuf(k);
1331: logpkt('r',rsn,(CHAR *)"<overflow>");
1332: return('Q');
1333: }
1334: for (x = 0; x < chklen; x++) /* Copy out the block check */
1335: pbc[x] = recpkt[j+x];
1336: pbc[x] = '\0'; /* Null-terminate block check string */
1337: recpkt[j] = '\0'; /* and the packet data. */
1338: debug(F101,"rpack chklen","",chklen);
1339:
1340: switch (chklen) { /* Check the block check */
1341: case 1:
1342: if (xunchar(*pbc) != chk1(recpkt+lp)) {
1343: debug(F110,"checked chars",recpkt+lp,0);
1344: debug(F101,"block check","",(int) xunchar(*pbc));
1345: debug(F101,"should be","",chk1(recpkt+lp));
1346: freerbuf(k);
1347: logpkt('r',-1,(CHAR *)"<crunched:chk1>");
1348: return('Q');
1349: }
1350: break;
1351: case 2:
1352: x = xunchar(*pbc) << 6 | xunchar(pbc[1]);
1353: if (x != chk2(recpkt+lp)) {
1354: debug(F110,"checked chars",recpkt+lp,0);
1355: debug(F101,"block check","", x);
1356: debug(F101,"should be","", (int) chk2(recpkt+lp));
1357: freerbuf(k);
1358: logpkt('r',-1,(CHAR *)"<crunched:chk2>");
1359: return('Q');
1360: }
1361: break;
1362: case 3:
1363: crc = (xunchar(pbc[0]) << 12)
1364: | (xunchar(pbc[1]) << 6)
1365: | (xunchar(pbc[2]));
1366: if (crc != chk3(recpkt+lp)) {
1367: debug(F110,"checked chars",recpkt+lp,0);
1368: debug(F101,"block check","",xunchar(*pbc));
1369: debug(F101,"should be","",(int) chk3(recpkt+lp));
1370: freerbuf(k);
1371: logpkt('r',-1,(CHAR *)"<crunched:chk3>");
1372: return('Q');
1373: }
1374: break;
1375: default: /* Shouldn't happen... */
1376: freerbuf(k);
1377: logpkt('r',-1,(CHAR *)"<crunched:chkx>");
1378: return('Q');
1379: }
1380: debug(F101,"rpack block check OK","",rsn);
1381:
1382: /* Now we can believe the sequence number, etc. */
1383: /* Here we violate strict principles of layering, etc, and look at the */
1384: /* packet sequence number. If there's already a packet with the same */
1385: /* number in the window, we remove this one so that the window will not */
1386: /* fill up. */
1387:
1388: if ((x = rseqtbl[rsn]) != -1) { /* Already a packet with this number */
1389: retrans++; /* Count it for statistics */
1390: debug(F101,"rpack got dup","",rsn);
1391: logpkt('r',rsn,(CHAR *)"<duplicate>");
1392: freerbuf(x); /* Free old buffer, keep new packet. */
1393: r_pkt[k].pk_rtr++; /* Count this as a retransmission. */
1394: }
1395:
1396: /* New packet, not seen before, enter it into the "database". */
1397:
1398: rseqtbl[rsn] = k; /* Make back pointer */
1399: r_pkt[k].pk_seq = rsn; /* Record in packet info structure */
1400: r_pkt[k].pk_typ = type; /* Sequence, type,... */
1401: r_pkt[k].pk_adr = rdatap; /* pointer to data buffer */
1402: screen(SCR_PT,(char)type,(long)rsn,(char *)sohp); /* Update screen */
1403: return(type); /* Return packet type */
1404: }
1405:
1406: /* L O G P K T -- Log packet number n, pointed to by s. */
1407:
1408: /* c = 's' (send) or 'r' (receive) */
1409:
1410: VOID
1411: #ifdef CK_ANSIC
1412: logpkt(char c,int n, CHAR *s)
1413: #else
1414: logpkt(c,n,s) char c; int n; CHAR *s;
1415: #endif /* CK_ANSIC */
1416: /* logpkt */ {
1417: char plog[20];
1418: if (pktlog && *s) {
1419: if (n < 0)
1420: sprintf(plog,"%c-xx-%02d-",c,(gtimer()%60));
1421: else
1422: sprintf(plog,"%c-%02d-%02d-",c,n,(gtimer()%60));
1423: if (zsout(ZPFILE,plog) < 0) pktlog = 0;
1424: else if (zsoutl(ZPFILE,(char *)s) < 0) pktlog = 0;
1425: }
1426: }
1427:
1428: #ifdef TLOG
1429:
1430: /* T S T A T S -- Record statistics in transaction log */
1431:
1432: VOID
1433: tstats() {
1434: char *tp;
1435: ztime(&tp); /* Get time stamp */
1436: tlog(F110,"End of transaction",tp,0L); /* Record it */
1437:
1438: if (filcnt < 1) return; /* If no files, done. */
1439:
1440: /* If multiple files, record character totals for all files */
1441:
1442: if (filcnt > 1) {
1443: tlog(F101," files","",filcnt);
1444: tlog(F101," total file characters ","",tfc);
1445: tlog(F101," communication line in ","",tlci);
1446: tlog(F101," communication line out ","",tlco);
1447: }
1448:
1449: /* Record timing info for one or more files */
1450:
1451: tlog(F101," elapsed time (seconds) ","",(long) tsecs);
1452: if (tsecs > 0) {
1453: long lx;
1454: lx = (tfc * 10L) / (long) tsecs;
1455: tlog(F101," effective data rate ","",lx/10L);
1456: if (speed <= 0L) speed = ttgspd();
1457: if (speed > 0L && speed != 8880L && network == 0) {
1458: lx = (lx * 100L) / speed;
1459: tlog(F101," efficiency (percent) ","",lx);
1460: }
1461: }
1462: tlog(F100,"","",0L); /* Leave a blank line */
1463: }
1464:
1465: /* F S T A T S -- Record file statistics in transaction log */
1466:
1467: VOID
1468: fstats() {
1469: tfc += ffc;
1470: tlog(F100," end of file","",0L);
1471: tlog(F101," file characters ","",ffc);
1472: tlog(F101," communication line in ","",flci);
1473: tlog(F101," communication line out ","",flco);
1474: }
1475: #else /* NOTLOG */
1476: VOID
1477: tstats() {}
1478:
1479: VOID
1480: fstats() {
1481: tfc += ffc;
1482: }
1483: #endif /* TLOG */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.