Return to ckcfn2.c CVS log

Up to [MW Coherent from dump] / coherent / e / bin / ckermit

Annotation of coherent/e/bin/ckermit/ckcfn2.c, revision 1.1

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

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.