Return to protz.c CVS log

Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104

Annotation of coherent/g/usr/lib/uucp/tay104/protz.c, revision 1.1

1.1     ! root        1: /* protz.c             Version 1.5, 92Apr24 */
        !             2: /* Modified by Ian Lance Taylor for Taylor UUCP 1.04 92Aug4.  */
        !             3: 
        !             4: /*
        !             5:  * Doug Evans, [email protected] or [email protected]
        !             6:  *
        !             7:  * This file provides the Zmodem protocol (by Chuck Forsberg) for
        !             8:  * Ian Taylor's UUCP package.
        !             9:  *
        !            10:  * It was originally developed to establish a uucp link between myself and my
        !            11:  * employer: Ivation Datasystems, Inc. of Ottawa. 
        !            12:  *
        !            13:  * My thanks to Ivation for letting me release this to the public. Given that
        !            14:  * Zmodem is in the public domain, no additional copyrights have been added.
        !            15:  *
        !            16:  *****************************************************************************
        !            17:  *
        !            18:  * It's been difficult fitting Zmodem into the UUCP world. I have been guided
        !            19:  * mostly by trying to plug it into Taylor UUCP. Where "the Zmodem way of doing
        !            20:  * things" conflicted with "the UUCP way of doing things", I have err'd on the
        !            21:  * side of UUCP. At the end of it all, I have achieved something that will plug
        !            22:  * into Taylor UUCP very easily, but some might argue that I have corrupted Z
        !            23:  * too much. At any rate, compatibility with sz/rz was sacrificed to achieve a
        !            24:  * clean UUCP protocol. Given that, I took the opportunity to start from
        !            25:  * scratch when defining protocol constants (EG: ZBIN).
        !            26:  *
        !            27:  * 1) I wasn't quite sure how to enhance Zmodem to handle send+receive in one
        !            28:  *    session, so I added a 'g' protocol like initialization sequence. This
        !            29:  *    also gets this stuff out of the way, in case we ever try to support
        !            30:  *    full-duplex.
        !            31:  *
        !            32:  *     Caller                      Callee
        !            33:  *     ------                      ------
        !            34:  *     ZINIT           -->     <-- ZINIT
        !            35:  *     ZDATA (ZCRCF)   -->     <-- ZDATA (ZCRCF)
        !            36:  *     ZACK            -->     <-- ZACK
        !            37:  *     ZINITEND        -->     <-- ZINITEND
        !            38:  *
        !            39:  *    ZINIT is a combination of ZRINIT and ZSINIT and is intended to exchange
        !            40:  *    simple protocol information (flags) and the protocol version number.
        !            41:  *    ZDATA is intended to include window size information as well as the
        !            42:  *    "Myattn" string (although at the moment it doesn't contain anything).
        !            43:  *    ZDATA may contain at most 1k bytes of data and is sent out as one ZCRCF
        !            44:  *    packet. Two ack's (ZACK + ZINITEND) are needed to ensure both sides have
        !            45:  *    received ZDATA.
        !            46:  *
        !            47:  * 2) I've hardcoded several protocol parameters, like 32 bit CRC's for data.
        !            48:  *    Others are not supported (we don't need them).
        !            49:  *
        !            50:  * 3) ZHEX headers use 32 bit CRC's.
        !            51:  *
        !            52:  * 4) Zmodem sends the ZFILE message "in one chunk". If there are errors, the
        !            53:  *    entire string is resent. I have continued this practice. All UUCP
        !            54:  *    commands are sent "in one chunk". This can be changed down the road if
        !            55:  *    necessary.
        !            56:  *
        !            57:  * 5) The ZEOF message has been replaced with a new ZCRCx value: ZCRCF. ZCRCF
        !            58:  *    is identical to ZCRCW except that it indicates the end of the message.
        !            59:  *    The protocol here is *not* a file transfer protocol. It is an end to end
        !            60:  *    transport protocol (that preserves message boundaries).
        !            61:  *
        !            62:  * 6) Zmodem handles restarting a file transfer, but as best as I can tell UUCP
        !            63:  *    does not. At least Taylor UUCP doesn't. And if UUCP does start handling
        !            64:  *    file restart, can it be plugged into the existing Zmodem way with zero
        !            65:  *    changes? Beats me. Therefore I have removed this part of the code. One
        !            66:  *    can always put it back in if and when UUCP handles it. Ditto for other
        !            67:  *    pieces of removed code: there's no point in overly complicating this code
        !            68:  *    when supporting all the bells and whistles requires enhancements to UUCP
        !            69:  *    itself.
        !            70:  *
        !            71:  *    *** It is easier to put code back in in an upward compatible manner ***
        !            72:  *    *** than it is to correct for misunderstood code or poorly merged   ***
        !            73:  *    *** (Zmodem vs UUCP) code.                                          ***
        !            74:  *
        !            75:  * 7) For the character in the initial "protocol selection" sequence, I have
        !            76:  *    chosen 'a'. I'm told 'z' is already in use for something that isn't
        !            77:  *    Zmodem. It's entirely reasonable to believe that if Zmodem ever becomes a
        !            78:  *    standard UUCP protocol, this won't be it (so I'll leave z/Z for them).
        !            79:  *    Publicly, this is the 'a' protocol. Internally, it is refered to as 'z'.
        !            80:  *    A little confusing, I know. Maybe in time I'll refer to it internally as
        !            81:  *    'a', or maybe in time this will be *the* 'z' protocol.
        !            82:  *
        !            83:  * 8) Since we are writing a transport protocol, which isn't supposed to know
        !            84:  *    anything about what is being transfered or where it is coming from, the
        !            85:  *    header data value has changed meaning. It no longer means "file position"
        !            86:  *    but instead means "window position". It is a running counter of the bytes
        !            87:  *    transfered. Each "message" begins on a 1k boundary so the count isn't a
        !            88:  *    precise byte count. The counter wraps every 4 gigabytes, although this
        !            89:  *    wrapping isn't supported yet.
        !            90:  *
        !            91:  *    FIXME: At present the max data transfered per session is 4 gigabytes.
        !            92:  *
        !            93:  ****************************************************************************
        !            94:  *
        !            95:  * A typical message sequence is (master sending file to slave):
        !            96:  *
        !            97:  *      Master                          Slave
        !            98:  *      ------                          -----
        !            99:  *     ZDATA (S, ZCRCF)        -->
        !           100:  *                             <--     ZACK
        !           101:  *                             <--     ZDATA (SY, ZCRCF)
        !           102:  *     ZACK                    -->
        !           103:  *     ZDATA                   -->
        !           104:  *                        ...  <--     ZACK/ZRPOS
        !           105:  *     ZDATA (ZCRCF)           -->
        !           106:  *                             <--     ZACK
        !           107:  *                             <--     ZDATA (CY, ZCRCF)
        !           108:  *     ZACK                    -->
        !           109:  *
        !           110:  * A typical message sequence is (master receiving file from slave):
        !           111:  *
        !           112:  *     Master                          Slave
        !           113:  *     ------                          -----
        !           114:  *     ZDATA (R, ZCRCF)        -->
        !           115:  *                             <--     ZACK
        !           116:  *                             <--     ZDATA (RY, ZCRCF)
        !           117:  *     ZACK                    -->
        !           118:  *                             <--     ZDATA
        !           119:  *     ZACK/ZRPOS      ...     -->
        !           120:  *                             <--     ZDATA (ZCRCF)
        !           121:  *     ZACK                    -->
        !           122:  *     ZDATA (CY, ZCRCF)       -->
        !           123:  *                             <--     ZACK
        !           124:  *
        !           125:  *****************************************************************************
        !           126:  *
        !           127:  * Notes:
        !           128:  * 1) For future bidirectional concerns, keep packet types "unidirectional".
        !           129:  *     Sender always uses:     ZDATA, ZNAK
        !           130:  *     Receiver always uses:   ZRPOS, ZACK
        !           131:  *     There is no intersection.
        !           132:  *
        !           133:  *    I'm not sure if this is necessary or even useful, but it seems to be.
        !           134:  *
        !           135:  * 2) I use to store the byte count / 32 in the data header. This left 5 bits
        !           136:  *    unused for future concerns. I removed this because of the following
        !           137:  *    situation when sending a file:
        !           138:  *
        !           139:  *     ZDATA (ZCRCG, xx bytes) - received ok
        !           140:  *     ZDATA (ZCRCF, 0 bytes)  - corrupted
        !           141:  *
        !           142:  *    At this point the receiver would like to send back a ZRPOS with a value 
        !           143:  *    of the size of the file. However, it can't because the value is divided
        !           144:  *    by 32, and it would have to round up to the next multiple of 32. This
        !           145:  *    seemed a little ugly, so I went with using the entire header to store
        !           146:  *    the byte count.
        !           147:  *
        !           148:  *****************************************************************************
        !           149:  *
        !           150:  * Source version:
        !           151:  * 
        !           152:  * 1.1,2,3
        !           153:  *     Protocol version 0
        !           154:  *     Early attempts, completely rewritten later.
        !           155:  *
        !           156:  * 1.4 Protocol version 1
        !           157:  *     Beta test sent to Ian for analysis 92Apr18.
        !           158:  *
        !           159:  * 1.5 Protocol version 1
        !           160:  *     Released 92Apr24.
        !           161:  *
        !           162:  *****************************************************************************
        !           163:  *
        !           164:  * Protocol version:
        !           165:  *
        !           166:  * A version number is exchanged in the ZINIT message, so it is possible to
        !           167:  * correct or enhance the protocol, without breaking existing versions.
        !           168:  * The purpose of this section is to document these versions as they come out.
        !           169:  * Remember, this is the protocol version, not the source version.
        !           170:  *
        !           171:  * 0   Initial version.
        !           172:  *     Zmodem controlled file transfer. This was more of a "plug Z
        !           173:  *     into UUCP as is" port.
        !           174:  *
        !           175:  * 1   Complete rewrite.
        !           176:  *     Made Z more of a transport protocol. UUCP now controls transfer and Z
        !           177:  *     is on the same footing as the other UUCP protocols.
        !           178:  *     Theoretically, there will be little pain when UUCP goes bidirectional.
        !           179:  */
        !           180: 
        !           181: #include "uucp.h"
        !           182: 
        !           183: #if USE_RCS_ID
        !           184: const char protz_rcsid[] = "$Id: protz.c,v 1.1 93/07/30 07:53:39 bin Exp Locker: bin $";
        !           185: #endif
        !           186: 
        !           187: #include <errno.h>
        !           188: 
        !           189: #include "uudefs.h"
        !           190: #include "uuconf.h"
        !           191: #include "conn.h"
        !           192: #include "trans.h"
        !           193: #include "system.h"
        !           194: #include "prot.h"
        !           195: 
        !           196: #define ZPROTOCOL_VERSION      1
        !           197: 
        !           198: /*
        !           199:  * Control message characters ...
        !           200:  */
        !           201: 
        !           202: #define ZPAD   '*'     /* Padding character begins frames */
        !           203: #define ZDLE   030     /* Ctrl-X Zmodem escape - `ala BISYNC DLE */
        !           204: #define ZBIN   'A'     /* Binary frame indicator */
        !           205: #define ZHEX   'B'     /* HEX frame indicator */
        !           206: 
        !           207: /*
        !           208:  * Frame types (see array "frametypes" in zm.c) ...
        !           209:  *
        !           210:  * Note that the numbers here have been reorganized, as we don't support
        !           211:  * all of them (nor do we need to).
        !           212:  *
        !           213:  * WARNING: The init sequence assumes ZINIT < ZDATA < ZACK < ZINITEND.
        !           214:  */
        !           215: 
        !           216: #define ZINIT          0       /* Init (contains protocol version, flags) */
        !           217: #define ZDATA          1       /* Data packet(s) follow */
        !           218: #define ZRPOS          2       /* Resume data trans at this position */
        !           219: #define ZACK           3       /* ACK to above */
        !           220: #define ZNAK           4       /* Last packet was garbled */
        !           221: #define Zreserved      5       /* reserved (for future concerns) */
        !           222: #define ZINITEND       6       /* end of init sequence */
        !           223: #define ZFIN           7       /* Finish session */
        !           224: 
        !           225: /*
        !           226:  * ZDLE sequences ...
        !           227:  *
        !           228:  * Note addition of ZCRCF: "end of message".
        !           229:  */
        !           230: 
        !           231: #define ZCRCE 'h'      /* CRC next, frame ends, header packet follows */
        !           232: #define ZCRCG 'i'      /* CRC next, frame continues nonstop */
        !           233: #define ZCRCQ 'j'      /* CRC next, frame continues, ZACK expected */
        !           234: #define ZCRCW 'k'      /* CRC next, ZACK expected, end of frame */
        !           235: #define ZCRCF 'l'      /* CRC next, ZACK expected, end of message */
        !           236: 
        !           237: #define ZRUB0 'm'      /* Translate to rubout 0177 */
        !           238: #define ZRUB1 'n'      /* Translate to rubout 0377 */
        !           239: 
        !           240: 
        !           241: /*
        !           242:  * zdlread return values (internal) ...
        !           243:  * Other values are ZM_ERROR, ZM_TIMEOUT, ZM_RCDO.
        !           244:  */
        !           245: 
        !           246: #define GOTOR  0400
        !           247: #define GOTCRCE (ZCRCE | GOTOR)        /* ZDLE-ZCRCE received */
        !           248: #define GOTCRCG (ZCRCG | GOTOR)        /* ZDLE-ZCRCG received */
        !           249: #define GOTCRCQ (ZCRCQ | GOTOR)        /* ZDLE-ZCRCQ received */
        !           250: #define GOTCRCW (ZCRCW | GOTOR)        /* ZDLE-ZCRCW received */
        !           251: #define GOTCRCF (ZCRCF | GOTOR)        /* ZDLE-ZCRCF received */
        !           252: 
        !           253: /*
        !           254:  * Byte positions within header array ...
        !           255:  */
        !           256: 
        !           257: #define ZF0    3       /* First flags byte */
        !           258: #define ZF1    2
        !           259: #define ZF2    1
        !           260: #define ZF3    0
        !           261: 
        !           262: #define ZP0    0       /* Low order 8 bits of position */
        !           263: #define ZP1    1
        !           264: #define ZP2    2
        !           265: #define ZP3    3       /* High order 8 bits of position */
        !           266: 
        !           267: /*
        !           268:  * Bit Masks for ZRQINIT flags byte ZF0 ...
        !           269:  */
        !           270: 
        !           271: #define TX_ESCCTL      1       /* Tx will escape control chars */
        !           272: 
        !           273: /*
        !           274:  * Possible errors when running ZMODEM ...
        !           275:  */
        !           276: 
        !           277: #define        ZM_ERROR        (-1)    /* crc error, etc. */
        !           278: #define ZM_TIMEOUT     (-2)
        !           279: #define ZM_RCDO                (-3)    /* Carrier Lost */
        !           280: 
        !           281: /*
        !           282:  * ASCII characters ...
        !           283:  */
        !           284: 
        !           285: #define LF             012
        !           286: #define CR             015
        !           287: #define XON            021
        !           288: #define XOFF           023
        !           289: 
        !           290: #define XON_WAIT       10      /* seconds */
        !           291: 
        !           292: /*
        !           293:  * Packet sizes ...
        !           294:  *
        !           295:  * FIXME: CPACKETSIZE is hardcoded in a lot of places.
        !           296:  *     It's not clear to me whether changing it's value would be a
        !           297:  *     "good thing" or not. But of course that doesn't excuse the hardcoding.
        !           298:  */
        !           299: 
        !           300: #define CPACKETSIZE            1024    /* max packet size (data only) */
        !           301: #define CFRAMELEN              12      /* header size */
        !           302: #define CSUFFIXLEN             10      /* suffix at end of data packets */
        !           303: #define CEXCHANGE_INIT_RETRIES 4
        !           304: 
        !           305: /* The header CRC value.  */
        !           306: 
        !           307: #if ANSI_C
        !           308: #define IHDRCRC 0xDEBB20E3UL
        !           309: #else
        !           310: #define IHDRCRC ((unsigned long) 0xDEBB20E3L)
        !           311: #endif
        !           312: 
        !           313: /* packet buffer size */
        !           314: #define CPACKBUFSIZE  (CFRAMELEN + 2 * CPACKETSIZE + CSUFFIXLEN + 42 /*slop*/)
        !           315: 
        !           316: /*
        !           317:  * Data types ...
        !           318:  */
        !           319: 
        !           320: typedef unsigned char achdrval_t[4];
        !           321: typedef unsigned long hdrval_t;
        !           322: typedef unsigned long winpos_t;
        !           323: 
        !           324: /*
        !           325:  * Configurable parms ...
        !           326:  *
        !           327:  * FIXME: <cZrx_buf_len> isn't used yet. It may not be needed.
        !           328:  */
        !           329: 
        !           330: #define CTIMEOUT               10
        !           331: #define CRETRIES               10
        !           332: #define CSTARTUP_RETRIES       4
        !           333: #define CGARBAGE               2400
        !           334: #define CSEND_WINDOW           16384
        !           335: #define FESCAPE_CONTROL                FALSE
        !           336: 
        !           337: static int cZtimeout = CTIMEOUT;       /* (seconds) */
        !           338: static int cZretries = CRETRIES;
        !           339: static int cZstartup_retries = CSTARTUP_RETRIES;
        !           340: static int cZmax_garbage = CGARBAGE;           /* max garbage before header */
        !           341: static int cZtx_window = CSEND_WINDOW;         /* our transmission window */
        !           342: static int cZrx_buf_len = 0;                   /* our reception buffer size */
        !           343: static boolean fZesc_ctl = FESCAPE_CONTROL;    /* escape control chars */
        !           344: 
        !           345: struct uuconf_cmdtab asZproto_params[] =
        !           346: {
        !           347:        {"timeout", UUCONF_CMDTABTYPE_INT, (pointer) & cZtimeout, NULL},
        !           348:        {"retries", UUCONF_CMDTABTYPE_INT, (pointer) & cZretries, NULL},
        !           349:        {"startup-retries", UUCONF_CMDTABTYPE_INT,
        !           350:           (pointer) & cZstartup_retries, NULL},
        !           351:        {"garbage", UUCONF_CMDTABTYPE_INT, (pointer) & cZmax_garbage, NULL},
        !           352:        {"send-window", UUCONF_CMDTABTYPE_INT, (pointer) & cZtx_window, NULL},
        !           353:        {"escape-control", UUCONF_CMDTABTYPE_BOOLEAN, (pointer) & fZesc_ctl,
        !           354:           NULL},
        !           355:        {NULL, 0, NULL, NULL}
        !           356: };
        !           357: 
        !           358: /*
        !           359:  * Variables for statistic gathering ...
        !           360:  *
        !           361:  * We use <wpZtxpos, wpZrxbytes> to record the number of "packets"
        !           362:  * sent/received. Packets is in double quotes because some of them aren't full.
        !           363:  */
        !           364: 
        !           365: static unsigned long cZheaders_sent;
        !           366: static unsigned long cZheaders_received;
        !           367: static unsigned long cZbytes_resent;
        !           368: static unsigned long cZtimeouts;
        !           369: static unsigned long cZerrors;
        !           370: 
        !           371: /*
        !           372:  * Data buffers ...
        !           373:  */
        !           374: 
        !           375: static char *zZtx_buf;         /* transmit buffer */
        !           376: 
        !           377: static char *zZtx_packet_buf;  /* raw outgoing packet data */
        !           378: static char *zZrx_packet_buf;  /* raw incoming packet data */
        !           379: 
        !           380: /*
        !           381:  * Transmitter state variables ...
        !           382:  */
        !           383: 
        !           384: static unsigned cZblklen;      /* data length in sent/received packets */
        !           385: static unsigned cZtxwspac;     /* spacing between ZCRCQ requests */
        !           386: /*static unsigned cZblklen_override;*//* override value for <cZblklen> */
        !           387: static unsigned cZtxwcnt;      /* counter used to space ack requests */
        !           388: static unsigned cZrxwcnt;      /* counter used to watch receiver's buf size */
        !           389: static winpos_t wpZtxstart;    /* <wpZtxpos> when message started */
        !           390: static winpos_t wpZtxpos;      /* transmitter position */
        !           391: static winpos_t wpZlastsync;   /* last offset to which we got a ZRPOS */
        !           392: static winpos_t wpZlrxpos;     /* receiver's last reported offset */
        !           393: static winpos_t wpZrxpos;      /* receiver file position */
        !           394: 
        !           395: static int iZlast_tx_data_packet; /* type of last ZDATA packet (ZCRCx) */
        !           396: static int iZjunk_count;       /* amount of garbage characters received */
        !           397: static int iZtleft;            /* for dynamic packet resizing */
        !           398: 
        !           399: static int iZbeenhereb4;       /* times we've been ZRPOS'd to same place */
        !           400: 
        !           401: /*
        !           402:  * Receiver state variables ...
        !           403:  */
        !           404: 
        !           405: static winpos_t wpZrxbytes;    /* receiver byte count */
        !           406: static int iZlast_rx_data_packet; /* last successfully received ZCRCx packet */
        !           407: 
        !           408: /*
        !           409:  * Misc. globals ...
        !           410:  */
        !           411: 
        !           412: static char xon = XON;
        !           413: 
        !           414: #ifdef DJE_TESTING
        !           415: int uucptest = -1;
        !           416: int uucptest2;
        !           417: int uucptestseed;
        !           418: #endif
        !           419: 
        !           420: /*
        !           421:  * Kludge!!!
        !           422:  * See fzfinish_tx(). Basically the next two globals are used to record the
        !           423:  * fact that we got a ZDATA, but aren't quite ready to process it.
        !           424:  */
        !           425: 
        !           426: static int iZpkt_rcvd_kludge;                  /* -1 if not valid */
        !           427: static hdrval_t hvZpkt_hdrval_kludge;
        !           428: 
        !           429: /*
        !           430:  * Packet types ...
        !           431:  */
        !           432: 
        !           433: static const char *azZframe_types[] = {
        !           434:        "Carrier Lost",         /* -3 */
        !           435:        "Timeout",              /* -2 */
        !           436:        "Error",                /* -1 */
        !           437: #define FTOFFSET 3
        !           438:        "ZINIT",
        !           439:        "ZDATA",
        !           440:        "ZRPOS",
        !           441:        "ZACK",
        !           442:        "ZNAK",
        !           443:        "Zreserved",
        !           444:        "ZINITEND",
        !           445:        "ZFIN",
        !           446:        "UNKNOWN!!!"
        !           447: };
        !           448: #define FTNUMBER       (sizeof(azZframe_types) / sizeof(char *))
        !           449: 
        !           450: #ifndef min
        !           451: #define min(a, b)      ((a) < (b) ? (a) : (b))
        !           452: #endif
        !           453: #define ZZHEADER_NAME(itype) \
        !           454:                azZframe_types[min((itype) + FTOFFSET, FTNUMBER - 1)]
        !           455: 
        !           456: /*
        !           457:  * Local functions ...
        !           458:  */
        !           459: 
        !           460: static boolean fzsend_data P((struct sdaemon *qdaemon, char *zdata,
        !           461:                              size_t cdata, boolean fendofmessage));
        !           462: static boolean fzprocess P((struct sdaemon *qdaemon));
        !           463: static boolean fzstart_proto P((struct sdaemon *qdaemon));
        !           464: static int izexchange_init P((struct sdaemon *qdaemon, int send_type,
        !           465:                              achdrval_t send_val, achdrval_t recv_val));
        !           466: static boolean fzshutdown_proto P((struct sdaemon *qdaemon));
        !           467: static boolean fzstart_tx P((void));
        !           468: static boolean fzfinish_tx P((struct sdaemon *qdaemon, long *plredo));
        !           469: static boolean fzstart_rx P((void));
        !           470: static boolean fzfinish_rx P((struct sdaemon *qdaemon));
        !           471: static boolean fzsend_hdr P((struct sdaemon *qdaemon, int ipkttype,
        !           472:                             int ihdrtype, hdrval_t hdrval,
        !           473:                             boolean fcheckreceive));
        !           474: static boolean fzsend_data_packet P((struct sdaemon *qdaemon, char *zdata,
        !           475:                                     size_t cdata, int frameend,
        !           476:                                     boolean fcheckreceive));
        !           477: static int czbuild_header P((char *zresult, int ipkttype, int ihdrtype,
        !           478:                             hdrval_t hdrval));
        !           479: static int czbuild_data_packet P((char *zresult, const char *zdata,
        !           480:                                  size_t cdata, int frameend));
        !           481: /*
        !           482:  * The rest of the functions do not follow Ian's naming style. I have left
        !           483:  * the names the same as the original zm source. Over time, they may change.
        !           484:  */
        !           485: static int izrecv_hdr P((struct sdaemon *qdaemon, achdrval_t hdr));
        !           486: static int zrbhdr32 P((struct sdaemon *qdaemon, achdrval_t hdr));
        !           487: static int zrhhdr P((struct sdaemon *qdaemon, achdrval_t hdr));
        !           488: static int zrdat32 P((struct sdaemon *qdaemon, char *buf, int length,
        !           489:                      int *iprxcount));
        !           490: static int getinsync P((struct sdaemon *qdaemon, boolean flag));
        !           491: static char *zputhex P((char *p, int ch));
        !           492: static char *zputchar P((char *p, int ch));
        !           493: static int zgethex P((struct sdaemon *qdaemon));
        !           494: static int zdlread P((struct sdaemon *qdaemon));
        !           495: static int noxrd7 P((struct sdaemon *qdaemon));
        !           496: static int realreadchar P((struct sdaemon *qdaemon, int timeout));
        !           497: static boolean fzreceive_ready P((void));
        !           498: static void stohdr P((hdrval_t pos, achdrval_t hdr));
        !           499: static hdrval_t rclhdr P((achdrval_t hdr));
        !           500: static hdrval_t hvzencode_data_hdr P((winpos_t cbytes));
        !           501: static void zdecode_data_hdr P((hdrval_t hdrval, winpos_t *pcbytes));
        !           502: static winpos_t lzupdate_rxpos P((achdrval_t rx_hdr, winpos_t rxpos,
        !           503:                                  winpos_t lrxpos, winpos_t txpos));
        !           504: 
        !           505: /*
        !           506:  * This macro replaces readchar() because it achieves a noticable speed up. The
        !           507:  * readchar() function has been renamed realreadchar(). Thanks to Ian for
        !           508:  * running this stuff through a profiler to find this out. Ian suggests further
        !           509:  * speed ups may be obtained by doing a similar thing in zrdat32().
        !           510:  */
        !           511: 
        !           512: /* Assign the next character to b. */
        !           513: #define READCHAR(qdaemon, b, i) \
        !           514:   (iPrecstart != iPrecend \
        !           515:    ? ((b) = BUCHAR (abPrecbuf[iPrecstart]), \
        !           516:       iPrecstart = (iPrecstart + 1) % CRECBUFLEN) \
        !           517:    : ((b) = realreadchar ((qdaemon), (i))))
        !           518: 
        !           519: /************************************************************************/
        !           520: 
        !           521: 
        !           522: /*
        !           523:  * Start the protocol ...
        !           524:  */
        !           525: 
        !           526: boolean
        !           527: fzstart(qdaemon, pzlog)
        !           528: struct sdaemon *qdaemon;
        !           529: char **pzlog;
        !           530: {
        !           531:        *pzlog = zbufalc (sizeof "protocol 'a' starting: , , , , , " + 100);
        !           532:        sprintf (*pzlog, "protocol 'a' starting: %d, %d, %d, %d, %d, %d",
        !           533:                cZtimeout, cZretries, cZstartup_retries,
        !           534:                cZmax_garbage, cZtx_window, fZesc_ctl);
        !           535: 
        !           536:         if (! fconn_set (qdaemon->qconn, PARITYSETTING_NONE,
        !           537:                         STRIPSETTING_EIGHTBITS, XONXOFF_OFF))
        !           538:                return FALSE;
        !           539: 
        !           540:        /*
        !           541:         * For now, we place tight restrictions on the size of the transmit
        !           542:         * window. This might be relaxed in the future. If it is relaxed,
        !           543:         * some of these tests will stay, some will go. That is why it is
        !           544:         * coded like it is.
        !           545:         */
        !           546: 
        !           547:        if (cZtx_window % 1024 != 0 ||
        !           548:                cZtx_window < 4096 || cZtx_window > 65536 ||
        !           549:                65536 % cZtx_window != 0
        !           550:        ) {
        !           551:                ulog (LOG_ERROR,
        !           552:           "fzstart: cZtx_window not one of 4096, 8192, 16384, 32768, 65536");
        !           553:                return FALSE;
        !           554:        }
        !           555: 
        !           556:        zZtx_buf = (char *) xmalloc (CPACKETSIZE);
        !           557:        zZtx_packet_buf = (char *) xmalloc (CPACKBUFSIZE);
        !           558:        zZrx_packet_buf = (char *) xmalloc (CPACKBUFSIZE);
        !           559: 
        !           560:        iZlast_tx_data_packet = -1;
        !           561:        iZlast_rx_data_packet = -1;
        !           562: 
        !           563:        wpZtxpos = wpZlrxpos = wpZrxpos = wpZrxbytes = 0;
        !           564:        cZtxwspac = cZtx_window / 4;
        !           565: 
        !           566:        cZheaders_sent = cZheaders_received = cZbytes_resent = 0;
        !           567:        cZtimeouts = cZerrors = 0;
        !           568: 
        !           569:        iZpkt_rcvd_kludge = -1;
        !           570: 
        !           571: #if 0
        !           572:        /*
        !           573:         * We ensure <cZtx_window> is at least 4k, so the following is
        !           574:         * unnecessary. It can be put back in later if needed.
        !           575:         */
        !           576:        if (cZblklen_override > cZtxwspac
        !           577:            || (!cZblklen_override && cZtxwspac < 1024))
        !           578:                cZblklen_override = cZtxwspac;
        !           579: #endif
        !           580: 
        !           581: #ifdef DJE_TESTING
        !           582:        {
        !           583:                extern int uucptest,uucptest2,uucptestseed;
        !           584:                FILE *f;
        !           585: 
        !           586:                if (uucptest == -1) {
        !           587:                        f = fopen ("/usr/local/src/bin/uucp/uucptest", "r");
        !           588:                        if (f != NULL) {
        !           589:                                fscanf (f, "%d %d %d",
        !           590:                                        &uucptestseed, &uucptest, &uucptest2);
        !           591:                                fclose (f);
        !           592:                        }
        !           593:                        srand (uucptestseed);
        !           594:                }
        !           595:        }
        !           596: #endif
        !           597: 
        !           598:        /*
        !           599:         * Fire up the protocol (exchange init messages) ...
        !           600:         */
        !           601: 
        !           602:        if (!fzstart_proto (qdaemon))
        !           603:                return FALSE;
        !           604: 
        !           605:        return TRUE;
        !           606: }
        !           607: 
        !           608: /*
        !           609:  * Stop the protocol ...
        !           610:  */
        !           611: 
        !           612: boolean
        !           613: fzshutdown(qdaemon)
        !           614: struct sdaemon *qdaemon;
        !           615: {
        !           616:        (void) fzshutdown_proto (qdaemon);
        !           617: 
        !           618:        xfree ((pointer) zZtx_buf);
        !           619:        xfree ((pointer) zZtx_packet_buf);
        !           620:        xfree ((pointer) zZrx_packet_buf);
        !           621:        zZtx_buf = NULL;
        !           622:        zZtx_packet_buf = NULL;
        !           623:        zZrx_packet_buf = NULL;
        !           624: 
        !           625:        /*
        !           626:         * Print some informative statistics ...
        !           627:         *
        !           628:         * I use the word "messages" here instead of "headers" because the
        !           629:         * latter is jargonese.
        !           630:         */
        !           631: 
        !           632:        ulog (LOG_NORMAL,
        !           633:              "Protocol 'a' messages: sent %lu, received %lu",
        !           634:              cZheaders_sent, cZheaders_received);
        !           635:        ulog (LOG_NORMAL,
        !           636:              "Protocol 'a' packets: sent %lu, received %lu",
        !           637:              wpZtxpos / 1024, wpZrxbytes / 1024);
        !           638:        if (cZbytes_resent != 0 || cZtimeouts != 0 || cZerrors != 0)
        !           639:                ulog (LOG_NORMAL,
        !           640:            "Protocol 'a' errors: bytes resent %lu, timeouts %lu, errors %lu",
        !           641:                      cZbytes_resent, cZtimeouts, cZerrors);
        !           642: 
        !           643:        /*
        !           644:         * Reset all the parameters to their default values, so that the
        !           645:         * protocol parameters used for this connection do not affect the
        !           646:         * next one.
        !           647:         */
        !           648: 
        !           649:        cZtimeout = CTIMEOUT;
        !           650:        cZretries = CRETRIES;
        !           651:        cZstartup_retries = CSTARTUP_RETRIES;
        !           652:        cZmax_garbage = CGARBAGE;
        !           653:        cZtx_window = CSEND_WINDOW;
        !           654:        fZesc_ctl = FESCAPE_CONTROL;
        !           655: 
        !           656:        cZheaders_sent = cZheaders_received = cZbytes_resent = 0;
        !           657:        cZtimeouts = cZerrors = 0;
        !           658: 
        !           659:        return TRUE;
        !           660: }
        !           661: 
        !           662: /*
        !           663:  * Send a command string ...
        !           664:  * We send everything up to and including the null byte.
        !           665:  *
        !           666:  * We assume the command will fit in the outgoing data buffer.
        !           667:  * FIXME: A valid assumption?
        !           668:  */
        !           669: 
        !           670: /*ARGSUSED*/
        !           671: boolean
        !           672: fzsendcmd(qdaemon, z, ilocal, iremote)
        !           673: struct sdaemon *qdaemon;
        !           674: const char *z;
        !           675: int ilocal;
        !           676: int iremote;
        !           677: {
        !           678:        size_t n,clen;
        !           679:        long lredo;
        !           680:        char *zbuf;
        !           681: 
        !           682:        clen = strlen (z) + 1;
        !           683: 
        !           684:        DEBUG_MESSAGE1 (DEBUG_PROTO, "fzsendcmd: sending command %s", z);
        !           685: 
        !           686:        if (!fzstart_tx ())     /* must be called before zzgetspace() */
        !           687:                return FALSE;
        !           688: 
        !           689:        if ((zbuf = zzgetspace (qdaemon, &n)) == NULL)
        !           690:                return FALSE;
        !           691: 
        !           692: #if DEBUG > 0
        !           693:        if (clen > n)
        !           694:                ulog (LOG_FATAL, "fzsendcmd: clen > n");
        !           695: #endif
        !           696: 
        !           697:        strcpy (zbuf, z);
        !           698: 
        !           699:        /*
        !           700:         * Send it out ...
        !           701:         */
        !           702: 
        !           703:        do {
        !           704:                if (!fzsend_data (qdaemon, zbuf, clen, TRUE))
        !           705:                        return FALSE;
        !           706:                if (!fzfinish_tx (qdaemon, &lredo))
        !           707:                        return FALSE;
        !           708:        } while (lredo >= 0);
        !           709: 
        !           710:        return fzprocess (qdaemon);
        !           711: }
        !           712: 
        !           713: /*
        !           714:  * Allocate a packet to send out ...
        !           715:  *
        !           716:  * Note that 'z' has dynamic packet resizing and that <cZblklen> will range
        !           717:  * from 32 to 1024, in multiples of 2.
        !           718:  */
        !           719: 
        !           720: /*ARGSUSED*/
        !           721: char *
        !           722: zzgetspace(qdaemon, pclen)
        !           723: struct sdaemon *qdaemon;
        !           724: size_t *pclen;
        !           725: {
        !           726:        *pclen = cZblklen;
        !           727:        return zZtx_buf;
        !           728: }
        !           729: 
        !           730: /*
        !           731:  * Send a block of data ...
        !           732:  *
        !           733:  * If (cdata == 0) then the end of the file has been reached.
        !           734:  */
        !           735: 
        !           736: /*ARGSUSED*/
        !           737: boolean
        !           738: fzsenddata(qdaemon, zdata, cdata, ilocal, iremote, ipos)
        !           739: struct sdaemon *qdaemon;
        !           740: char *zdata;
        !           741: size_t cdata;
        !           742: int ilocal;
        !           743: int iremote;
        !           744: long ipos;
        !           745: {
        !           746:        DEBUG_MESSAGE1 (DEBUG_PROTO, "fzsenddata: %d bytes", cdata);
        !           747: 
        !           748:        if (! fzsend_data (qdaemon, zdata, cdata, cdata == 0))
        !           749:                return FALSE;
        !           750:        return fzprocess (qdaemon);
        !           751: }
        !           752: 
        !           753: /*
        !           754:  * Send a block of data (command or file) ...
        !           755:  */
        !           756: 
        !           757: /* This should buffer the data internally.  Until it does, it needs to
        !           758:    be able to reset the file position when it is called.  This is
        !           759:    really ugly.  */
        !           760: extern struct stransfer *qTsend;
        !           761: 
        !           762: static boolean
        !           763: fzsend_data(qdaemon, zdata, cdata, fendofmessage)
        !           764: struct sdaemon *qdaemon;
        !           765: char *zdata;
        !           766: size_t cdata;
        !           767: boolean fendofmessage;
        !           768: {
        !           769:        size_t n;
        !           770: 
        !           771:        if (iZlast_tx_data_packet == -1 || iZlast_tx_data_packet == ZCRCW) {
        !           772:                cZtxwcnt = cZrxwcnt = 0;
        !           773:                iZjunk_count = 0;
        !           774:                if (!fzsend_hdr (qdaemon, ZBIN, ZDATA,
        !           775:                                 hvzencode_data_hdr (wpZtxpos), TRUE))
        !           776:                        return FALSE;
        !           777:        }
        !           778: 
        !           779:        n = cdata;
        !           780: 
        !           781:        if (fendofmessage)
        !           782:                iZlast_tx_data_packet = ZCRCF;
        !           783:        else if (iZjunk_count > 3)
        !           784:                iZlast_tx_data_packet = ZCRCW;
        !           785:        else if (wpZtxpos == wpZlastsync)
        !           786:                iZlast_tx_data_packet = ZCRCW;
        !           787:        else if (cZrx_buf_len && (cZrxwcnt += n) >= cZrx_buf_len)
        !           788:                iZlast_tx_data_packet = ZCRCW;
        !           789:        else if ((cZtxwcnt += n) >= cZtxwspac) {
        !           790:                iZlast_tx_data_packet = ZCRCQ;
        !           791:                cZtxwcnt = 0;
        !           792:        } else
        !           793:                iZlast_tx_data_packet = ZCRCG;
        !           794: 
        !           795:        if (++iZtleft > 3) {
        !           796:                iZtleft = 0;
        !           797:                if (cZblklen < 1024)
        !           798:                        cZblklen *= 2;
        !           799: #if 0  /* <cZblklen_override> is currently unnecessary */
        !           800:                if (cZblklen_override && cZblklen > cZblklen_override)
        !           801:                        cZblklen = cZblklen_override;
        !           802: #endif
        !           803:                if (cZblklen > 1024)
        !           804:                        cZblklen = 1024;
        !           805:                if (cZrx_buf_len && cZblklen > cZrx_buf_len)
        !           806:                        cZblklen = cZrx_buf_len;
        !           807:        }
        !           808: 
        !           809: #if DEBUG > 1
        !           810:        if (FDEBUGGING(DEBUG_PROTO)) {
        !           811:                const char *type;
        !           812: 
        !           813:                switch (iZlast_tx_data_packet) {
        !           814:                case ZCRCW: type = "ZCRCW"; break;
        !           815:                case ZCRCG: type = "ZCRCG"; break;
        !           816:                case ZCRCQ: type = "ZCRCQ"; break;
        !           817:                case ZCRCE: type = "ZCRCE"; break;
        !           818:                case ZCRCF: type = "ZCRCF"; break;
        !           819:                default : type = "UNKNOWN!!!"; break;
        !           820:                }
        !           821:                DEBUG_MESSAGE3 (DEBUG_PROTO,
        !           822:                                "fzsend_data: %s, pos 0x%lx, %d bytes",
        !           823:                                type, wpZtxpos, n);
        !           824:        }
        !           825: #endif
        !           826: 
        !           827:        if (!fzsend_data_packet (qdaemon, zdata, n, iZlast_tx_data_packet,
        !           828:                                 TRUE))
        !           829:                return FALSE;
        !           830: 
        !           831:        wpZtxpos += n;
        !           832: 
        !           833:        if (iZlast_tx_data_packet == ZCRCW) {
        !           834:                /*
        !           835:                 * FIXME: Ideally this would be done in fzprocess. However, it
        !           836:                 *      is only called if there is data pending which there
        !           837:                 *      may not be yet. I could have patched fploop() a bit but
        !           838:                 *      for now, I've done it like this.
        !           839:                 */
        !           840:                switch (getinsync (qdaemon, FALSE)) {
        !           841:                case ZACK:
        !           842:                        break;
        !           843:                case ZRPOS:
        !           844:                        if (qTsend == NULL
        !           845:                            || ! ffileisopen (qTsend->e)) {
        !           846:                                ulog (LOG_ERROR, "Can't reset non-file");
        !           847:                                return FALSE;
        !           848:                        }
        !           849:                        iZlast_tx_data_packet = -1; /* trigger ZDATA */
        !           850:                        DEBUG_MESSAGE1 (DEBUG_PROTO,
        !           851:                                        "fzsend_data: Seeking to %ld",
        !           852:                                        (long) (wpZrxpos - wpZtxstart));
        !           853:                        if (!ffileseek (qTsend->e, wpZrxpos - wpZtxstart)) {
        !           854:                                ulog (LOG_ERROR, "seek: %s", strerror (errno));
        !           855:                                return FALSE;
        !           856:                        }
        !           857:                        break;
        !           858:                default:
        !           859:                        return FALSE;
        !           860:                }
        !           861:                return TRUE;
        !           862:        }
        !           863: 
        !           864:        /*
        !           865:         * If we've reached the maximum transmit window size, let the
        !           866:         * receiver catch up ...
        !           867:         *
        !           868:         * I use (cZtx_window - 2048) to play it safe.
        !           869:         */
        !           870: 
        !           871:        while (wpZtxpos - wpZlrxpos >= cZtx_window - 2048) {
        !           872:                if (iZlast_tx_data_packet != ZCRCQ) {
        !           873:                    if (!fzsend_data_packet (qdaemon, zdata, (size_t) 0,
        !           874:                                             iZlast_tx_data_packet = ZCRCQ,
        !           875:                                             TRUE))
        !           876:                                return FALSE;
        !           877:                }
        !           878:                /*
        !           879:                 * FIXME: I'd rather not call ffileseek() in this file. When we
        !           880:                 *      start buffering the outgoing data, the following
        !           881:                 *      ffileseek() will disappear.
        !           882:                 */
        !           883:                switch (getinsync (qdaemon, TRUE)) {
        !           884:                case ZACK:
        !           885:                        break;
        !           886:                case ZRPOS:
        !           887:                        if (qTsend == NULL
        !           888:                            || ! ffileisopen (qTsend->e)) {
        !           889:                                ulog (LOG_ERROR, "Can't reset non-file");
        !           890:                                return FALSE;
        !           891:                        }
        !           892:                        iZlast_tx_data_packet = -1; /* trigger ZDATA */
        !           893:                        DEBUG_MESSAGE1 (DEBUG_PROTO,
        !           894:                                        "fzsend_data: Seeking to %ld",
        !           895:                                        (long) (wpZrxpos - wpZtxstart));
        !           896:                        if (!ffileseek (qTsend->e, wpZrxpos - wpZtxstart)) {
        !           897:                                ulog (LOG_ERROR, "seek: %s", strerror (errno));
        !           898:                                return FALSE;
        !           899:                        }
        !           900:                        break;
        !           901:                default:
        !           902:                        return FALSE;
        !           903:                }
        !           904:        }
        !           905: 
        !           906:        return TRUE;
        !           907: }
        !           908: 
        !           909: /*
        !           910:  * Process existing data ...
        !           911:  */
        !           912: 
        !           913: static boolean
        !           914: fzprocess(qdaemon)
        !           915: struct sdaemon *qdaemon;
        !           916: {
        !           917:        int c,ch;
        !           918: 
        !           919:        while (fzreceive_ready ()) {
        !           920:                READCHAR (qdaemon, ch, 1);
        !           921:                switch (ch) {
        !           922:                case ZPAD:
        !           923:                        /* see if we're detecting ZRPOS packets quickly */
        !           924:                        DEBUG_MESSAGE0 (DEBUG_PROTO,
        !           925:                                        "fzprocess: possible ZRPOS packet");
        !           926:                        /* We just ate the ZPAD char that getinsync
        !           927:                           expects, so put it back.  */
        !           928:                        iPrecstart = ((iPrecstart + CRECBUFLEN - 1)
        !           929:                                      % CRECBUFLEN);
        !           930:                        c = getinsync (qdaemon, TRUE);
        !           931:                        if (c == ZACK)
        !           932:                                break;
        !           933:                        /* FIXME: sz does a TCFLSH here */
        !           934: #if 0  /* FIXME: Not sure if this is needed, or where to put it. */
        !           935:                        /* ZCRCE - dinna wanna starta ping-pong game */
        !           936:                        if (!fzsend_data_packet (qdaemon, zZtx_packet_buf,
        !           937:                                                 0, ZCRCE, TRUE))
        !           938:                                return FALSE;
        !           939: #endif
        !           940:                        if (c == ZRPOS) {
        !           941:                                if (qTsend == NULL
        !           942:                                    || ! ffileisopen (qTsend->e)) {
        !           943:                                        ulog (LOG_ERROR,
        !           944:                                              "Attempt to back up non-file");
        !           945:                                        return FALSE;
        !           946:                                }
        !           947:                                if (! ffileseek (qTsend->e,
        !           948:                                                 wpZrxpos - wpZtxstart)) {
        !           949:                                        ulog (LOG_ERROR,
        !           950:                                              "seek: %s", strerror (errno));
        !           951:                                        return FALSE;
        !           952:                                }
        !           953:                                iZlast_tx_data_packet = -1; /* trigger ZDATA */
        !           954:                                break;  /* not returning is intentional */
        !           955:                        }
        !           956:                        return FALSE;
        !           957:                case XOFF:
        !           958:                case XOFF | 0200:
        !           959:                        READCHAR (qdaemon, ch, XON_WAIT);
        !           960:                        break;
        !           961:                case CR:
        !           962:                        break;
        !           963:                default:
        !           964:                        iZjunk_count++;
        !           965:                        break;
        !           966:                }
        !           967:        }
        !           968: 
        !           969:        return TRUE;
        !           970: }
        !           971: 
        !           972: /*
        !           973:  * Wait for data to come in.
        !           974:  *
        !           975:  * This continues processing until a complete file or command has been
        !           976:  * received.
        !           977:  */
        !           978: 
        !           979: boolean
        !           980: fzwait(qdaemon)
        !           981: struct sdaemon *qdaemon;
        !           982: {
        !           983:        int c,cerr,rxcount;
        !           984:        boolean fexit;
        !           985:        achdrval_t rx_hdr;
        !           986: 
        !           987:        if (!fzstart_rx ())
        !           988:                return FALSE;
        !           989: 
        !           990:        cerr = cZretries;
        !           991: 
        !           992:        goto nxthdr;
        !           993: 
        !           994:        for (;;) {
        !           995:                if (!fzsend_hdr (qdaemon, ZHEX, ZRPOS,
        !           996:                                 hvzencode_data_hdr (wpZrxbytes), FALSE))
        !           997:                        return FALSE;
        !           998: nxthdr:
        !           999:                c = izrecv_hdr (qdaemon, rx_hdr);
        !          1000: 
        !          1001:                switch (c) {
        !          1002:                case ZM_TIMEOUT:
        !          1003:                case ZNAK:
        !          1004:                        if (--cerr < 0) {
        !          1005:                                ulog (LOG_ERROR, "fzwait: retries exhausted");
        !          1006:                                return FALSE;
        !          1007:                        }
        !          1008:                        continue;
        !          1009:                case ZM_ERROR:
        !          1010:                        if (--cerr < 0) {
        !          1011:                                ulog (LOG_ERROR, "fzwait: retries exhausted");
        !          1012:                                return FALSE;
        !          1013:                        }
        !          1014:                        /*fport_break ();*/
        !          1015:                        continue;
        !          1016:                case ZM_RCDO:
        !          1017:                case ZFIN:
        !          1018:                        return FALSE;
        !          1019:                case ZRPOS:
        !          1020:                case ZACK:
        !          1021:                        goto nxthdr;    /* ignore, partner is out of sync */
        !          1022:                case ZDATA: {
        !          1023:                        winpos_t rx_bytes;
        !          1024: 
        !          1025:                        zdecode_data_hdr (rclhdr (rx_hdr), &rx_bytes);
        !          1026:                        DEBUG_MESSAGE2 (DEBUG_PROTO,
        !          1027:                                "fzwait: bytes(us,them) 0x%lx,0x%lx",
        !          1028:                                wpZrxbytes, rx_bytes);
        !          1029:                        if (rx_bytes != wpZrxbytes) {
        !          1030:                                if (--cerr < 0) {
        !          1031:                                        ulog (LOG_ERROR,
        !          1032:                                              "fzwait: retries exhausted");
        !          1033:                                        return FALSE;
        !          1034:                                }
        !          1035:                                (void) zrdat32 (qdaemon, zZrx_packet_buf,
        !          1036:                                                1024, &rxcount);
        !          1037:                                /*fport_break ();*/
        !          1038:                                /*
        !          1039:                                 * FIXME: Seems to me we should ignore this one
        !          1040:                                 *      and go for a timeout, the theory being
        !          1041:                                 *      that the appropriate ZRPOS has already
        !          1042:                                 *      been sent. We're obviously out of sync.
        !          1043:                                 *      /dje 92Mar10
        !          1044:                                 */
        !          1045:                                continue;       /* goto nxthdr? */
        !          1046:                        }
        !          1047: moredata:
        !          1048:                        /*
        !          1049:                         * Do not call fgot_data() with (rxcount == 0) if it's
        !          1050:                         * not ZCRCF. fgot_data() will erroneously think this
        !          1051:                         * is the end of the message.
        !          1052:                         */
        !          1053:                        c = zrdat32 (qdaemon, zZrx_packet_buf, 1024,
        !          1054:                                     &rxcount);
        !          1055: #if DEBUG > 1
        !          1056:                        if (FDEBUGGING(DEBUG_PROTO)) {
        !          1057:                                const char *msg;
        !          1058: 
        !          1059:                                if (c < 0) {
        !          1060:                                        msg = ZZHEADER_NAME(c);
        !          1061:                                } else {
        !          1062:                                        switch (c) {
        !          1063:                                        case GOTCRCW: msg = "ZCRCW"; break;
        !          1064:                                        case GOTCRCG: msg = "ZCRCG"; break;
        !          1065:                                        case GOTCRCQ: msg = "ZCRCQ"; break;
        !          1066:                                        case GOTCRCE: msg = "ZCRCE"; break;
        !          1067:                                        case GOTCRCF: msg = "ZCRCF"; break;
        !          1068:                                        default : msg = NULL; break;
        !          1069:                                        }
        !          1070:                                }
        !          1071:                                if (msg != NULL)
        !          1072:                                        DEBUG_MESSAGE2 (DEBUG_PROTO,
        !          1073:                                              "fzwait: zrdat32: %s, %d bytes",
        !          1074:                                                        msg, rxcount);
        !          1075:                                else
        !          1076:                                        DEBUG_MESSAGE2 (DEBUG_PROTO,
        !          1077:                                              "fzwait: zrdat32: %d, %d bytes",
        !          1078:                                                        c, rxcount);
        !          1079:                        }
        !          1080: #endif
        !          1081:                        switch (c) {
        !          1082:                        case ZM_ERROR:  /* CRC error */
        !          1083:                                cZerrors++;
        !          1084:                                if (--cerr < 0) {
        !          1085:                                        ulog (LOG_ERROR,
        !          1086:                                              "fzwait: retries exhausted");
        !          1087:                                        return FALSE;
        !          1088:                                }
        !          1089:                                /*fport_break ();*/
        !          1090:                                continue;
        !          1091:                        case ZM_TIMEOUT:
        !          1092:                                cZtimeouts++;
        !          1093:                                if (--cerr < 0) {
        !          1094:                                        ulog (LOG_ERROR,
        !          1095:                                              "fzwait: retries exhausted");
        !          1096:                                        return FALSE;
        !          1097:                                }
        !          1098:                                continue;
        !          1099:                        case ZM_RCDO:
        !          1100:                                return FALSE;
        !          1101:                        case GOTCRCW:
        !          1102:                                iZlast_rx_data_packet = ZCRCW;
        !          1103:                                cerr = cZretries;
        !          1104:                                if (rxcount != 0
        !          1105:                                    && !fgot_data (qdaemon, zZrx_packet_buf,
        !          1106:                                                   (size_t) rxcount,
        !          1107:                                                   (const char *) NULL,
        !          1108:                                                   (size_t) 0,
        !          1109:                                                   -1, -1, (long) -1,
        !          1110:                                                   TRUE, &fexit))
        !          1111:                                        return FALSE;
        !          1112:                                wpZrxbytes += rxcount;
        !          1113:                                if (!fzsend_hdr (qdaemon, ZHEX, ZACK,
        !          1114:                                             hvzencode_data_hdr (wpZrxbytes),
        !          1115:                                             FALSE))
        !          1116:                                        return FALSE;
        !          1117:                                if (! fsend_data (qdaemon->qconn, &xon,
        !          1118:                                                  (size_t) 1, FALSE))
        !          1119:                                  return FALSE;
        !          1120:                                goto nxthdr;
        !          1121:                        case GOTCRCQ:
        !          1122:                                iZlast_rx_data_packet = ZCRCQ;
        !          1123:                                cerr = cZretries;
        !          1124:                                if (rxcount != 0
        !          1125:                                    && !fgot_data (qdaemon, zZrx_packet_buf,
        !          1126:                                                   (size_t) rxcount,
        !          1127:                                                   (const char *) NULL,
        !          1128:                                                   (size_t) 0,
        !          1129:                                                   -1, -1, (long) -1,
        !          1130:                                                   TRUE, &fexit))
        !          1131:                                        return FALSE;
        !          1132:                                wpZrxbytes += rxcount;
        !          1133:                                if (!fzsend_hdr (qdaemon, ZHEX, ZACK,
        !          1134:                                             hvzencode_data_hdr (wpZrxbytes),
        !          1135:                                             FALSE))
        !          1136:                                        return FALSE;
        !          1137:                                goto moredata;
        !          1138:                        case GOTCRCG:
        !          1139:                                iZlast_rx_data_packet = ZCRCG;
        !          1140:                                cerr = cZretries;
        !          1141:                                if (rxcount != 0
        !          1142:                                    && !fgot_data (qdaemon, zZrx_packet_buf,
        !          1143:                                                   (size_t) rxcount,
        !          1144:                                                   (const char *) NULL,
        !          1145:                                                   (size_t) 0,
        !          1146:                                                   -1, -1, (long) -1,
        !          1147:                                                   TRUE, &fexit))
        !          1148:                                        return FALSE;
        !          1149:                                wpZrxbytes += rxcount;
        !          1150:                                goto moredata;
        !          1151:                        case GOTCRCE:
        !          1152:                                iZlast_rx_data_packet = ZCRCE;
        !          1153:                                cerr = cZretries;
        !          1154:                                if (rxcount != 0
        !          1155:                                    && !fgot_data (qdaemon, zZrx_packet_buf,
        !          1156:                                                   (size_t) rxcount,
        !          1157:                                                   (const char *) NULL,
        !          1158:                                                   (size_t) 0,
        !          1159:                                                   -1, -1, (long) -1,
        !          1160:                                                   TRUE, &fexit))
        !          1161:                                        return FALSE;
        !          1162:                                wpZrxbytes += rxcount;
        !          1163:                                goto nxthdr;
        !          1164:                        case GOTCRCF:
        !          1165:                                iZlast_rx_data_packet = ZCRCF;
        !          1166:                                /*
        !          1167:                                 * fzfinish_rx() must be called before
        !          1168:                                 * fgot_data() because fgot_data() will send
        !          1169:                                 * out a UUCP-command but the sender won't be
        !          1170:                                 * ready for it until it receives our final
        !          1171:                                 * ZACK.
        !          1172:                                 */
        !          1173:                                cerr = cZretries;
        !          1174:                                wpZrxbytes += rxcount;
        !          1175:                                if (!fzfinish_rx (qdaemon))
        !          1176:                                        return FALSE;
        !          1177:                                if (!fgot_data (qdaemon, zZrx_packet_buf,
        !          1178:                                                (size_t) rxcount,
        !          1179:                                                (const char *) NULL,
        !          1180:                                                (size_t) 0, -1, -1,
        !          1181:                                                (long) -1, TRUE, &fexit))
        !          1182:                                        return FALSE;
        !          1183:                                /*
        !          1184:                                 * FIXME: Examine <fexit>?
        !          1185:                                 * Or maybe ensure it's TRUE?
        !          1186:                                 */
        !          1187:                                return TRUE;
        !          1188:                        }
        !          1189:                        return FALSE;
        !          1190:                }
        !          1191:                default:
        !          1192:                        ulog (LOG_FATAL, "fzwait: received header %s",
        !          1193:                                ZZHEADER_NAME(c));
        !          1194:                        return FALSE;
        !          1195:                }
        !          1196:        }
        !          1197: 
        !          1198:        return TRUE;
        !          1199: }
        !          1200: 
        !          1201: /*
        !          1202:  * File level routine. Called when initiating/terminating file transfers.
        !          1203:  *
        !          1204:  * When starting to send a file:       (TRUE, TRUE, cbytes)
        !          1205:  * When starting to receive a file:    (TRUE, FALSE, -1)
        !          1206:  * When send EOF, check resend:                (FALSE, TRUE, -1)
        !          1207:  * When receive EOF, check re-receive: (FALSE, FALSE, -1)
        !          1208:  */
        !          1209: 
        !          1210: boolean
        !          1211: fzfile(qdaemon, qtrans, fstart, fsend, cbytes, pfhandled)
        !          1212: struct sdaemon *qdaemon;
        !          1213: struct stransfer *qtrans;
        !          1214: boolean fstart;
        !          1215: boolean fsend;
        !          1216: long cbytes;
        !          1217: boolean *pfhandled;
        !          1218: {
        !          1219:        long iredo;
        !          1220: 
        !          1221:        *pfhandled = FALSE;
        !          1222: 
        !          1223:        DEBUG_MESSAGE2 (DEBUG_PROTO, "fzfile: fstart=%d, fsend=%d", fstart,
        !          1224:                        fsend);
        !          1225: 
        !          1226:        if (fsend) {
        !          1227:                if (fstart)
        !          1228:                        return fzstart_tx ();
        !          1229:                if (! fzfinish_tx (qdaemon, &iredo))
        !          1230:                        return FALSE;
        !          1231:                if (iredo >= 0) {
        !          1232:                        if (! ffileisopen (qtrans->e)) {
        !          1233:                                ulog (LOG_ERROR,
        !          1234:                                      "Attempt to back up non-file");
        !          1235:                                return FALSE;
        !          1236:                        }
        !          1237:                        if (! ffileseek (qtrans->e, iredo)) {
        !          1238:                                ulog (LOG_ERROR,
        !          1239:                                      "seek: %s", strerror (errno));
        !          1240:                                return FALSE;
        !          1241:                        }
        !          1242:                        *pfhandled = TRUE;
        !          1243:                        qtrans->fsendfile = TRUE;
        !          1244:                        return fqueue_send (qdaemon, qtrans);
        !          1245:                }
        !          1246:        }
        !          1247: 
        !          1248:        return TRUE;
        !          1249: }
        !          1250: 
        !          1251: /****************************************************************************/
        !          1252: 
        !          1253: 
        !          1254: #if 0  /* not used, we only use 32 bit crc's */
        !          1255: /*
        !          1256:  * crctab calculated by Mark G. Mendel, Network Systems Corporation
        !          1257:  */
        !          1258: 
        !          1259: static unsigned short crctab[256] = {
        !          1260:     0x0000,  0x1021,  0x2042,  0x3063,  0x4084,  0x50a5,  0x60c6,  0x70e7,
        !          1261:     0x8108,  0x9129,  0xa14a,  0xb16b,  0xc18c,  0xd1ad,  0xe1ce,  0xf1ef,
        !          1262:     0x1231,  0x0210,  0x3273,  0x2252,  0x52b5,  0x4294,  0x72f7,  0x62d6,
        !          1263:     0x9339,  0x8318,  0xb37b,  0xa35a,  0xd3bd,  0xc39c,  0xf3ff,  0xe3de,
        !          1264:     0x2462,  0x3443,  0x0420,  0x1401,  0x64e6,  0x74c7,  0x44a4,  0x5485,
        !          1265:     0xa56a,  0xb54b,  0x8528,  0x9509,  0xe5ee,  0xf5cf,  0xc5ac,  0xd58d,
        !          1266:     0x3653,  0x2672,  0x1611,  0x0630,  0x76d7,  0x66f6,  0x5695,  0x46b4,
        !          1267:     0xb75b,  0xa77a,  0x9719,  0x8738,  0xf7df,  0xe7fe,  0xd79d,  0xc7bc,
        !          1268:     0x48c4,  0x58e5,  0x6886,  0x78a7,  0x0840,  0x1861,  0x2802,  0x3823,
        !          1269:     0xc9cc,  0xd9ed,  0xe98e,  0xf9af,  0x8948,  0x9969,  0xa90a,  0xb92b,
        !          1270:     0x5af5,  0x4ad4,  0x7ab7,  0x6a96,  0x1a71,  0x0a50,  0x3a33,  0x2a12,
        !          1271:     0xdbfd,  0xcbdc,  0xfbbf,  0xeb9e,  0x9b79,  0x8b58,  0xbb3b,  0xab1a,
        !          1272:     0x6ca6,  0x7c87,  0x4ce4,  0x5cc5,  0x2c22,  0x3c03,  0x0c60,  0x1c41,
        !          1273:     0xedae,  0xfd8f,  0xcdec,  0xddcd,  0xad2a,  0xbd0b,  0x8d68,  0x9d49,
        !          1274:     0x7e97,  0x6eb6,  0x5ed5,  0x4ef4,  0x3e13,  0x2e32,  0x1e51,  0x0e70,
        !          1275:     0xff9f,  0xefbe,  0xdfdd,  0xcffc,  0xbf1b,  0xaf3a,  0x9f59,  0x8f78,
        !          1276:     0x9188,  0x81a9,  0xb1ca,  0xa1eb,  0xd10c,  0xc12d,  0xf14e,  0xe16f,
        !          1277:     0x1080,  0x00a1,  0x30c2,  0x20e3,  0x5004,  0x4025,  0x7046,  0x6067,
        !          1278:     0x83b9,  0x9398,  0xa3fb,  0xb3da,  0xc33d,  0xd31c,  0xe37f,  0xf35e,
        !          1279:     0x02b1,  0x1290,  0x22f3,  0x32d2,  0x4235,  0x5214,  0x6277,  0x7256,
        !          1280:     0xb5ea,  0xa5cb,  0x95a8,  0x8589,  0xf56e,  0xe54f,  0xd52c,  0xc50d,
        !          1281:     0x34e2,  0x24c3,  0x14a0,  0x0481,  0x7466,  0x6447,  0x5424,  0x4405,
        !          1282:     0xa7db,  0xb7fa,  0x8799,  0x97b8,  0xe75f,  0xf77e,  0xc71d,  0xd73c,
        !          1283:     0x26d3,  0x36f2,  0x0691,  0x16b0,  0x6657,  0x7676,  0x4615,  0x5634,
        !          1284:     0xd94c,  0xc96d,  0xf90e,  0xe92f,  0x99c8,  0x89e9,  0xb98a,  0xa9ab,
        !          1285:     0x5844,  0x4865,  0x7806,  0x6827,  0x18c0,  0x08e1,  0x3882,  0x28a3,
        !          1286:     0xcb7d,  0xdb5c,  0xeb3f,  0xfb1e,  0x8bf9,  0x9bd8,  0xabbb,  0xbb9a,
        !          1287:     0x4a75,  0x5a54,  0x6a37,  0x7a16,  0x0af1,  0x1ad0,  0x2ab3,  0x3a92,
        !          1288:     0xfd2e,  0xed0f,  0xdd6c,  0xcd4d,  0xbdaa,  0xad8b,  0x9de8,  0x8dc9,
        !          1289:     0x7c26,  0x6c07,  0x5c64,  0x4c45,  0x3ca2,  0x2c83,  0x1ce0,  0x0cc1,
        !          1290:     0xef1f,  0xff3e,  0xcf5d,  0xdf7c,  0xaf9b,  0xbfba,  0x8fd9,  0x9ff8,
        !          1291:     0x6e17,  0x7e36,  0x4e55,  0x5e74,  0x2e93,  0x3eb2,  0x0ed1,  0x1ef0
        !          1292: };
        !          1293: #endif /* crctab */
        !          1294: 
        !          1295: /*
        !          1296:  * Copyright (C) 1986 Gary S. Brown.  You may use this program, or
        !          1297:  * code or tables extracted from it, as desired without restriction.
        !          1298:  */
        !          1299: 
        !          1300: /* First, the polynomial itself and its table of feedback terms.  The  */
        !          1301: /* polynomial is                                                       */
        !          1302: /* X^32+X^26+X^23+X^22+X^16+X^12+X^11+X^10+X^8+X^7+X^5+X^4+X^2+X^1+X^0 */
        !          1303: /* Note that we take it "backwards" and put the highest-order term in  */
        !          1304: /* the lowest-order bit.  The X^32 term is "implied"; the LSB is the   */
        !          1305: /* X^31 term, etc.  The X^0 term (usually shown as "+1") results in    */
        !          1306: /* the MSB being 1.                                                    */
        !          1307: 
        !          1308: /* Note that the usual hardware shift register implementation, which   */
        !          1309: /* is what we're using (we're merely optimizing it by doing eight-bit  */
        !          1310: /* chunks at a time) shifts bits into the lowest-order term.  In our   */
        !          1311: /* implementation, that means shifting towards the right.  Why do we   */
        !          1312: /* do it this way?  Because the calculated CRC must be transmitted in  */
        !          1313: /* order from highest-order term to lowest-order term.  UARTs transmit */
        !          1314: /* characters in order from LSB to MSB.  By storing the CRC this way,  */
        !          1315: /* we hand it to the UART in the order low-byte to high-byte; the UART */
        !          1316: /* sends each low-bit to hight-bit; and the result is transmission bit */
        !          1317: /* by bit from highest- to lowest-order term without requiring any bit */
        !          1318: /* shuffling on our part.  Reception works similarly.                  */
        !          1319: 
        !          1320: /* The feedback terms table consists of 256, 32-bit entries.  Notes:   */
        !          1321: /*                                                                     */
        !          1322: /*     The table can be generated at runtime if desired; code to do so */
        !          1323: /*     is shown later.  It might not be obvious, but the feedback      */
        !          1324: /*     terms simply represent the results of eight shift/xor opera-    */
        !          1325: /*     tions for all combinations of data and CRC register values.     */
        !          1326: /*                                                                     */
        !          1327: /*     The values must be right-shifted by eight bits by the "updcrc"  */
        !          1328: /*     logic; the shift must be unsigned (bring in zeroes).  On some   */
        !          1329: /*     hardware you could probably optimize the shift in assembler by  */
        !          1330: /*     using byte-swap instructions.                                   */
        !          1331: 
        !          1332: static unsigned long crc_32_tab[] = { /* CRC polynomial 0xedb88320 */
        !          1333:     0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL,
        !          1334:     0x076dc419L, 0x706af48fL, 0xe963a535L, 0x9e6495a3L,
        !          1335:     0x0edb8832L, 0x79dcb8a4L, 0xe0d5e91eL, 0x97d2d988L,
        !          1336:     0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L, 0x90bf1d91L,
        !          1337:     0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
        !          1338:     0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L,
        !          1339:     0x136c9856L, 0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL,
        !          1340:     0x14015c4fL, 0x63066cd9L, 0xfa0f3d63L, 0x8d080df5L,
        !          1341:     0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L, 0xa2677172L,
        !          1342:     0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
        !          1343:     0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L,
        !          1344:     0x32d86ce3L, 0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L,
        !          1345:     0x26d930acL, 0x51de003aL, 0xc8d75180L, 0xbfd06116L,
        !          1346:     0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L, 0xb8bda50fL,
        !          1347:     0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
        !          1348:     0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL,
        !          1349:     0x76dc4190L, 0x01db7106L, 0x98d220bcL, 0xefd5102aL,
        !          1350:     0x71b18589L, 0x06b6b51fL, 0x9fbfe4a5L, 0xe8b8d433L,
        !          1351:     0x7807c9a2L, 0x0f00f934L, 0x9609a88eL, 0xe10e9818L,
        !          1352:     0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
        !          1353:     0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL,
        !          1354:     0x6c0695edL, 0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L,
        !          1355:     0x65b0d9c6L, 0x12b7e950L, 0x8bbeb8eaL, 0xfcb9887cL,
        !          1356:     0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L, 0xfbd44c65L,
        !          1357:     0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
        !          1358:     0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL,
        !          1359:     0x4369e96aL, 0x346ed9fcL, 0xad678846L, 0xda60b8d0L,
        !          1360:     0x44042d73L, 0x33031de5L, 0xaa0a4c5fL, 0xdd0d7cc9L,
        !          1361:     0x5005713cL, 0x270241aaL, 0xbe0b1010L, 0xc90c2086L,
        !          1362:     0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
        !          1363:     0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L,
        !          1364:     0x59b33d17L, 0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL,
        !          1365:     0xedb88320L, 0x9abfb3b6L, 0x03b6e20cL, 0x74b1d29aL,
        !          1366:     0xead54739L, 0x9dd277afL, 0x04db2615L, 0x73dc1683L,
        !          1367:     0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,
        !          1368:     0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L,
        !          1369:     0xf00f9344L, 0x8708a3d2L, 0x1e01f268L, 0x6906c2feL,
        !          1370:     0xf762575dL, 0x806567cbL, 0x196c3671L, 0x6e6b06e7L,
        !          1371:     0xfed41b76L, 0x89d32be0L, 0x10da7a5aL, 0x67dd4accL,
        !          1372:     0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
        !          1373:     0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L,
        !          1374:     0xd1bb67f1L, 0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL,
        !          1375:     0xd80d2bdaL, 0xaf0a1b4cL, 0x36034af6L, 0x41047a60L,
        !          1376:     0xdf60efc3L, 0xa867df55L, 0x316e8eefL, 0x4669be79L,
        !          1377:     0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
        !          1378:     0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL,
        !          1379:     0xc5ba3bbeL, 0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L,
        !          1380:     0xc2d7ffa7L, 0xb5d0cf31L, 0x2cd99e8bL, 0x5bdeae1dL,
        !          1381:     0x9b64c2b0L, 0xec63f226L, 0x756aa39cL, 0x026d930aL,
        !          1382:     0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
        !          1383:     0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L,
        !          1384:     0x92d28e9bL, 0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L,
        !          1385:     0x86d3d2d4L, 0xf1d4e242L, 0x68ddb3f8L, 0x1fda836eL,
        !          1386:     0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L, 0x18b74777L,
        !          1387:     0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
        !          1388:     0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L,
        !          1389:     0xa00ae278L, 0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L,
        !          1390:     0xa7672661L, 0xd06016f7L, 0x4969474dL, 0x3e6e77dbL,
        !          1391:     0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L, 0x37d83bf0L,
        !          1392:     0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
        !          1393:     0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L,
        !          1394:     0xbad03605L, 0xcdd70693L, 0x54de5729L, 0x23d967bfL,
        !          1395:     0xb3667a2eL, 0xc4614ab8L, 0x5d681b02L, 0x2a6f2b94L,
        !          1396:     0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL, 0x2d02ef8dL
        !          1397: };
        !          1398: 
        !          1399: /*
        !          1400:  * updcrc macro derived from article Copyright (C) 1986 Stephen Satchell. 
        !          1401:  *  NOTE: First argument must be in range 0 to 255.
        !          1402:  *        Second argument is referenced twice.
        !          1403:  * 
        !          1404:  * Programmers may incorporate any or all code into their programs, 
        !          1405:  * giving proper credit within the source. Publication of the 
        !          1406:  * source routines is permitted so long as proper credit is given 
        !          1407:  * to Stephen Satchell, Satchell Evaluations and Chuck Forsberg, 
        !          1408:  * Omen Technology.
        !          1409:  */
        !          1410: 
        !          1411: #define updcrc(cp, crc) (crctab[((crc >> 8) & 255)] ^ (crc << 8) ^ cp)
        !          1412: 
        !          1413: #define UPDC32(b, crc) \
        !          1414:   (crc_32_tab[((unsigned)(crc) ^ (unsigned)(b)) & 0xff] \
        !          1415:    ^ (((crc) >> 8) & 0x00ffffffL))
        !          1416: 
        !          1417: /****************************************************************************/
        !          1418: 
        !          1419: /*
        !          1420:  * This section contains the guts of the Zmodem protocol. The intention
        !          1421:  * is to leave as much of it alone as possible at the start. Overtime it
        !          1422:  * will be cleaned up (EG: I'd like to clean up the naming of the globals).
        !          1423:  * Also, Zmodem has a different coding style. Over time this will be converted
        !          1424:  * to the Taylor UUCP coding style.
        !          1425:  */
        !          1426: 
        !          1427: /*
        !          1428:  * Start the protocol (exchange init packets) ...
        !          1429:  *
        !          1430:  * UUCP can transfer files in both directions in one session. Therefore the
        !          1431:  * init sequence is a little different.
        !          1432:  *
        !          1433:  * 1) ZINIT packets are exchanged
        !          1434:  *    - contains protocol version and protocol flags
        !          1435:  * 2) ZDATA packets are exchanged
        !          1436:  *    - is intended to contain various numeric and string information
        !          1437:  * 3) ZACK packets are exchanged
        !          1438:  * 4) ZINITEND packets are exchanged
        !          1439:  */
        !          1440: 
        !          1441: static boolean
        !          1442: fzstart_proto(qdaemon)
        !          1443: struct sdaemon *qdaemon;
        !          1444: {
        !          1445:        int i;
        !          1446:        achdrval_t tx_hdr,rx_hdr;
        !          1447: 
        !          1448:        for (i = 0; i < cZstartup_retries; i++) {
        !          1449:                stohdr (0L, tx_hdr);
        !          1450:                tx_hdr[ZF0] = ZPROTOCOL_VERSION;
        !          1451:                if (fZesc_ctl)
        !          1452:                        tx_hdr[ZF1] |= TX_ESCCTL;
        !          1453:                switch (izexchange_init (qdaemon, ZINIT, tx_hdr, rx_hdr)) {
        !          1454:                case -1: return FALSE;
        !          1455:                case 0:  continue;
        !          1456:                case 1:  break;
        !          1457:                }
        !          1458: #if 0  /* can't work, but kept for documentation */
        !          1459:                if (rx_hdr[ZF0] == 0) {
        !          1460:                        ulog (LOG_ERROR, "Old protocol version, init failed");
        !          1461:                        return FALSE;
        !          1462:                }
        !          1463: #endif
        !          1464:                fZesc_ctl = fZesc_ctl || (rx_hdr[ZF1] & TX_ESCCTL) != 0;
        !          1465: 
        !          1466:                stohdr (0L, tx_hdr);
        !          1467:                switch (izexchange_init (qdaemon, ZDATA, tx_hdr, rx_hdr)) {
        !          1468:                case -1: return FALSE;
        !          1469:                case 0:  continue;
        !          1470:                case 1:  break;
        !          1471:                }
        !          1472: 
        !          1473:                stohdr (0L, tx_hdr);
        !          1474:                switch (izexchange_init (qdaemon, ZACK, tx_hdr, rx_hdr)) {
        !          1475:                case -1: return FALSE;
        !          1476:                case 0:  continue;
        !          1477:                case 1:  break;
        !          1478:                }
        !          1479: 
        !          1480:                stohdr (0L, tx_hdr);
        !          1481:                switch (izexchange_init (qdaemon, ZINITEND, tx_hdr, rx_hdr)) {
        !          1482:                case -1: return FALSE;
        !          1483:                case 0:  continue;
        !          1484:                case 1:  break;
        !          1485:                }
        !          1486: 
        !          1487:                DEBUG_MESSAGE0 (DEBUG_PROTO,
        !          1488:                                "fzstart_proto: Protocol started");
        !          1489:                return TRUE;
        !          1490: 
        !          1491:                /* FIXME: see protg.c regarding sequencing here. */
        !          1492:        }
        !          1493: 
        !          1494:        ulog (LOG_ERROR, "Protocol init failed");
        !          1495:        return FALSE;
        !          1496: }
        !          1497: 
        !          1498: /*
        !          1499:  * Exchange init messages. This is based on 'g'.
        !          1500:  * See the comments concerning fgexchange_init() in protg.c.
        !          1501:  *
        !          1502:  * We return 1 for success, 0 for restart, -1 for comm failure (terminate).
        !          1503:  */
        !          1504: 
        !          1505: static int
        !          1506: izexchange_init(qdaemon, send_type, send_val, recv_val)
        !          1507: struct sdaemon *qdaemon;
        !          1508: int send_type;
        !          1509: achdrval_t send_val;
        !          1510: achdrval_t recv_val;
        !          1511: {
        !          1512:        int i,recv_type,count;
        !          1513: 
        !          1514:        for (i = 0; i < CEXCHANGE_INIT_RETRIES; i++) {
        !          1515:                if (!fzsend_hdr (qdaemon, send_type == ZDATA ? ZBIN : ZHEX,
        !          1516:                                 send_type, rclhdr (send_val), FALSE))
        !          1517:                        return -1;
        !          1518: 
        !          1519:                /*
        !          1520:                 * The ZDATA packet is intended to contain the <Attn> string
        !          1521:                 * (eventually, if it's ever usable) and allow for anything
        !          1522:                 * else that will need to be thrown in.
        !          1523:                 */
        !          1524: 
        !          1525:                if (send_type == ZDATA) {
        !          1526:                        count = czbuild_data_packet (zZtx_packet_buf, "",
        !          1527:                                                     (size_t) 1, ZCRCF);
        !          1528:                        if (!fsend_data (qdaemon->qconn, zZtx_packet_buf,
        !          1529:                                         (size_t) count, FALSE))
        !          1530:                                return -1;
        !          1531:                }
        !          1532: 
        !          1533:                recv_type = izrecv_hdr (qdaemon, recv_val);
        !          1534: 
        !          1535:                switch (recv_type) {
        !          1536:                case ZM_TIMEOUT:
        !          1537:                case ZM_ERROR:
        !          1538:                        continue;
        !          1539:                case ZM_RCDO:
        !          1540:                case ZFIN:
        !          1541:                        return -1;
        !          1542:                case ZINIT:
        !          1543:                case ZACK:
        !          1544:                case ZINITEND:
        !          1545:                        break;
        !          1546:                case ZDATA:
        !          1547:                        if (zrdat32 (qdaemon, zZrx_packet_buf, 1024, &count)
        !          1548:                            == GOTCRCF)
        !          1549:                                break;
        !          1550:                        continue;
        !          1551:                default:
        !          1552:                        continue;
        !          1553:                }
        !          1554: 
        !          1555:                if (recv_type == send_type)
        !          1556:                        return 1;
        !          1557: 
        !          1558:                /*
        !          1559:                 * If the other side is farther along than we are, we have lost
        !          1560:                 * a packet.  Fall immediately back to ZINIT (but don't fail
        !          1561:                 * if we are already doing ZINIT, since that would count
        !          1562:                 * against cStart_retries more than it should).
        !          1563:                 *
        !          1564:                 * FIXME: The ">" test is "<" in protg.c. Check who's right.
        !          1565:                 */
        !          1566: 
        !          1567:                if (recv_type > send_type && send_type != ZINIT)
        !          1568:                        return 0;
        !          1569: 
        !          1570:                /*
        !          1571:                 * If we are sending ZINITEND and we receive an ZINIT, the
        !          1572:                 * other side has falled back (we know this because we have
        !          1573:                 * seen a ZINIT from them).  Fall back ourselves to start
        !          1574:                 * the whole handshake over again.
        !          1575:                 */
        !          1576: 
        !          1577:                if (recv_type == ZINIT && send_type == ZINITEND)
        !          1578:                        return 0;
        !          1579:        }
        !          1580: 
        !          1581:        return 0;
        !          1582: }
        !          1583: 
        !          1584: /*
        !          1585:  * Shut down the protocol ...
        !          1586:  */
        !          1587: 
        !          1588: static boolean
        !          1589: fzshutdown_proto(qdaemon)
        !          1590: struct sdaemon *qdaemon;
        !          1591: {
        !          1592:        (void) fzsend_hdr (qdaemon, ZHEX, ZFIN, 0L, FALSE);
        !          1593:        return TRUE;
        !          1594: }
        !          1595: 
        !          1596: /*
        !          1597:  * Reset the transmitter side for sending a new message ...
        !          1598:  */
        !          1599: 
        !          1600: static boolean
        !          1601: fzstart_tx()
        !          1602: {
        !          1603:        iZlast_tx_data_packet = -1;
        !          1604: 
        !          1605:        /*
        !          1606:         * <wpZlastsync> is set to -1L to suppress ZCRCW request otherwise
        !          1607:         * triggered by (wpZlastsync == wpZtxpos).
        !          1608:         */
        !          1609: 
        !          1610:        cZblklen = 1024;
        !          1611:        wpZlastsync = -1L;
        !          1612:        iZbeenhereb4 = 0;
        !          1613:        iZtleft = 0;
        !          1614:        iZjunk_count = 0;
        !          1615: 
        !          1616:        wpZtxpos = (wpZtxpos + 1024L) & ~1023L; /* next packet boundary */
        !          1617:        wpZlrxpos = wpZrxpos = wpZtxpos;
        !          1618: 
        !          1619:        wpZtxstart = wpZtxpos;  /* so we can compute the "file offset" */
        !          1620: 
        !          1621:        return TRUE;
        !          1622: }
        !          1623: 
        !          1624: /*
        !          1625:  * Finish the sending of a message ...
        !          1626:  *
        !          1627:  * Basically, we wait for some indication that the receiver received our last
        !          1628:  * message. If the receiver tells us to restart from some point, we set
        !          1629:  * *plredo to that point.
        !          1630:  *
        !          1631:  * FIXME: This function is a major kludge at the moment. It is taken from
        !          1632:  *     getinsync(). It is necessary because I don't yet buffer outgoing data.
        !          1633:  *     It will go away when we do (buffer outgoing data).
        !          1634:  */
        !          1635: 
        !          1636: static boolean
        !          1637: fzfinish_tx(qdaemon, plredo)
        !          1638: struct sdaemon *qdaemon;
        !          1639: long *plredo;
        !          1640: {
        !          1641:        int c,cerr,ctimeouts;
        !          1642:        achdrval_t rx_hdr;
        !          1643:        winpos_t rx_bytes;
        !          1644: 
        !          1645:        *plredo = -1;
        !          1646:        cerr = cZretries;
        !          1647:        ctimeouts = 0;
        !          1648: 
        !          1649:        DEBUG_MESSAGE4 (DEBUG_PROTO,
        !          1650:          "fzfinish_tx: txpos=0x%lx, rxpos=0x%lx, lrxpos=0x%lx, rxbytes=0x%lx",
        !          1651:                        wpZtxpos, wpZrxpos, wpZlrxpos, wpZrxbytes);
        !          1652: 
        !          1653:        for (;;) {
        !          1654:                c = izrecv_hdr (qdaemon, rx_hdr);
        !          1655: 
        !          1656:                switch (c) {
        !          1657:                case ZRPOS:
        !          1658:                        wpZrxpos = lzupdate_rxpos (rx_hdr, wpZrxpos,
        !          1659:                                                   wpZlrxpos, wpZtxpos);
        !          1660:                        /*
        !          1661:                         * If the receiver sends a ZRPOS for the 1k block after
        !          1662:                         * the one we're currently at, we lost the final ZACK.
        !          1663:                         * We cheat and ignore this ZRPOS. Remember: the theory
        !          1664:                         * is that this entire function will go away when we
        !          1665:                         * begin buffering the outgoing data. Of course, one
        !          1666:                         * can reword the protocol definition and say this
        !          1667:                         * isn't cheating at all.
        !          1668:                         */
        !          1669:                        if (((wpZtxpos + 1024) & ~1023) == wpZrxpos)
        !          1670:                                return TRUE;
        !          1671:                        cZbytes_resent += wpZtxpos - wpZrxpos;
        !          1672:                        wpZlrxpos = wpZtxpos = wpZrxpos;
        !          1673:                        if (wpZlastsync == wpZrxpos) {
        !          1674:                                if (++iZbeenhereb4 > 4)
        !          1675:                                        if (cZblklen > 32)
        !          1676:                                                cZblklen /= 2;
        !          1677:                                /* FIXME: shouldn't we reset iZbeenhereb4? */
        !          1678:                        }
        !          1679:                        wpZlastsync = wpZrxpos;
        !          1680:                        iZlast_tx_data_packet = ZCRCW; /* force a timeout */
        !          1681:                        *plredo = wpZrxpos - wpZtxstart;
        !          1682:                        return TRUE;
        !          1683:                case ZACK:
        !          1684:                        wpZrxpos = lzupdate_rxpos (rx_hdr, wpZrxpos,
        !          1685:                                                   wpZlrxpos, wpZtxpos);
        !          1686:                        wpZlrxpos = wpZrxpos;
        !          1687:                        if (wpZtxpos == wpZrxpos)  /* the ACK we want? */
        !          1688:                                return TRUE;
        !          1689:                        break;
        !          1690:                case ZDATA:
        !          1691:                        /*
        !          1692:                         * We cheat here and take advantage of UUCP's current
        !          1693:                         * half duplex nature. If we get a ZDATA starting on
        !          1694:                         * the next 1k boundary, we lost the ZACK. We cheat and
        !          1695:                         * tuck it away so that izrecv_hdr() can later detect
        !          1696:                         * it. Remember: see above.
        !          1697:                         */
        !          1698:                        zdecode_data_hdr (rclhdr (rx_hdr), &rx_bytes);
        !          1699:                        if (((wpZrxbytes + 1024L) & ~1023L) == rx_bytes) {
        !          1700:                                iZpkt_rcvd_kludge = ZDATA;
        !          1701:                                hvZpkt_hdrval_kludge = rclhdr (rx_hdr);
        !          1702:                                return TRUE;
        !          1703:                        }
        !          1704:                        break;  /* ignore, out of sync (old) */
        !          1705:                case ZNAK:
        !          1706:                        /*
        !          1707:                         * We cheat here and take advantage of UUCP's current
        !          1708:                         * half duplex nature. If we get a ZNAK starting on
        !          1709:                         * the next 1k boundary, we lost the ZACK. We cheat and
        !          1710:                         * throw the ZNAK away. Remember: see above.
        !          1711:                         *
        !          1712:                         * On the other hand, if (rx_bytes == wpZrxbytes) then
        !          1713:                         * the other side is also in fzfinish_tx(). He must
        !          1714:                         * have lost our ZACK, so we send him another.
        !          1715:                         */
        !          1716:                        zdecode_data_hdr (rclhdr (rx_hdr), &rx_bytes);
        !          1717:                        if (((wpZrxbytes + 1024L) & ~1023L) == rx_bytes)
        !          1718:                                return TRUE;
        !          1719:                        if (rx_bytes == wpZrxbytes) {
        !          1720:                                if (!fzsend_hdr (qdaemon, ZHEX, ZACK,
        !          1721:                                             hvzencode_data_hdr (wpZrxbytes),
        !          1722:                                             TRUE))
        !          1723:                                        return FALSE;
        !          1724:                        }
        !          1725:                        break;  /* ignore, out of sync (old) */
        !          1726:                case ZFIN:
        !          1727:                case ZM_RCDO:
        !          1728:                        return FALSE;
        !          1729:                case ZM_TIMEOUT:
        !          1730:                        if (--cerr < 0) {
        !          1731:                                ulog (LOG_ERROR,
        !          1732:                                      "fzfinish_tx: retries exhausted");
        !          1733:                                return FALSE;
        !          1734:                        }
        !          1735:                        /*
        !          1736:                         * Normally the sender doesn't send NAK's for timeouts.
        !          1737:                         * We have to here because of the following scenario:
        !          1738:                         *
        !          1739:                         * - We send ZDATA/ZCRCF
        !          1740:                         * - They send ZACK (corrupted)
        !          1741:                         * - They send ZDATA/ZCRCF (corrupted)
        !          1742:                         *
        !          1743:                         * At this point, both sides are in fzfinish_tx().
        !          1744:                         * We only send ZNAK every second timeout to increase
        !          1745:                         * our timeout delay vs. our partner. This tries to
        !          1746:                         * avoid ZRPOS and ZNAK "passing in transit".
        !          1747:                         */
        !          1748:                        if (++ctimeouts % 2 == 0)
        !          1749:                                if (!fzsend_hdr (qdaemon, ZHEX, ZNAK,
        !          1750:                                                 hvzencode_data_hdr (wpZtxpos),
        !          1751:                                                 TRUE))
        !          1752:                                        return FALSE;
        !          1753:                        break;
        !          1754:                case ZM_ERROR:
        !          1755:                default:
        !          1756:                        if (--cerr < 0) {
        !          1757:                                ulog (LOG_ERROR,
        !          1758:                                      "fzfinish_tx: retries exhausted");
        !          1759:                                return FALSE;
        !          1760:                        }
        !          1761:                        if (!fzsend_hdr (qdaemon, ZHEX, ZNAK,
        !          1762:                                         hvzencode_data_hdr (wpZtxpos),
        !          1763:                                         TRUE))
        !          1764:                                return FALSE;
        !          1765:                        break;
        !          1766:                }
        !          1767:        }
        !          1768: }
        !          1769: 
        !          1770: /*
        !          1771:  * Initialize the receiver ...
        !          1772:  */
        !          1773: 
        !          1774: static boolean
        !          1775: fzstart_rx()
        !          1776: {
        !          1777:        wpZrxbytes = (wpZrxbytes + 1024L) & ~1023L; /* next packet boundary */
        !          1778: 
        !          1779:        return TRUE;
        !          1780: }
        !          1781: 
        !          1782: /*
        !          1783:  * Terminate the receiver ...
        !          1784:  *
        !          1785:  * Acknowledge the last packet received.
        !          1786:  */
        !          1787: 
        !          1788: static boolean
        !          1789: fzfinish_rx(qdaemon)
        !          1790: struct sdaemon *qdaemon;
        !          1791: {
        !          1792:        DEBUG_MESSAGE0 (DEBUG_PROTO, "fzfinish_rx: message/file received");
        !          1793: 
        !          1794:        return fzsend_hdr (qdaemon, ZHEX, ZACK,
        !          1795:                           hvzencode_data_hdr (wpZrxbytes), FALSE);
        !          1796: }
        !          1797: 
        !          1798: /*
        !          1799:  * Send a Zmodem header to our partner ...
        !          1800:  */
        !          1801: 
        !          1802: static boolean
        !          1803: fzsend_hdr(qdaemon, ipkttype, ihdrtype, hdrval, fcheckreceive)
        !          1804: struct sdaemon *qdaemon;
        !          1805: int ipkttype;
        !          1806: int ihdrtype;
        !          1807: hdrval_t hdrval;
        !          1808: boolean fcheckreceive;
        !          1809: {
        !          1810:        int cpacketlen;
        !          1811: 
        !          1812:        DEBUG_MESSAGE2 (DEBUG_PROTO, "fzsend_hdr: %s, data = 0x%lx",
        !          1813:                        ZZHEADER_NAME(ihdrtype), hdrval);
        !          1814: 
        !          1815:        cpacketlen = czbuild_header (zZtx_packet_buf, ipkttype,
        !          1816:                                     ihdrtype, hdrval);
        !          1817: 
        !          1818: #ifdef DJE_TESTING
        !          1819: #if 0
        !          1820:        if (ihdrtype == ZACK && rand () % 100 < uucptest2) {
        !          1821:                cZheaders_sent++;
        !          1822:                return TRUE;
        !          1823:        }
        !          1824: #else
        !          1825:        if (ihdrtype == ZACK || ihdrtype == ZDATA) {
        !          1826:                boolean fresult;
        !          1827:                int old;
        !          1828:                extern int uucptest,uucptest2;
        !          1829: 
        !          1830:                old = uucptest;
        !          1831:                uucptest = uucptest2;
        !          1832:                cZheaders_sent++;
        !          1833:                fresult = fsend_data (qdaemon->qconn, zZtx_packet_buf,
        !          1834:                                      (size_t) cpacketlen, fcheckreceive);
        !          1835:                uucptest = old;
        !          1836:                return fresult;
        !          1837:        }
        !          1838: #endif
        !          1839: #endif
        !          1840:        cZheaders_sent++;
        !          1841:        return fsend_data (qdaemon->qconn, zZtx_packet_buf,
        !          1842:                           (size_t) cpacketlen, fcheckreceive);
        !          1843: }
        !          1844: 
        !          1845: /*
        !          1846:  * Send a data packet to our partner ...
        !          1847:  * <frameend> is one of ZCRCx.
        !          1848:  */
        !          1849: 
        !          1850: static boolean
        !          1851: fzsend_data_packet(qdaemon, zdata, cdata, frameend, fcheckreceive)
        !          1852: struct sdaemon *qdaemon;
        !          1853: char *zdata;
        !          1854: size_t cdata;
        !          1855: int frameend;
        !          1856: boolean fcheckreceive;
        !          1857: {
        !          1858:        int cpacketlen;
        !          1859: 
        !          1860:        cpacketlen = czbuild_data_packet (zZtx_packet_buf, zdata, cdata,
        !          1861:                                          frameend);
        !          1862: 
        !          1863:        return fsend_data (qdaemon->qconn, zZtx_packet_buf,
        !          1864:                           (size_t) cpacketlen, fcheckreceive);
        !          1865: }
        !          1866: 
        !          1867: /*
        !          1868:  * Build Zmodem headers ...
        !          1869:  *
        !          1870:  * Note that we use 32 bit CRC's for ZHEX headers.
        !          1871:  *
        !          1872:  * This function is a combination of zm fns: zsbhdr(), zsbh32(), and zshhdr().
        !          1873:  */
        !          1874: 
        !          1875: static int
        !          1876: czbuild_header(zresult, ipkttype, ihdrtype, hdrval)
        !          1877: char *zresult;
        !          1878: int ipkttype;
        !          1879: int ihdrtype;
        !          1880: hdrval_t hdrval;
        !          1881: {
        !          1882:        char *p;
        !          1883:        int i;
        !          1884:        unsigned long crc;
        !          1885:        achdrval_t achdrval;
        !          1886: 
        !          1887:        p = zresult;
        !          1888: 
        !          1889:        switch (ipkttype) {
        !          1890:        case ZBIN:
        !          1891:                *p++ = ZPAD;
        !          1892:                *p++ = ZDLE;
        !          1893:                *p++ = ZBIN;
        !          1894:                p = zputchar (p, ihdrtype);
        !          1895:                crc = ICRCINIT;
        !          1896:                crc = UPDC32 (ihdrtype, crc);
        !          1897:                stohdr (hdrval, achdrval);
        !          1898:                for (i = 0; i < 4; i++) {
        !          1899:                        p = zputchar (p, achdrval[i]);
        !          1900:                        crc = UPDC32 (achdrval[i], crc);
        !          1901:                }
        !          1902:                crc = ~crc;
        !          1903:                for (i = 0; i < 4; i++) {
        !          1904:                        p = zputchar (p, (char) crc);
        !          1905:                        crc >>= 8;
        !          1906:                }
        !          1907:                break;
        !          1908:        case ZHEX:      /* build hex header */
        !          1909:                *p++ = ZPAD;
        !          1910:                *p++ = ZPAD;
        !          1911:                *p++ = ZDLE;
        !          1912:                *p++ = ZHEX;
        !          1913:                p = zputhex (p, ihdrtype);
        !          1914:                crc = ICRCINIT;
        !          1915:                crc = UPDC32 (ihdrtype, crc);
        !          1916:                stohdr (hdrval, achdrval);
        !          1917:                for (i = 0; i < 4; i++) {
        !          1918:                        p = zputhex (p, achdrval[i]);
        !          1919:                        crc = UPDC32 (achdrval[i], crc);
        !          1920:                }
        !          1921:                crc = ~crc;
        !          1922:                for (i = 0; i < 4; i++) {
        !          1923:                        p = zputhex (p, (char) crc);
        !          1924:                        crc >>= 8;
        !          1925:                }
        !          1926:                *p++ = CR;
        !          1927:                /*
        !          1928:                 * Uncork the remote in case a fake XOFF has stopped data flow.
        !          1929:                 */
        !          1930:                if (ihdrtype != ZFIN && ihdrtype != ZACK) /* FIXME: why? */
        !          1931:                        *p++ = XON;
        !          1932:                break;
        !          1933:        default:
        !          1934:                ulog (LOG_FATAL, "czbuild_header: ipkttype == %d", ipkttype);
        !          1935:                break;
        !          1936:        }
        !          1937: 
        !          1938:        return p - zresult;
        !          1939: }
        !          1940: 
        !          1941: /*
        !          1942:  * Build Zmodem data packets ...
        !          1943:  *
        !          1944:  * This function is zsdata() and zsda32() from the zm source.
        !          1945:  */
        !          1946: 
        !          1947: static int
        !          1948: czbuild_data_packet(zresult, zdata, cdata, frameend)
        !          1949: char *zresult;
        !          1950: const char *zdata;
        !          1951: size_t cdata;
        !          1952: int frameend;
        !          1953: {
        !          1954:        char *p;
        !          1955:        unsigned long crc;
        !          1956: 
        !          1957:        p = zresult;
        !          1958: 
        !          1959:        crc = ICRCINIT;
        !          1960:        for ( ; cdata-- != 0; zdata++) {
        !          1961:                char c;
        !          1962: 
        !          1963:                c = *zdata;
        !          1964:                if (c & 0140)
        !          1965:                        *p++ = c;
        !          1966:                else
        !          1967:                        p = zputchar (p, c);
        !          1968:                crc = UPDC32 ((unsigned char) c, crc);
        !          1969:        }
        !          1970:        *p++ = ZDLE;
        !          1971:        *p++ = frameend;
        !          1972:        crc = UPDC32 (frameend, crc);
        !          1973:        crc = ~crc;
        !          1974:        for (cdata = 0; cdata < 4; cdata++) {
        !          1975:                p = zputchar (p, (char) crc);
        !          1976:                crc >>= 8;
        !          1977:        }
        !          1978:        if (frameend == ZCRCW || frameend == ZCRCE || frameend == ZCRCF) {
        !          1979:                *p++ = CR;
        !          1980:                *p++ = XON;
        !          1981:        }
        !          1982: 
        !          1983:        return p - zresult;
        !          1984: }
        !          1985: 
        !          1986: /*
        !          1987:  * Read in a header ...
        !          1988:  *
        !          1989:  * This is function zgethdr() from the Zmodem source.
        !          1990:  */
        !          1991: 
        !          1992: static int
        !          1993: izrecv_hdr(qdaemon, hdr)
        !          1994: struct sdaemon *qdaemon;
        !          1995: achdrval_t hdr;
        !          1996: {
        !          1997:        int c,cerr;
        !          1998: 
        !          1999:        /*
        !          2000:         * Kludge alert! If another part of the program received a packet but
        !          2001:         * wasn't ready to handle it, it is tucked away for us to handle now.
        !          2002:         */
        !          2003: 
        !          2004:        if (iZpkt_rcvd_kludge != -1) {
        !          2005:                c = iZpkt_rcvd_kludge;
        !          2006:                iZpkt_rcvd_kludge = -1;
        !          2007:                stohdr (hvZpkt_hdrval_kludge, hdr);
        !          2008:                DEBUG_MESSAGE2 (DEBUG_PROTO,
        !          2009:                                "izrecv_hdr: queued %s, data = 0x%lx",
        !          2010:                                ZZHEADER_NAME(c), rclhdr (hdr));
        !          2011:                cZheaders_received++;
        !          2012:                return c;
        !          2013:        }
        !          2014: 
        !          2015:        cerr = cZmax_garbage;   /* Max bytes before start of frame */
        !          2016: 
        !          2017: again:
        !          2018:        switch (c = noxrd7 (qdaemon)) {
        !          2019:        case ZM_TIMEOUT:
        !          2020:        case ZM_ERROR:
        !          2021:        case ZM_RCDO:
        !          2022:                goto fifi;
        !          2023:        case ZPAD:              /* This is what we want */
        !          2024:                break;
        !          2025:        case CR:                /* padding at end of previous header */
        !          2026:        default:
        !          2027:                if (--cerr < 0) {
        !          2028:                        c = ZM_ERROR;
        !          2029:                        goto fifi;
        !          2030:                }
        !          2031:                goto again;
        !          2032:        }
        !          2033: 
        !          2034: splat:
        !          2035:        switch (c = noxrd7 (qdaemon)) {
        !          2036:        case ZPAD:
        !          2037:                if (--cerr < 0) {
        !          2038:                        c = ZM_ERROR;
        !          2039:                        goto fifi;
        !          2040:                }
        !          2041:                goto splat;
        !          2042:        case ZM_TIMEOUT:
        !          2043:        case ZM_RCDO:
        !          2044:                goto fifi;
        !          2045:        case ZDLE:              /* This is what we want */
        !          2046:                break;
        !          2047:        default:
        !          2048:                if (--cerr < 0) {
        !          2049:                        c = ZM_ERROR;
        !          2050:                        goto fifi;
        !          2051:                }
        !          2052:                goto again;
        !          2053:        }
        !          2054: 
        !          2055:        switch (c = noxrd7 (qdaemon)) {
        !          2056:        case ZM_TIMEOUT:
        !          2057:        case ZM_RCDO:
        !          2058:                goto fifi;
        !          2059:        case ZBIN:
        !          2060:                c = zrbhdr32 (qdaemon, hdr);
        !          2061:                break;
        !          2062:        case ZHEX:
        !          2063:                c = zrhhdr (qdaemon, hdr);
        !          2064:                break;
        !          2065:        default:
        !          2066:                if (--cerr < 0) {
        !          2067:                        c = ZM_ERROR;
        !          2068:                        goto fifi;
        !          2069:                }
        !          2070:                goto again;
        !          2071:        }
        !          2072: 
        !          2073: fifi:
        !          2074:        switch (c) {
        !          2075:        case ZM_TIMEOUT:
        !          2076:                cZtimeouts++;
        !          2077:                break;
        !          2078:        case ZM_ERROR:
        !          2079:                cZerrors++;
        !          2080:                break;
        !          2081:        case ZM_RCDO:
        !          2082:                break;
        !          2083:        default:
        !          2084:                cZheaders_received++;
        !          2085:                break;
        !          2086:        }
        !          2087:        DEBUG_MESSAGE2 (DEBUG_PROTO, "izrecv_hdr: %s, data = 0x%x",
        !          2088:                        ZZHEADER_NAME(c), rclhdr (hdr));
        !          2089: 
        !          2090:        return c;
        !          2091: }
        !          2092: 
        !          2093: /*
        !          2094:  * Receive a binary style header (type and position) with 32 bit FCS ...
        !          2095:  */
        !          2096: 
        !          2097: static int
        !          2098: zrbhdr32(qdaemon, hdr)
        !          2099: struct sdaemon *qdaemon;
        !          2100: achdrval_t hdr;
        !          2101: {
        !          2102:        int c,i,type;
        !          2103:        unsigned long crc;
        !          2104: 
        !          2105:        if ((c = zdlread (qdaemon)) & ~0377)
        !          2106:                return c;
        !          2107:        type = c;
        !          2108:        crc = ICRCINIT;
        !          2109:        crc = UPDC32 (c, crc);
        !          2110: 
        !          2111:        for (i = 0; i < 4; i++) {
        !          2112:                if ((c = zdlread (qdaemon)) & ~0377)
        !          2113:                        return c;
        !          2114:                crc = UPDC32 (c, crc);
        !          2115:                hdr[i] = (char) c;
        !          2116:        }
        !          2117:        for (i = 0; i < 4; i++) {
        !          2118:                if ((c = zdlread (qdaemon)) & ~0377)
        !          2119:                        return c;
        !          2120:                crc = UPDC32 (c, crc);
        !          2121:        }
        !          2122:        if (crc != IHDRCRC)
        !          2123:                return ZM_ERROR;
        !          2124: 
        !          2125:        return type;
        !          2126: }
        !          2127: 
        !          2128: /*
        !          2129:  * Receive a hex style header (type and position) ...
        !          2130:  */
        !          2131: 
        !          2132: static int
        !          2133: zrhhdr(qdaemon, hdr)
        !          2134: struct sdaemon *qdaemon;
        !          2135: achdrval_t hdr;
        !          2136: {
        !          2137:        int c,i,type;
        !          2138:        unsigned long crc;
        !          2139: 
        !          2140:        if ((c = zgethex (qdaemon)) < 0)
        !          2141:                return c;
        !          2142:        type = c;
        !          2143:        crc = ICRCINIT;
        !          2144:        crc = UPDC32 (c, crc);
        !          2145: 
        !          2146:        for (i = 0; i < 4; i++) {
        !          2147:                if ((c = zgethex (qdaemon)) < 0)
        !          2148:                        return c;
        !          2149:                crc = UPDC32 (c, crc);
        !          2150:                hdr[i] = (char) c;
        !          2151:        }
        !          2152:        for (i = 0; i < 4; i++) {
        !          2153:                if ((c = zgethex (qdaemon)) < 0)
        !          2154:                        return c;
        !          2155:                crc = UPDC32 (c, crc);
        !          2156:        }
        !          2157:        if (crc != IHDRCRC)
        !          2158:                return ZM_ERROR;
        !          2159: 
        !          2160:        return type;
        !          2161: }
        !          2162: 
        !          2163: /*
        !          2164:  * Receive a data packet ...
        !          2165:  */
        !          2166: 
        !          2167: static int
        !          2168: zrdat32(qdaemon, buf, length, iprxcount)
        !          2169: struct sdaemon *qdaemon;
        !          2170: char *buf;
        !          2171: int length;
        !          2172: int *iprxcount;
        !          2173: {
        !          2174:        int c,d;
        !          2175:        unsigned long crc;
        !          2176:        char *end;
        !          2177: 
        !          2178:        crc = ICRCINIT;
        !          2179:        *iprxcount = 0;
        !          2180:        end = buf + length;
        !          2181:        while (buf <= end) {
        !          2182:                if ((c = zdlread (qdaemon)) & ~0377) {
        !          2183: crcfoo:
        !          2184:                        switch (c) {
        !          2185:                        case GOTCRCE:
        !          2186:                        case GOTCRCG:
        !          2187:                        case GOTCRCQ:
        !          2188:                        case GOTCRCW:
        !          2189:                        case GOTCRCF:
        !          2190:                                d = c;
        !          2191:                                c &= 0377;
        !          2192:                                crc = UPDC32 (c, crc);
        !          2193:                                if ((c = zdlread (qdaemon)) & ~0377)
        !          2194:                                        goto crcfoo;
        !          2195:                                crc = UPDC32 (c, crc);
        !          2196:                                if ((c = zdlread (qdaemon)) & ~0377)
        !          2197:                                        goto crcfoo;
        !          2198:                                crc = UPDC32 (c, crc);
        !          2199:                                if ((c = zdlread (qdaemon)) & ~0377)
        !          2200:                                        goto crcfoo;
        !          2201:                                crc = UPDC32 (c, crc);
        !          2202:                                if ((c = zdlread (qdaemon)) & ~0377)
        !          2203:                                        goto crcfoo;
        !          2204:                                crc = UPDC32 (c, crc);
        !          2205:                                if (crc != IHDRCRC)
        !          2206:                                        return ZM_ERROR;
        !          2207:                                *iprxcount = length - (end - buf);
        !          2208:                                return d;
        !          2209:                        case ZM_TIMEOUT:
        !          2210:                        case ZM_RCDO:
        !          2211:                                return c;
        !          2212:                        default:
        !          2213:                                return ZM_ERROR;
        !          2214:                        }
        !          2215:                }
        !          2216:                *buf++ = (char) c;
        !          2217:                crc = UPDC32 (c, crc);
        !          2218:        }
        !          2219: 
        !          2220:        return ZM_ERROR;        /* bad packet, too long */
        !          2221: }
        !          2222: 
        !          2223: /*
        !          2224:  * Respond to receiver's complaint, get back in sync with receiver ...
        !          2225:  */
        !          2226: 
        !          2227: static int
        !          2228: getinsync(qdaemon, flag)
        !          2229: struct sdaemon *qdaemon;
        !          2230: boolean flag;
        !          2231: {
        !          2232:        int c,cerr;
        !          2233:        achdrval_t rx_hdr;
        !          2234: 
        !          2235:        cerr = cZretries;
        !          2236: 
        !          2237:        for (;;) {
        !          2238:                c = izrecv_hdr (qdaemon, rx_hdr);
        !          2239: 
        !          2240:                switch (c) {
        !          2241:                case ZRPOS:
        !          2242:                        wpZrxpos = lzupdate_rxpos (rx_hdr, wpZrxpos,
        !          2243:                                                   wpZlrxpos, wpZtxpos);
        !          2244:                        cZbytes_resent += wpZtxpos - wpZrxpos;
        !          2245:                        wpZlrxpos = wpZtxpos = wpZrxpos;
        !          2246:                        if (wpZlastsync == wpZrxpos) {
        !          2247:                                if (++iZbeenhereb4 > 4)
        !          2248:                                        if (cZblklen > 32)
        !          2249:                                                cZblklen /= 2;
        !          2250:                                /* FIXME: shouldn't we reset iZbeenhereb4? */
        !          2251:                        }
        !          2252:                        wpZlastsync = wpZrxpos;
        !          2253:                        return ZRPOS;
        !          2254:                case ZACK:
        !          2255:                        wpZrxpos = lzupdate_rxpos (rx_hdr, wpZrxpos,
        !          2256:                                                   wpZlrxpos, wpZtxpos);
        !          2257:                        wpZlrxpos = wpZrxpos;
        !          2258:                        if (flag || wpZtxpos == wpZrxpos)
        !          2259:                                return ZACK;
        !          2260:                        break;
        !          2261:                case ZNAK: {
        !          2262:                        winpos_t rx_bytes;
        !          2263:                        /*
        !          2264:                         * Our partner is in fzfinish_tx() and is waiting
        !          2265:                         * for ZACK ...
        !          2266:                         */
        !          2267:                        zdecode_data_hdr (rclhdr (rx_hdr), &rx_bytes);
        !          2268:                        if (rx_bytes == wpZrxbytes) {
        !          2269:                                if (!fzsend_hdr (qdaemon, ZHEX, ZACK,
        !          2270:                                             hvzencode_data_hdr (wpZrxbytes),
        !          2271:                                             TRUE))
        !          2272:                                        return FALSE;
        !          2273:                        }
        !          2274:                        break;
        !          2275:                }
        !          2276:                case ZFIN:
        !          2277:                case ZM_RCDO:
        !          2278:                        return c;
        !          2279:                case ZM_TIMEOUT:
        !          2280:                        if (--cerr < 0) {
        !          2281:                                ulog (LOG_ERROR,
        !          2282:                                      "getinsync: retries exhausted");
        !          2283:                                return ZM_ERROR;
        !          2284:                        }
        !          2285:                        break;  /* sender doesn't send ZNAK for timeout */
        !          2286:                case ZM_ERROR:
        !          2287:                default:
        !          2288:                        if (--cerr < 0) {
        !          2289:                                ulog (LOG_ERROR,
        !          2290:                                      "getinsync: retries exhausted");
        !          2291:                                return ZM_ERROR;
        !          2292:                        }
        !          2293:                        if (!fzsend_hdr (qdaemon, ZHEX, ZNAK,
        !          2294:                                         hvzencode_data_hdr (wpZtxpos),
        !          2295:                                         TRUE))
        !          2296:                                return ZM_ERROR;
        !          2297:                        break;
        !          2298:                }
        !          2299:        }
        !          2300: }
        !          2301: 
        !          2302: /*
        !          2303:  * Send a byte as two hex digits ...
        !          2304:  */
        !          2305: 
        !          2306: static char *
        !          2307: zputhex(p, ch)
        !          2308: char *p;
        !          2309: int ch;
        !          2310: {
        !          2311:        static char digits[] = "0123456789abcdef";
        !          2312: 
        !          2313:        *p++ = digits[(ch & 0xF0) >> 4];
        !          2314:        *p++ = digits[ch & 0xF];
        !          2315:        return p;
        !          2316: }
        !          2317: 
        !          2318: /*
        !          2319:  * Send character c with ZMODEM escape sequence encoding ...
        !          2320:  *
        !          2321:  * Escape XON, XOFF.
        !          2322:  * FIXME: Escape CR following @ (Telenet net escape) ... disabled for now
        !          2323:  *     Will need to put back references to <lastsent>.
        !          2324:  */
        !          2325: 
        !          2326: static char *
        !          2327: zputchar(p, ch)
        !          2328: char *p;
        !          2329: int ch;
        !          2330: {
        !          2331:        char c = ch;
        !          2332: 
        !          2333:        /* Quick check for non control characters */
        !          2334: 
        !          2335:        if (c & 0140) {
        !          2336:                *p++ = c;
        !          2337:        } else {
        !          2338:                switch (c & 0377) {
        !          2339:                case ZDLE:
        !          2340:                        *p++ = ZDLE;
        !          2341:                        *p++ = c ^ 0100;
        !          2342:                        break;
        !          2343:                case CR:
        !          2344: #if 0
        !          2345:                        if (!fZesc_ctl && (lastsent & 0177) != '@')
        !          2346:                                goto sendit;
        !          2347: #endif
        !          2348:                        /* fall through */
        !          2349:                case 020:       /* ^P */
        !          2350:                case XON:
        !          2351:                case XOFF:
        !          2352:                        *p++ = ZDLE;
        !          2353:                        c ^= 0100;
        !          2354: /*sendit:*/
        !          2355:                        *p++ = c;
        !          2356:                        break;
        !          2357:                default:
        !          2358:                        if (fZesc_ctl && !(c & 0140)) {
        !          2359:                                *p++ = ZDLE;
        !          2360:                                c ^= 0100;
        !          2361:                        }
        !          2362:                        *p++ = c;
        !          2363:                        break;
        !          2364:                }
        !          2365:        }
        !          2366: 
        !          2367:        return p;
        !          2368: }
        !          2369: 
        !          2370: /*
        !          2371:  * Decode two lower case hex digits into an 8 bit byte value ...
        !          2372:  */
        !          2373: 
        !          2374: static int
        !          2375: zgethex(qdaemon)
        !          2376: struct sdaemon *qdaemon;
        !          2377: {
        !          2378:        int c,n;
        !          2379: 
        !          2380:        if ((c = noxrd7 (qdaemon)) < 0)
        !          2381:                return c;
        !          2382:        n = c - '0';
        !          2383:        if (n > 9)
        !          2384:                n -= ('a' - ':');
        !          2385:        if (n & ~0xF)
        !          2386:                return ZM_ERROR;
        !          2387:        if ((c = noxrd7 (qdaemon)) < 0)
        !          2388:                return c;
        !          2389:        c -= '0';
        !          2390:        if (c > 9)
        !          2391:                c -= ('a' - ':');
        !          2392:        if (c & ~0xF)
        !          2393:                return ZM_ERROR;
        !          2394:        c += (n << 4);
        !          2395: 
        !          2396:        return c;
        !          2397: }
        !          2398: 
        !          2399: /*
        !          2400:  * Read a byte, checking for ZMODEM escape encoding ...
        !          2401:  */
        !          2402: 
        !          2403: static int
        !          2404: zdlread(qdaemon)
        !          2405: struct sdaemon *qdaemon;
        !          2406: {
        !          2407:        int c;
        !          2408: 
        !          2409: again:
        !          2410:        READCHAR (qdaemon, c, cZtimeout);
        !          2411:        if (c < 0)
        !          2412:                return c;
        !          2413:        if (c & 0140)           /* quick check for non control characters */
        !          2414:                return c;
        !          2415:        switch (c) {
        !          2416:        case ZDLE:
        !          2417:                break;
        !          2418:        case XON:
        !          2419:                goto again;
        !          2420:        case XOFF:
        !          2421:                READCHAR (qdaemon, c, XON_WAIT);
        !          2422:                goto again;
        !          2423:        default:
        !          2424:                if (fZesc_ctl && !(c & 0140))
        !          2425:                        goto again;
        !          2426:                return c;
        !          2427:        }
        !          2428: 
        !          2429: again2:
        !          2430:        READCHAR (qdaemon, c, cZtimeout);
        !          2431:        if (c < 0)
        !          2432:                return c;
        !          2433:        switch (c) {
        !          2434:        case ZCRCE:
        !          2435:        case ZCRCG:
        !          2436:        case ZCRCQ:
        !          2437:        case ZCRCW:
        !          2438:        case ZCRCF:
        !          2439:                return c | GOTOR;
        !          2440:        case ZRUB0:                     /* FIXME: This is never generated. */
        !          2441:                return 0177;
        !          2442:        case ZRUB1:                     /* FIXME: This is never generated. */
        !          2443:                return 0377;
        !          2444:        case XON:
        !          2445:                goto again2;
        !          2446:        case XOFF:
        !          2447:                READCHAR (qdaemon, c, XON_WAIT);
        !          2448:                goto again2;
        !          2449:        default:
        !          2450:                if (fZesc_ctl && !(c & 0140))
        !          2451:                        goto again2;            /* FIXME: why again2? */
        !          2452:                if ((c & 0140) == 0100)
        !          2453:                        return c ^ 0100;
        !          2454:                break;
        !          2455:        }
        !          2456: 
        !          2457:        return ZM_ERROR;
        !          2458: }
        !          2459: 
        !          2460: /*
        !          2461:  * Read a character from the modem line with timeout ...
        !          2462:  * Eat parity bit, XON and XOFF characters.
        !          2463:  */
        !          2464: 
        !          2465: static int
        !          2466: noxrd7(qdaemon)
        !          2467: struct sdaemon *qdaemon;
        !          2468: {
        !          2469:        int c;
        !          2470: 
        !          2471:        for (;;) {
        !          2472:                READCHAR (qdaemon, c, cZtimeout);
        !          2473:                if (c < 0)
        !          2474:                        return c;
        !          2475:                switch (c &= 0177) {
        !          2476:                case XON:
        !          2477:                        continue;
        !          2478:                case XOFF:
        !          2479:                        READCHAR (qdaemon, c, XON_WAIT);
        !          2480:                        continue;
        !          2481:                case CR:
        !          2482:                case ZDLE:
        !          2483:                        return c;
        !          2484:                default:
        !          2485:                        if (fZesc_ctl && !(c & 0140))
        !          2486:                                continue;
        !          2487:                        return c;
        !          2488:                }
        !          2489:        }
        !          2490: }
        !          2491: 
        !          2492: /*
        !          2493:  * Read a character from the receive buffer, or from the line if empty ...
        !          2494:  *
        !          2495:  * <timeout> is in seconds (maybe make it tenths of seconds like in Zmodem?)
        !          2496:  */
        !          2497: 
        !          2498: static int
        !          2499: realreadchar(qdaemon, timeout)
        !          2500: struct sdaemon *qdaemon;
        !          2501: int timeout;
        !          2502: {
        !          2503:        int c;
        !          2504: 
        !          2505:        if ((c = breceive_char (qdaemon->qconn, timeout, TRUE)) >= 0)
        !          2506:                return c;
        !          2507: 
        !          2508:        switch (c) {
        !          2509:        case -1:
        !          2510:                return ZM_TIMEOUT;
        !          2511:        case -2:
        !          2512:                return ZM_RCDO;
        !          2513:        }
        !          2514: 
        !          2515:        ulog (LOG_FATAL, "realreadchar: breceive_char() returned %d", c);
        !          2516:        return ZM_ERROR;
        !          2517: }
        !          2518: 
        !          2519: 
        !          2520: /*
        !          2521:  * Check if the receive channel has any characters in it.
        !          2522:  *
        !          2523:  * At present we can only test the receive buffer. No mechanism is available
        !          2524:  * to go to the hardware. This should not be a problem though, as long as all
        !          2525:  * appropriate calls to fsend_data() set <fdoread> to TRUE.
        !          2526:  */
        !          2527: 
        !          2528: static boolean
        !          2529: fzreceive_ready()
        !          2530: {
        !          2531:        return iPrecstart != iPrecend;
        !          2532: }
        !          2533: 
        !          2534: /*
        !          2535:  * Store integer value in an achdrval_t ...
        !          2536:  */
        !          2537: 
        !          2538: static void
        !          2539: stohdr(val, hdr)
        !          2540: hdrval_t val;
        !          2541: achdrval_t hdr;
        !          2542: {
        !          2543:        hdr[ZP0] = (char) val;
        !          2544:        hdr[ZP1] = (char) (val >> 8);
        !          2545:        hdr[ZP2] = (char) (val >> 16);
        !          2546:        hdr[ZP3] = (char) (val >> 24);
        !          2547: }
        !          2548: 
        !          2549: /*
        !          2550:  * Recover an integer from a header ...
        !          2551:  */
        !          2552: 
        !          2553: static hdrval_t
        !          2554: rclhdr(hdr)
        !          2555: achdrval_t hdr;
        !          2556: {
        !          2557:        hdrval_t v;
        !          2558: 
        !          2559:        v = hdr[ZP3] & 0377;
        !          2560:        v = (v << 8) | (hdr[ZP2] & 0377);
        !          2561:        v = (v << 8) | (hdr[ZP1] & 0377);
        !          2562:        v = (v << 8) | (hdr[ZP0] & 0377);
        !          2563: 
        !          2564:        return v;
        !          2565: }
        !          2566: 
        !          2567: /*
        !          2568:  * Encode a <hdrval_t> from the byte count ...
        !          2569:  *
        !          2570:  * We use to store the byte count / 32 and a message sequence number which
        !          2571:  * made this function very useful. Don't remove it.
        !          2572:  * FIXME: Well, maybe remove it later.
        !          2573:  */
        !          2574: 
        !          2575: static hdrval_t
        !          2576: hvzencode_data_hdr(cbytes)
        !          2577: winpos_t cbytes;
        !          2578: {
        !          2579:        return (hdrval_t) cbytes;
        !          2580: }
        !          2581: 
        !          2582: /*
        !          2583:  * Decode a <hdrval_t> into a byte count ...
        !          2584:  *
        !          2585:  * We use to store the byte count / 32 and a message sequence number which
        !          2586:  * made this function very useful. Don't remove it.
        !          2587:  * FIXME: Well, maybe remove it later.
        !          2588:  */
        !          2589: 
        !          2590: static void
        !          2591: zdecode_data_hdr(hdrval, pcbytes)
        !          2592: hdrval_t hdrval;
        !          2593: winpos_t *pcbytes;
        !          2594: {
        !          2595:        *pcbytes = hdrval;
        !          2596: }
        !          2597: 
        !          2598: /*
        !          2599:  * Update <wpZrxpos> from the received data header value ...
        !          2600:  *
        !          2601:  * FIXME: Here is where we'd handle wrapping around at 4 gigabytes.
        !          2602:  */
        !          2603: 
        !          2604: static winpos_t
        !          2605: lzupdate_rxpos(rx_hdr, rxpos, lrxpos, txpos)
        !          2606: achdrval_t rx_hdr;
        !          2607: winpos_t rxpos,lrxpos,txpos;
        !          2608: {
        !          2609:        winpos_t rx_pktpos;
        !          2610: 
        !          2611:        zdecode_data_hdr (rclhdr (rx_hdr), &rx_pktpos);
        !          2612: 
        !          2613:        DEBUG_MESSAGE4 (DEBUG_PROTO,
        !          2614:    "lzupdate_rxpos: rx_pktpos=0x%lx, rxpos=0x%lx, lrxpos=0x%lx, txpos=0x%lx",
        !          2615:                        rx_pktpos, rxpos, lrxpos, txpos);
        !          2616: 
        !          2617:        /*
        !          2618:         * Check if <rx_pktpos> valid. It could be old.
        !          2619:         */
        !          2620: 
        !          2621:        if (rx_pktpos < wpZlrxpos
        !          2622:            || rx_pktpos > ((wpZtxpos + 1024L) & ~1023L))
        !          2623:                return rxpos;
        !          2624: 
        !          2625:        return rx_pktpos;
        !          2626: }

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