ckcfn2.c

   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 <fdc@columbia.edu>,
   7   Columbia University Academic Information Systems, New York City.
   8
   9   Copyright (C) 1985, 2004,
  10     Trustees of Columbia University in the City of New York.
  11     All rights reserved.  See the C-Kermit COPYING.TXT file or the
  12     copyright text in the ckcmai.c module for disclaimer and permissions.
  13 */
  14 /*
  15  Note -- if you change this file, please amend the version number and date at
  16  the top of ckcfns.c accordingly.
  17 */
  18
  19 #include "ckcsym.h"                     /* Compilation options */
  20 #include "ckcdeb.h"                     /* Debugging and other symbols */
  21 #include "ckcasc.h"                     /* ASCII symbols */
  22 #include "ckcker.h"                     /* Kermit symbols */
  23 #include "ckcxla.h"                     /* Translation */
  24 #include "ckcnet.h"                     /* IKS and VMS #define TCPSOCKET */
  25 #ifdef TCPSOCKET                        /* For TELNET business in spack() */
  26 extern int tn_nlm, ttnproto, tn_b_nlm;
  27 #endif /* TCPSOCKET */
  28
  29 extern int parity, network, local, interrupted, fatalio, wasclosed;
  30
  31 int kstartactive = 0;                   /* Flag for kstart() in a packet */
  32
  33 static CHAR p_tbl[] = {                 /* Even parity table for dopar(). */
  34     (CHAR) '\000',                      /* ANSI C casts '\ooo' constants  */
  35     (CHAR) '\201',                      /* to signed char, so we have to  */
  36     (CHAR) '\202',                      /* cast back to unsigned char...  */
  37     (CHAR) '\003',
  38     (CHAR) '\204',
  39     (CHAR) '\005',
  40     (CHAR) '\006',
  41     (CHAR) '\207',
  42     (CHAR) '\210',
  43     (CHAR) '\011',
  44     (CHAR) '\012',
  45     (CHAR) '\213',
  46     (CHAR) '\014',
  47     (CHAR) '\215',
  48     (CHAR) '\216',
  49     (CHAR) '\017',
  50     (CHAR) '\220',
  51     (CHAR) '\021',
  52     (CHAR) '\022',
  53     (CHAR) '\223',
  54     (CHAR) '\024',
  55     (CHAR) '\225',
  56     (CHAR) '\226',
  57     (CHAR) '\027',
  58     (CHAR) '\030',
  59     (CHAR) '\231',
  60     (CHAR) '\232',
  61     (CHAR) '\033',
  62     (CHAR) '\234',
  63     (CHAR) '\035',
  64     (CHAR) '\036',
  65     (CHAR) '\237',
  66     (CHAR) '\240',
  67     (CHAR) '\041',
  68     (CHAR) '\042',
  69     (CHAR) '\243',
  70     (CHAR) '\044',
  71     (CHAR) '\245',
  72     (CHAR) '\246',
  73     (CHAR) '\047',
  74     (CHAR) '\050',
  75     (CHAR) '\251',
  76     (CHAR) '\252',
  77     (CHAR) '\053',
  78     (CHAR) '\254',
  79     (CHAR) '\055',
  80     (CHAR) '\056',
  81     (CHAR) '\257',
  82     (CHAR) '\060',
  83     (CHAR) '\261',
  84     (CHAR) '\262',
  85     (CHAR) '\063',
  86     (CHAR) '\264',
  87     (CHAR) '\065',
  88     (CHAR) '\066',
  89     (CHAR) '\267',
  90     (CHAR) '\270',
  91     (CHAR) '\071',
  92     (CHAR) '\072',
  93     (CHAR) '\273',
  94     (CHAR) '\074',
  95     (CHAR) '\275',
  96     (CHAR) '\276',
  97     (CHAR) '\077',
  98     (CHAR) '\300',
  99     (CHAR) '\101',
 100     (CHAR) '\102',
 101     (CHAR) '\303',
 102     (CHAR) '\104',
 103     (CHAR) '\305',
 104     (CHAR) '\306',
 105     (CHAR) '\107',
 106     (CHAR) '\110',
 107     (CHAR) '\311',
 108     (CHAR) '\312',
 109     (CHAR) '\113',
 110     (CHAR) '\314',
 111     (CHAR) '\115',
 112     (CHAR) '\116',
 113     (CHAR) '\317',
 114     (CHAR) '\120',
 115     (CHAR) '\321',
 116     (CHAR) '\322',
 117     (CHAR) '\123',
 118     (CHAR) '\324',
 119     (CHAR) '\125',
 120     (CHAR) '\126',
 121     (CHAR) '\327',
 122     (CHAR) '\330',
 123     (CHAR) '\131',
 124     (CHAR) '\132',
 125     (CHAR) '\333',
 126     (CHAR) '\134',
 127     (CHAR) '\335',
 128     (CHAR) '\336',
 129     (CHAR) '\137',
 130     (CHAR) '\140',
 131     (CHAR) '\341',
 132     (CHAR) '\342',
 133     (CHAR) '\143',
 134     (CHAR) '\344',
 135     (CHAR) '\145',
 136     (CHAR) '\146',
 137     (CHAR) '\347',
 138     (CHAR) '\350',
 139     (CHAR) '\151',
 140     (CHAR) '\152',
 141     (CHAR) '\353',
 142     (CHAR) '\154',
 143     (CHAR) '\355',
 144     (CHAR) '\356',
 145     (CHAR) '\157',
 146     (CHAR) '\360',
 147     (CHAR) '\161',
 148     (CHAR) '\162',
 149     (CHAR) '\363',
 150     (CHAR) '\164',
 151     (CHAR) '\365',
 152     (CHAR) '\366',
 153     (CHAR) '\167',
 154     (CHAR) '\170',
 155     (CHAR) '\371',
 156     (CHAR) '\372',
 157     (CHAR) '\173',
 158     (CHAR) '\374',
 159     (CHAR) '\175',
 160     (CHAR) '\176',
 161     (CHAR) '\377'
 162 };
 163
 164 /*  D O P A R  --  Add an appropriate parity bit to a character  */
 165
 166 CHAR
 167 #ifdef CK_ANSIC
 168 dopar(register CHAR ch)
 169 #else
 170 dopar(ch) register CHAR ch;
 171 #endif /* CK_ANSIC */
 172     {
 173     register unsigned int a;
 174     if (!parity
 175 #ifdef TCPSOCKET
 176         || (network && (ttnproto == NP_TELNET) && (TELOPT_ME(TELOPT_BINARY)))
 177 #ifndef NOXFER
 178         || (!local && sstelnet)         /* TELNET BINARY MODE */
 179 #endif /* NOXFER */
 180 #endif /* TCPSOCKET */
 181         ) return((CHAR) (ch & 255)); else a = ch & 127;
 182     switch (parity) {
 183         case 'e':  return(p_tbl[a]);                 /* Even */
 184         case 'm':  return((CHAR) (a | 128));         /* Mark */
 185         case 'o':  return((CHAR) (p_tbl[a] ^ 128));  /* Odd */
 186         case 's':  return((CHAR) a);                 /* Space */
 187         default:   return((CHAR) a);                 /* Something illegal */
 188     }
 189 }
 190
 191 #ifndef NOXFER                          /* Rest of this file... */
 192
 193 #define NEWDPL                          /* New dynamic packet length method */
 194
 195 #ifdef VMS
 196 extern int batch;
 197 #else
 198 extern int backgrd;
 199 #endif /* VMS */
 200
 201 #ifdef DYNAMIC
 202 extern struct pktinfo *s_pkt;           /* array of pktinfo structures */
 203 extern struct pktinfo *r_pkt;           /* array of pktinfo structures */
 204 #else
 205 extern struct pktinfo s_pkt[];          /* array of pktinfo structures */
 206 extern struct pktinfo r_pkt[];          /* array of pktinfo structures */
 207 #endif /* DYNAMIC */
 208
 209 extern int sseqtbl[], rseqtbl[], sbufuse[], sacktbl[], wslots, winlo, wslotn,
 210   sbufnum, rbufnum, pktpaus, reliable;
 211
 212 #ifdef STREAMING
 213 static int dontsend = 0;
 214 extern int streaming;
 215 #endif /* STREAMING */
 216
 217 extern int ttprty;                      /* from ck*tio.c */
 218 extern int autopar;
 219
 220 extern int spsiz, spmax, rpsiz, timint, timef, npad, bestlen, maxsend;
 221 extern int rpt, rptq, rptflg, capas, spsizf, en_fin, tsecs, flow;
 222 extern int pktnum, sndtyp, rcvtyp, bctr, bctu, bctl, rsn, rln, maxtry, size;
 223 extern int osize, maxsize, spktl, rpktl, nfils, stdouf, fsecs;
 224 extern int turn, turnch, displa, pktlog, seslog, xflg, mypadn;
 225 extern int hcflg, server, cxseen, czseen, discard, slostart;
 226 extern int nakstate, quiet, success, xitsta, what, filestatus;
 227 extern int spackets, rpackets, timeouts, retrans, crunched, urpsiz;
 228 extern int carrier, fdispla, srvidl;
 229
 230 #ifdef GFTIMER
 231 extern CKFLOAT fptsecs, fpfsecs, fpxfsecs;
 232 #endif /* GFTIMER */
 233
 234 extern long filcnt, filrej, ffc, flci, flco, tlci, tlco, tfc, speed;
 235 extern long filcps, tfcps;
 236
 237 extern char *cmarg, filnam[];
 238
 239 extern CHAR padch, mypadc, eol, seol, ctlq, sstate;
 240 extern CHAR *recpkt, *data, myinit[];
 241 extern CHAR *srvptr, stchr, mystch, *rdatap;
 242 extern CHAR padbuf[];
 243 extern CHAR * epktmsg;
 244 extern int epktrcvd, epktsent;
 245
 246 #ifdef OS2                              /* AUTODOWNLOAD parameters */
 247 extern int adl_kmode, adl_zmode;        /* Match Packet to signal download */
 248 extern char * adl_kstr;                 /* KERMIT Download String */
 249 extern char * adl_zstr;                 /* ZMODEM Download String */
 250 #endif /* OS2 */
 251
 252 #ifdef CK_AUTODL
 253 CHAR ksbuf[96] = { NUL, NUL };          /* Autodownload "Kermit Start" buf */
 254 #endif /* CK_AUTODL */
 255
 256 int numerrs = 0;                        /* Number of packet errors so far */
 257 int rcvtimo = 0;                        /* Timeout for receiving a packet */
 258 int idletmo = 0;                        /* Flag for idle timeout */
 259
 260 long filcps = 0L;                       /* CPS most recent file transferred */
 261 long tfcps  = 0L;                       /* CPS most recent transaction */
 262 long xfsecs = 0L;                       /* Elapsed time for most recent file */
 263 #ifdef GFTIMER
 264 CKFLOAT fpxfsecs = 0.0;                 /* Ditto, but floating point */
 265 #endif /* GFTIMER */
 266
 267 #ifdef CK_TIMERS
 268 int rrttbl[64], srttbl[64];             /* Packet timestamp tables */
 269 extern int rttflg;
 270 #define RTT_SCALE 1000
 271 long
 272   rttsamples,                           /* Round trip time samples */
 273   rttdelay,                             /* RTT delay */
 274   pktintvl,                             /* Interpacket arrival time */
 275   rttvariance,                          /* RTT variance */
 276   rttstddev;                            /* RTT standard deviation */
 277 #endif /* CK_TIMERS */
 278
 279 /* CRC generation tables */
 280
 281 long crcta[16] = { 0L, 010201L, 020402L, 030603L, 041004L,
 282   051205L, 061406L, 071607L, 0102010L, 0112211L, 0122412L, 0132613L, 0143014L,
 283   0153215L, 0163416L, 0173617L
 284 };
 285
 286 long crctb[16] = { 0L, 010611L, 021422L, 031233L, 043044L,
 287   053655L, 062466L, 072277L, 0106110L, 0116701L, 0127532L, 0137323L, 0145154L,
 288   0155745L, 0164576L, 0174367L
 289 };
 290
 291 #ifdef CK_TIMERS
 292 /*
 293   Round-trip timer calculations adapted from Tim Kientzle's article,
 294   "Improving Kermit Performance", Dr Dobb's Journal, February 1996.
 295 */
 296
 297
 298 /*  R T T I N I T  --  Initialize timers at start of transaction  */
 299
 300 VOID
 301 rttinit() {                             /* Initialize round-trip timing */
 302     int i;
 303
 304     if (timint == 0)
 305       return;
 306
 307     rttsamples  = 0L;                   /* Samples (packets) */
 308     rttvariance = 0L;                   /* Variance in delay */
 309     rttdelay    = (long) timint * RTT_SCALE; /* Delay */
 310     pktintvl    = (long) timint * RTT_SCALE; /* Delay */
 311     rttstddev   = (long) timint * RTT_SCALE; /* Standard deviation of delay */
 312
 313     /* Tables of timestamps indexed by packet sequence number */
 314
 315     for (i = 0; i < 64; i++) {
 316         rrttbl[i] = -1;                 /* Time each packet was received */
 317         srttbl[i] = -1;                 /* Time each packet was sent */
 318     }
 319     rcvtimo = timint;                   /* Initial timeout is what user said */
 320 }
 321
 322 /*  G E T R T T  --  Get packet round trip time  */
 323 /*
 324   Call with nakstate == 0 if file sender, nonzero if receiver,
 325   and n == packet sequence number of the packet we just received.
 326
 327   Returns:
 328   -1 on failure with rcvtimo set to timint (what the user said), or:
 329    0 on success with rcvtimo set to dynamically calculated value:
 330      1 <= rcvtimo <= timint * 3.
 331 */
 332 int
 333 getrtt(nakstate, n) int nakstate, n; {
 334     extern int mintime, maxtime;
 335     static int prevz = 0, prevr = 0;
 336     int x, y, yy, z = 0, zz = 0;        /* How long did it take to get here? */
 337
 338     rcvtimo = timint;                   /* Default timeout is what user said */
 339
 340     if (timint == 0)                    /* We're not timing out. */
 341       return(0);
 342
 343     if (!rttflg)                        /* Not supposed to be doing this? */
 344       return(-1);                       /*  So don't */
 345
 346     if (!RTT_SCALE)                     /* Paranoia... */
 347       return(-1);
 348
 349     /* rtimer() (reset timer) is not called until 1st data packet */
 350 #ifdef GFTIMER
 351     /* rftimer(); */
 352 #endif /* GFTIMER */
 353     /* S (F [ A ] D* Z)* B */
 354
 355     /* NOTE: we calculate both the round-trip time AND the packet */
 356     /* arrival rate.  We don't use the RTT for anything, we just display it. */
 357     /* Timeouts are based on the packet arrival rate. */
 358
 359     if (spackets > 3) {                 /* Don't start till 4th packet */
 360         if (nakstate) {                 /* File receiver */
 361             x = rrttbl[n];                   /* Time when I got packet n */
 362             y = rrttbl[n > 0 ? n - 1 : 63];  /* Time when I got packet n-1 */
 363             yy = srttbl[n > 0 ? n - 1 : 63]; /* Time when I sent ACK(n-1) */
 364             if (x > -1 && y > -1) {     /* Be careful */
 365                 z = x - y;              /* Packet rate */
 366                 zz = x - yy;            /* Round trip time */
 367                 z++;                    /* So sender & receiver differ */
 368                 debug(F101,"RTT RECV","",z);
 369             } else {                    /* This shouldn't happen */
 370                 debug(F101,"RTT RECV ERROR spackets","",spackets);
 371                 debug(F101,"RTT RECV ERROR sequence","",n);
 372                 return(-1);
 373             }
 374         } else {                        /* File sender */
 375             x = rrttbl[n];              /* Time when I got ACK(n) */
 376             y = rrttbl[n > 0 ? n - 1 : 63]; /* Time when I got packet n-1 */
 377             yy = srttbl[n];             /* Time when I sent n */
 378             if (x > -1 && y > -1) {
 379                 z = x - y;              /* Packet rate */
 380                 zz = x - yy;            /* Round trip time */
 381                 debug(F101,"RTT SEND","",z);
 382             } else {
 383                 debug(F100,"RTT SEND ERROR","",0);
 384                 return(-1);
 385             }
 386         }
 387         if (z < 1)                      /* For fast connections */
 388           z = RTT_SCALE / 2;            /* Convert to scale... */
 389         else
 390           z *= RTT_SCALE;
 391         debug(F101,"RTT z scaled","",z);
 392
 393         if (zz < 1)                     /* For fast connections */
 394           zz = RTT_SCALE / 2;           /* Convert to scale... */
 395         else
 396           zz *= RTT_SCALE;
 397
 398         rttdelay = zz;                  /* Round trip time of this packet */
 399 #ifdef COMMENT
 400 /*
 401   This was used in C-Kermit 7.0 (and 6.0?) but not only is it overkill,
 402   it also can produce ridiculously long timeouts under certain conditions.
 403   Replaced in 8.0 by a far simpler and more aggressive strategy.
 404 */
 405         if (rttsamples++ == 0L) {       /* First sample */
 406             pktintvl = z;
 407         } else {                        /* Subsequent samples */
 408             long oldavg = pktintvl;
 409             long rttdiffsq;
 410
 411             if (rttsamples > 30)        /* Use real average for first 30 */
 412               rttsamples = 30;          /*  then decaying average. */
 413
 414             /* Average delay, difference squared, variance, std deviation */
 415
 416             pktintvl += (z - pktintvl) / rttsamples;
 417             rttdiffsq = (z - oldavg) * (z - oldavg);
 418             rttvariance += (rttdiffsq - rttvariance) / rttsamples;
 419             debug(F101,"RTT stddev1","",rttstddev);
 420             if (rttstddev < 1L)         /* It can be zero, in which case */
 421               rttstddev = RTT_SCALE / 3; /* set it to something small... */
 422             rttstddev = (rttstddev + rttvariance / rttstddev) / 2;
 423         }
 424         debug(F101,"RTT stddev2","",rttstddev);
 425         debug(F101,"RTT delay  ","",pktintvl);
 426         rcvtimo = (pktintvl + (3L * rttstddev)) / RTT_SCALE + 1;
 427         if (rpackets < 32)              /* Allow for slow start */
 428           rcvtimo += rcvtimo + 2;
 429         else if (rpackets < 64)
 430           rcvtimo += rcvtimo / 2 + 1;
 431         /* On a reliable link, don't try too hard to time out. */
 432         /* Especially on fast local network connections. */
 433         if (server && what == W_NOTHING) /* Server command wait */
 434           rcvtimo = rcvtimo;            /* == srvtim */
 435         else if (reliable == SET_ON && rcvtimo > 0) /* Reliable */
 436           rcvtimo = rcvtimo +15;        /* and not server command wait */
 437         else                            /* Not reliable or server cmd wait */
 438           rcvtimo = rcvtimo;
 439         if (rcvtimo < mintime)          /* Lower bound */
 440           rcvtimo = mintime;
 441         if (maxtime > 0) {              /* User specified an upper bound */
 442             if (rcvtimo > maxtime)
 443               rcvtimo = maxtime;
 444         } else if (maxtime == 0) {      /* User didn't specify */
 445             if (rcvtimo > timint * 6)
 446               rcvtimo = timint * 6;
 447         }
 448 #else  /* COMMENT */
 449 #ifdef CKFLOAT
 450         {
 451             CKFLOAT x;
 452             x = (CKFLOAT)(prevz + z + z) / 3.0;
 453             rcvtimo = (int)((((CKFLOAT)x * 2.66) / RTT_SCALE) + 0.5);
 454             debug(F101,"RTT rcvtimo (float)","",rcvtimo);
 455         }
 456 #else
 457         rcvtimo = (prevz + z + z) / RTT_SCALE;
 458         debug(F101,"RTT rcvtimo (int)","",rcvtimo);
 459 #endif /* CKFLOAT */
 460 #endif /* COMMENT */
 461
 462         zz = (rttdelay + 500) / 1000;
 463         if (rcvtimo > (zz * 3))
 464           rcvtimo = zz * 3;
 465
 466         if (rcvtimo < 1)
 467           rcvtimo = 1;
 468         if (mintime > 0) {
 469             if (rcvtimo < mintime)      /* Lower bound */
 470               rcvtimo = mintime;
 471         }
 472         if (maxtime > 0) {              /* Upper bound */
 473             if (rcvtimo > maxtime)
 474               rcvtimo = maxtime;
 475         }
 476         if (rcvtimo == (prevr - 1))
 477           rcvtimo++;
 478
 479         debug(F101,"RTT final rcvtimo","",rcvtimo);
 480     }
 481     prevz = z;
 482     prevr = rcvtimo;
 483     return(0);
 484 }
 485 #endif /* CK_TIMERS */
 486
 487 /*  I N P U T  --  Attempt to read packet number 'pktnum'.  */
 488
 489 /*
 490  This is the function that feeds input to Kermit's finite state machine,
 491  in the form of a character in the range 32-126, normally a packet type
 492  (uppercase letter) or pseudo-packet-type (lowercase letter).
 493
 494  If a special start state is in effect, that state is returned as if it were
 495  the type of an incoming packet.
 496 */
 497 int
 498 input() {
 499     int type = 0, acktype;              /* Received packet type */
 500     int x, y, k;                        /* Workers */
 501     int z, pi, nf;                      /* Worker, packet index, NAK flag */
 502     int nak2ack = 0;
 503
 504     debug(F000,"input sstate","",sstate);
 505     debug(F101,"input nakstate","",nakstate);
 506     debug(F000,"input sndtyp","",sndtyp);
 507     debug(F101,"input xitsta","",xitsta);
 508     debug(F101,"input what","",what);
 509
 510     while (1) {                         /* Big loop... */
 511 /*
 512   It is ttchk()'s responsibility to tell us if the connection is broken,
 513   and to do so instantly and nondestructively -- no blocking, etc, that would
 514   slow down file transfer.
 515 */
 516         if (ttchk() < 0) {
 517             debug(F100,"input CONNECTION BROKEN","",0);
 518             fatalio = 1;
 519             return('q');
 520         }
 521         if (sstate != 0) {              /* If a start state is in effect, */
 522             type = sstate;              /* return it like a packet type, */
 523             sstate = 0;                 /* and then nullify it. */
 524             numerrs = 0;                /* (PWP) no errors so far */
 525             return(type);
 526         }
 527         if (nakstate) {                 /* This section for file receiver. */
 528             if (wslots > 1) {           /* If we're doing windows, */
 529                 x = rseqtbl[winlo];     /* see if desired packet already in. */
 530                 debug(F101,"input winlo","",winlo);
 531                 debug(F101,"input rseqtbl[winlo]","",rseqtbl[winlo]);
 532                 if (x > -1) {           /* Already there? */
 533                     if (r_pkt[x].pk_seq == winlo) { /* (double check) */
 534                         rsn = winlo;                /* Yes, return its info */
 535                         debug(F101,"input return pre-stashed packet","",rsn);
 536                         dumprbuf();
 537                         rdatap = r_pkt[x].pk_adr;   /* like rpack would do. */
 538                         rln = (int)strlen((char *) rdatap);
 539                         type = r_pkt[x].pk_typ;
 540                         break;
 541                     }
 542                 }
 543             }
 544             type = rpack();             /* Try to read a packet. */
 545             debug(F101,"input rpack","",type);
 546
 547             while (type == 'e') {       /* Handle echoes */
 548                 debug(F101,"input echo discarded","",type);
 549                 type = rpack();
 550             }
 551 #ifdef DEBUG
 552             if (deblog) {
 553                 if (type == 'D')
 554                   debug(F011,"input type D=",(char *)rdatap,39);
 555                 else
 556                   debug(F000,"input type",(char *)rdatap,type);
 557             }
 558 #endif /* DEBUG */
 559 #ifndef OLDCHKINT
 560             if (type == 'z') {
 561                 epktrcvd = 1;
 562                 errpkt((CHAR *)"User cancelled.");
 563                 type = 'E';
 564                 break;
 565             }
 566 #endif /* OLDCHKINT */
 567             if (type < -1) {
 568                 char * s;
 569                 s = (type == -2) ?
 570                   "FAILED - Interrupted" :
 571                     "FAILED - Connection lost";
 572
 573                 xxscreen(SCR_PT,'q',0L,s);
 574                 dologend();
 575                 return('q');            /* Ctrl-C or connection lost */
 576             }
 577             if (type < 0) {             /* Receive window full */
 578                 /* Another thing to do here would be to delete */
 579                 /* the highest packet and NAK winlo.  But that */
 580                 /* shouldn't be necessary since the other Kermit */
 581                 /* should not have sent a packet outside the window. */
 582 #ifdef COMMENT
 583                 char foo[256];
 584                 ckmakxmsg(foo,256,"Receive window full (rpack): wslots=",
 585                           ckitoa(wslots)," winlo=",ckitoa(winlo)," pktnum=",
 586                           ckitoa(pktnum), NULL,NULL,NULL,NULL,NULL,NULL);
 587                 errpkt((CHAR *)foo);
 588                 debug(F100,foo,"",0);
 589 #else
 590                 errpkt((CHAR *)"Receive window full");
 591                 debug(F101,"rpack receive window full","",0);
 592                 debug(F101," wslots","",wslots);
 593                 debug(F101," winlo","",winlo);
 594                 debug(F101," pktnum","",pktnum);
 595 #endif
 596                 dumprbuf();
 597                 type = 'E';
 598                 break;
 599             }
 600             dumprbuf();
 601
 602 #ifdef OLDCHKINT
 603             if (chkint() < 0) {         /* Check for console interrupts. */
 604                 errpkt((CHAR *)"User cancelled."); /* (old way) */
 605                 type = 'E';
 606                 break;
 607             }
 608 #endif /* OLDCHKINT */
 609
 610 #ifdef STREAMING
 611             if (streaming) {            /* Streaming */
 612                 if (type == 'Q' || type == 'T') { /* Errors are fatal. */
 613                     crunched++;         /* For statistics */
 614                     errpkt((CHAR *)"Transmission error on reliable link.");
 615                     type = 'E';
 616                 }
 617             }
 618 #endif /* STREAMING */
 619             if (type == 'E') {
 620                 debug(F101,"input got E, nakstate","",nakstate);
 621                 break;                  /* Error packet */
 622             }
 623             if (type == 'Q') {          /* Crunched packet. */
 624                 crunched++;
 625                 numerrs++;
 626 /*
 627   Packet arrived damaged.  It was most likely the packet we were expecting
 628   next, so we send a NAK for that packet.  Prior to 5A(189), we always
 629   NAK'd winlo here, but that was bad because if two (or more) different
 630   packets were damaged, we would keep NAKing the first one and never NAK the
 631   other ones, which could result in a lengthy series of timeouts.  Now we
 632   NAK the oldest as-yet-unNAK'd missing packet.
 633 */
 634 #ifdef CK_TIMERS
 635                 rcvtimo++;              /* Stretch the timeout a little */
 636 #endif /* CK_TIMERS */
 637                 z = (winlo + wslots) % 64;  /* Search from winlo to z */
 638                 debug(F101,"ZZZ crunched z","",z);
 639                 nf = 0;                     /* NAK flag not set yet */
 640                 for (x = winlo; x != z; x = (x + 1) % 64) {
 641                     debug(F101,"ZZZ x","",x);
 642                     if (rseqtbl[x] > -1) /* Have I received packet x? */
 643                       continue;          /* Yes, go on. */
 644                     debug(F101,"ZZZ x not recd yet","",x);
 645                     pi = sseqtbl[x];     /* No, have I NAK'd it yet? */
 646                     if (pi < 0 || s_pkt[pi].pk_rtr == 0) {
 647                         debug(F101,"ZZZ x not NAK'd yet","",x);
 648                         nack(x);         /* No, NAK it now. */
 649                         nf = 1;          /* Flag that I did. */
 650                         break;
 651                     }
 652                 }
 653                 if (!nf) {              /* If we didn't NAK anything above, */
 654                     debug(F101,"ZZZ NAKing winlo","",winlo);
 655                     if (nack(winlo) < 0) { /* we have to NAK winlo (again) */
 656                         errpkt((CHAR *)"Too many retries."); /* Too many */
 657                         type = 'E';
 658                         break;
 659                     }
 660                 }
 661                 continue;
 662             }
 663
 664             if (type == 'T') {          /* Timeout */
 665 #ifndef OS2
 666                 /* K95 does this its own way */
 667                 if (server && srvidl) {
 668                     idletmo = 1;
 669                     debug(F101,"SERVER IDLE TIMEOUT","",srvidl);
 670                     return('q');
 671                 }
 672 #endif /* OS2 */
 673 #ifdef CK_TIMERS
 674                 rcvtimo++;              /* Stretch the timeout a little */
 675 #endif /* CK_TIMERS */
 676                 timeouts++;
 677                 debug(F101,"input receive-state timeout, winlo","",winlo);
 678                 /* NAK only the packet at window-low */
 679                 debug(F101,"input sending NAK for winlo","",winlo);
 680                 x = ttchk();
 681                 if (x > 0)              /* Don't give up if there is still */
 682                   continue;             /* something to read. */
 683                 else if (x < 0) {
 684                     dologend();
 685                     fatalio = 1;
 686                     return('q');        /* Connection Lost */
 687                 }
 688                 if (nack(winlo) < 0) {
 689                     debug(F101,"input sent too many naks","",winlo);
 690                     errpkt((CHAR *)"Too many retries.");
 691                     type = 'E';
 692                     break;
 693                 } else continue;
 694             }
 695             if (rsn == winlo) {         /* Got the packet we want, done. */
 696 #ifdef CK_TIMERS
 697                 if (rttflg && timint)   /* Dynamic round trip timers? */
 698                   getrtt(nakstate, rsn); /* yes, do it. */
 699 #endif /* CK_TIMERS */
 700                 debug(F101,"input rsn=winlo","",rsn);
 701                 break;
 702             }
 703
 704             /* Got a packet out of order. */
 705
 706             debug(F101,"input out of sequence, rsn","",rsn);
 707             k = rseqtbl[rsn];           /* Get window slot of this packet. */
 708             debug(F101,"input rseqtbl[rsn]","",k);
 709             if (k < 0) {
 710                 debug(F101,"input recv can't find index for rcvd pkt","",rsn);
 711                 /* Was "Internal error 21" */
 712                 /* This should not happen  */
 713                 errpkt((CHAR *)"Sliding windows protocol error.");
 714                 type = 'E';
 715                 break;
 716             }
 717             y = chkwin(rsn,winlo,wslots); /* See what window it's in. */
 718             debug(F101,"input recv chkwin","",y);
 719             if (y == 1) {               /* From previous window. */
 720 #ifdef STREAMING
 721                 if (!streaming)         /* NO RESEND IF STREAMING! */
 722 #endif /* STREAMING */
 723                   resend(rsn);          /* Resend the ACK (might have data) */
 724                 freerpkt(rsn);          /* Get rid of received packet */
 725                 continue;               /* Back to wait for another packet */
 726             } else {                    /* In this window or out of range */
 727                 if (y < 0)              /* If out of range entirely, */
 728                   freerpkt(rsn);        /* release its buffer */
 729
 730 #ifdef STREAMING
 731                 if (streaming) {        /* Streaming (this shouldn't happen) */
 732                     errpkt((CHAR *)"Sequence error on reliable link.");
 733                     type = 'E';
 734                     break;
 735                 }
 736 #endif /* STREAMING */
 737
 738 /* If our receive window is full, NAK window-low */
 739
 740                 if (rbufnum < 1) {      /* Receive window full? */
 741                     if (nack(winlo) < 0) {    /* No choice, must NAK winlo. */
 742                         errpkt((CHAR *)"Too many retries."); /* Too many */
 743                         type = 'E';
 744                         break;
 745                     } else continue;
 746                 }
 747 /*
 748   Receive window not full.  This is a packet in the current window but it is
 749   not the desired packet at winlo.  So therefore there are gaps before this
 750   packet.  So we find the "lowest" unNAK'd missing packet, if any, between
 751   winlo and this one, and NAK it.  If there are no as-yet-unNAK'd missing
 752   packets in the window, then we send nothing and go wait for another packet.
 753   In theory, this could result in a timeout, but in practice it is likely that
 754   the already-NAK'd missing packets are already on their way.  Note, we do not
 755   NAK ahead of ourselves, as that only creates unnecessary retransmissions.
 756 */
 757                 for (x = winlo; x != rsn; x = (x + 1) % 64) {
 758                     if (rseqtbl[x] > -1) /* Have I received packet x? */
 759                       continue;          /* Yes, check next sequence number. */
 760                     pi = sseqtbl[x];     /* No, have I NAK'd it yet? */
 761                     if (pi < 0 || s_pkt[pi].pk_rtr == 0) {
 762                         nack(x);         /* No, NAK it now. */
 763                         break;
 764                     }
 765                 }
 766             }
 767 /*!!!*/
 768         } else {                        /* Otherwise file sender... */
 769
 770 #ifdef STREAMING
 771             if (streaming && sndtyp == 'D') {
 772                 debug(F101,"STREAMING input streaming","",streaming);
 773                 debug(F000,"STREAMING input sndtyp","",sndtyp);
 774                 rsn = winlo;
 775                 type = 'Y';             /* Pretend we got an ACK */
 776             }
 777 #endif /* STREAMING */
 778             if (!nak2ack) {             /* NAK(n+1) = ACK(n) */
 779                 if (wslots > 1) {       /* Packet at winlo already ACK'd? */
 780                     if (sacktbl[winlo]) { /* If so,  */
 781                         sacktbl[winlo] = 0; /* Turn off the ACK'd flag */
 782                         winlo = (winlo + 1) % 64; /* Rotate the window */
 783                         type = 'Y';     /* And return ACK */
 784                         debug(F101,
 785                               "input send returning pre-stashed ACK","",
 786                               winlo-1);
 787                         break;
 788                     }
 789                 }
 790 #ifdef STREAMING
 791                 if (!(streaming && sndtyp == 'D')) { /* Not streaming | data */
 792                     type = rpack();     /* Try to read an acknowledgement */
 793                 } else {                /* Streaming and in Data phase */
 794                     type = 'Y';         /* Assume all is normal */
 795                     if (chkint() < 0)   /* Check for console interrupts. */
 796                       type = 'z';
 797                     else if (ttchk() > 4 + bctu) /* Check for return traffic */
 798                       type = rpack();
 799                     debug(F000,"input streaming type","",type);
 800                 }
 801 #endif /* STREAMING */
 802                 debug(F111,"input send",(char *) rdatap,(int) type);
 803                 while (type == 'e') {   /* Handle echoes */
 804                     debug(F000,"echo discarded","",type);
 805                     type = rpack();
 806                 }
 807 #ifndef OLDCHKINT
 808                 if (type == 'z') {
 809                     epktrcvd = 1;
 810                     errpkt((CHAR *)"User cancelled.");
 811                     type = 'E';
 812                     break;
 813                 }
 814 #endif /* OLDCHKINT */
 815                 if (type < -1) {
 816                     xxscreen(SCR_PT,'q',0L,
 817                            ((char *)((type == -2) ?
 818                            "Interrupted" :
 819                            "Connection lost"))
 820                            );
 821                     if (type != -2)
 822                       dologend();
 823                     return('q');        /* Ctrl-C or connection lost */
 824                 }
 825                 if (type == -1) {
 826 #ifdef COMMENT
 827                     char foo[256];
 828                     ckmakxmsg(foo,256,
 829                               "Receive window full (error 18): wslots=",
 830                               ckitoa(wslots),
 831                               " winlo=",ckitoa(winlo)," pktnum=",
 832                               ckitoa(pktnum), NULL,NULL,NULL,NULL,NULL,NULL);
 833                     errpkt((CHAR *)foo);
 834                     debug(F100,foo,"",0);
 835 #else
 836                     errpkt((CHAR *)"Receive window full"); /* was "internal */
 837                     debug(F101," wslots","",wslots); /* error 18" */
 838                     debug(F101," winlo","",winlo);
 839                     debug(F101," pktnum","",pktnum);
 840 #endif /* COMMENT */
 841                     dumprbuf();
 842                     type = 'E';
 843                     break;
 844                 }
 845                 dumprbuf();             /* Debugging */
 846
 847 #ifdef OLDCHKINT
 848                 if (chkint() < 0) {     /* Check for console interrupts. */
 849                     errpkt((CHAR *)"User cancelled.");
 850                     return(type = 'E');
 851                 }
 852 #endif /* OLDCHKINT */
 853
 854                 /* Got a packet */
 855
 856 #ifdef STREAMING
 857                 if (streaming) {                /* Streaming */
 858                     if (type == 'Q' || type == 'T') { /* Errors are fatal. */
 859                         crunched++;     /* For statistics */
 860                         errpkt((CHAR *)"Transmission error on reliable link.");
 861                         type = 'E';
 862                     }
 863                 }
 864 #endif /* STREAMING */
 865                 if (type == 'E') {
 866                     debug(F101,"input send got E, nakstate","",nakstate);
 867                     break;              /* Error packet */
 868                 }
 869                 if (type == 'Q') {      /* Crunched packet */
 870                     crunched++;         /* For statistics */
 871                     numerrs++;          /* For packet resizing */
 872                     x = resend(winlo);  /* Resend window-low */
 873                     if (x < 0) {
 874                         type = 'E';
 875                         errpkt((CHAR *)"Too many retries");
 876                         break;
 877                     }
 878                     continue;
 879                 }
 880                 if (type == 'T') {      /* Timeout waiting for ACKs. */
 881                     timeouts++;         /* Count it */
 882                     numerrs++;          /* Count an error too */
 883                     debug(F101,"input send state timeout, winlo","",winlo);
 884
 885                     /* Retransmit the oldest un-ACK'd packet. */
 886
 887                     debug(F101,"input send resending winlo","",winlo);
 888                     if (resend(winlo) < 0) { /* Check retries */
 889                         debug(F101,"input send too many resends","",maxtry);
 890                         errpkt((CHAR *)"Too many retries");
 891                         return(type = 'E');
 892                     }
 893 #ifdef NEWDPL
 894                     /* Reduce prevailing packet length */
 895                     x = sseqtbl[winlo]; /* Get length of packet we want ACKd */
 896                     if (x > -1) {       /* Only if we have a valid index */
 897                         if (s_pkt[x].pk_typ == 'D') { /* only for D packets */
 898                             spsiz = (s_pkt[x].pk_len + 8) >> 1; /* halve it */
 899                             if (spsiz < 20) spsiz = 20; /* within reason */
 900                             debug(F101,"input T cut packet length","",spsiz);
 901                         }
 902                     }
 903 #endif /* NEWDPL */
 904                     continue;
 905                 }
 906             }
 907             /* Got an actual normal packet */
 908
 909             nak2ack = 0;                /* Unset this flag. */
 910             y = chkwin(rsn,winlo,wslots); /* Is it in the window? */
 911             debug(F101,"input send rsn","",rsn);
 912             debug(F101,"input send winlo","",winlo);
 913             debug(F101,"input send chkwin","",y);
 914
 915             if (type == 'Y') {          /* Got an ACK */
 916                 if (y == 0) {           /* In current window */
 917                     if (spackets < 4)   /* Error counter doesn't count */
 918                       numerrs = 0;      /* until data phase. */
 919                     sacktbl[rsn]++;     /* Mark the packet as ACK'd */
 920                     x = sseqtbl[rsn];   /* Get ACK'd packet's buffer index */
 921                     debug(F101,"bestlen ack x","",x);
 922 #ifdef NEWDPL
 923                     if (x > -1) {
 924                         acktype = s_pkt[x].pk_typ; /* Get type */
 925                         debug(F000,"bestlen ack type","",acktype);
 926
 927                         if (acktype == 'D') { /* Adjust data packet length */
 928                             if (spsiz > bestlen) {
 929                                 bestlen = spsiz;
 930                                 debug(F101,"bestlen B","",bestlen);
 931                             }
 932 #ifdef DEBUG
 933                             if (deblog) {
 934                                 debug(F101,"bestlen retry","",s_pkt[x].pk_rtr);
 935                                 debug(F101,"bestlen len","",s_pkt[x].pk_len);
 936                                 debug(F101,"bestlen spackets","",spackets);
 937                             }
 938 #endif /* DEBUG */
 939                             /* Set new best length */
 940                             if (s_pkt[x].pk_rtr == 0 &&
 941                                 s_pkt[x].pk_len + 8 > bestlen) {
 942                                 bestlen = s_pkt[x].pk_len + 8;
 943                                 if (bestlen > spmax)
 944                                   bestlen = spmax;
 945                                 debug(F101,"bestlen A","",bestlen);
 946                             }
 947 #ifdef DEBUG
 948                             if (deblog) {
 949                                 debug(F101,"bestlen wslots","",wslots);
 950                                 debug(F101,"bestlen maxsend","",maxsend);
 951                             }
 952 #endif /* DEBUG */
 953                             /* Slow start */
 954                             if (slostart &&
 955                                 (maxsend <= spmax) &&
 956                                 (rpackets < 11) &&
 957                                 (numerrs == 0)) {
 958                                 spsiz = spsiz << 1;
 959                                 debug(F101,"bestlen spsiz A","",spsiz);
 960
 961                             /* Creep up to best length */
 962                             } else if ((spackets > 5) &&
 963                                        (spsiz < bestlen - 8)) {
 964                                 spsiz += (bestlen - spsiz) / 3;
 965                                 debug(F101,"bestlen spsiz B","",spsiz);
 966
 967                             /* Push the envelope */
 968                             } else if ((spackets % (wslots + 1) == 0) &&
 969                                        (spackets > 6) &&
 970                                        (bestlen < spmax - 8) &&
 971                                        (spsiz < spmax)) {
 972                                 spsiz += (spmax - bestlen) / 3;
 973                                 debug(F101,"bestlen spsiz C","",spsiz);
 974                             }
 975                             /* But not too far */
 976                             if (spsiz > spmax) {
 977                                 spsiz = spmax;
 978                                 debug(F101,"bestlen spsiz D","",spsiz);
 979                             }
 980                         }
 981                     }
 982 #endif /* NEWDPL */
 983
 984 #ifdef CK_TIMERS
 985                     if (rttflg && timint) /* If doing dynamic timers */
 986                       getrtt(nakstate, rsn); /* call routine to set it. */
 987 #endif /* CK_TIMERS */
 988 /*
 989   NOTE: The following statement frees the buffer of the ACK we just got.
 990   But the upper layers still need the data, like if it's the ACK to an I,
 991   S, F, D, Z, or just about any kind of packet.  So for now, freerbuf()
 992   deallocates the buffer, but does not erase the data or destroy the pointer
 993   to it.  There's no other single place where these receive buffers can be
 994   correctly freed (?) ...
 995 */
 996                     freerpkt(rsn);      /* Free the ACK's buffer */
 997                     freesbuf(rsn);      /* *** Free the sent packet's buffer */
 998                     if (rsn == winlo) { /* Got the one we want */
 999                         sacktbl[winlo] = 0;
1000                         winlo = (winlo + 1) % 64;
1001                         debug(F101,"input send rotated send window","",winlo);
1002                         break;          /* Return the ACK */
1003                     } else {
1004                         debug(F101,"input send mark pkt","",rsn);
1005                         continue;       /* Otherwise go read another packet */
1006                     }
1007                 } else if (y == 1 && wslots < 2) { /* (190) ACK for previous */
1008                     numerrs++;          /* == NAK for current, count error */
1009                     debug(F101,"input send ACK for previous","",rsn);
1010                     freerpkt(rsn);      /* Free NAK's buffer */
1011                     x = resend(winlo);  /* Resend current packet */
1012                     if (x < 0) {
1013                         type = 'E';
1014                         errpkt((CHAR *)"Too many retries");
1015                         break;
1016                     } else continue;    /* Resend ok, go read another packet */
1017                 } else {                /* Other cases, just ignore */
1018                     debug(F101,"input send ACK out of window","",rsn);
1019                     freerpkt(rsn);
1020                     continue;
1021                 }
1022             }
1023             if (type == 'N') {          /* NAK */
1024                 numerrs++;              /* Count an error */
1025 #ifdef STREAMING
1026                 if (streaming) {                /* Streaming */
1027                     errpkt((CHAR *)"NAK received on reliable link.");
1028                     type = 'E';
1029                     break;
1030                 }
1031 #endif /* STREAMING */
1032
1033                 debug(F101,"input send NAK","",rsn);
1034 #ifdef NEWDPL
1035                 /* Reduce prevailing packet length */
1036                 x = sseqtbl[rsn];       /* Length of packet that was NAK'd */
1037                 if (x > -1) {           /* If it's a Data packet we've sent */
1038                     if (s_pkt[x].pk_typ == 'D') {
1039                         spsiz = (s_pkt[x].pk_len + 8) >> 1; /* Halve length */
1040 #ifdef COMMENT
1041                         /* This might be a good idea -- haven't tried it ... */
1042                         if (bestlen > 0 && spsiz > bestlen)
1043                           spsiz = bestlen;
1044 #endif /* COMMENT */
1045                         if (spsiz < 20) spsiz = 20;
1046                         debug(F101,"input N cut packet length","",spsiz);
1047                     }
1048                 }
1049 #endif /* NEWDPL */
1050                 freerpkt(rsn);          /* Free buffer where NAK lies. */
1051                 if (y == 0) {           /* In current window */
1052                     debug(F100," in window","",0);
1053                     k = sseqtbl[rsn];   /* Get pointer to NAK'd packet. */
1054                     if (k < 0 || (k > -1 && s_pkt[k].pk_typ == ' ')) {
1055                         x = resend(winlo); /* Packet we haven't sent yet. */
1056                     } else {
1057                         x = resend(rsn); /* Resend requested packet. */
1058                     }
1059                     if (x < 0) {        /* Resend error is fatal.  */
1060                         type = 'E';
1061                         errpkt((CHAR *)"Too many retries");
1062                         break;
1063                     } else continue;    /* Resend ok, go read another packet */
1064                 } else if ((rsn == (pktnum + 1) % 64)) { /* NAK for next pkt */
1065                     if (wslots > 1) {
1066                         debug( F101,"NAK for next packet, windowing","",rsn);
1067                         x = resend(winlo); /* Resend window-low */
1068                         if (x < 0) {
1069                             type = 'E';
1070                             errpkt((CHAR *)"Too many retries");
1071                             break;
1072                         }
1073                         continue;       /* Go back and read another pkt */
1074                     }
1075                     debug(F101,"NAK for next packet, no windowing","",rsn);
1076                     x = (rsn == 0) ? 63 : rsn - 1;
1077                     if (x == 0 && (sndtyp == 'S' || sndtyp == 'I')) {
1078                         resend(0);      /* ACK for S or I packet missing */
1079                         continue;       /* so resend the S or I */
1080                     }
1081                     rsn = x;            /* Else, treat NAK(n+1) as ACK(n) */
1082                     nak2ack = 1;        /* Go back and process the ACK */
1083                     continue;
1084                 } else if (y > 0) {     /* NAK for pkt we can't resend */
1085                     debug(F101," NAK out of window","",rsn); /* bad... */
1086                     type = 'E';
1087                     errpkt((CHAR *)"NAK out of window");
1088                     break;
1089                 } else continue;        /* Ignore other NAKs */
1090             }                           /* End of file-sender NAK handler */
1091
1092             if (rsn == winlo) {         /* Not ACK, NAK, timeout, etc. */
1093                 debug(F000,"input send unexpected type","",type);
1094                 break;
1095             }
1096         }                               /* End of file-sender section */
1097     }                                   /* End of input() while() loop */
1098 /*
1099   When the window size is 1 and we have the packet we want, there can not
1100   possibly be anything waiting for us on the connection that is useful to us.
1101   However, there might be redundant copies of a packet we already got, which
1102   would cause needless cycles of repeated packets.  Therefore we flush the
1103   communications input buffer now to try to get rid of undesired and unneeded
1104   packets that we have not read yet.
1105 */
1106     if (wslotn == 1                     /* (not wslots!) */
1107 #ifdef STREAMING
1108         && !streaming                   /* But not when streaming */
1109 #endif /* STREAMING */
1110         ) {
1111         debug(F100,"input about to flush","",0);
1112         ttflui();               /* Got what we want, clear input buffer. */
1113     }
1114 #ifndef NEWDPL
1115     if (!nakstate)                      /* When sending */
1116       rcalcpsz();                       /* recalculate size every packet */
1117 #endif /* NEWDPL */
1118     if (type == 'E')
1119       xitsta |= (what ? what : 1);      /* Remember what failed. */
1120     debug(F101,"input winlo","",winlo);
1121     debug(F101,"input rsn","",rsn);
1122     debug(F000,"input returning type","",type);
1123     return(rcvtyp = type);              /* Success, return packet type. */
1124 }
1125
1126 #ifdef PARSENSE
1127 /*  P A R C H K  --  Check if Kermit packet has parity  */
1128
1129 /*
1130   Call with s = pointer to packet, start = packet start character, n = length.
1131   Returns 0 if packet has no parity, -1 on error, or, if packet has parity:
1132     'e' for even, 'o' for odd, 'm' for mark.  Space parity cannot be sensed.
1133   So a return value of 0 really means either space or none.
1134   Returns -2 if parity has already been checked during this protocol operation.
1135 */
1136 int
1137 #ifdef CK_ANSIC
1138 parchk(CHAR *s, CHAR start, int n)
1139 #else
1140 parchk(s,start,n) CHAR *s, start; int n;
1141 #endif /* CK_ANSIC */
1142 /* parchk */ {
1143     CHAR s0, s1, s2, s3;
1144
1145     debug(F101,"parchk n","",n);
1146     debug(F101,"parchk start","",start);
1147
1148     s0 = s[0] & 0x7f;                   /* Mark field (usually Ctrl-A) */
1149
1150     if (s0 != start || n < 5) return(-1); /* Not a valid packet */
1151
1152 /* Look at packet control fields, which never have 8th bit set */
1153 /* First check for no parity, most common case. */
1154
1155     if (((s[0] | s[1] | s[2] | s[3]) & 0x80) == 0)
1156       return(0);                        /* No parity or space parity */
1157
1158 /* Check for mark parity */
1159
1160     if (((s[0] & s[1] & s[2] & s[3]) & 0x80) == 0x80)
1161       return('m');                      /* Mark parity */
1162
1163 /* Packet has some kind of parity */
1164 /* Make 7-bit copies of control fields */
1165
1166     s1 = s[1] & 0x7f;                   /* LEN */
1167     s2 = s[2] & 0x7f;                   /* SEQ */
1168     s3 = s[3] & 0x7f;                   /* TYPE */
1169
1170 /* Check for even parity */
1171
1172     if ((s[0] == p_tbl[s0]) &&
1173         (s[1] == p_tbl[s1]) &&
1174         (s[2] == p_tbl[s2]) &&
1175         (s[3] == p_tbl[s3]))
1176       return('e');
1177
1178 /* Check for odd parity */
1179
1180     if ((s[0] != p_tbl[s0]) &&
1181         (s[1] != p_tbl[s1]) &&
1182         (s[2] != p_tbl[s2]) &&
1183         (s[3] != p_tbl[s3]))
1184       return('o');
1185
1186 /* Otherwise it's probably line noise.  Let checksum calculation catch it. */
1187
1188     return(-1);
1189 }
1190 #endif /* PARSENSE */
1191 \f
1192 /*
1193   Check to make sure timeout intervals are long enough to allow maximum
1194   length packets to get through before the timer goes off.  If not, the
1195   timeout interval is adjusted upwards.
1196
1197   This routine is called at the beginning of a transaction, before we
1198   know anything about the delay characteristics of the line.  It works
1199   only for serial communication devices; it trusts the speed reported by
1200   the operating system.
1201
1202   Call with a timout interval.  Returns it, adjusted if necessary.
1203 */
1204 int
1205 chktimo(timo,flag) int timo, flag; {
1206     long cps, z; int x, y;
1207 #ifdef STREAMING
1208     debug(F101,"chktimo streaming","",streaming);
1209     if (streaming)
1210       return(0);
1211 #endif /* STREAMING */
1212
1213     debug(F101,"chktimo timo","",timo); /* Timeout before adjustment */
1214     debug(F101,"chktimo flag","",flag);
1215
1216     if (flag)                           /* Don't change timeout if user */
1217       return(timo);                     /* gave SET SEND TIMEOUT command. */
1218     debug(F101,"chktimo spmax","",spmax);
1219     debug(F101,"chktimo urpsiz","",urpsiz);
1220
1221     if (!network) {                     /* On serial connections... */
1222         speed = ttgspd();               /* Get current speed. */
1223         if (speed > 0L) {
1224             cps = speed / 10L;          /* Convert to chars per second */
1225             if (cps > 0L) {
1226                 long plen;              /* Maximum of send and rcv pkt size */
1227                 z = cps * (long) timo;  /* Chars per timeout interval */
1228                 z -= z / 10L;           /* Less 10 percent */
1229                 plen = spmax;
1230                 if (urpsiz > spmax) plen = urpsiz;
1231                 debug(F101,"chktimo plen","",plen);
1232                 if (z < plen) {         /* Compare with packet size */
1233                     x = (int) ((long) plen / cps); /* Adjust if necessary */
1234                     y = x / 10;         /* Add 10 percent for safety */
1235                     if (y < 2) y = 2;   /* Or 2 seconds, whichever is more */
1236                     x += y;
1237                     if (x > timo)       /* If this is greater than current */
1238                       timo = x;         /* timeout, change the timeout */
1239                     debug(F101,"chktimo new timo","",timo);
1240                 }
1241             }
1242         }
1243     }
1244     return(timo);
1245 }
1246 \f
1247 /*  S P A C K  --  Construct and send a packet  */
1248
1249 /*
1250   spack() sends a packet of the given type, sequence number n, with len data
1251   characters pointed to by d, in either a regular or extended- length packet,
1252   depending on len.  Returns the number of bytes actually sent, or else -1
1253   upon failure.  Uses global npad, padch, mystch, bctu, data.  Leaves packet
1254   fully built and null-terminated for later retransmission by resend().
1255   Updates global sndpktl (send-packet length).
1256
1257   NOTE: The global pointer "data" is assumed to point into the 7th position
1258   of a character array (presumably in packet buffer for the current packet).
1259   It was used by getpkt() to build the packet data field.  spack() fills in
1260   the header to the left of the data pointer (the data pointer is defined
1261   in getsbuf() in ckcfn3.c).  If the address "d" is the same as "data", then
1262   the packet's data field has been built "in place" and need not be copied.
1263 */
1264 int
1265 #ifdef CK_ANSIC
1266 spack(char pkttyp, int n, int len, CHAR *d)
1267 #else
1268 spack(pkttyp,n,len,d) char pkttyp; int n, len; CHAR *d;
1269 #endif /* CK_ANSIC */
1270 /* spack */ {
1271     register int i;
1272     int ix, j, k, x, lp, longpkt, copy, loglen;
1273
1274 #ifdef GFTIMER
1275     CKFLOAT t1 = 0.0, t2 = 0.0;
1276 #endif /* GFTIMER */
1277
1278     register CHAR *cp, *mydata;
1279     unsigned crc;
1280
1281     copy = (d != data);                 /* Flag whether data must be copied  */
1282
1283 #ifdef DEBUG
1284     if (deblog) {                       /* Save lots of function calls! */
1285         debug(F101,"spack n","",n);
1286         if (pkttyp != 'D') {            /* Data packets would be too long */
1287             debug(F111,"spack data",data,data);
1288             debug(F111,"spack d",d,d);
1289         }
1290         debug(F101,"spack len","",len);
1291         debug(F101,"spack copy","",copy);
1292     }
1293 #endif /* DEBUG */
1294
1295     longpkt = (len + bctl + 2) > 94;    /* Decide whether it's a long packet */
1296     mydata = data - 7 + (longpkt ? 0 : 3); /* Starting position of header */
1297     k = sseqtbl[n];                     /* Packet structure info for pkt n */
1298 #ifdef DEBUG
1299     if (deblog) {                       /* Save 2 more function calls... */
1300         debug(F101,"spack mydata","",mydata);
1301         debug(F101,"spack sseqtbl[n]","",k);
1302         if (k < 0) {
1303 #ifdef STREAMING
1304             if (!streaming)
1305 #endif /* STREAMING */
1306               debug(F101,"spack sending packet out of window","",n);
1307         }
1308     }
1309 #endif /* DEBUG */
1310     if (k > -1) {
1311         s_pkt[k].pk_adr = mydata;       /* Remember address of packet. */
1312         s_pkt[k].pk_seq = n;            /* Record sequence number */
1313         s_pkt[k].pk_typ = pkttyp;       /* Record packet type */
1314     }
1315     spktl = 0;                          /* Initialize length of this packet */
1316     i = 0;                              /* and position in packet. */
1317
1318 /* Now fill the packet */
1319
1320     mydata[i++] = mystch;               /* MARK */
1321     lp = i++;                           /* Position of LEN, fill in later */
1322
1323     mydata[i++] = tochar(n);            /* SEQ field */
1324     mydata[i++] = pkttyp;               /* TYPE field */
1325     j = len + bctl;                     /* Length of data + block check */
1326     if (longpkt) {                      /* Long packet? */
1327         int x;                          /* Yes, work around SCO Xenix/286 */
1328 #ifdef CKTUNING
1329         unsigned int chk;
1330 #endif /* CKTUNING */
1331         x = j / 95;                     /* compiler bug... */
1332         mydata[lp] = tochar(0);         /* Set LEN to zero */
1333         mydata[i++] = tochar(x);        /* Extended length, high byte */
1334         mydata[i++] = tochar(j % 95);   /* Extended length, low byte */
1335 #ifdef CKTUNING
1336         /* Header checksum - skip the function calls and loops */
1337           chk = (unsigned) mydata[lp]   +
1338                 (unsigned) mydata[lp+1] +
1339                 (unsigned) mydata[lp+2] +
1340                 (unsigned) mydata[lp+3] +
1341                 (unsigned) mydata[lp+4] ;
1342         mydata[i++] = tochar((CHAR) ((((chk & 0300) >> 6) + chk) & 077));
1343 #else
1344         mydata[i] = '\0';               /* Terminate for header checksum */
1345         mydata[i++] = tochar(chk1(mydata+lp,5));
1346 #endif /* CKTUNING */
1347     } else mydata[lp] = tochar(j+2);    /* Normal LEN */
1348 /*
1349   When sending a file, the data is already in the right place.  If it weren't,
1350   it might make sense to optimize this section by using memcpy or bcopy
1351   (neither of which are portable), but only if our packets were rather long.
1352   When receiving, we're only sending ACKs so it doesn't matter.  So count the
1353   following loop as a sleeping dog.
1354 */
1355     if (copy)                           /* Data field built in place? */
1356       for ( ; len--; i++) mydata[i] = *d++; /* No, must copy. */
1357     else                                /* Otherwise, */
1358       i += len;                         /* Just skip past data field. */
1359     mydata[i] = '\0';                   /* Null-terminate for checksum calc. */
1360
1361     switch (bctu) {                     /* Block check */
1362         case 1:                         /* 1 = 6-bit chksum */
1363             ix = i - lp;                /* Avoid "order of operation" error */
1364             mydata[i++] = tochar(chk1(mydata+lp,ix));
1365             break;
1366         case 2:                         /* 2 = 12-bit chksum */
1367             j = chk2(mydata+lp,i-lp);
1368             mydata[i++] = (unsigned)tochar((j >> 6) & 077);
1369             mydata[i++] = (unsigned)tochar(j & 077);
1370             break;
1371         case 3:                         /* 3 = 16-bit CRC */
1372             crc = chk3(mydata+lp,i-lp);
1373             mydata[i++] = (unsigned)tochar(((crc & 0170000)) >> 12);
1374             mydata[i++] = (unsigned)tochar((crc >> 6) & 077);
1375             mydata[i++] = (unsigned)tochar(crc & 077);
1376             break;
1377         case 4:                         /* 2 = 12-bit chksum, blank-free */
1378             j = chk2(mydata+lp,i-lp);
1379             mydata[i++] =
1380               (unsigned)(tochar((unsigned)(((j >> 6) & 077) + 1)));
1381             mydata[i++] = (unsigned)(tochar((unsigned)((j & 077) + 1)));
1382             break;
1383     }
1384     loglen = i;
1385     mydata[i++] = seol;                 /* End of line (packet terminator) */
1386 #ifdef TCPSOCKET
1387 /*
1388   If TELNET connection and packet terminator is carriage return,
1389   we must stuff either LF or NUL, according to SET TELNET NEWLINE-MODE
1390   (tn_nlm), to meet the TELNET NVT specification, unless user said RAW.
1391
1392   If NEWLINE-MODE is set to LF instead of CR, we still send CR-NUL
1393   on a NVT connection and CR on a binary connection.
1394 */
1395     if (
1396 #ifdef STREAMING
1397         !dontsend &&
1398 #endif /* STREAMING */
1399         ((network && ttnproto == NP_TELNET) || (!local && sstelnet))
1400         && seol == CR) {
1401         switch (TELOPT_ME(TELOPT_BINARY) ? tn_b_nlm : tn_nlm) {
1402           case TNL_CR:                  /* NVT or BINARY */
1403             break;
1404           case TNL_CRNUL:
1405             mydata[i++] = NUL;
1406             break;
1407           case TNL_CRLF:
1408             mydata[i++] = LF;
1409             break;
1410         }
1411     }
1412 #endif /* TCPSOCKET */
1413     mydata[i] = '\0';                   /* Terminate string */
1414     if (
1415 #ifdef STREAMING
1416         !dontsend &&
1417 #endif /* STREAMING */
1418         pktlog
1419         )                               /* Save a function call! */
1420       logpkt('s',n,mydata,loglen);      /* Log the packet */
1421
1422     /* (PWP) add the parity quickly at the end */
1423     if (parity) {
1424         switch (parity) {
1425           case 'e':                     /* Even */
1426             for (cp = &mydata[i-1]; cp >= mydata; cp--)
1427               *cp = p_tbl[*cp];
1428             break;
1429           case 'm':                     /* Mark */
1430             for (cp = &mydata[i-1]; cp >= mydata; cp--)
1431               *cp |= 128;
1432             break;
1433           case 'o':                     /* Odd */
1434             for (cp = &mydata[i-1]; cp >= mydata; cp--)
1435               *cp = p_tbl[*cp] ^ 128;
1436             break;
1437           case 's':                     /* Space */
1438             for (cp = &mydata[i-1]; cp >= mydata; cp--)
1439               *cp &= 127;
1440             break;
1441         }
1442     }
1443     if (pktpaus) msleep(pktpaus);       /* Pause if requested */
1444     x = 0;
1445
1446     if (npad) {
1447 #ifdef STREAMING
1448         if (dontsend)
1449           x = 0;
1450         else
1451 #endif /* STREAMING */
1452           x = ttol(padbuf,npad);        /* Send any padding */
1453     }
1454     if (x > -1) {
1455 #ifdef CK_TIMERS
1456         if (timint > 0) {
1457             if (pkttyp == 'N')
1458               srttbl[n > 0 ? n-1 : 63] = gtimer();
1459             else
1460               srttbl[n] = gtimer();
1461         }
1462 #endif /* CK_TIMERS */
1463         spktl = i;                      /* Remember packet length */
1464         if (k > -1)
1465           s_pkt[k].pk_len = spktl;      /* also in packet info structure */
1466
1467 #ifdef DEBUG
1468 #ifdef GFTIMER
1469 /*
1470   This code shows (in the debug log) how long it takes write() to execute.
1471   Sometimes on a congested TCP connection, it can surprise you -- 90 seconds
1472   or more...
1473 */
1474         if (
1475 #ifdef STREAMING
1476             !dontsend &&
1477 #endif /* STREAMING */
1478             deblog
1479             )
1480           t1 = gftimer();
1481 #endif /* GFTIMER */
1482 #endif /* DEBUG */
1483
1484 #ifdef STREAMING
1485         if (dontsend) {
1486             debug(F000,"STREAMING spack skipping","",pkttyp);
1487             x = 0;
1488         } else
1489 #endif /* STREAMING */
1490         x = ttol(mydata,spktl);         /* Send the packet */
1491     }
1492 #ifdef STREAMING
1493     if (!dontsend) {
1494 #endif /* STREAMING */
1495         debug(F101,"spack spktl","",spktl);
1496         debug(F101,"spack ttol returns","",x);
1497         if (x < 0) {                    /* Failed. */
1498             if (local && x < -1) {
1499                 xxscreen(SCR_ST,ST_ERR,0L,"FAILED: Connection lost");
1500                 /* We can't send an E packet because the connection is lost. */
1501                 epktsent = 1;           /* So pretend we sent one. */
1502                 fatalio = 1;            /* Remember we got a fatal i/o error */
1503                 dologend();
1504                 ckstrncpy((char *)epktmsg,"Connection lost",PKTMSGLEN);
1505             }
1506             return(x);
1507         }
1508         if (spktl > maxsend)            /* Keep track of longest packet sent */
1509           maxsend = spktl;
1510 #ifdef DEBUG
1511 #ifdef GFTIMER
1512         if (deblog)  {                  /* Log elapsed time for write() */
1513             t2 = gftimer();
1514             debug(F101,"spack ttol msec","",(long)((t2-t1)*1000.0));
1515         }
1516 #endif /* GFTIMER */
1517 #endif /* DEBUG */
1518 #ifdef STREAMING
1519     }
1520 #endif /* STREAMING */
1521
1522     sndtyp = pkttyp;                    /* Remember packet type for echos */
1523 #ifdef STREAMING
1524     if (!dontsend) {                    /* If really sent, */
1525         spackets++;                     /* count it. */
1526         flco += spktl;                  /* Count the characters */
1527         tlco += spktl;                  /* for statistics... */
1528 #ifdef DEBUG
1529         if (deblog) {                   /* Save two function calls! */
1530             dumpsbuf();                 /* Dump send buffers to debug log */
1531             debug(F111,"spack calling screen, mydata=",mydata,n);
1532         }
1533 #endif /* DEBUG */
1534     }
1535 #endif /* STREAMING */
1536     if (local) {
1537         int x = 0;
1538         if (fdispla != XYFD_N) x = 1;
1539         if ((fdispla == XYFD_B) && (pkttyp == 'D' || pkttyp == 'Y')) x = 0;
1540         if (x)
1541           xxscreen(SCR_PT,pkttyp,(long)n,(char *)mydata); /* Update screen */
1542     }
1543     return(spktl);                      /* Return length */
1544 }
1545
1546 /*  C H K 1  --  Compute a type-1 Kermit 6-bit checksum.  */
1547
1548 int
1549 chk1(pkt,len) register CHAR *pkt; register int len; {
1550     register unsigned int chk;
1551 #ifdef CKTUNING
1552 #ifdef COMMENT
1553     register unsigned int m;            /* Avoid function call */
1554     m = (parity) ? 0177 : 0377;
1555     for (chk = 0; len-- > 0; pkt++)
1556       chk += *pkt & m;
1557 #else
1558     chk = 0;
1559     while (len-- > 0) chk += (unsigned) *pkt++;
1560 #endif /* COMMENT */
1561 #else
1562     chk = chk2(pkt,len);
1563 #endif /* CKTUNING */
1564     chk = (((chk & 0300) >> 6) + chk) & 077;
1565     debug(F101,"chk1","",chk);
1566     return((int) chk);
1567 }
1568
1569 /*  C H K 2  --  Compute the numeric sum of all the bytes in the packet.  */
1570
1571 unsigned int
1572 chk2(pkt,len) register CHAR *pkt; register int len; {
1573     register long chk;
1574 #ifdef COMMENT
1575     register unsigned int m;
1576     m = (parity) ? 0177 : 0377;
1577     for (chk = 0; len-- > 0; pkt++)
1578       chk += *pkt & m;
1579 #else
1580     /* Parity has already been stripped */
1581     chk = 0L;
1582     while (len-- > 0) chk += (unsigned) *pkt++;
1583 #endif /* COMMENT */
1584     debug(F101,"chk2","",(unsigned int) (chk & 07777));
1585     return((unsigned int) (chk & 07777));
1586 }
1587
1588 /*  C H K 3  --  Compute a type-3 Kermit block check.  */
1589 /*
1590  Calculate the 16-bit CRC-CCITT of a null-terminated string using a lookup
1591  table.  Assumes the argument string contains no embedded nulls.
1592 */
1593 #ifdef COMMENT
1594 unsigned int
1595 chk3(pkt,parity,len) register CHAR *pkt; int parity; register int len; {
1596     register long c, crc;
1597     register unsigned int m;
1598     m = (parity) ? 0177 : 0377;
1599     for (crc = 0; len-- > 0; pkt++) {
1600         c = crc ^ (long)(*pkt & m);
1601         crc = (crc >> 8) ^ (crcta[(c & 0xF0) >> 4] ^ crctb[c & 0x0F]);
1602     }
1603     return((unsigned int) (crc & 0xFFFF));
1604 }
1605 #else
1606 unsigned int
1607 chk3(pkt,len) register CHAR *pkt; register int len; {
1608     register long c, crc;
1609     for (crc = 0; len-- > 0; pkt++) {
1610         c = crc ^ (long)(*pkt);
1611         crc = (crc >> 8) ^ (crcta[(c & 0xF0) >> 4] ^ crctb[c & 0x0F]);
1612     }
1613     debug(F101,"chk3","",(unsigned int) (crc & 0xFFFF));
1614     return((unsigned int) (crc & 0xFFFF));
1615 }
1616 #endif /* COMMENT */
1617
1618 /*  N X T P K T  --  Next Packet  */
1619 /*
1620   Get packet number of next packet to send and allocate a buffer for it.
1621   Returns:
1622     0 on success, with global pktnum set to the packet number;
1623    -1 on failure to allocate buffer (fatal);
1624    -2 if resulting packet number is outside the current window.
1625 */
1626 int
1627 nxtpkt() {                              /* Called by file sender */
1628     int j, n, x;
1629
1630     debug(F101,"nxtpkt pktnum","",pktnum);
1631     debug(F101,"nxtpkt winlo ","",winlo);
1632     n = (pktnum + 1) % 64;              /* Increment packet number mod 64 */
1633     debug(F101,"nxtpkt n","",n);
1634 #ifdef STREAMING
1635     if (!streaming) {
1636         x = chkwin(n,winlo,wslots);     /* Don't exceed window boundary */
1637         debug(F101,"nxtpkt chkwin","",x);
1638         if (x)
1639           return(-2);
1640         j = getsbuf(n);                 /* Get a buffer for packet n */
1641         if (j < 0) {
1642             debug(F101,"nxtpkt getsbuf failure","",j);
1643             return(-1);
1644         }
1645     }
1646 #endif /* STREAMING */
1647     pktnum = n;
1648     return(0);
1649 }
1650
1651 /* Functions for sending ACKs and NAKs */
1652
1653 /* Note, we should only ACK the packet at window-low (winlo) */
1654 /* However, if an old packet arrives again (e.g. because the ACK we sent */
1655 /* earlier was lost), we ACK it again. */
1656
1657 int
1658 ack() {                                 /* Acknowledge the current packet. */
1659     return(ackns(winlo,(CHAR *)""));
1660 }
1661
1662 #ifdef STREAMING
1663 int
1664 fastack() {                             /* Acknowledge packet n */
1665     int j, k, n, x;
1666     n = winlo;
1667
1668     k = rseqtbl[n];                     /* First find received packet n. */
1669     debug(F101,"STREAMING fastack k","",k);
1670     freesbuf(n);                        /* Free current send-buffer, if any */
1671     if ((j = getsbuf(n)) < 0) {
1672         /* This can happen if we have to re-ACK an old packet that has */
1673         /* already left the window.  It does no harm. */
1674         debug(F101,"STREAMING fastack can't getsbuf","",n);
1675     }
1676     dontsend = 1;
1677     x = spack('Y',n,0,(CHAR *)"");      /* Now send it (but not really) */
1678     dontsend = 0;
1679     if (x < 0) return(x);
1680     debug(F101,"STREAMING fastack x","",x);
1681     if (k > -1)
1682       freerbuf(k);                      /* don't need it any more */
1683     if (j > -1)
1684       freesbuf(j);                      /* and don't need to keep ACK either */
1685     winlo = (winlo + 1) % 64;
1686     return(0);
1687 }
1688 #endif /* STREAMING */
1689
1690 int
1691 ackns(n,s) int n; CHAR *s; {            /* Acknowledge packet n */
1692     int j, k, x;
1693     debug(F111,"ackns",s,n);
1694
1695     k = rseqtbl[n];                     /* First find received packet n. */
1696     debug(F101,"ackns k","",k);
1697     freesbuf(n);                        /* Free current send-buffer, if any */
1698     if ((j = getsbuf(n)) < 0) {
1699         /* This can happen if we have to re-ACK an old packet that has */
1700         /* already left the window.  It does no harm. */
1701         debug(F101,"ackns can't getsbuf","",n);
1702     }
1703     x = spack('Y',n,(int)strlen((char *)s),s); /* Now send it. */
1704     if (x < 0) return(x);
1705     debug(F101,"ackns winlo","",winlo);
1706     debug(F101,"ackns n","",n);
1707     if (n == winlo) {                   /* If we're acking winlo */
1708         if (k > -1)
1709           freerbuf(k);                  /* don't need it any more */
1710         if (j > -1)
1711           freesbuf(j);                  /* and don't need to keep ACK either */
1712         winlo = (winlo + 1) % 64;
1713     }
1714     return(0);
1715 }
1716
1717 int
1718 ackn(n) int n; {                        /* Send ACK for packet number n */
1719     return(ackns(n,(CHAR *)""));
1720 }
1721
1722 int
1723 ack1(s) CHAR *s; {                      /* Send an ACK with data. */
1724     if (!s) s = (CHAR *)"";
1725     debug(F110,"ack1",(char *)s,0);
1726     return(ackns(winlo,s));
1727 }
1728
1729 /* N A C K  --   Send a Negative ACKnowledgment. */
1730 /*
1731  Call with the packet number, n, to be NAK'd.
1732  Returns -1 if that packet has been NAK'd too many times, otherwise 0.
1733  Btw, it is not right to return 0 under error conditions.  This is
1734  done because the -1 code is used for cancelling the file transfer.
1735  More work is needed here.
1736 */
1737 int
1738 nack(n) int n; {
1739     int i, x;
1740
1741     if (n < 0 || n > 63) {
1742         debug(F101,"nack bad pkt num","",n);
1743         return(0);
1744     } else debug(F101,"nack","",n);
1745     if ((i = sseqtbl[n]) < 0) {         /* If necessary */
1746         if (getsbuf(n) < 0) {           /* get a buffer for this NAK */
1747             debug(F101,"nack can't getsbuf","",n);
1748             return(0);
1749         } else i = sseqtbl[n];          /* New slot number */
1750     }
1751     if (maxtry > 0 && s_pkt[i].pk_rtr++ > maxtry) /* How many? */
1752       return(-1);                       /* Too many... */
1753
1754 /* Note, don't free this buffer.  Eventually an ACK will come, and that */
1755 /* will set it free.  If not, well, it's back to ground zero anyway...  */
1756
1757     x = spack('N',n,0,(CHAR *) "");     /* NAKs never have data. */
1758     return(x);
1759 }
1760
1761 #ifndef NEWDPL                          /* This routine no longer used */
1762 /*
1763  * (PWP) recalculate the optimal packet length in the face of errors.
1764  * This is a modified version of the algorithm by John Chandler in Kermit/370,
1765  * see "Dynamic Packet Size Control", Kermit News, V2 #1, June 1988.
1766  *
1767  * This implementation minimizes the total overhead equation, which is
1768  *
1769  *   Total chars = file_chars + (header_len * num_packs)
1770  *                            + (errors * (header_len + packet_len))
1771  *
1772  * Differentiate with respect to number of chars, solve for packet_len, get:
1773  *
1774  *   packet_len = sqrt (file_chars * header_len / errors)
1775  */
1776
1777 /*
1778  (FDC) New super-simple algorithm.  If there was an error in the most recent
1779  packet exchange, cut the send-packet size in half, down to a minimum of 20.
1780  If there was no error, increase the size by 5/4, up to the maximum negotiated
1781  length.  Seems to be much more responsive than previous algorithm, which took
1782  forever to recover the original packet length, and it also went crazy under
1783  certain conditions.
1784
1785  Here's another idea for packet length resizing that keeps a history of the
1786  last n packets.  Push a 1 into the left end of an n-bit shift register if the
1787  current packet is good, otherwise push a zero.  The current n-bit value, w, of
1788  this register is a weighted sum of the noise hits for the last n packets, with
1789  the most recent weighing the most.  The current packet length is some function
1790  of w and the negotiated packet length, like:
1791
1792    (2^n - w) / (2^n) * (negotiated length)
1793
1794  If the present resizing method causes problems, think about this one a little
1795  more.
1796 */
1797 VOID
1798 rcalcpsz() {
1799
1800 #ifdef COMMENT
1801 /* Old way */
1802     register long x, q;
1803     if (numerrs == 0) return;           /* bounds check just in case */
1804
1805     /* overhead on a data packet is npad+5+bctr, plus 3 if extended packet */
1806     /* an ACK is 5+bctr */
1807
1808     /* first set x = per packet overhead */
1809     if (wslots > 1)                     /* Sliding windows */
1810       x = (long) (npad+5+bctr);         /* packet only, don't count ack */
1811     else                                /* Stop-n-wait */
1812       x = (long) (npad+5+3+bctr+5+bctr); /* count packet and ack. */
1813
1814     /* then set x = packet length ** 2 */
1815     x = x * ( ffc / (long) numerrs);    /* careful of overflow */
1816
1817     /* calculate the long integer sqrt(x) quickly */
1818     q = 500;
1819     q = (q + x/q) >> 1;
1820     q = (q + x/q) >> 1;
1821     q = (q + x/q) >> 1;
1822     q = (q + x/q) >> 1;         /* should converge in about 4 steps */
1823     if ((q > 94) && (q < 130))  /* break-even point for long packets */
1824       q = 94;
1825     if (q > spmax) q = spmax;   /* maximum bounds */
1826     if (q < 10) q = 10;         /* minimum bounds */
1827     spsiz = q;                  /* set new send packet size */
1828     debug(F101,"rcalcpsiz","",q);
1829 #else
1830 /* New way */
1831     debug(F101,"rcalcpsiz numerrs","",numerrs);
1832     debug(F101,"rcalcpsiz spsiz","",spsiz);
1833     if (spackets < 3) {
1834         numerrs = 0;
1835         return;
1836     }
1837     if (numerrs)
1838       spsiz = spsiz / 2;
1839     else
1840       spsiz = (spsiz / 4) * 5;
1841     if (spsiz < 20) spsiz = 20;
1842     if (spsiz > spmax) spsiz = spmax;
1843     debug(F101,"rcalcpsiz new spsiz","",spsiz);
1844     numerrs = 0;
1845 #endif /* COMMENT */
1846 }
1847 #endif /* NEWDPL */
1848
1849 /*  R E S E N D  --  Retransmit packet n.  */
1850
1851 /*
1852   Returns 0 or positive on success (the number of retries for packet n).
1853   On failure, returns a negative number, and an error message is placed
1854   in recpkt.
1855 */
1856 int
1857 resend(n) int n; {                      /* Send packet n again. */
1858     int j, k, x;
1859 #ifdef GFTIMER
1860     CKFLOAT t1 = 0.0, t2 = 0.0;
1861 #endif /* GFTIMER */
1862
1863     debug(F101,"resend seq","",n);
1864
1865     k = chkwin(n,winlo,wslots);         /* See if packet in current window */
1866     j = -1;                             /* Assume it's lost */
1867     if (k == 0) j = sseqtbl[n];         /* See if we still have a copy of it */
1868     if (k != 0 || j < 0) {              /* If not.... */
1869         if (nakstate && k == 1) {
1870 /*
1871   Packet n is in the previous window and we are the file receiver.
1872   We already sent the ACK and deallocated its buffer so we can't just
1873   retransmit the ACK.  Rather than give up, we try some tricks...
1874 */
1875             if (n == 0 && spackets < 63 && myinit[0]) { /* ACK to Send-Init */
1876 /*
1877   If the packet number is 0, and we're at the beginning of a protocol
1878   operation (spackets < 63), then we have to resend the ACK to an I or S
1879   packet, complete with parameters in the data field.  So we take a chance and
1880   send a copy of the parameters in an ACK packet with block check type 1.
1881 */
1882                 int bctlsav;            /* Temporary storage */
1883                 int bctusav;
1884                 bctlsav = bctl;         /* Save current block check length */
1885                 bctusav = bctu;         /* and type */
1886                 bctu = bctl = 1;        /* Set block check to 1 */
1887                 x = spack('Y',0,(int)strlen((char *)myinit),(CHAR *)myinit);
1888                 if (x < 0) return(x);
1889                 logpkt('#',n,(CHAR *)"<reconstructed>",0); /* Log it */
1890                 bctu = bctusav;         /* Restore block check type */
1891                 bctl = bctlsav;         /* and length */
1892
1893             } else {                    /* Not the first packet */
1894 /*
1895   It's not the first packet of the protocol operation.  It's some other packet
1896   that we have already ACK'd and forgotten about.  So we take a chance and
1897   send an empty ACK using the current block-check type.  Usually this will
1898   work out OK (like when acking Data packets), and no great harm will be done
1899   if it was some other kind of packet (F, etc).  If we are requesting an
1900   interruption of the file transfer, the flags are still set, so we'll catch
1901   up on the next packet.
1902 */
1903                 x = spack('Y',n,0,(CHAR *) "");
1904                 if (x < 0) return(x);
1905             }
1906             retrans++;
1907             xxscreen(SCR_PT,'%',(long)pktnum,"Retransmission");
1908             return(0);
1909         } else {
1910 /*
1911   Packet number is not in current or previous window.  We seem to hit this
1912   code occasionally at the beginning of a transaction, for apparently no good
1913   reason.  Let's just log it for debugging, send nothing, and try to proceed
1914   with the protocol rather than killing it.
1915 */
1916             debug(F101,"resend PKT NOT IN WINDOW","",n);
1917             debug(F101,"resend k","",k);
1918             return(0);
1919         }
1920     }
1921
1922 /* OK, it's in the window and it's not lost. */
1923
1924     debug(F101,"resend pktinfo index","",k);
1925
1926     if (maxtry > 0 && s_pkt[j].pk_rtr++ > maxtry) { /* Over retry limit */
1927         xitsta |= what;
1928         return(-1);
1929     }
1930     debug(F101,"resend retry","",s_pkt[j].pk_rtr); /* OK so far */
1931     dumpsbuf();                         /* (debugging) */
1932     if (s_pkt[j].pk_typ == ' ') {       /* Incompletely formed packet */
1933         if (nakstate) {                 /* (This shouldn't happen any more) */
1934             nack(n);
1935             retrans++;
1936             xxscreen(SCR_PT,'%',(long)pktnum,"(resend)");
1937             return(s_pkt[j].pk_rtr);
1938         } else {                        /* No packet to resend! */
1939 #ifdef COMMENT
1940 /*
1941   This happened (once) while sending a file with 2 window slots and typing
1942   X to the sender to cancel the file.  But since we're cancelling anyway,
1943   there's no need to give a scary message.
1944 */
1945             sprintf((char *)epktmsg,
1946                     "resend logic error: NPS, n=%d, j=%d.",n,j);
1947             return(-2);
1948 #else
1949 /* Just ignore it. */
1950             return(0);
1951 #endif /* COMMENT */
1952         }
1953     }
1954 #ifdef DEBUG
1955 #ifdef GFTIMER
1956     if (deblog) t1 = gftimer();
1957 #endif /* GFTIMER */
1958 #endif /* DEBUG */
1959
1960     /* Everything ok, send the packet */
1961 #ifdef CK_TIMERS
1962     if (timint > 0)
1963       srttbl[n] = gtimer();             /* Update the timer */
1964 #endif /* CK_TIMERS */
1965     x = ttol(s_pkt[j].pk_adr,s_pkt[j].pk_len);
1966
1967 #ifdef DEBUG
1968 #ifdef GFTIMER
1969     if (deblog)  {
1970         t2 = gftimer();
1971         debug(F101,"resend ttol msec","",(long)((t2-t1)*1000.0));
1972     }
1973 #endif /* GFTIMER */
1974 #endif /* DEBUG */
1975     debug(F101,"resend ttol returns","",x);
1976
1977     retrans++;                          /* Count a retransmission */
1978     xxscreen(SCR_PT,'%',(long)pktnum,"(resend)"); /* Tell user about resend */
1979     logpkt('S',n,s_pkt[j].pk_adr, s_pkt[j].pk_len); /* Log the resent packet */
1980     return(s_pkt[j].pk_rtr);            /* Return the number of retries. */
1981 }
1982
1983 /*  E R R P K T  --  Send an Error Packet  */
1984
1985 int
1986 errpkt(reason) CHAR *reason; {          /* ...containing the reason given */
1987     extern int rtimo, state, justone;
1988     int x, y;
1989     czseen = 1;                         /* Also cancels batch */
1990     state = 0;                          /* Reset protocol state */
1991     debug(F110,"errpkt",reason,0);
1992     tlog(F110,"Protocol Error:",(char *)reason,0L);
1993     xxscreen(SCR_EM,0,0L,reason);
1994     encstr(reason);
1995     x = spack('E',pktnum,size,data);
1996     ckstrncpy((char *)epktmsg,(char *)reason,PKTMSGLEN);
1997     y = quiet; quiet = 1; epktsent = 1; /* Close files silently. */
1998     clsif(); clsof(1);
1999     quiet = y;
2000 /*
2001   I just sent an E-packet.  I'm in local mode, I was receiving a file,
2002   I'm not a server, and sliding windows are in use.  Therefore, there are
2003   likely to be a bunch of packets already "in the pipe" on their way to me
2004   by the time the remote sender gets the E-packet.  So the next time I
2005   CONNECT or try to start another protocol operation, I am likely to become
2006   terribly confused by torrents of incoming material.  To prevent this,
2007   the following code soaks up packets from the connection until there is an
2008   error or timeout, without wasting too much time waiting.
2009
2010   Exactly the same problem occurs when I am in remote mode or if I am
2011   in server mode with the justone flag set.  In remote mode not only
2012   does the packet data potentially get echo'd back to the sender which
2013   is confusing to the user in CONNECT mode, but it also may result in the
2014   host performing bizarre actions such as suspending the process if ^Z is
2015   unprefixed, etc.
2016
2017   Furthermore, thousands of packets bytes in the data stream prevent the
2018   client from being able to process Telnet Kermit Option negotiations
2019   properly.
2020 */
2021 #ifdef STREAMING
2022     /* Because streaming sets the timeout to 0... */
2023     if (streaming) {
2024         timint = rcvtimo = rtimo;
2025         streaming = 0;
2026     }
2027 #endif /* STREAMING */
2028     if (what & W_RECV &&
2029         (!server || (server && justone)) &&
2030         (wslots > 1
2031 #ifdef STREAMING
2032          || streaming
2033 #endif /* STREAMING */
2034          )) {
2035 #ifdef GFTIMER
2036         CKFLOAT oldsec, sec = (CKFLOAT) 0.0;
2037 #else
2038         int oldsec, sec = 0;
2039 #endif /* GFTIMER */
2040         debug(F101,"errpkt draining","",wslots);
2041         xxscreen(SCR_ST,ST_MSG,0l,"Draining incoming packets, wait...");
2042         while (x > -1) {                /* Don't bother if no connection */
2043             oldsec = sec;
2044 #ifdef GFTIMER
2045             sec = gftimer();
2046             if (oldsec != (CKFLOAT) 0.0)
2047               timint = rcvtimo = (int) (sec - oldsec + 0.5);
2048 #else
2049             sec = gtimer();
2050             if (oldsec != 0)
2051               timint = rcvtimo = sec - oldsec + 1;
2052 #endif /* GFTIMER */
2053             if (timint < 1)
2054               timint = rcvtimo = 1;
2055             msleep(50);                 /* Allow a bit of slop */
2056             x = rpack();                /* Read a packet */
2057             if (x == 'T' || x == 'z')   /* Timed out means we're done */
2058               break;
2059             xxscreen(SCR_PT,x,rsn,"");  /* Let user know */
2060         }
2061         xxscreen(SCR_ST,ST_MSG,0l,"Drain complete.");
2062     }
2063     if ((x = (what & W_KERMIT)))
2064       xitsta |= x;                      /* Remember what failed. */
2065     success = 0;
2066     return(y);
2067 }
2068
2069 /* scmd()  --  Send a packet of the given type */
2070
2071 int
2072 #ifdef CK_ANSIC
2073 scmd(char t, CHAR *dat)
2074 #else
2075 scmd(t,dat) char t; CHAR *dat;
2076 #endif /* CK_ANSIC */
2077 /* scmd */ {
2078     int x;
2079     extern char * srimsg;
2080     debug(F000,"scmd",dat,t);
2081     if (encstr(dat) < 0) {              /* Encode the command string */
2082         srimsg = "String too long";
2083         return(-1);
2084     }
2085     x = spack(t,pktnum,size,data);
2086     debug(F101,"scmd spack","",x);
2087     return(x);
2088 }
2089
2090 /* Compose and Send GET packet */
2091
2092 struct opktparm {                       /* O-Packet item list */
2093     CHAR * opktitem;
2094     struct opktparm * opktnext;
2095 };
2096
2097 struct opktparm * opkthead = NULL;      /* Linked list of O-packet fields */
2098 int opktcnt = 0;                        /* O-Packet counter */
2099 char * srimsg = NULL;                   /* GET-Packet error message */
2100
2101 /* S O P K T  --  Send O-Packet */
2102 /*
2103   Sends one O-Packet each time called, using first-fit method of filling
2104   the packet from linked list of parameters pointed to by opkthead.
2105   To be called repeatedly until list is empty or there is an error.
2106   Returns:
2107    -1 on failure.
2108     0 on success and no more fields left to send.
2109     1 on success but with more fields left to be sent.
2110 */
2111
2112 int
2113 sopkt() {
2114     int n = 0;                          /* Field number in this packet */
2115     int rc = 0;                         /* Return code */
2116     int len = 0;                        /* Data field length */
2117     char c = NUL;
2118     struct opktparm * o = NULL;
2119     struct opktparm * t = NULL;
2120     struct opktparm * prev = NULL;
2121     CHAR * dsave = data;
2122     int x, ssave = spsiz;
2123
2124     srimsg = NULL;                      /* Error message */
2125     o = opkthead;                       /* Point to head of list */
2126     if (!o) {                           /* Oops, no list... */
2127         srimsg = "GET Packet Internal Error 1";
2128         debug(F100,"sopkt NULL list","",0);
2129         return(-1);
2130     }
2131     while (o) {                         /* Go thru linked list... */
2132         c = *(o->opktitem);             /* Parameter code */
2133         debug(F000,"sopkt",o->opktitem,c);
2134         x = encstr((CHAR *)o->opktitem);
2135         debug(F111,"sopkt encstr",dsave,x);
2136         if (x < 0) {                    /* Encode this item */
2137             if (n == 0) {               /* Failure, first field in packet */
2138                 debug(F100,"sopkt overflow","",0);
2139                 spsiz = ssave;          /* Restore these */
2140                 data = dsave;
2141                 o = opkthead;           /* Free linked list */
2142                 while (o) {
2143                     if (o->opktitem) free(o->opktitem);
2144                     t = o->opktnext;
2145                     free((char *)o);
2146                     o = t;
2147                 }
2148                 opkthead = NULL;
2149                 srimsg = "GET Packet Too Long for Server";
2150                 return(-1);             /* Fail */
2151             } else {                    /* Not first field in packet */
2152                 debug(F110,"sopkt leftover",o->opktitem,0);
2153                 prev = o;               /* Make this one the new previous */
2154                 o = o->opktnext;        /* Get next */
2155                 c = NUL;                /* So we know we're not done */
2156                 *data = NUL;            /* Erase any partial encoding */
2157                 continue;               /* We can try this one again later */
2158             }
2159         }
2160         n++;                            /* Encoding was successful */
2161         debug(F111,"sopkt field",data,x);
2162         len += x;                       /* Total data field length */
2163         data += x;                      /* Set up for next field... */
2164         spsiz -= x;
2165         free(o->opktitem);              /* Free item just encoded */
2166         if (o == opkthead) {            /* If head */
2167             opkthead = o->opktnext;     /* Move head to next */
2168             free((char *)o);            /* Free this list node */
2169             o = opkthead;
2170         } else {                        /* If not head */
2171             o = o->opktnext;            /* Get next */
2172             prev->opktnext = o;         /* Link previous to next */
2173         }
2174         if (c == '@')                   /* Loop exit */
2175           break;
2176         if (!o && !opkthead) {          /* Set up End Of Parameters Field */
2177             o = (struct opktparm *)malloc(sizeof(struct opktparm));
2178             if (o) {
2179                 opkthead = o;
2180                 if (!(o->opktitem = (CHAR *)malloc(3))) {
2181                     free((char *)o);
2182                     srimsg = "GET Packet Internal Error 8";
2183                     return(-1);
2184                 }
2185                 ckstrncpy((char *)(o->opktitem), "@ ", 3);
2186                 debug(F111,"sopkt o->opktitem",o->opktitem,
2187                       strlen((char *)(o->opktitem)));
2188                 o->opktnext = NULL;
2189             }
2190         }
2191     }
2192     data = dsave;                       /* Restore globals */
2193     spsiz = ssave;
2194     debug(F110,"sopkt data",data,0);
2195     debug(F101,"sopkt opktcnt","",opktcnt);
2196     if (opktcnt++ > 0) {
2197         if (nxtpkt() < 0) {             /* Get next packet number and buffer */
2198             srimsg = "GET Packet Internal Error 9";
2199             return(-1);
2200         }
2201     }
2202     debug(F101,"sopkt pktnum","",pktnum);
2203     rc = spack((char)'O',pktnum,len,data); /* Send O-Packet */
2204     debug(F101,"sopkt spack","",rc);
2205     if (rc < 0)                         /* Failed */
2206       srimsg = "Send Packet Failure";   /* Set message */
2207     else                                /* Succeeded */
2208       rc = (c == '@') ? 0 : 1;          /* 1 = come back for more, 0 = done */
2209     debug(F101,"sopkt rc","",rc);
2210     return(rc);
2211 }
2212
2213 /* S R I N I T  --  Send GET packet  */
2214 /*
2215   Sends the appropriate GET-Class packet.
2216   Returns:
2217   -1 on error
2218    0 if packet sent successfully and we can move on to the next state
2219    1 if an O-packet was sent OK but more O packets still need to be sent.
2220 */
2221 int
2222 srinit(reget, retrieve, opkt) int reget, retrieve, opkt; {
2223     int x = 0, left = 0;
2224     extern int oopts, omode;
2225     CHAR * p = NULL;
2226 #ifdef RECURSIVE
2227     extern int recursive;
2228     debug(F101,"srinit recursive","",recursive);
2229 #endif /* RECURSIVE */
2230     debug(F101,"srinit reget","",reget);
2231     debug(F101,"srinit retrieve","",retrieve);
2232     debug(F101,"srinit opkt","",opkt);
2233     debug(F101,"srinit oopts","",oopts);
2234     debug(F101,"srinit omode","",omode);
2235     debug(F110,"srinit cmarg",cmarg,0);
2236     srimsg = NULL;
2237
2238     opktcnt = 0;
2239     if (!cmarg) cmarg = "";
2240     if (!*cmarg) {
2241         srimsg = "GET with no filename";
2242         debug(F100,"srinit null cmarg","",0);
2243         return(-1);
2244     }
2245     if (opkt) {                         /* Extended GET is totally different */
2246         char buf[16];
2247         struct opktparm * o = NULL;
2248         struct opktparm * prev = NULL;
2249
2250         buf[0] = NUL;
2251
2252         /* Build O-Packet fields and send (perhaps first) O-Packet */
2253
2254         if (oopts > -1) {               /* Write Option flags */
2255             o = (struct opktparm *)malloc(sizeof(struct opktparm));
2256             if (!o) {
2257                 srimsg = "GET Packet Internal Error 2";
2258                 debug(F100,"srinit malloc fail O1","",0);
2259                 return(-1);
2260             }
2261             sprintf(buf,"Ox%d",oopts);  /* safe */
2262             x = (int) strlen(buf+2);
2263             buf[1] = tochar(x);
2264             o->opktitem = (CHAR *)malloc(x + 3);
2265             if (!o->opktitem) {
2266                 srimsg = "GET Packet Internal Error 3";
2267                 debug(F100,"srinit malloc fail O2","",0);
2268                 return(-1);
2269             }
2270             ckstrncpy((char *)(o->opktitem),buf,x+3);
2271             o->opktnext = NULL;
2272             if (!opkthead)
2273               opkthead = o;
2274             prev = o;
2275         }
2276         if (omode > -1) {               /* If Xfer Mode specified, write it */
2277             o = (struct opktparm *)malloc(sizeof(struct opktparm));
2278             if (!o) {
2279                 srimsg = "GET Packet Internal Error 4";
2280                 debug(F100,"srinit malloc fail M1","",0);
2281                 return(-1);
2282             }
2283             sprintf(buf,"Mx%d",omode);  /* safe */
2284             x = (int) strlen(buf+2);
2285             buf[1] = tochar(x);
2286             o->opktitem = (CHAR *)malloc(x + 3);
2287             if (!o->opktitem) {
2288                 srimsg = "GET Packet Internal Error 5";
2289                 debug(F100,"srinit malloc fail O2","",0);
2290                 return(-1);
2291             }
2292             ckstrncpy((char *)(o->opktitem),buf,x+3);
2293             o->opktnext = NULL;
2294             if (!opkthead)
2295               opkthead = o;
2296             else
2297               prev->opktnext = o;
2298             prev = o;
2299         }
2300
2301         /* Same deal for oname and opath eventually but not needed now... */
2302
2303         x = strlen(cmarg);              /* Now do filename */
2304         if (x > spsiz - 4) {
2305             srimsg = "GET Packet Too Long for Server";
2306             return(-1);
2307         }
2308         o = (struct opktparm *)malloc(sizeof(struct opktparm));
2309         if (!o) {
2310             srimsg = "GET Packet Internal Error 6";
2311             debug(F100,"srinit malloc fail F1","",0);
2312             return(-1);
2313         }
2314         left = x + 6;
2315         o->opktitem = (CHAR *)malloc(left + 1);
2316         if (!o->opktitem) {
2317             srimsg = "GET Packet Internal Error 7";
2318             debug(F100,"srinit malloc fail F2","",0);
2319             return(-1);
2320         }
2321         p = o->opktitem;
2322         *p++ = 'F';
2323         left--;
2324         if (x > 94) {                   /* Too long for normal length */
2325             *p++ = SYN;                 /* Escape length with Ctrl-V */
2326             *p++ = tochar(x / 95);
2327             *p++ = tochar(x % 95);
2328             left -= 3;
2329         } else {                        /* Normal encoding for 94 or less */
2330             *p++ = tochar(x);
2331             left--;
2332         }
2333         ckstrncpy((char *)p,cmarg,left); /* Copy the filename */
2334         o->opktnext = NULL;
2335         if (!opkthead)
2336           opkthead = o;
2337         else
2338           prev->opktnext = o;
2339         prev = o;
2340
2341         /* End of Parameters */
2342
2343         prev->opktnext = NULL;          /* End of list. */
2344         return(sopkt());
2345     }
2346
2347     /* Not Extended GET */
2348
2349     if (encstr((CHAR *)cmarg) < 0) {    /* Encode the filename. */
2350         srimsg = "GET Packet Too Long for Server";
2351         return(-1);
2352     }
2353     if (retrieve) {                     /* Send the packet. */
2354 #ifdef RECURSIVE
2355         if (recursive)
2356           x = spack((char)'W',pktnum,size,data); /* GET /DELETE /RECURSIVE */
2357         else
2358 #endif /* RECURSIVE */
2359           x = spack((char)'H',pktnum,size,data); /* GET /DELETE */
2360     }
2361 #ifdef RECURSIVE
2362     else if (recursive)
2363       x = spack((char)'V',pktnum,size,data); /* GET /RECURSIVE */
2364 #endif /* RECURSIVE */
2365     else
2366       x = spack((char)(reget ? 'J' : 'R'),pktnum,size,data); /* GET */
2367     if (x < 0)
2368       srimsg = "Send Packet Failure";
2369     return(x < 0 ? x : 0);
2370 }
2371
2372
2373 /*  K S T A R T  --  Checks for a Kermit packet while in terminal mode.  */
2374
2375 /*  (or command mode...)  */
2376
2377 #ifdef CK_AUTODL
2378 int
2379 #ifdef CK_ANSIC
2380 kstart(CHAR ch)
2381 #else
2382 kstart(ch) CHAR ch;
2383 #endif /* CK_ANSIC */
2384 /* kstart */ {
2385     static CHAR * p = NULL;
2386
2387 #ifdef OS2
2388     static CHAR * pk = NULL;
2389 #endif /* OS2 */
2390     ch &= 0177;                         /* Strip 8th bit */
2391
2392     /* Because we're in cooked mode at the command prompt... */
2393
2394     if (ch == LF) {
2395         debug(F110,"kstart","ch == LF",0);
2396         if ((what == W_COMMAND || what == W_INIT || what == W_NOTHING)) {
2397             if (eol == CR) {
2398                 ch = eol;
2399                 debug(F110,"kstart","ch = CR",0);
2400             }
2401         }
2402     }
2403
2404 #ifdef OS2
2405     if (adl_kmode == ADL_STR) {
2406         if (!ch)
2407           return(0);
2408         if (!pk)
2409           pk = adl_kstr;
2410
2411         if (ch == *pk) {
2412             pk++;
2413             if (*pk == '\0') {
2414                 pk = adl_kstr;
2415                 debug(F100, "kstart Kermit Start String","",0);
2416                 return(PROTO_K + 1);
2417             }
2418         } else
2419           pk = adl_kstr;
2420     }
2421 #endif /* OS2 */
2422
2423     if (ch == stchr) {                  /* Start of packet */
2424         kstartactive = 1;
2425         p = ksbuf;
2426         *p = ch;
2427         debug(F101,"kstart SOP","",ch);
2428     } else if (ch == eol) {             /* End of packet */
2429         kstartactive = 0;
2430         if (p) {
2431             debug(F101,"kstart EOL","",ch);
2432             p++;
2433             if (p - ksbuf < 94 ) {
2434                 int rc = 0;
2435                 *p++ = ch;
2436                 *p = NUL;
2437                 rc = chkspkt((char *)ksbuf);
2438                 debug(F111,"kstart EOP chkspkt", ksbuf, rc);
2439                 p = NULL;
2440                 if (!rc) return(0);
2441                 if (rc == 2) rc = -1;
2442                 debug(F111,"kstart ksbuf",ksbuf,rc);
2443                 return(rc);
2444             } else {
2445                 debug(F110,"kstart","p - ksbuf >= 94",0);
2446                 p = NULL;
2447             }
2448         }
2449     } else if (p) {
2450         if (ch < SP)
2451           kstartactive = 0;
2452         p++;
2453         if (p - ksbuf < 94) {
2454             *p = ch;
2455         } else {
2456             p = NULL;
2457             debug(F110,"kstart","p - ksbuf >= 94",0);
2458         }
2459     }
2460     return(0);
2461 }
2462
2463 #ifdef CK_XYZ
2464
2465 /*  Z S T A R T  --  Checks for a ZMODEM packet while in terminal mode.  */
2466
2467 int
2468 #ifdef CK_ANSIC
2469 zstart(CHAR ch)
2470 #else
2471 zstart(ch) CHAR ch;
2472 #endif /* CK_ANSIC */
2473 /* zstart */ {
2474     static CHAR * matchstr = (CHAR *) "\030B00";
2475     /* "rz\r**\030B00000000000000\r\033J\021"; */
2476     static CHAR * p = NULL;
2477     extern int inserver;
2478
2479     if (inserver)
2480       return(0);
2481
2482     if (!ch)
2483       return(0);
2484     if (!p) {
2485 #ifdef OS2
2486         p = adl_zmode == ADL_PACK ? matchstr : adl_zstr;
2487 #else
2488         p = matchstr;
2489 #endif /* OS2 */
2490     }
2491     if (ch == *p) {
2492         p++;
2493         if (*p == '\0') {
2494 #ifdef OS2
2495             if (adl_zmode == ADL_PACK) {
2496                 p = matchstr;
2497                 debug(F100, "zstart Zmodem SOP","",0);
2498             } else {
2499                 p = adl_zstr;
2500                 debug(F100, "zstart Zmodem Start String","",0);
2501             }
2502 #else
2503             p = matchstr;
2504             debug(F100, "zstart Zmodem SOP","",0);
2505 #endif /* OS2 */
2506             return(PROTO_Z + 1);
2507         }
2508     } else {
2509 #ifdef OS2
2510         p = adl_zmode == ADL_PACK ? matchstr : adl_zstr;
2511 #else
2512         p = matchstr;
2513 #endif /* OS2 */
2514     }
2515     return(0);
2516 }
2517 #endif /* CK_XYZ */
2518
2519 #ifndef NOICP
2520 #ifdef CK_APC
2521 /*  A U T O D O W N  */
2522
2523 #ifdef CK_ANSIC
2524 VOID
2525 autodown(int ch)
2526 #else
2527 VOID
2528 autodown(ch) int ch;
2529 #endif /* CK_ANSIC */
2530 /* autodown */ {
2531
2532 /* The Kermit and Zmodem Auto-download calls go here */
2533
2534     extern int justone;                 /* From protocol module */
2535     extern int debses, protocol, apcactive, autodl, inautodl;
2536 #ifdef DCMDBUF
2537     extern char *apcbuf;
2538 #else
2539     extern char apcbuf[];
2540 #endif /* DCMDBUF */
2541 #ifdef OS2
2542     extern int apclength, term_io;
2543 #endif /* OS2 */
2544     int k = 0;
2545
2546     if ((autodl || inautodl
2547 #ifdef IKS_OPTION
2548          || TELOPT_SB(TELOPT_KERMIT).kermit.me_start
2549 #endif /* IKS_OPTION */
2550          ) && !debses) {
2551 #ifdef CK_XYZ
2552 #ifdef XYZ_INTERNAL
2553         extern int p_avail;
2554 #else
2555         int p_avail = 1;
2556 #endif /* XYZ_INTERNAL */
2557         if (p_avail && zstart((CHAR) ch)) {
2558             debug(F100, "Zmodem download","",0);
2559 #ifdef OS2
2560 #ifndef NOTERM
2561             apc_command(APC_LOCAL,"receive /protocol:zmodem");
2562 #endif /* NOTERM */
2563 #else /* OS2 */
2564             ckstrncpy(apcbuf,"receive /protocol:zmodem",APCBUFLEN);
2565             apcactive = APC_LOCAL;
2566 #endif /* OS2 */
2567             return;
2568         }
2569 #endif /* CK_XYZ */
2570
2571         /* First try... */
2572         k = kstart((CHAR) ch);
2573         if (
2574 #ifdef NOSERVER
2575             k > 0
2576 #else /* NOSERVER */
2577             k
2578 #endif /* NOSERVER */
2579             ) {                         /* We saw a valid S or I packet */
2580             if (k < 0) {                /* Stuff RECEIVE into APC buffer */
2581                 justone = 1;
2582                 switch (protocol) {
2583 #ifdef CK_XYZ
2584                   case PROTO_G:
2585                     ckstrncpy(apcbuf,
2586                               "set proto kermit, server, set protocol g",
2587                               APCBUFLEN
2588                               );
2589                     break;
2590                   case PROTO_X:
2591                     ckstrncpy(apcbuf,
2592                               "set proto kermit,server,set proto xmodem",
2593                               APCBUFLEN
2594                               );
2595                     break;
2596                   case PROTO_XC:
2597                     ckstrncpy(apcbuf,
2598                            "set proto kermit,server,set proto xmodem-crc",
2599                               APCBUFLEN
2600                               );
2601                       break;
2602                   case PROTO_Y:
2603                     ckstrncpy(apcbuf,
2604                               "set proto kermit,server, set protocol y",
2605                               APCBUFLEN
2606                               );
2607                     break;
2608                   case PROTO_Z:
2609                     ckstrncpy(apcbuf,
2610                               "set proto kermit,server,set proto zmodem",
2611                               APCBUFLEN
2612                               );
2613                     break;
2614 #endif /* CK_XYZ */
2615                   case PROTO_K:
2616                     ckstrncpy(apcbuf,"server",APCBUFLEN);
2617                     break;
2618                 }
2619             } else {
2620                 justone = 0;
2621                 ckstrncpy(apcbuf,"receive /protocol:kermit",APCBUFLEN);
2622             }
2623 #ifdef OS2
2624 #ifndef NOTERM
2625             apc_command(APC_LOCAL,apcbuf);
2626 #endif /* NOTERM */
2627 #else /* OS2 */
2628             ckstrncpy(apcbuf,"receive /protocol:zmodem",APCBUFLEN);
2629             apcactive = APC_LOCAL;
2630 #endif /* OS2 */
2631             return;
2632         }
2633     }
2634 }
2635 #endif /* CK_APC */
2636 #endif /* NOICP */
2637
2638 /*  C H K S P K T  --  Check if buf contains a valid S or I packet  */
2639
2640 int
2641 chkspkt(buf) char *buf; {
2642     int buflen;
2643     int len = -1;
2644     CHAR chk;
2645     char type = 0;
2646     char *s = buf;
2647
2648     if (!buf) return(0);
2649     buflen = strlen(buf);
2650     if (buflen < 5) return(0);          /* Too short */
2651     if (*s++ != stchr) return(0);       /* SOH */
2652     len = xunchar(*s++);                /* Length */
2653     if (len < 0) return(0);
2654     if (*s++ != SP) return(0);          /* Sequence number */
2655     type = *s++;                        /* Type */
2656     if (type != 'S' && type != 'I')
2657       return(0);
2658     if (buflen < len + 2) return(0);
2659     s += (len - 3);                     /* Position of checksum */
2660     chk = (CHAR) (*s);                  /* Checksum */
2661     *s = NUL;
2662     if (xunchar(chk) != chk1((CHAR *)(buf+1),buflen-2)) /* Check it */
2663       return(0);
2664     *s = chk;
2665     return(type == 'S' ? 1 : 2);
2666 }
2667 #endif /* CK_AUTODL */
2668
2669 /* R P A C K  --  Read a Packet */
2670
2671 /*
2672   rpack reads a packet and returns the packet type, or else Q if the
2673   packet was invalid, or T if a timeout occurred.  Upon successful return,
2674   sets the values of global rsn (received sequence number),  rln (received
2675   data length), and rdatap (pointer to null-terminated data field), and
2676   returns the packet type.  NOTE: This is an inner-loop function so must be
2677   efficient.  Protect function calls by if-tests where possible, e.g.
2678   "if (pktlog) logpkt(...);".
2679 */
2680 int
2681 rpack() {
2682     register int i, j, x, lp;           /* Local variables */
2683 #ifdef CKTUNING
2684     unsigned int chk;
2685 #endif /* CKTUNING */
2686     int k, type, chklen;
2687     unsigned crc;
2688     CHAR pbc[5];                        /* Packet block check */
2689     CHAR *sohp;                         /* Pointer to SOH */
2690     CHAR e;                             /* Packet end character */
2691
2692 #ifdef GFTIMER
2693     CKFLOAT t1 = 0.0, t2 = 0.0;
2694 #endif /* GFTIMER */
2695
2696     debug(F101,"rpack pktnum","",pktnum);
2697
2698 #ifndef OLDCHKINT
2699     if (chkint() < 0)                   /* Check for console interrupts. */
2700       return('z');
2701 #endif /* OLDCHKINT */
2702
2703     k = getrbuf();                      /* Get a new packet input buffer. */
2704     debug(F101,"rpack getrbuf","",k);
2705     if (k < 0) {                        /* Return like this if none free. */
2706         return(-1);
2707     }
2708     recpkt = r_pkt[k].bf_adr;
2709     *recpkt = '\0';                     /* Clear receive buffer. */
2710     sohp = recpkt;                      /* Initialize pointers to it. */
2711     rdatap = recpkt;
2712     rsn = rln = -1;                     /* In case of failure. */
2713     e = (turn) ? turnch : eol;          /* Use any handshake char for eol */
2714
2715 /* Try to get a "line". */
2716
2717 #ifdef CK_AUTODL
2718     debug(F110,"rpack ksbuf",ksbuf,0);
2719     if (ksbuf[0]) {                     /* Kermit packet already */
2720         int x;                          /* collected for us in CONNECT mode */
2721         CHAR *s1 = recpkt, *s2 = ksbuf;
2722         j = 0;
2723         while (*s2) {                   /* Copy and get length */
2724             *s1++ = *s2++;              /* No point optimizing this since */
2725             j++;                        /* it's never more than ~20 chars */
2726         }
2727         *s1 = NUL;
2728 #ifdef PARSENSE
2729         x = parchk(recpkt, stchr, j);   /* Check parity */
2730         debug(F000,"autodownload parity","",parity);
2731         debug(F000,"autodownload parchk","",x);
2732         if (x > -1 && parity != x) {
2733             autopar = 1;
2734             parity = x;
2735         }
2736 #endif /* PARSENSE */
2737         ksbuf[0] = NUL;                 /* Don't do this next time! */
2738
2739     } else {                            /* Normally go read a packet */
2740 #endif /* CK_AUTODL */
2741
2742 #ifdef DEBUG
2743         if (deblog) {
2744             debug(F101,"rpack timint","",timint);
2745             debug(F101,"rpack rcvtimo","",rcvtimo);
2746 #ifdef STREAMING
2747             debug(F101,"rpack streaming","",streaming);
2748 #endif /* STREAMING */
2749 #ifdef GFTIMER
2750             /* Measure how long it takes to read a packet */
2751             t1 = gftimer();
2752 #endif /* GFTIMER */
2753         }
2754 #endif /* DEBUG */
2755
2756 /* JUST IN CASE (otherwise this could clobber streaming) */
2757
2758         if ((timint == 0
2759 #ifdef STREAMING
2760              || streaming
2761 #endif /* STREAMING */
2762              ) && (rcvtimo != 0)) {
2763             debug(F101,"rpack timint 0 || streaming but rcvtimo","",rcvtimo);
2764             rcvtimo = 0;
2765         }
2766
2767 #ifdef PARSENSE
2768 #ifdef UNIX
2769 /*
2770   So far the final turn argument is only for ck[uvdl]tio.c.  Should be added
2771   to the others too.  (turn == handshake character.)
2772 */
2773         j = ttinl(recpkt,r_pkt[k].bf_len - 1,rcvtimo,e,stchr,turn);
2774 #else
2775 #ifdef VMS
2776         j = ttinl(recpkt,r_pkt[k].bf_len - 1,rcvtimo,e,stchr,turn);
2777 #else
2778 #ifdef datageneral
2779         j = ttinl(recpkt,r_pkt[k].bf_len - 1,rcvtimo,e,stchr,turn);
2780 #else
2781 #ifdef STRATUS
2782         j = ttinl(recpkt,r_pkt[k].bf_len - 1,rcvtimo,e,stchr,turn);
2783 #else
2784 #ifdef OS2
2785         j = ttinl(recpkt,r_pkt[k].bf_len - 1,rcvtimo,e,stchr,turn);
2786 #else
2787 #ifdef OSK
2788         j = ttinl(recpkt,r_pkt[k].bf_len - 1,rcvtimo,e,stchr,turn);
2789 #else
2790         j = ttinl(recpkt,r_pkt[k].bf_len - 1,rcvtimo,e,stchr);
2791 #endif /* OSK */
2792 #endif /* OS2 */
2793 #endif /* STRATUS */
2794 #endif /* datageneral */
2795 #endif /* VMS */
2796 #endif /* UNIX */
2797         if (parity != 0 && parity != 's' && ttprty != 0) {
2798             if (parity != ttprty) autopar = 1;
2799             parity = ttprty;
2800         }
2801 #else /* !PARSENSE */
2802         j = ttinl(recpkt,r_pkt[k].bf_len - 1,rcvtimo,e);
2803 #endif /* PARSENSE */
2804
2805 #ifdef DEBUG
2806         if (deblog)  {
2807             debug(F101,"rpack ttinl len","",j);
2808 #ifdef GFTIMER
2809             t2 = gftimer();
2810             debug(F101,"rpack ttinl msec","",(long)((t2-t1)*1000.0));
2811 #endif /* GFTIMER */
2812         }
2813 #endif /* DEBUG */
2814
2815 #ifdef STREAMING
2816     if (streaming && sndtyp == 'D' && j == 0)
2817         return('Y');
2818 #endif /* STREAMING */
2819
2820         if (j < 0) {
2821             /* -1 == timeout, -2 == ^C, -3 == connection lost or fatal i/o */
2822             debug(F101,"rpack: ttinl fails","",j); /* Otherwise, */
2823             freerbuf(k);                /* Free this buffer */
2824             if (j < -1) {               /* Bail out if ^C^C typed. */
2825                 if (j == -2) {
2826                     interrupted = 1;
2827                     debug(F101,"rpack ^C server","",server);
2828                     debug(F101,"rpack ^C en_fin","",en_fin);
2829                 } else if (j == -3) {
2830                     fatalio = 1;
2831                     debug(F101,"rpack fatalio","",en_fin);
2832                 }
2833                 return(j);
2834             }
2835             if (nakstate)               /* j == -1 is a read timeout */
2836               xxscreen(SCR_PT,'T',(long)winlo,"");
2837             else
2838               xxscreen(SCR_PT,'T',(long)pktnum,"");
2839             logpkt('r',-1,(CHAR *)"<timeout>",0);
2840             if (flow == 1) ttoc(XON);   /* In case of Xoff blockage. */
2841             return('T');
2842         }
2843 #ifdef CK_AUTODL
2844     }
2845 #endif /* CK_AUTODL */
2846
2847     rpktl = j;
2848     tlci += j;                          /* All OK, Count the characters. */
2849     flci += j;
2850
2851 /* Find start of packet */
2852
2853 #ifndef PARSENSE
2854     for (i = 0; (recpkt[i] != stchr) && (i < j); i++)
2855       sohp++;                           /* Find mark */
2856     if (i++ >= j) {                     /* Didn't find it. */
2857         logpkt('r',-1,"<timeout>",0);
2858         freerbuf(k);
2859         return('T');
2860     }
2861 #else
2862     i = 1;                              /* ttinl does this for us */
2863 #endif /* PARSENSE */
2864
2865     rpackets++;                         /* Count received packet. */
2866     lp = i;                             /* Remember LEN position. */
2867     if ((j = xunchar(recpkt[i++])) == 0) { /* Get packet length.  */
2868         if ((j = lp+5) > MAXRP) {       /* Long packet */
2869             return('Q');                /* Too long */
2870         }
2871
2872 #ifdef CKTUNING
2873         /* Save some function-call and loop overhead... */
2874 #ifdef COMMENT
2875         /* ttinl() already removed parity */
2876         if (parity)
2877 #endif /* COMMENT */
2878           chk = (unsigned) ((unsigned) recpkt[i-1] +
2879                             (unsigned) recpkt[i]   +
2880                             (unsigned) recpkt[i+1] +
2881                             (unsigned) recpkt[i+2] +
2882                             (unsigned) recpkt[i+3]
2883                             );
2884 #ifdef COMMENT
2885         else
2886           chk = (unsigned) ((unsigned) (recpkt[i-1] & 077) +
2887                             (unsigned) (recpkt[i]   & 077) +
2888                             (unsigned) (recpkt[i+1] & 077) +
2889                             (unsigned) (recpkt[i+2] & 077) +
2890                             (unsigned) (recpkt[i+3] & 077)
2891                             );
2892 #endif /* COMMENT */
2893         if (xunchar(recpkt[j]) != ((((chk & 0300) >> 6) + chk) & 077))
2894 #else
2895         x = recpkt[j];                  /* Header checksum. */
2896         recpkt[j] = '\0';               /* Calculate & compare. */
2897         if (xunchar(x) != chk1(recpkt+lp,5))
2898 #endif /* CKTUNING */
2899           {
2900               freerbuf(k);
2901               logpkt('r',-1,(CHAR *)"<crunched:hdr>",0);
2902               xxscreen(SCR_PT,'%',(long)pktnum,"Bad packet header");
2903               return('Q');
2904           }
2905 #ifndef CKTUNING
2906         recpkt[j] = x;                  /* Checksum ok, put it back. */
2907 #endif /* CKTUNING */
2908         rln = xunchar(recpkt[j-2]) * 95 + xunchar(recpkt[j-1]) - bctl;
2909         j = 3;                          /* Data offset. */
2910     } else if (j < 3) {
2911         debug(F101,"rpack packet length less than 3","",j);
2912         freerbuf(k);
2913         logpkt('r',-1,(CHAR *)"<crunched:len>",0);
2914         xxscreen(SCR_PT,'%',(long)pktnum,"Bad packet length");
2915         return('Q');
2916     } else {
2917         rln = j - bctl - 2;             /* Regular packet */
2918         j = 0;                          /* No extended header */
2919     }
2920     rsn = xunchar(recpkt[i++]);         /* Sequence number */
2921     if (pktlog)                         /* Save a function call! */
2922       logpkt('r',rsn,sohp,rln+bctl+j+4);
2923     if (rsn < 0 || rsn > 63) {
2924         debug(F101,"rpack bad sequence number","",rsn);
2925         freerbuf(k);
2926         if (pktlog)
2927           logpkt('r',rsn,(CHAR *)"<crunched:seq>",0);
2928         xxscreen(SCR_PT,'%',(long)pktnum,"Bad sequence number");
2929         return('Q');
2930     }
2931 /*
2932   If this packet has the same type as the packet just sent, assume it is
2933   an echo and ignore it.  Don't even bother with the block check calculation:
2934   even if the packet is corrupted, we don't want to NAK an echoed packet.
2935   Nor must we NAK an ACK or NAK.
2936 */
2937     type = recpkt[i++];                 /* Get packet's TYPE field */
2938     if (type == sndtyp || (nakstate && (type == 'N' /* || type == 'Y' */ ))) {
2939         debug(F000,"rpack echo","",type); /* If it's an echo */
2940         freerbuf(k);                    /* Free this buffer */
2941         logpkt('#',rsn,(CHAR *)"<echo:ignored>",0);
2942         return('e');                    /* Return special (lowercase) code */
2943     }
2944 /*
2945   Separate the data from the block check, accounting for the case where
2946   a packet was retransmitted after the block check switched.
2947 */
2948     if (type == 'I' || type == 'S') {   /* I & S packets always have type 1 */
2949         chklen = 1;
2950         rln = rln + bctl - 1;
2951     } else if (type == 'N') {           /* A NAK packet never has data */
2952         chklen = xunchar(recpkt[lp]) - 2;
2953         rln = rln + bctl - chklen;
2954     } else chklen = bctl;
2955 #ifdef DEBUG
2956     if (deblog) {                       /* Save 2 function calls */
2957         debug(F101,"rpack bctl","",bctl);
2958         debug(F101,"rpack chklen","",chklen);
2959     }
2960 #endif /* DEBUG */
2961     i += j;                             /* Buffer index of DATA field */
2962     rdatap = recpkt+i;                  /* Pointer to DATA field */
2963     if ((j = rln + i) > r_pkt[k].bf_len) { /* Make sure it fits */
2964         debug(F101,"packet too long","",j);
2965         freerbuf(k);
2966         logpkt('r',rsn,(CHAR *)"<overflow>",0);
2967         return('Q');
2968     }
2969     for (x = 0; x < chklen; x++)        /* Copy the block check */
2970       pbc[x] = recpkt[j+x];             /* 3 bytes at most. */
2971     pbc[x] = '\0';                      /* Null-terminate block check string */
2972     recpkt[j] = '\0';                   /* and the packet Data field. */
2973
2974     if (chklen == 2 && bctu == 4) {     /* Adjust for Blank-Free-2 */
2975         chklen = 4;                     /* (chklen is now a misnomer...) */
2976         debug(F100,"rpack block check B","",0);
2977     }
2978     switch (chklen) {                   /* Check the block check */
2979       case 1:                           /* Type 1, 6-bit checksum */
2980         if (xunchar(*pbc) != chk1(recpkt+lp,j-lp)) {
2981 #ifdef DEBUG
2982             if (deblog) {
2983                 debug(F110,"checked chars",recpkt+lp,0);
2984                 debug(F101,"block check (1)","",(int) xunchar(*pbc));
2985                 debug(F101,"should be (1)","",chk1(recpkt+lp,j-lp));
2986             }
2987 #endif /* DEBUG */
2988             freerbuf(k);
2989             logpkt('r',-1,(CHAR *)"<crunched:chk1>",0);
2990             xxscreen(SCR_PT,'%',(long)pktnum,"Checksum error");
2991             return('Q');
2992         }
2993         break;
2994       case 2:                           /* Type 2, 12-bit checksum */
2995         x = xunchar(*pbc) << 6 | xunchar(pbc[1]);
2996         if (x != chk2(recpkt+lp,j-lp)) { /* No match */
2997             if (type == 'E') {          /* Allow E packets to have type 1 */
2998                 recpkt[j++] = pbc[0];
2999                 recpkt[j] = '\0';
3000                 if (xunchar(pbc[1]) == chk1(recpkt+lp,j-lp))
3001                   break;
3002                 else
3003                   recpkt[--j] = '\0';
3004             }
3005 #ifdef DEBUG
3006             if (deblog) {
3007                 debug(F110,"checked chars",recpkt+lp,0);
3008                 debug(F101,"block check (2)","", x);
3009                 debug(F101,"should be (2)","", (int) chk2(recpkt+lp,j-lp));
3010             }
3011 #endif /* DEBUG */
3012             freerbuf(k);
3013             logpkt('r',-1,(CHAR *)"<crunched:chk2>",0);
3014             xxscreen(SCR_PT,'%',(long)pktnum,"Checksum error");
3015             return('Q');
3016         }
3017         break;
3018       case 3:                           /* Type 3, 16-bit CRC */
3019         crc = (xunchar(pbc[0]) << 12)
3020             | (xunchar(pbc[1]) << 6)
3021             | (xunchar(pbc[2]));
3022         if (crc != chk3(recpkt+lp,j-lp)) {
3023             if (type == 'E') {          /* Allow E packets to have type 1 */
3024                 recpkt[j++] = pbc[0];
3025                 recpkt[j++] = pbc[1];
3026                 recpkt[j] = '\0';
3027                 if (xunchar(pbc[2]) == chk1(recpkt+lp,j-lp))
3028                   break;
3029                 else { j -=2; recpkt[j] = '\0'; }
3030             }
3031 #ifdef DEBUG
3032             if (deblog) {
3033                 debug(F110,"checked chars",recpkt+lp,0);
3034                 debug(F101,"block check (3)","",crc);
3035                 debug(F101,"should be (3)","",(int) chk3(recpkt+lp,j-lp));
3036             }
3037 #endif /* DEBUG */
3038             freerbuf(k);
3039             logpkt('r',-1,(CHAR *)"<crunched:chk3>",0);
3040             xxscreen(SCR_PT,'%',(long)pktnum,"CRC error");
3041             return('Q');
3042         }
3043         break;
3044       case 4:                           /* Type 4 = Type 2, no blanks. */
3045         x = (unsigned)((xunchar(*pbc) - 1) << 6) |
3046           (unsigned)(xunchar(pbc[1]) - 1);
3047         if (x != chk2(recpkt+lp,j-lp)) {
3048             if (type == 'E') {  /* Allow E packets to have type 1 */
3049                 recpkt[j++] = pbc[0];
3050                 recpkt[j] = '\0';
3051                 if (xunchar(pbc[1]) == chk1(recpkt+lp,j-lp))
3052                   break;
3053                 else
3054                   recpkt[--j] = '\0';
3055             }
3056             debug(F101,"bad type B block check","",x);
3057             freerbuf(k);
3058             logpkt('r',-1,(CHAR *)"<crunched:chkb>",0);
3059             xxscreen(SCR_PT,'%',(long)pktnum,"Checksum error");
3060             return('Q');
3061         }
3062         break;
3063       default:                  /* Shouldn't happen... */
3064         freerbuf(k);
3065         logpkt('r',-1,(CHAR *)"<crunched:chkx>",0);
3066         xxscreen(SCR_PT,'%',(long)pktnum,"(crunched)");
3067         return('Q');
3068     }
3069     debug(F101,"rpack block check OK","",rsn);
3070
3071 /* Now we can believe the sequence number, and other fields. */
3072 /* Here we violate strict principles of layering, etc, and look at the  */
3073 /* packet sequence number.  If there's already a packet with the same   */
3074 /* number in the window, we remove this one so that the window will not */
3075 /* fill up. */
3076
3077     if ((x = rseqtbl[rsn]) != -1) {     /* Already a packet with this number */
3078         retrans++;                      /* Count it for statistics */
3079         debug(F101,"rpack got dup","",rsn);
3080         logpkt('r',rsn,(CHAR *)"<duplicate>",0);
3081         freerbuf(x);                    /* Free old buffer, keep new packet. */
3082         r_pkt[k].pk_rtr++;              /* Count this as a retransmission. */
3083     }
3084
3085 /* New packet, not seen before, enter it into the receive window. */
3086
3087 #ifdef CK_TIMERS
3088     if (timint > 0)
3089       rrttbl[rsn] = gtimer();           /* Timestamp */
3090 #endif /* CK_TIMERS */
3091
3092     rseqtbl[rsn] = k;                   /* Make back pointer */
3093     r_pkt[k].pk_seq = rsn;              /* Record in packet info structure */
3094     r_pkt[k].pk_typ = type;             /* Sequence, type,... */
3095     r_pkt[k].pk_adr = rdatap;           /* pointer to data buffer */
3096     if (local) {                        /* Save a function call! */
3097         int x = 0;
3098         if (fdispla != XYFD_N) x = 1;
3099         if (fdispla == XYFD_B && (type == 'D' || sndtyp == 'D')) x = 0;
3100         if (x)                          /* Update screen */
3101           xxscreen(SCR_PT,(char)type,(long)rsn,(char *)sohp);
3102     }
3103     return(type);                       /* Return packet type */
3104 }
3105
3106 /*  L O G P K T  --  Log packet number n, pointed to by s.  */
3107
3108 /* c = 's' (send) or 'r' (receive) */
3109
3110 VOID
3111 #ifdef CK_ANSIC
3112 logpkt(char c,int n, CHAR *s, int len)
3113 #else
3114 logpkt(c,n,s,len) char c; int n; CHAR *s; int len;
3115 #endif /* CK_ANSIC */
3116 /* logpkt */ {
3117     char plog[20];
3118     if (!s) s = (CHAR *)"";
3119     if (pktlog) if (chkfn(ZPFILE) > 0) {
3120         if (n < 0)                      /* Construct entry header */
3121           sprintf(plog,"%c-xx-%02d-",c,(gtimer()%60)); /* safe */
3122         else
3123           sprintf(plog,"%c-%02d-%02d-",c,n,(gtimer()%60)); /* safe */
3124         if (zsoutx(ZPFILE,plog,(int)strlen(plog)) < 0) {
3125             pktlog = 0;
3126             return;
3127         } else {
3128             if (len == 0)
3129               len = strlen((char *)s);
3130             if (len > 0) {
3131                 char * p;               /* Make SOP printable */
3132                 int x;                  /* so we can look at logs without */
3133                 p = dbchr(*s);          /* triggering autodownload. */
3134                 x = strlen(dbchr(*s));
3135                 if (*s < 32 || (*s > 127 && *s < 160)) {
3136                     if (zsoutx(ZPFILE,p,x) < 0) {
3137                         pktlog = 0;
3138                         return;
3139                     } else {
3140                         len--;
3141                         s++;
3142                     }
3143                 }
3144             }
3145             if (zsoutx(ZPFILE,(char *)s,len) < 0) {
3146                 pktlog = 0;
3147                 return;
3148             } else if (zsoutx(ZPFILE,
3149 #ifdef UNIX
3150                               "\n", 1
3151 #else
3152 #ifdef datageneral
3153                               "\n", 1
3154 #else
3155 #ifdef OSK
3156                               "\r", 1
3157 #else
3158 #ifdef MAC
3159                               "\r", 1
3160 #else
3161                               "\015\012", 2
3162 #endif /* MAC */
3163 #endif /* OSK */
3164 #endif /* datageneral */
3165 #endif /* UNIX */
3166                               ) < 0) {
3167                 pktlog = 0;
3168             }
3169         }
3170     }
3171 }
3172
3173 /*  T S T A T S  --  Record statistics in transaction log  */
3174
3175 VOID
3176 tstats() {
3177     char *tp = NULL;
3178 #ifdef GFTIMER
3179     CKFLOAT xx;                         /* Elapsed time divisor */
3180 #endif /* GFTIMER */
3181
3182     debug(F101,"tstats xfsecs","",xfsecs);
3183     debug(F101,"tstats filcnt","",filcnt);
3184     if (filcnt == 1) {                  /* Get timing for statistics */
3185         tsecs = xfsecs;                 /* Single file, we already have it */
3186 #ifdef GFTIMER
3187         debug(F101,"tstats fpxfsecs","",(int)fpxfsecs);
3188         fptsecs = fpxfsecs;
3189 #endif /* GFTIMER */
3190     } else {                            /* Multiple files */
3191         tsecs = gtimer();               /* Get current time */
3192 #ifdef GFTIMER
3193         fptsecs = gftimer();
3194 #endif /* GFTIMER */
3195     }
3196 #ifdef GFTIMER
3197     if (fptsecs <= GFMINTIME)           /* Calculate CPS */
3198       fptsecs = (CKFLOAT) GFMINTIME;
3199     debug(F101,"tstats fptsecs","",(int)fptsecs);
3200     xx = (CKFLOAT) tfc / fptsecs;
3201     if (sizeof(long) <= 4) {            /* doesn't account for 16-bit longs */
3202         if (xx  > 2147483647.0)
3203           tfcps = 2147483647L;          /* 31 bits */
3204         else
3205           tfcps = (long) xx;
3206     } else
3207       tfcps = (long) xx;
3208 #else
3209     if (tsecs < 2L)
3210       tsecs = 1L;
3211     debug(F101,"tstats tsecs","",tsecs);
3212     tfcps = tfc / tsecs;
3213 #endif /* GFTIMER */
3214
3215     ztime(&tp);                         /* Get time stamp */
3216     tlog(F100,"","",0L);                /* Leave a blank line */
3217     tlog(F110,"Transaction complete",tp,0L);  /* Record it */
3218
3219     if (filcnt < 1) return;             /* If no files, done. */
3220
3221 /* If multiple files, record character totals for all files */
3222
3223     if (filcnt > 1) {
3224         tlog(F101," files transferred       ","",filcnt - filrej);
3225         tlog(F101," total file characters   ","",tfc);
3226         tlog(F101," communication line in   ","",tlci);
3227         tlog(F101," communication line out  ","",tlco);
3228     }
3229
3230 /* Record timing info for one or more files */
3231
3232 #ifdef GFTIMER
3233     if (filcnt - filrej == 1) {
3234         tlog(F101," elapsed time (seconds)  ","",(long) fpxfsecs);
3235         tlog(F101," effective data rate     ","",filcps);
3236     } else {
3237         tlog(F101," elapsed time (seconds)  ","",(long) fptsecs);
3238         tlog(F101," effective data rate     ","",(long) xx);
3239     }
3240 #else
3241     tlog(F101," elapsed time (seconds)  ","",(long) tsecs);
3242     if (tsecs > 0) {
3243         long lx;
3244         lx = (tfc * 10L) / (long) tsecs;
3245         tlog(F101," effective data rate     ","",lx/10L);
3246     }
3247 #endif /* GFTIMER */
3248     tlog(F100,"","",0L);                /* Leave a blank line */
3249 }
3250
3251 /*  F S T A T S  --  Record file statistics in transaction log  */
3252
3253 VOID
3254 fcps() {
3255 #ifdef GFTIMER
3256     double xx;
3257     fpxfsecs = gftimer() - fpfsecs;
3258     if (fpxfsecs <= GFMINTIME)
3259       fpxfsecs = (CKFLOAT) GFMINTIME;
3260     xx = (CKFLOAT) ffc / fpxfsecs;
3261     if (sizeof(long) <= 4) {
3262         if (xx  > 2147483647.0)
3263           tfcps = 2147483647L;          /* 31 bits */
3264         else
3265           filcps = (long) xx;
3266     } else
3267       filcps = (long) xx;
3268     if (sizeof(int) >= 4)
3269       xfsecs = (int) fpxfsecs;
3270     else if (fpxfsecs < 32768.0)
3271       xfsecs = (int) fpxfsecs;
3272     else
3273       xfsecs = 32767;
3274 #else /* GFTIMER */
3275     xfsecs = gtimer() - fsecs;
3276     if (xfsecs < 1L) xfsecs = 1L;
3277     filcps = ffc / xfsecs;
3278 #endif /* GFTIMER */
3279 }
3280
3281 VOID
3282 fstats() {
3283     tfc += ffc;
3284 #ifdef DEBUG
3285     if (deblog) {
3286         debug(F101,"fstats tfc","",tfc);
3287         debug(F101,"fstats what","",what);
3288         debug(F110,"fstats epktmsg",epktmsg,0);
3289     }
3290 #endif /* DEBUG */
3291 #ifdef TLOG
3292     if (!discard && !cxseen && !czseen && what != W_NOTHING && !*epktmsg)
3293       tlog(F101," complete, size","",ffc);
3294 #endif /* TLOG */
3295 }
3296
3297 #endif /* NOXFER */