# The HYDRA file transfer protocol.

    Document: FSC-0072
    Version:  001
    Date:     21-Feb-1993

                        The HYDRA file transfer protocol

                   Joaquim H. Homrighausen and Arjen G. Lentz

    Status of this document:

         This FSC suggests a proposed protocol for the FidoNet(r) community,
         and requests discussion and suggestions for improvements.
         Distribution of this document is subject to the restrictions listed
         below.

         Fido and FidoNet are registered marks of Tom Jennings and Fido
         Software.

        ---------------------------------------------------------------------
         Copyright 1991-1993 Joaquim H. Homrighausen. All rights reserved.
         Copyright 1991-1993 Lentz Software Development. All rights reserved.
        ---------------------------------------------------------------------

        Restrictions
        =====================================================================
        You are granted a license to implement the HYDRA file transfer
        protocol, HYDRA hereafter, in your own programs and/or use the sample
        source code and adapt these to your particular situation and needs;
        subject to the following conditions:

        o You must refer to it as the HYDRA file transfer protocol, and you
          must give credit to the authors of HYDRA in any information screens
          or literature pertaining to your programs that contains other such
          information (credits, your own copyrights, etc.).

        o HYDRA will always remain backwards compatible with previous
          revisions. HYDRA allows for expansion of its features without
          interfering with previous revisions. It is, however, important that
          different people do not expand the protocol in different directions.
          We therefore ask you to contact us if you have any needs/ideas
          regarding HYDRA, so development can be synchronized and beneficial
          to all.

        o If your implementation cannot converse with past or future revisions
          as supplied by us, then you must refer to it as "HYDRA derived", or
          as "a variation of HYDRA", or words to that effect.

        Permission is hereby granted to the FTSC (FidoNet Technical Standards
        Committee) and other technical organisations to republish this
        document in its entirety. Librarians may change the title page and
        page headers to match their library format as long as all copyrights
        and body text remain unaltered. The original document name and source
        must be mentioned in any republished versions of this document.

        No organization, company, person, or other being may impose any fees
        for any reason for providing this document. This document may not be
        sold or otherwise transferred for personal or company gain under any
        circumstances.

        Disclaimer
        =====================================================================
        This information is provided "as is" and comes with no warranties of
        any kind, either expressed or implied. There is no support available
        for this package. It's intended to be used by programmers and
        developers.

        In no event shall the authors be liable to you or anyone else for any
        damages, including any lost profits, lost savings or other incidental
        or consequential damages arising out of the use or inability to use
        this information.

        Revision timestamps
        =====================================================================
        001                           0x2b1aab00                 Dec 01, 1992

        Introduction
        =====================================================================
        This document will not attempt to convince the reader that HYDRA is
        of value to him/her or that it is better than other file transfer
        protocols, it will simply describe the protocol. Just to get it out
        of the way, HYDRA is not the ultimate file transfer protocol.

        The authors do, however, feel that it offers an significant
        improvement over those file transfer protocols available today. HYDRA
        is a bi-directional protocol with the ability to receive and send
        files simultaneously. There are other bi-directional file transfer
        protocols, but to the authors' knowledge no public specifications
        exist.

        HYDRA owes much to Zmodem and its designer, Chuck Forsberg as well as
        to Janus, designed by Rick Huebner. We would like to think of HYDRA
        as a combination of both with a few extra options installed.

        The basic concept of a bi-directional file transfer protocol is
        simple. Both data channels are utilized to transmit and receive files
        simultaneously. I.e. two 100 kb files can be exchanged between two
        parties in the time it takes a fully streaming uni-directional file
        transfer protocol to transmit one of the files.

        Protocol design
        =====================================================================
        The ultimate goal when designing HYDRA was to design a protocol that
        is as simple and robust as possible; complexity increase the problem
        of faulty implementations.

        The obvious function of a file transfer protocol is to transport a
        collection of data from its source to its destination as efficient
        possible and without jeopardizing the integrity of the data.

        The lack of data compression and lost packet management (as used in
        Kermit and Super Kermit) is intentional. The authors feel that this
        unnecessarily increases the complexity of the protocol.

        While HYDRA performs to its best on full duplex links, it should be
        possible to use it on links using proprietary protocols such as the
        US Robotics HST protocol which features one 14.4 kbps data channel
        and one 450 bps back channel.

        The protocol design should be flexible enough for future enhancements
        while maintaining backward compatibility.

        Protocol requirements and restrictions
        =====================================================================
        HYDRA require that the link can handle ASCII character 24 (DLE) as
        well as all ASCII characters in the range 32 through 126. All other
        characters can be escaped or encoded by the protocol as required by
        the link.

        Capability of the computer to perform simultaneous serial I/O as well
        as simultaneous serial I/O combined with disk access is preferred,
        but can be circumvented by opting for windowed transmission instead
        of full streaming.

        HYDRA calls for the ability to check whether there is anything in the
        serial input buffer (i.e. "peek-ahead"), but it doesn't mind if it
        has to wait for a second if there is no data available (using for
        instance the UNIX alarm() mechanism).

        The protocol is extremely tolerant with timeouts (i.e. satellite or
        network delays) while still maintaining maximum reliability,
        robustness, and throughput.

        Terms and definitions
        =====================================================================
        A BYTE                   An 8-bit unsigned character.
        A WORD                   A 16-bit unsigned integer.
        A DWORD                  A 32-bit unsigned integer.
        A LONG                   A 32-bit SIGNED integer.
        FILE OFFSETS (position)  A long.
        NUL                      The ASCII character 0.
        BS                       The ASCII character 8.
        CR                       The ASCII character 13.
        XOFF                     The ASCII character 17.
        XON                      The ASCII character 19.
        H_DLE                    The HYDRA link escape character, ASCII 24
                                 (^X).
        SP or SPACE              The ASCII character 32.
        UNIX timestamp           A specific time and date expressed as the
                                 number of seconds since midnight, January
                                 1st, 1970. All UNIX timestamps used in HYDRA
                                 are expressed in local time.

        Multi-byte items are transmitted in "low-byte first" order, so big-
        endian CPUs (like 680xx) need to do some byteswapping, depending on
        the implementation.

        Values preceded by '0x' are in hexadecimal notation (base 16, 0..9
        a..f). All values transmitted in hexadecimal notation must be
        converted to lowercase characters and left-padded to their full
        size with '0' prior to transmission. E.g. a WORD with the value 255
        (decimal) is expressed as 00ff. A LONG with the value 255 (decmial)
        is expressed as 000000ff.

        In formulas, "AND" means bitwise AND, "XOR" means bitwise Exclusive
        OR, "NOT" is ones complement (i.e. all zeros become ones, all ones
        become zeros). The ">>" is a shift operation to the right, "R >> 3"
        means shift R three bits to the right.

        General packet format
        =====================================================================
        All data exchange is done with framed packets protected by 16 or 32
        bit CRC values appended to the packet data and packet type (low-
        byte first). The only exception to this is the cancel sequence of 5
        consecutive H_DLE characters.

        All packets except those with the type DATA are followed by a CR
        (ASCII 13) to help get through some buffered environments and aid
        possible debugging and/or tracing. If requested by the other side in
        its INIT packet, packets can also be prefixed by a specific data
        string which can include NULs, delays or break signals. Refer to the
        section on the INIT packet for more information.

                              Format of unframed packet

                    +------------------------------------------+
                    ~ Zero or more bytes packet dependent data ~
                    +------------------------------------------+
                    | Packet type byte                         |
                    +------------------------------------------+
                    | CRC-16/32 of packet data and packet type |
                    +------------------------------------------+

                                Table of packet types

             +--------+---------+-----+--------------------------------+
             |Name    |Character|ASCII|Description                     |
             +--------+---------+-----+--------------------------------+
             |START   |   'A'   |  65 |Startup sequence                |
             |INIT    |   'B'   |  66 |Session initialisation          |
             |INITACK |   'C'   |  67 |Response to INIT packet         |
             |FINFO   |   'D'   |  68 |File information                |
             |FINFOACK|   'E'   |  69 |Response to FINFO packet        |
             |DATA    |   'F'   |  70 |File data packet                |
             |DATAACK |   'G'   |  71 |File data position ACK packet   |
             |RPOS    |   'H'   |  72 |Reposition request packet       |
             |EOF     |   'I'   |  73 |End of file packet              |
             |EOFACK  |   'J'   |  74 |Response to EOF packet          |
             |END     |   'K'   |  75 |End of session                  |
             |IDLE    |   'L'   |  76 |Idle (just saying I'm alive)    |
             |DEVDATA |   'M'   |  77 |Data to specified device     (1)|
             |DEVDACK |   'N'   |  78 |Response to DEVDATA packet   (1)|
             +--------+---------+-----+--------------------------------+

        (1) Support for DEVDATA and DEVDACK types is optional and indicated
            in INIT state of a HYDRA session.

                               Format of framed packet

                   +----------------------+--------------------+
                   |        H_DLE         |Packet format byte  |
                   +----------------------+--------------------+
                   ~               Encoded packet              ~
                   +----------------------+--------------------+
                   |        H_DLE         |End of framed packet|
                   +----------------------+--------------------+

                                Table of packet formats

               +----+---------+-----+--------------------------------+
               |Name|Character|ASCII|Description                     |
               +----+---------+-----+--------------------------------+
               |END |   'a'   |  97 |End of framed packet            |
               |BIN |   'b'   |  98 |Binary packet                   |
               |HEX |   'c'   |  99 |Hex encoded packet              |
               |ASC |   'd'   | 100 |Shifted 7-bit encoded packet (1)|
               |UUE |   'e'   | 101 |UUencoded packet             (1)|
               +----+---------+-----+--------------------------------+

        (1) Support for ASC and/or UUE formats is optional and indicated in
            the INIT state of a HYDRA session.

        Packet sender and receiver state charts
        ---------------------------------------------------------------------

    TXPKT (Sender)
    +--------+------------------------------+--------------------------+----------+
    |State   |Predicate(s)                  |Action(s)                 |Next state|
    +--------+-+----------------------------+--------------------------+----------+
    |Begin   |1|pkttype == START or         |format = HEXPKT           |Format    |
    |        | |pkttype == INIT or          |                          |          |
    |        | |pkttype == INITACK or       |                          |          |
    |        | |pkttype == END or           |                          |          |
    |        | |pkttype == IDLE             |                          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|Escape 8th bit (7 bit link) |                          |Coding    |
    |        +-+----------------------------+--------------------------+----------+
    |        |3|else (no spc.pkt, 8bit link)|format = BINPKT           |Format    |
    +--------+-+----------------------------+--------------------------+----------+
    |Coding  |1|escape all control chars &  |format = UUEPKT           |Format    |
    |        | |UUENCODED packets allowed   |                          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|ASCII packets allowed       |format = ASCPKT           |Format    |
    |        +-+----------------------------+--------------------------+----------+
    |        |3|7 bit link &                |format = HEXPKT           |Format    |
    |        | |escape all control chars &  |                          |          |
    |        | |UUE/ASC pkts not allowed    |                          |          |
    +--------+-+----------------------------+--------------------------+----------+
    |Format  |                              |Append format byte to data|CRC       |
    +--------+-+----------------------------+--------------------------+----------+
    |CRC     |1|format != HEXPKT &          |Calc CRC-32 (data,pkttype)|Encode    |
    |        | |CRC-32 allowed              |Append one's complement of|          |
    |        | |                            |CRC to data, lowbyte first|          |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|else (HEXPKT or no CRC-32)  |Calc CRC-16 (data,pkttype)|Encode    |
    |        | |                            |Append one's complement of|          |
    |        | |                            |CRC to data, lowbyte first|          |
    +--------+-+----------------------------+--------------------------+----------+
    |Encode  |1|format == BINPKT            |BIN escape databuf        |Prefix    |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|format == HEXPKT            |HEX encode databuf        |Prefix    |
    |        +-+----------------------------+--------------------------+----------+
    |        |3|format == ASCPKT            |ASC encode/escape databuf |Prefix    |
    |        +-+----------------------------+--------------------------+----------+
    |        |4|format == UUEPKT            |UUE encode databuf        |Prefix    |
    +--------+-+----------------------------+--------------------------+----------+
    |Prefix  |1|No more prefix characters   |                          |Transmit  |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|Prefix character ASCII 221  |Send 1 second break signal|          |
    |        +-+----------------------------+--------------------------+----------+
    |        |3|Prefix character ASCII 222  |1 second delay            |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |4|Prefix character ASCII 223  |Transmit NUL (ASCII 0)    |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |5|else (any other character)  |Transmit character        |          |
    +--------+-+----------------------------+--------------------------+----------+
    |Transmit|                              |Transmit H_DLE,format byte|Suffix    |
    |        |                              |Transmit encoded buffer   |          |
    |        |                              |Transmit H_DLE,pktend byte|          |
    +--------+-+----------------------------+--------------------------+----------+
    |Suffix  |1|pkttype != DATA &           |Transmit CR,LF (ASC 13,10)|Done      |
    |        | |pktformat != BINPKT         |                          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|else (pkttype == DATA or    |                          |Done      |
    |        | |      pktformat == BINPKT)  |                          |          |
    +--------+-+----------------------------+--------------------------+----------+

    RXPKT (Receiver)
    +--------+------------------------------+--------------------------+----------+
    |State   |Predicate(s)                  |Action(s)                 |Next state|
    +--------+------------------------------+--------------------------+----------+
    |Reset   |                              |rxdle = 0                 |NextByte  |
    |        |                              |format = 0                |          |
    |        |                              |pktlen = 0                |          |
    +--------+-+----------------------------+--------------------------+----------+
    |NextByte|1|User wishes to abort session|Report reason for abort   |Abort     |
    |        | |or carrier lost             |                          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|Byte available in inputbuf  |                          |StripIn   |
    |        +-+----------------------------+--------------------------+----------+
    |        |3|braintimer expired          |Report braindead situation|Abort     |
    |        +-+----------------------------+--------------------------+----------+
    |        |4|Any other timer expired     |Tell responsible party    |          |
    +--------+-+----------------------------+--------------------------+----------+
    |StripIn |1|Escape 8th bit (7 bit link) |c = c AND 0x7f (strip 8th)|StripC    |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|else (8 bit link)           |                          |StripC    |
    +--------+-+----------------------------+--------------------------+----------+
    |StripC  |1|Escape ctlchars with 8th set|n = c AND 0x7f (strip 8th)|Process   |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|else (let 8 bit ctl through)|n = c                     |Process   |
    +--------+-+----------------------------+--------------------------+----------+
    |Process |1|c == H_DLE                  |increment rxdle           |DLE       |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|Escape XON/XOFF &           |Eat these                 |NextByte  |
    |        | |n == XON or n == XOFF       |                          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |3|Escape all control chars &  |Eat these                 |NextByte  |
    |        | |n < 32 or n == 127          |                          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |4|rxdle > 0                   |                          |Escape    |
    |        +-+----------------------------+--------------------------+----------+
    |        |5|else (no eating or escaping)|                          |Store     |
    +--------+-+----------------------------+--------------------------+----------+
    |DLE     |1|rxdle == 5                  |Report remote wants abort |Abort     |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|else (rxdle < 5)            |                          |NextByte  |
    +--------+-+----------------------------+--------------------------+----------+
    |Escape  |1|c == PKTEND                 |                          |PktEnd    |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|c == BINPKT                 |format = BINPKT           |PktStart  |
    |        +-+----------------------------+--------------------------+----------+
    |        |3|c == HEXPKT                 |format = HEXPKT           |PktStart  |
    |        +-+----------------------------+--------------------------+----------+
    |        |4|c == ASCPKT                 |format = ASCPKT           |PktStart  |
    |        +-+----------------------------+--------------------------+----------+
    |        |5|c == UUEPKT                 |format = UUEPKT           |PktStart  |
    |        +-+----------------------------+--------------------------+----------+
    |        |6|else (normal escaped char)  |c = c XOR 0x40            |Store     |
    |        | |                            |rxdle = 0                 |Store     |
    +--------+-+----------------------------+--------------------------+----------+
    |Store   |1|format == 0                 |Garbage                   |NextByte  |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|pktlen >= maximum           |Pkt too long / lost PKTEND|Reset     |
    |        +-+----------------------------+--------------------------+----------+
    |        |3|else (fmt > 0 & len < max)  |Append c to databuffer    |NextByte  |
    |        | |                            |increment pktlen          |          |
    +--------+-+----------------------------+--------------------------+----------+
    |PktStart|                              |rxdle = 0                 |NextByte  |
    |        |                              |pktlen = 0                |          |
    +--------+-+----------------------------+--------------------------+----------+
    |PktEnd  |1|format == 0                 |End without start, garbage|Reset     |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|format == BINPKT            |(No more decoding needed) |CalcCRC   |
    |        +-+----------------------------+--------------------------+----------+
    |        |3|format == HEXPKT            |ok = Decode HEXPKT        |CheckDec  |
    |        +-+----------------------------+--------------------------+----------+
    |        |4|format == ASCPKT            |ok = Decode ASCPKT        |CheckDec  |
    |        +-+----------------------------+--------------------------+----------+
    |        |5|format == UUEPKT            |ok = Decode UUEPKT        |CheckDec  |
    +--------+-+----------------------------+--------------------------+----------+
    |CheckDec|1|ok (no errors during decode)|                          |CalcCRC   |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|else (errors in decoding)   |Bad encoding, ignore pkt  |Reset     |
    +--------+-+----------------------------+--------------------------+----------+
    |CalcCRC |1|format != HEXPKT &          |Calc CRC-32 over databuf  |CheckCRC  |
    |        | |CRC-32 allowed              |ok = (crc == 0xdebb20e3)  |          |
    |        | |                            |pktlen = pktlen - 4       |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|else (HEXPKT or no CRC-32)  |Calc CRC-16 over databuf  |CheckCRC  |
    |        | |                            |ok = (crc == 0xf0b8)      |          |
    |        | |                            |pktlen = pktlen - 2       |          |
    +--------+-+----------------------------+--------------------------+----------+
    |CheckCRC|1|ok (CRC matched magic)      |pkttype = last byte of buf|Reset     |
    |        | |                            |pktlen = pktlen - 1       |          |
    |        | |                            |Hand pkt to higher level  |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|else (CRC check failed)     |Bad CRC, ignore packet    |Reset     |
    +--------+-+----------------------------+--------------------------+----------+

        BIN packet format
        ---------------------------------------------------------------------
        The binary packet format require an 8-bit data channel. If requested
        by either side, one or more sets of control characters are escaped.
        In this case, when one of these characters appears in an unframed
        packet, a H_DLE is sent followed by the character XOR 0x40. The H_DLE
        character itself is always transmitted in this fashion. On the
        receiver side, if the character after a H_DLE is not one of the
        packet format bytes, this character is decoded using XOR 0x40 again.

    BINPKT Escaping
    +--------+------------------------------+--------------------------+----------+
    |State   |Predicate(s)                  |Action(s)                 |Next state|
    +--------+------------------------------+--------------------------+----------+
    |Begin   |                              |txlastc = 0               |NextByte  |
    +--------+-+----------------------------+--------------------------+----------+
    |NextByte|1|No more bytes to process    |                          |Done      |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|Escape ctlchars with 8th set|n = c AND 0x7f (strip 8th)|Escape    |
    |        +-+----------------------------+--------------------------+----------+
    |        |3|else (let 8 bit ctl through)|n = c                     |Escape    |
    +--------+-+----------------------------+--------------------------+----------+
    |Escape  |1|n == H_DLE                  |Output H_DLE              |Output    |
    |        | |                            |c = c XOR 0x40            |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|Escape XON/XOFF &           |Output H_DLE              |Output    |
    |        | |n == XON or n == XOFF       |c = c XOR 0x40            |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |3|Escape Telenet &            |Output H_DLE              |Output    |
    |        | |n == CR &                   |c = c XOR 0x40            |          |
    |        | |txlasc == '@'               |                          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |4|Escape all control chars &  |Output H_DLE              |Output    |
    |        | |n < 32 or n == 127          |c = c XOR 0x40            |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |5|else (any other character)  |                          |Output    |
    +--------+-+----------------------------+--------------------------+----------+
    |Output  |                              |Store c                   |NextByte  |
    |        |                              |txlastc = c               |          |
    +--------+------------------------------+--------------------------+----------+

        HEX packet format
        ---------------------------------------------------------------------
        Supported by all implementations, this packet format is used in
        worst-case situations and upon startup of a session when it is not
        yet known what restrictions the line and the other side will place on
        the link.

        Packet types always transmitted in HEX format are: START, INIT,
        INITACK, IDLE, END.

        HEX format packets always use a 16-bit CRC.

        HEX packets assume a 7-bit link, escaping all control characters and
        filtering all control characters upon receipt.

        ASCII characters in the range 128-255 (high bit set) are encoded by
        first transmitting a backslash ('\') character (ASCII 92), followed
        by the character in two lowercase hex-digits (bits 4-7 in first
        digit, bits 0-3 in second).

        Uppercase hex-digits are not permitted.

        The backslash character itself is transmitted as two backslashes.

        ASCII characters in the range 0-31 and 127 (all control characters)
        are escaped with H_DLE in the same fashion as in binary (BIN)
        packets.

        Decoded  byte 1
                +------+
                76543210
                +--++--+
        Encoded  h1  h2

    HEXPKT Encoding/Escaping
    +--------+------------------------------+--------------------------+----------+
    |State   |Predicate(s)                  |Action(s)                 |Next state|
    +--------+-+----------------------------+--------------------------+----------+
    |NextByte|1|No more bytes to process    |                          |Done      |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|High bit of c set           |Output \ (backslash)      |          |
    |        | |                            |Output hexdigit(c bit 4-7)|          |
    |        | |                            |Output hexdigit(c bit 0-3)|          |
    |        +-+----------------------------+--------------------------+----------+
    |        |3|c < 32 or c == 127          |Output H_DLE              |          |
    |        | |                            |Output (c XOR 0x40)       |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |4|c == \ (backslash)          |Output \ (backslash)      |          |
    |        | |                            |Output \ (backslash)      |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |5|else (any other character)  |Output c                  |          |
    +--------+-+----------------------------+--------------------------+----------+

    HEXPKT Decoding
    +--------+------------------------------+--------------------------+----------+
    |State   |Predicate(s)                  |Action(s)                 |Next state|
    +--------+-+----------------------------+--------------------------+----------+
    |NextByte|1|No more bytes to process    |                          |Done OK   |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|c == \ (backslash)          |                          |Escape    |
    |        +-+----------------------------+--------------------------+----------+
    |        |3|else (any other character)  |Output c                  |Escape    |
    +--------+-+----------------------------+--------------------------+----------+
    |Escape  |1|No more bytes to process    |Premature end of data     |Error     |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|c == \ (backslash)          |Output \ (backslash)      |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |3|c == lowercase hexdigit     |Save c, move ptr to next  |NextHex   |
    |        +-+----------------------------+--------------------------+----------+
    |        |4|else (all other characters) |Invalid character         |Error     |
    +--------+-+----------------------------+--------------------------+----------+
    |NextHex |1|No more bytes to process    |Premature end of data     |Error     |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|c == lowercase hexdigit     |Output (1st << 4 OR 2nd)  |NextByte  |
    |        +-+----------------------------+--------------------------+----------+
    |        |3|else (all other characters) |Invalid character         |Error     |
    +--------+-+----------------------------+--------------------------+----------+

        ASC packet format
        ---------------------------------------------------------------------
        Support of this packet format is optional and signalled in the INIT
        packet with the ASC flag in the "Supported options" field. 8-bit data
        is transformed into 7-bit data by a simple shift operation. Each byte
        is inserted at the top of a shift register, the lower seven bits are
        moved out. So seven 8-bit bytes are encoded into eight 7-bit
        characters.

        The end of the packet is padded by a maximum of six bits of 0 to make
        the number of bits a multiple of seven and thereby creating
        complete characters (so the receiver stops decoding when there are
        less than seven bits left). The output can contain control
        characters, so if escaping of these characters is required, this is
        done as in BIN packets using the H_DLE method.

        Decoded  byte 7  byte 6  byte 5  byte 4  byte 3  byte 2  byte 1
                +------++------++------++------++------++------++------+
                76543210765432107654321076543210765432107654321076543210
                +-----++-----++-----++-----++-----++-----++-----++-----+
        Encoded   c8     c7      c6    c5     c4     c3     c2     c1

    ASCPKT Encoding/Escaping
    +--------+------------------------------+--------------------------+----------+
    |State   |Predicate(s)                  |Action(s)                 |Next state|
    +--------+------------------------------+--------------------------+----------+
    |Reset   |                              |n = 0 (16 bit wide!)      |NextByte  |
    |        |                              |bitshift = 0              |          |
    +--------+-+----------------------------+--------------------------+----------+
    |NextByte|1|No more bytes to process    |                          |Flush     |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|else (more bytes to process)|n = n OR (c << bitshift)  |Shift     |
    |        | |                            |BINPKT escape (n & 0x7f)  |          |
    |        | |                            |n = n >> 7                |          |
    |        | |                            |increment bitshift        |          |
    +--------+-+----------------------------+--------------------------+----------+
    |Shift   |1|bitshift == 7               |BINPKT escape (n & 0x7f)  |Reset     |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|else (bitshift < 7)         |                          |NextByte  |
    +--------+-+----------------------------+--------------------------+----------+
    |Flush   |1|bitshift > 0                |BINPKT escape (n & 0x7f)  |Done      |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|else (bitshift == 0)        |                          |Done      |
    +--------+-+----------------------------+--------------------------+----------+

    ASCPKT Decoding
    +--------+------------------------------+--------------------------+----------+
    |State   |Predicate(s)                  |Action(s)                 |Next state|
    +--------+------------------------------+--------------------------+----------+
    |Begin   |                              |n = 0 (16 bit wide!)      |NextByte  |
    |        |                              |bitshift = 0              |          |
    +--------+-+----------------------------+--------------------------+----------+
    |NextByte|1|No more bytes to process    |                          |Done OK   |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|else (more bytes to process)|c = c AND 0x7f            |Shift     |
    |        | |                            |n = n OR (c << bitshift)  |          |
    |        | |                            |bitshift = bitshift + 7   |          |
    +--------+-+----------------------------+--------------------------+----------+
    |Shift   |1|bitshift >= 8               |Output (n AND 0xff)       |NextByte  |
    |        | |                            |n = n >> 8                |          |
    |        | |                            |bitshift = bitshift - 8   |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|else (bitshift < 8)         |                          |NextByte  |
    +--------+-+----------------------------+--------------------------+----------+

        UUE packet format
        ---------------------------------------------------------------------
        Support of this packet format is optional and signalled in the INIT
        packet with the UUE flag in the "Supported options" field. The 8-bit
        data is transformed into printable ASCII using the UUENCODE
        algorithm. Three 8-bit bytes are encoded into four printable ASCII
        characters. This done by taking the bottom six bits left and adding
        '!' (ASCII 33) to move this character value into printable ASCII
        range.

        The end of the packet is padded by a maximum of five bits of 0 to
        make the number of bits a multiple of six and thereby creating
        complete characters (so the receiver stops decoding when there are
        less than six bits left). The output of this coding scheme does not
        need any further escaping before transmission.

        Decoded  byte 3  byte 2  byte 1
                +------++------++------+
                765432107654321076543210
                +----++----++----++----+
        Encoded   c4    c3    c2    c1

    UUEPKT Encoding
    +--------+------------------------------+--------------------------+----------+
    |State   |Predicate(s)                  |Action(s)                 |Next state|
    +--------+-+----------------------------+--------------------------+----------+
    |NextByte|1|Less than three bytes left  |                          |Flush     |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|else (three or more left)   |UUE(in[0]>>2)             |          |
    |        | |                            |UUE(in[0]<<4 OR in[1]>>4) |          |
    |        | |                            |UUE(in[1]<<2 OR in[2]>>6) |          |
    |        | |                            |UUE(in[2])                |          |
    |        | |                            |(UUE: (c AND 0x3f) + '!') |          |
    +--------+-+----------------------------+--------------------------+----------+
    |Flush   |1|No more bytes left          |                          |Done      |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|One byte left               |UUE(in[0]>>2)             |Done      |
    |        | |                            |UUE(in[0]<<4)             |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |3|Two bytes left              |UUE(in[0]>>2)             |Done      |
    |        | |                            |UUE(in[0]<<4 OR in[1]>>4) |          |
    |        | |                            |UUE(in[1]<<2)             |          |
    +--------+-+----------------------------+--------------------------+----------+

    UUEPKT Decoding
    +--------+------------------------------+--------------------------+----------+
    |State   |Predicate(s)                  |Action(s)                 |Next state|
    +--------+-+----------------------------+--------------------------+----------+
    |NextByte|1|Less than four bytes left   |                          |Flush     |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|else (four or more left) &  |UD(i[0])<<2 OR UD(i[1])>>4|          |
    |        | |(c AND 0x7f) is in UUE range|UD(i[1])<<4 OR UD(i[2])>>2|          |
    |        | |                            |UD(i[2])<<6 OR UD(i[3])   |          |
    |        | |                            |(UD: (c - '!') AND 0x3f)  |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |3|else (all other characters) |Invalid character(s)      |Error     |
    +--------+-+----------------------------+--------------------------+----------+
    |Flush   |1|No bytes left or            |                          |Done OK   |
    |        | |Less than two bytes left    |                          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|Two bytes left &            |UD(i[0])<<2 OR UD(i[1])>>4|Done OK   |
    |        | |(c AND 0x7f) is in UUE range|                          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |3|Three bytes left &          |UD(i[0])<<2 OR UD(i[1])>>4|Done OK   |
    |        | |(c AND 0x7f) is in UUE range|UD(i[1])<<4 OR UD(i[2])>>2|          |
    |        +-+----------------------------+--------------------------+----------+
    |        |4|else (all other characters) |Invalid character(s)      |Error     |
    +--------+-+----------------------------+--------------------------+----------+

        START packet                                             (HEX format)
        ---------------------------------------------------------------------
        This packet is sent to tell the remote to initiate a HYDRA session.

        The complete framed packet as transmitted looks like:

            ASCII values   24    99  65  92 102  53  92  97  51    24    97
                        +-------+---+---+---+---+---+---+---+---+-------+---+
            Characters  | H_DLE | c | A | \ | f | 5 | \ | a | 3 | H_DLE | a |
                        +-------+---+---+---+---+---+---+---+---+-------+---+

        Applications may scan for this sequence to automatically start HYDRA
        when the remote transmits this packet (AutoStart). Prior to the START
        packet, a special string is transmitted to enable remote starting
        from a command prompt, hydra<CR> (the word hydra in lowercase):

            ASCII values 104 121 100 114  97  13
                        +---+---+---+---+---+----+
            Characters  | h | y | d | r | a | CR |
                        +---+---+---+---+---+----+

        The special string combined with the START packet is transmitted at
        five second intervals until either a START or INIT packet is received
        from the remote, or the maximum number of retries is reached. Any
        other packet types received in this stage must be ignored as they
        could be remains of a previous session.

        INIT packet                                              (HEX format)
        ---------------------------------------------------------------------
        The INIT packet contains file transfer session options. The remote
        acknowledges this packet by returning an INITACK packet.

                                  INIT packet data

                     +---------------------------------------+
                     ~ Application ID string, NUL terminated ~
                     +---------------------------------------+
                     ~ Supported options, NUL terminated     ~
                     +---------------------------------------+
                     ~ Desired options, NUL terminated       ~
                     +---------------------------------------+
                     | Desired transmitter window size or 0  |
                     +---------------------------------------+
                     | Desired receiver window size or 0     |
                     +---------------------------------------+
                     ~ Other general options, NUL terminated ~
                     +---------------------------------------+
                     ~ Packet prefix string, NUL terminated  ~
                     +---------------------------------------+

        The application ID string contains a printable ASCII string with the
        document revision date, product name, product revision number, and
        optionally the product serial number. The format of the string is:

            <RevDate><ProductName><,><ProductRevision>[<,><ProductSerial#>]

        RevDate is the UNIX timestamp (the hour, minute, and second portion
        is assumed to be zero), in hexadecimal notation, of the HYDRA
        document that the application is supposed to support. None of the
        following three fields should exceed thirty characters in length and
        must not contain any control characters (ASCII 0-31) or the comma
        character (ASCII 44). The field separator is a comma (ASCII 44)
        character.

        Capability flags

            XON        Escape <XON> and <XOFF> characters.
            TLN        Escape the <CR>@<CR> sequence (Telenet escape).
            CTL        Escape ASCII characters 0-31 and 127.
            HIC        Escape above three with high bit set.
            HI8        Escape ASCII characters 128-255 and strip the high bit.
            BRK        Can transmit a break signal.
            ASC        Can handle ASC packets.
            UUE        Can handle UUE packets.
            C32        Can receive packets with 32-bit CRC error detection.
            DEV        Can receive device packets.
            FPT        Can receive filenames with paths.

        Capability flags are always three characters long, in uppercase, and
        seperated by a comma character (ASCII 44). Please note that the first
        five flags must be supported by all applications that implement the
        HYDRA specifications.

        The "Supported options" string contain the capability flags of the
        options that the application support. The "Desired options" string
        contain the capability flags of the options that the application
        would like to use/enable for the session. Some flags do not have to
        be specified in both strings. E.g. if the C32 flag is present in the
        "Supported options" string and the remote system indicates support
        for the same flag, 32-bit CRC error detection will be used. An
        application may not ask for an option it does not support.

        Escaping certain characters or bits also means filtering any
        occurrence of them in the incoming data stream. At the start of a
        session, it is assumed that the first five capability flags are in
        effect, i.e. the high bit is stripped off every received character
        and all control characters are filtered out.

        The "Desired transmitter/receiver window size" fields are long
        integers expressed in hexadecimal notation. With these options each
        side tells the other to use window management of the requested size
        when transmitting file data, instead of using full streaming (0).
        The window setting is completely seperate for both directions.
        If one side requests a smaller window size than the other, that
        smaller size will be used for that direction; also, a window of any
        size takes precedence over no window (0).
        Please note that the terms 'transmitter' and 'receiver' used for the
        fields in the INIT packet are from the view of the side transmitting
        that packet, so the other side should merge the 'transmitter' window
        field from the received INIT packet with its own 'receiver' window
        field.

        The "General options" string currently has no other fields than
        "Desired tx/rx window size"; the string is NUL terminated.

        The packet prefix string is normally empty, but may be provided by
        the remote if required. The maximum length of a packet prefix string
        is 30 characters. All characters should be transmitted as specified,
        with the following exceptions:

                    Table of special packet prefix string chars

                   +-----+--------------------------------------+
                   |ASCII|Description                           |
                   +-----+--------------------------------------+
                   | 221 |Transmit a break signal for one second|
                   | 222 |Delay one second before next character|
                   | 223 |Transmit a NUL (ASCII 0) character    |
                   +-----+--------------------------------------+

        INITACK packet                                           (HEX format)
        ---------------------------------------------------------------------
        The INITACK packet is used to acknowledge the receipt of the remote's
        INIT packet.

        Duplicate INIT packets should be acknowledged too, as the remote may
        have missed previous INITACK packets; the reception of such a
        duplicate packet should not however reset the braindead timer, as it
        does not mean a change of state and is not actual file data.

        FINFO packet
        ---------------------------------------------------------------------
        File information packet, sent to notify the remote that another file
        is to be transmitted, or to signal end of batch. After the FINFO
        packet has been transmitted, the timer is set to the normal timeout
        value. The sender then waits for an FINFOACK packet from the remote
        or for the timer to expire. In the event of a timeout, the transmit/
        wait sequence is repeated with half the normal timeout value until
        the maximum number of retries has been reached.

                                  FINFO packet data
                       +-------------------------------------+
                       ~ File information, NUL terminated    ~
                       +-------------------------------------+

                       File information        End of batch
                      +-----------------+   +-----------------+
                      | Timestamp or 0  |   |       NUL       |
                      +-----------------+   +-----------------+
                      | Filesize or 0   |
                      +-----------------+
                      | Reserved (0)    |
                      +-----------------+
                      | Transaction #   |
                      +-----------------+
                      | File count or 0 |
                      +-----------------+
                      ~ Short filename  ~
                      +-----------------+
                      ~ Real filename   ~
                      +-----------------+
                      |     NUL         |
                      +-----------------+

        End of batch is signalled by an empty string (only the terminating
        NUL).

        The first five fields are long integers expressed in hexadecimal
        notation.

        Timestamp is a UNIX timestamp representing the creation time of the
        file. If the creation time is not known, this is zero.

        Filesize is the size of the file in bytes. If the size of the file is
        not known, this is zero. This field should not be used as an exact
        measure of the size of the file. It is safe to assume that you should
        not receive less data than specified in this field, but the file may
        grow while it is being transferred (e.g. the result of a background
        process).

        Transaction # is a unique number for each set of files being sent
        during the session. This is primarily used to allow the receiving
        application to group several files together and store them in
        specific directories as a result of automated file requests. If the
        file being sent is not a result of an automated file request, this
        field must be set to zero.

        File count is the session file counter. For the first file in a
        session, this field contains the total number of files to be sent
        during the session; for subsequent files, it contains the file number
        in the session, starting with two (2). If the total number of files
        is not known, this field contains zero for all files.

        The first filename field must be specified in lowercase characters.
        It must conform to MS-DOS filename conventions and not exceed 12
        characters in length (excluding the terminating NUL character). The
        second field, real filename, is the actual filename on the sending
        system. If this field is not present, the short filename field is
        used.

        No directory paths may be specified in the short filename. Directory
        paths may be specified in the real filename field if the "Desired
        options" of the receiver contains FPT. If the real filename field
        contains a path, it may include any ASCII character in the range 32
        (0x20) through 255 (0xff) with \ characters translated to /. A drive
        specifier may be present in the <Drive>: (e.g. c:) format. If both
        the short and real filename fields are present, they are separated
        by a NUL character. There is never more than one NUL character
        terminating the packet.

        FINFOACK packet
        ---------------------------------------------------------------------
        Sent in response to an FINFO packet. If the FINFO packet contained
        file information, the FINFOACK packet is also used to instruct the
        remote how to proceed with the transfer.

                                FINFOACK packet data
                     +---------------------------------------+
                     | Long file offset, special code, or 0  |
                     +---------------------------------------+

        The only data in this packet is a long integer. In response to an
        an end of batch FINFO packet, the file offset is set to zero (0). In
        all other cases, file offset is one of the following:

                           File offsets and special values
               +------+----------------------------------------------+
               |Offset|Description                                   |
               +------+----------------------------------------------+
               | >=0  |Seek to specified offset and start sending (1)|
               |  -1  |Already have file                          (2)|
               |  -2  |Send file during another batch (not now)      |
               +------+----------------------------------------------+

        (1) This can only be something other than zero if the FINFO packet
            specified a filesize other than zero (i.e. the size of the file
            is known to the receiver).

        (2) The sending application should consider the file as having been
            sent successfully. This is primarily used to prevent duplicate
            files from being transmitted.

        DATA packet
        ---------------------------------------------------------------------
        Packet containing actual file data.

                                      DATA packet
                      +-----------------------------------------+
                      | Long file offset of file data block     |
                      +-----------------------------------------+
                      ~ Variable length data block 0-2048 bytes ~
                      +-----------------------------------------+

        If the file offset corresponds with what is expected by the receiver,
        the data block is saved and the file position increased accordingly.
        If the file offset is not correct, DATA packets may have been lost or
        failed the CRC check. Bad packets are ignored because it is not
        certain that the bad packet was an actual DATA packet and not some
        other type of packet. The file offset comparison is therefore the
        only way to find out about lost or bad data.

        When a bad data packet is detected, an RPOS packet is transmitted by
        the receiver to force the sender to seek to the desired file offset
        and resume transmission from it. After transmitting the RPOS packet,
        the receiver initializes a timer and continues to monitor received
        DATA packets while comparing their file offset with its desired
        offset.

        If the offset of a newly received DATA packet is greater than the
        offset received in the last DATA packet prior to transmitting the
        RPOS packet, the sender has not yet seen the RPOS packet, or the
        DATA packet was already in the data stream when the RPOS packet was
        transmitted.

        If the received offset matches the requested offset, the transfer is
        resumed, otherwise, a new RPOS packet is transmitted by the receiver
        and the timer restarted.

        If the timer expires, another RPOS packet is transmitted by the
        receiver. This is repeated until the maximum number of retries has
        been reached.

        If the receiver encounters more missing or invalid DATA packets at
        the same offset than it finds acceptable and it is not the originator
        of the session, it may decide to revert to a one-way transfer and
        wait with sending the remainder of its own files until the remote has
        transmitted its end of batch signal. It is possible that some hard-
        ware is not capable or well suited for a bi-directional file transfer
        involving large volumes of data (see description of the IDLE packet).

        DATAACK packet
        ---------------------------------------------------------------------
        Transmitted by the receiver with its current file offset after
        receiving a valid DATA packet.

                                  DATAACK packet data
                              +------------------------+
                              |    Long file offset    |
                              +------------------------+

        This packet is only transmitted if there is a window in operation
        for that direction (selected in the INIT stage of the session), in
        which case the sender uses the DATAACK file offsets to manage its
        transmit window. If the sender's file offset is greater than or equal
        to the last DATAACK offset received plus the window size, no more
        data is transmitted by the sender until a DATAACK packet is received
        which allows the sender to proceed without exceeding the window size.

        While waiting for the DATAACK packet, the sender checks its timer
        and retry counter. If the timer expires before a valid DATAACK packet
        is received, the next DATA packet is transmitted, the retry counter
        incremented, and the timer restarted with half the normal timeout.
        This system ensures that the two sides do not end up waiting for
        each other in case packets are lost; the receiver will respond with
        either a DATAACK or RPOS packet. Receipt of a DATAACK packet does not
        reset the braindead timer.

        There are two windowing systems the receiver can use: sliding window
        or segmented streaming.

        If the receiver is capable of simultaneous serial and disk I/O, it
        will transmit a DATAACK packet for every received DATA packet, or
        every few DATA packets if it wants to be more economical with line
        capacity.
        Sliding window transmission is just a method of keeping the runahaid
        of the transmitter within reasonable limits (for sattelite or network
        links with long delays), thereby allowing for faster error recovery.
        Because of Hydra's tolerancy to delays and method of error recovery,
        sliding windows transmission is not normally required and full
        streaming can be used.

        If however the receiver is not capable of simultaneous serial and
        disk I/O, it will will process received DATA packets until the window
        size is reached (or slightly exceeded), write the received packets to
        disk, and then transmit one DATAACK packet to signal that it can
        receive the next segment of data.

        If the sender cannot handle simultaneous serial and disk I/O, it can
        apply the segmented streaming technique for reading data segments of
        the negotiated window size from disk.

        RPOS packet
        ---------------------------------------------------------------------
        Transmitted by the receiver to force the sender to seek to a specific
        position in the file and resume the transfer (as described above).

        The RPOS packet is also used by the receiver to skip a file once the
        transfer has been initiated. This is done by transmitting a RPOS
        packet with -2 as the desired offset and then waiting for a EOF
        packet with the same offset (-2). Once the EOF packet is received,
        the receiver responds to it by transmitting a EOFACK packet and then
        proceeds to wait for the next FINFO packet.

                              RPOS packet dependent data
                      +----------------------------------------+
                      | Long file offset                       |
                      +----------------------------------------+
                      | Desired datablock size (word, 64-2048) |
                      +----------------------------------------+
                      | Long RPOS packet ID                    |
                      +----------------------------------------+

                                     File offsets
                 +------+-------------------------------------------+
                 |Offset|Description                                |
                 +------+-------------------------------------------+
                 | >=0  |Seek to specified offset and resume sending|
                 |  -2  |Send file during another batch (not now)   |
                 +------+-------------------------------------------+

        The desired data blocksize field tells the sender what blocksize
        to use when it resumes transmitting from the specified file offset.

        Each new RPOS packet should be given a different packet ID. This
        allows the sender to identify and ignore duplicate RPOS packets.
        The ID need not be sequential, but it must not have the same value as
        any other RPOS packet sent during the transmission of the same file.
        A RPOS ID value of zero (0) is not permitted. The same ID value is
        only used when sending multiple RPOS packets due to an expired RPOS
        packet timer as described above (DATA packet).

        EOF packet
        ---------------------------------------------------------------------
        Indicates that the end of the file has been reached by the sender.
        The packet is transmitted after the last DATA packet with file data.
        The EOF packet only contains one field which holds the current file
        offset of the sender (i.e. the actual size of the file).

        After the EOF packet has been transmitted, the timer is set to the
        normal timeout value. The sender then waits for an EOFACK packet
        from the remote or for the timer to expire. In the event of a
        timeout, the transmit/wait sequence is repeated with half the normal
        timeout value until the maximum number of retries has been reached.

        In the event that the receiver requests to skip the file by
        transmitting a RPOS(-2) packet (see RPOS packet), the EOF packet
        contains the same value (-2). If the sender wants to skip the file
        currently being transmitted, it issues an EOF packet with -2 as the
        offset value.

        EOF packets with an incorrect offset should be treated by the
        receiver as if it was an incorrect DATA packet (i.e. transmitting an
        RPOS packet). Accepted EOF packets are acknowledged by transmitting
        an EOFACK packet.

                                    EOF packet data
                         +----------------------------------+
                         | Long file offset or special code |
                         +----------------------------------+

                             File offsets and special value
                   +------+----------------------------------------+
                   |Offset|Description                             |
                   +------+----------------------------------------+
                   | >=0  |Final offset in file (size of file)     |
                   |  -2  |Send file during another batch (not now)|
                   +------+----------------------------------------+

        EOFACK packet
        ---------------------------------------------------------------------
        Transmitted in response to an accepted EOF packet. After transmitting
        this packet, the receiver waits for the FINFO packet of the next file
        or end of batch.

        END packet                                               (HEX format)
        ---------------------------------------------------------------------
        Once all files have been transmitted by both sides and no device
        packets remain to be transmitted, the end of session sequence is
        initiated. END packets are always sent in HEX format.

        Two END packets are transmitted and the transmit timer set to half
        the normal timeout. The application then waits for an END packet from
        the remote or for the transmit timer to expire. In the event of a
        timeout, the transmit/wait sequence is repeated until the maximum
        number of retries has been reached. At this point, the HYDRA session
        may be considered to be successful as both batches were completed.

        If an END packet is received before timeout, another three (3) END
        packets are transmitted and the protocol exits. Both sides need to
        transmit END packets and receive at least one from the remote.

        IDLE packet                                              (HEX format)
        ---------------------------------------------------------------------
        The IDLE packet is used to let the remote know that the application
        is still alive. This is only applicable in uni-directional transfer
        mode to let the remote know that your application is still alive when
        it is receiving files, and after having transmitted an end of batch
        signal to the remote and not having any more files to send for the
        remainder of the session.

        When applicable, the IDLE packet is transmitted every 20 seconds. The
        remote resets its braindead timer upon receipt of an IDLE packet. If
        an application receives an IDLE packet while it is in a state where
        it is transmitting IDLE packets to the remote, something is wrong.
        This could occur if both sides have accidentally switched to one-way
        mode waiting for the remote to finish its batch. In this situation,
        one-way should be disabled to prevent a complete deadlock. Note that
        if both sides have finished their batch, the end of session sequence
        (see END packet) should be initiated.

        DEVDATA packet
        ---------------------------------------------------------------------
        Support for the DEVDATA and DEVDACK packets is optional and indicated
        in the INIT packet with the DEV flag in the "Supported options"
        field. The ID value is a long, different for each new device data
        packet sent. A value of zero (0) is not permitted.

        Only one DEVDATA packet may be transmitted at a time; the side
        issuing it then waits either for a timeout of the device transmit
        timer, or for a DEVDACK packet with the correct ID value to be
        received from the remote. If the timer expires before a correct
        DEVDACK packet is received, the DEVDATA packet is again transmitted,
        and the nnumber of device transmit retries incremented. If the
        maximum number of retries is reached, the HYDRA session is aborted;
        apparently the other is not functioning properly, or data is not
        getting through. In either case, the normal operation of the
        protocol (transferring files) will also fail.

        The name of the device to which the data is addressed is transmitted
        as an uppercase fixed-length three character NUL terminated string.
        There are two pre-defined device names as described below. If an
        unknown device name is specified, or a duplicate DEVDATA packet is
        received (one with the same ID value as a previously received and
        acknowledged DEVDATA packet), the packet is simply discarded after
        transmitting a DEVDACK packet with the corresponding ID value.

        DEVDATA and DEVDACK packets do not reset the braindead timer. They
        operate independently from the normal protocol. Device packets may
        only be transmitted after the initialization sequence, and before
        both sides have completed their batch. If a DEVDATA packet has not
        yet been acknowledged, the end of session sequence is delayed until
        a DEVDACK packet has been sent in response.

                           DEVDATA packet dependent data
               +--------------------------------------------------+
               | Long DEVDATA packet ID value                     |
               +--------------------------------------------------+
               | 3 character uppercase device name, NUL terminated|
               +--------------------------------------------------+
               ~ Variable length device data block (0-2048)       ~
               +--------------------------------------------------+

                               Predefined device names
                    +---+-------------------------------------+
                    |Dev|Description                          |
                    +---+-------------------------------------+
                    |MSG|Print data in protocol message window|
                    |CON|Print data to user console           |
                    +---+-------------------------------------+

        The MSG device may be used to notify the remote of protocol-specific
        issues, i.e. "One-way transfer mode". Such messages may be logged,
        but should not be considered to be machine-readable.

        The CON device may be used to implement a "chat" or conversation
        feature. This is a special case in which a session *can* be prolonged
        after end of batch, but not against the remote's will.
        While chat is enabled, there is no transition from the REND to the
        END transmitter state. When a CON device packet is transmitted in
        chat mode and the txstate is REND, the own braindead timer is reset.
        If the other side does initiate the end sequence by sending an END
        packet, the chat mode is immediately terminated and the session ended
        in a clean manner. If one side does not want to (continue) chat, and
        the other side does not comply, the one side will abort after a
        braindead timeout, so this chat system does not mean a security flaw.
        Each side is responsible for keeping the session going on his end
        until its own user has finished chatting. It is suggested that the
        software apply a timeout of say 1 minute to keyboard input, ending
        the chat automatically if the user stops typing but does not exit
        chat mode. Also, the chat mode should be initiated with a special key
        so that it can not erronously be started or prolonged.

        DEVDACK packet
        ---------------------------------------------------------------------
        Transmitted in response to a DEVDATA packet. The device data ID value
        must correspond to the ID of the previously received DEVDATA packet.

                                  DEVDACK packet data
                             +---------------------------+
                             | Long device data ID value |
                             +---------------------------+

    DEVICE sender (devtxstate HTD_...)
    +--------+------------------------------+--------------------------+----------+
    |State   |Predicate(s)                  |Action(s)                 |Next state|
    +--------+------------------------------+--------------------------+----------+
    |Begin   |                              |devtxid = 0               |DONE      |
    |        |                              |reset devtxtimer          |          |
    +--------+-+----------------------------+--------------------------+----------+
    |DONE    |1|wish to send device data &  |increase devtxid          |DATA      |
    |        | |other side allows DEV pkts  |devtxretries = 0          |          |
    |        | |                            |reset devtxtimer          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|wish to send device data &  |Tell calling function     |          |
    |        | |other doesn't allow DEV pkts|it's not on...            |          |
    +--------+-+----------------------------+--------------------------+----------+
    |DATA    |1|devtxretries == 10          |Report too many errors    |Abort     |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|else (devtxretries < 10)    |txpkt DEVDATA(id,dev,data)|DACK      |
    |        | |                            |devtxtimer = timeout      |          |
    +--------+-+----------------------------+--------------------------+----------+
    |DACK    |1|rxpkt DACK &                |reset devtxtimer          |DONE      |
    |        | |DACK(id) == devtxid         |                          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|devtxtimer expired          |Report devtx timeout      |DATA      |
    |        | |                            |increase devtxretries     |          |
    +--------+-+----------------------------+--------------------------+----------+

    DEVICE RECEIVER
    +--------+------------------------------+--------------------------+----------+
    |State   |Predicate(s)                  |Action(s)                 |Next state|
    +--------+------------------------------+--------------------------+----------+
    |Begin   |                              |devrxid = 0               |DONE      |
    +--------+-+----------------------------+--------------------------+----------+
    |DONE    |1|rxpkt DEVDATA               |txpkt DEVDACK(id)         |CheckID   |
    +--------+-+----------------------------+--------------------------+----------+
    |CheckID |1|DEVDATA(id) != devrxid      |devrxid = DEVDATA(id)     |Process   |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|else (apparent duplicate)   |                          |DONE      |
    +--------+-+----------------------------+--------------------------+----------+
    |Process |1|DEVDATA(dev) == MSG         |Print protocol message    |DONE      |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|DEVDATA(dev) == CON         |Output to user console    |DONE      |
    |        +-+----------------------------+--------------------------+----------+
    |        |3|DEVDATA(dev) == known&ok    |Call processing routine   |DONE      |
    |        +-+----------------------------+--------------------------+----------+
    |        |4|else (unknown/not-ok device)|One-way into bitbucket    |DONE      |
    +--------+-+----------------------------+--------------------------+----------+

        Packet length and data block size
        ---------------------------------------------------------------------
        The maximum length of a source data block (i.e. raw, non processed
        input file or device data) is 2048 bytes. The maximum allowed length
        of the packet data is 2048 + 8 = 2056 bytes. The eight bytes are to
        provide sufficient room for the additional fields in the DATA and
        DEVDATA packets. Packetizing adds an additional three to five bytes.
        The maximum length of a framed packet being transmitted can be three
        times the size of its source data depending on what type of encoding
        scheme is used (ASC, HEX, UUE, BIN). The minimum length of a data
        block is 64 bytes.

        The block size of DATA packets is based on the physical (DCE) link
        speed and is established as follows:

                +---------+------------------+-------------------+
                |DCE speed|Maximum block size|Starting block size|
                +---------+------------------+-------------------+
                |  300 bps|     256 bytes    |     256 bytes     |
                | 1200 bps|     512 bytes    |     256 bytes     |
                | 2400 bps|    1024 bytes    |     512 bytes     |
                |>2400 bps|    2048 bytes    |     512 bytes     |
                +---------+------------------+-------------------+

        The blocksize is initialized to the starting blocksize when a session
        is first started. After each kilobyte of file data transmitted, the
        blocksize is doubled until it reaches the maximum allowed blocksize.

        When the maximum allowed blocksize has been reached, the variable
        keeping track of how many bytes are needed to increase the blocksize
        is reset to zero.

        If a request for retransmission (RPOS packet) is received from the
        receiver, the blocksize is immediately set to that specified in the
        retransmission request. Every time this occurs, the number of bytes
        needed to double the blocksize is increased by 1024 with a maximum of
        of 8192 bytes. The end result is that more data has to be
        successfully transmitted before the blocksize is increased for each
        error that occurs.

        The length of a data block is dynamic and always in the range 0-2048
        bytes. A data block is never padded. If there is insufficient data
        to fill a block of the current blocksize, the blocksize is adjusted
        to the amount of remaining data.

        The blocksize logic is not reset between files in a session.

        Timers and retry counters
        =====================================================================
        Each process in the protocol (transmit, receive and device transmit)
        has its own timer and retry counter, and there is one overall
        braindead timer. Allowed are 10 tries, the braindead timeout is 120
        seconds, and the other timeouts are based on the speed of the line
        and the state of the protocol. It can be calculated as (40960/DCE
        rate), with a minimum of 10 seconds and a maximum of 60 seconds.

                         +---------+----------+----------+
                         |DCE speed|Timeout   |Half      |
                         +---------+----------+----------+
                         |  300 bps|60 seconds|30 seconds|
                         | 1200 bps|34 seconds|17 seconds|
                         | 2400 bps|17 seconds| 8 seconds|
                         |>2400 bps|10 seconds| 5 seconds|
                         +---------+----------+----------+

        If the output buffer is empty, the timeout value is halved. In
        general, this is the case if the number of tries is greater than zero
        and during the init and end sequences. These timeouts are not fatal
        situations, they just give the remote a reasonable amount of time to
        receive and respond to a packet before a retry occurs. Duplicate
        packets are always identified and ignored. A retry counter is reset
        if there is a change of state, or a reposition different from the
        previous file offset occurs.

        The braindead timer monitors useful data from the other side: a first
        response to a transmitted supervisiory packet, or a received packet
        with file data at the correct offset. Device packets and packets that
        do not signify any progress of the protocol do not affect the
        braindead timer.

        No other timers (such as one between characters in a packet) are
        necessary.

        Aborting a session
        =====================================================================
        A session is aborted with five consequetive CAN (^X or ASCII 24)
        characters. Whenever a state table mentions "Abort", the following
        procedure is to be followed:

        Clear the output buffer and transmit eight CAN characters followed by
        ten BS (^H or ASCII 8) characters; wait a few seconds for the data to
        be transmitted to the remote, purge the input buffer and exit the
        protocol code.

    GENERAL sender (txstate HTX_...)
    +--------+------------------------------+--------------------------+----------+
    |State   |Predicate(s)                  |Action(s)                 |Next state|
    +--------+------------------------------+--------------------------+----------+
    |Begin   |                              |txretries = 0             |START     |
    |        |                              |reset txtimer             |          |
    |        |                              |blksize = startblksize    |          |
    |        |                              |goodbytes = 0             |          |
    |        |                              |goodneeded = 1024         |          |
    |        |                              |braintimer = 120          |          |
    +--------+-+----------------------------+--------------------------+----------+
    |START   |1|txretries == 10             |Report too many errors    |Abort     |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|else (txretries < 10)       |txstr AutoStart           |SWAIT     |
    |        | |                            |txpkt START               |          |
    |        | |                            |txtimer = 5               |          |
    +--------+-+----------------------------+--------------------------+----------+
    |SWAIT   |1|rxpkt START or              |txretries = 0             |INIT      |
    |        | |rxpkt INIT                  |reset txtimer             |          |
    |        | |                            |braintimer = 120          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|txtimer expired             |Report tx timeout         |START     |
    |        | |                            |increment txretries       |          |
    +--------+-+----------------------------+--------------------------+----------+
    |INIT    |1|txretries == 10             |Report too many errors    |Abort     |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|else (txretries < 10)       |txpkt INIT(linkinfo)      |INITACK   |
    |        | |                            |txtimer = timeout/2       |          |
    +--------+-+----------------------------+--------------------------+----------+
    |INITACK |1|rxpkt INITACK               |txretries = 0             |RINIT     |
    |        | |                            |reset txtimer             |          |
    |        | |                            |braintimer = 120          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|txtimer expired             |Report tx timeout         |INIT      |
    |        | |                            |increment txretries       |          |
    +--------+-+----------------------------+--------------------------+----------+
    |RINIT   |1|rxstate != INIT             |                          |NextFile  |
    +--------+-+----------------------------+--------------------------+----------+
    |NextFile|1|No files left?              |Report end of batch       |ToFName   |
    |        | |                            |Set NULL fileinfo         |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|Can access next file?       |Set up fileinfo           |ToFName   |
    |        +-+----------------------------+--------------------------+----------+
    |        |3|Can't access file?          |Report access failure     |NextFile  |
    +--------+-+----------------------------+--------------------------+----------+
    |ToFName |                              |txsyncid = 0              |FINFO     |
    |        |                              |txretries = 0             |          |
    |        |                              |reset txtimer             |          |
    +--------+-+----------------------------+--------------------------+----------+
    |FINFO   |1|txretries == 10             |Report too many errors    |Abort     |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|txretries > 0               |txpkt FINFO(fileinfo)     |FINFOACK  |
    |        | |                            |txtimer = timeout/2       |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |3|else (txretries == 0)       |txpkt FINFO(fileinfo)     |FINFOACK  |
    |        | |                            |txtimer = timeout         |          |
    +--------+-+----------------------------+--------------------------+----------+
    |FINFOACK|1|NULL fname (end of batch) & |txtimer = idletimeout     |REND      |
    |        | |rxpkt FINFOACK              |braintimer = 120          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|rxpkt FINFOACK &            |txpos = FINFOACK(pos)     |DATA      |
    |        | |FINFOACK(pos) >= 0          |txretries = 0             |          |
    |        | |                            |txlastack = 0             |          |
    |        | |                            |braintimer = 120          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |3|rxpkt FINFOACK &            |They already have file    |NextFile  |
    |        | |FINFOACK(pos) == -1)        |braintimer = 120          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |4|rxpkt FINFOACK &            |Skip this file for now    |NextFile  |
    |        | |FINFOACK(pos) == -2)        |braintimer = 120          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |5|txtimer expired             |Report tx timeout         |FINFO     |
    |        | |                            |inrease txretries         |          |
    +--------+-+----------------------------+--------------------------+----------+
    |DATA    |1|rxstate != Done &           |txtimer = idletimeout     |XWAIT     |
    |        | |hdxlink == True             |                          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|rxpkt DATAACK &             |txlastack = DATAACK(pos)  |          |
    |        | |DATAACK(pos) > txlastack    |                          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |3|rxpkt RPOS &                |Skip this file for now    |SkipFile  |
    |        | |RPOS(pos) < 0               |braintimer = 120          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |4|rxpkt RPOS &                |Report too many errors    |Abort     |
    |        | |RPOS(id) == txsyncid &      |                          |          |
    |        | |inc txretries == 10         |                          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |5|rxpkt RPOS &                |txpos = RPOS(pos)         |          |
    |        | |RPOS(id) != txsyncid &      |txsyncid = RPOS(id)       |          |
    |        | |RPOS(pos) >= 0              |txretries = 1             |          |
    |        | |                            |blksize = RPOS(blksize)   |          |
    |        | |                            |goodbytes = 0             |          |
    |        | |                            |inc goodneeded + 1024     |          |
    |        | |                            |if (goodneeded > 8192)    |          |
    |        | |                            |   goodneeded = 8192      |          |
    |        | |                            |braintimer = 120          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |6|File seek/read error or     |Skip this file for now    |SkipFile  |
    |        | |user wishes to skip file    |                          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |7|txwindow &                  |if (txretries > 0)        |DATAACK   |
    |        | |txpos >= txlastack+txwindow |   txtimer = timeout/2    |          |
    |        | |                            |else                      |          |
    |        | |                            |   txtimer = timeout      |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |8|Enough room in output &     |txpkt DATA(pos,data)      |          |
    |        | |more filedata(blksize) to go|txpos += datalen          |          |
    |        | |                            |inc goodbytes + datalen   |          |
    |        | |                            |if goodbytes > goodneeded |          |
    |        | |                            |   Store txpos,blksize    |          |
    |        | |                            |   blksize * 2 (max.2048) |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |9|End of filedata reached     |                          |EOF       |
    +--------+-+----------------------------+--------------------------+----------+
    |SkipFile|                              |txpos = -1                |EOF       |
    |        |                              |txretries = 0             |          |
    +--------+-+----------------------------+--------------------------+----------+
    |DATAACK |1|txretries == 10             |Report too many errors    |Abort     |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|rxpkt DATAACK &             |txlastack = DATAACK(pos)  |DATA      |
    |        | |DATAACK(pos) > txlastack &  |txretries = 0             |          |
    |        | |txpos < DATAACK(pos) + txwin|reset txtimer             |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |3|rxpkt RPOS                  |Handle RPOS in state DATA |          |
    |        | |                            |but stay in this state    |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |4|txtimer expired             |Report tx timeout         |DATA      |
    |        | |                            |increment txretries       |          |
    +--------+-+----------------------------+--------------------------+----------+
    |XWAIT   |1|rxstate == Done             |reset txtimer             |DATA      |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|rxpkt DATAACK &             |txlastack = DATAACK(pos)  |          |
    |        | |DATAACK(pos) > txlastack    |                          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |3|rxpkt RPOS                  |Handle RPOS in state DATA |          |
    |        | |                            |but stay in this state    |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |4|rxpkt IDLE                  |hdxlink = False           |DATA      |
    |        | |                            |reset txtimer             |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |5|txtimer expired             |txpkt IDLE                |          |
    |        | |                            |txtimer = idletimeout     |          |
    +--------+-+----------------------------+--------------------------+----------+
    |EOF     |1|txretries == 10             |Report too many errors    |Abort     |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|txretries > 0               |txpkt EOF(txpos)          |EOFACK    |
    |        | |                            |txtimer = timeout/2       |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |3|else (txretries == 0)       |txpkt EOF(txpos)          |EOFACK    |
    |        | |                            |txtimer = timeout         |          |
    +--------+-+----------------------------+--------------------------+----------+
    |EOFACK  |1|rxpkt EOFACK                |braintimer = 120          |NextFile  |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|rxpkt DATAACK &             |txlastack = DATAACK(pos)  |          |
    |        | |DATAACK(pos) > txlastack    |                          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |3|rxpkt RPOS &                |rxpos == -2               |EOF       |
    |        | |RPOS(pos) == -2 &           |                          |          |
    |        | |rxpos != -2                 |                          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |4|rxpkt RPOS &                |Handle as in state DATA   |DATA      |
    |        | |RPOS(pos) >= 0              |                          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |5|txtimer expired             |Report tx timeout         |EOF       |
    |        | |                            |increment txretries       |          |
    +--------+-+----------------------------+--------------------------+----------+
    |REND    |1|rxstate == DONE &           |txretries = 0             |END       |
    |        | |devtxstate == DONE          |                          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|txtimer expired             |txpkt IDLE                |          |
    |        | |                            |txtimer = idletimeout     |          |
    +--------+-+----------------------------+--------------------------+----------+
    |END     |1|txretries == 10             |                          |Abort     |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|else (txretries < 10)       |txpkt END (twice)         |ENDACK    |
    |        | |                            |txtimer = timeout/2       |          |
    +--------+-+----------------------------+--------------------------+----------+
    |ENDACK  |1|rxpkt END                   |txpkt END (thrice)        |Done      |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|txtimer expired             |Report tx timeout         |END       |
    |        | |                            |increment txretries       |          |
    +--------+-+----------------------------+--------------------------+----------+

    GENERAL RECEIVER (rxstate HRX_...)
    +--------+------------------------------+--------------------------+----------+
    |State   |Predicate(s)                  |Action(s)                 |Next state|
    +--------+------------------------------+--------------------------+----------+
    |Begin   |                              |reset rxtimer             |START     |
    |        |                              |lastrxdlen = startblksize |          |
    |        |                              |(tx handles braintimer)   |          |
    +--------+-+----------------------------+--------------------------+----------+
    |INIT    |1|rxpkt INIT &                |txpkt INITACK             |FINFO     |
    |        | |INIT(options) are compatible|Set options               |          |
    |        | |                            |braintimer = 120          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|INIT(options) not compatible|Report link failure       |Abort     |
    +--------+-+----------------------------+--------------------------+----------+
    |FINFO   |1|rxpkt INIT (apparent dup)   |txpkt INITACK             |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|rxpkt FINFO &               |Report end of batch       |          |
    |        | |FINFO(fileinfo) == Empty    |txpkt FINFOACK            |DONE      |
    |        | |                            |braintimer = 120          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |3|rxpkt FINFO &               |do not want this file     |          |
    |        | |we already have file        |txpkt FINFOACK(-1)        |          |
    |        | |                            |braintimer = 120          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |4|rxpkt FINFO &               |Skip this file for now    |          |
    |        | |open/diskspace error        |txpkt FINFOACK(-2)        |          |
    |        | |                            |braintimer = 120          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |5|rxpkt FINFO &               |rxpos = resume offset     |ToData    |
    |        | |file we want to resume      |                          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |6|rxpkt FINFO &               |rxpos = 0                 |ToData    |
    |        | |new file for us             |                          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |7|rxpkt EOF (apparent dup)    |txpkt EOFACK              |          |
    +--------+-+----------------------------+--------------------------+----------+
    |ToData  |                              |txpkt FINFOACK(rxpos)     |DATA      |
    |        |                              |rxsyncid = 0              |          |
    |        |                              |rxlastsync = 0;           |          |
    |        |                              |rxretries = 0             |          |
    |        |                              |reset rxtimer             |          |
    |        |                              |braintimer = 120          |          |
    +--------+-+----------------------------+--------------------------+----------+
    |DATA    |1|rxpkt FINFO (apparent dup)  |txpkt FINFOACK(rxpos)     |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|rxpkt DATA &                |Store data                |          |
    |        | |DATA(pos) == rxpos          |rxpos += datalen          |          |
    |        | |                            |rxretries = 0             |          |
    |        | |                            |rxlastsync = rxpos        |          |
    |        | |                            |reset rxtimer             |          |
    |        | |                            |braintimer = 120          |          |
    |        | |                            |if (rxwindow)             |          |
    |        | |                            |   txpkt DATAACK(rxpos)   |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |3|rxpkt DATA &                |Report bad rxpos          |BadPos    |
    |        | |DATA(pos) != rxpos          |                          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |4|rxpkt EOF &                 |Close file, received ok   |OkEOF     |
    |        | |EOF(pos) == rxpos           |                          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |5|rxpkt EOF &                 |Close, save for resume    |OkEOF     |
    |        | |EOF(pos) == -2              |                          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |6|rxpkt EOF &                 |Report bad EOF            |BadPos    |
    |        | |EOF(pos) != rxpos           |                          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |7|File write error or         |Close, save for resume    |          |
    |        | |user wishes to skip file    |rxpos = -2                |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |8|rxpkt IDLE &                |braintimer = 120          |          |
    |        | |hdxlink == False            |                          |          |
    +--------+-+----------------------------+--------------------------+----------+
    |BadPos  |1|DATA/EOF(pos) <= rxlastsync |rxretries = 0             |Timer     |
    |        | |                            |reset rxtimer             |          |
    |        | |                            |rxlastsync = pos          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|DATA/EOF(pos) > rxlastsync  |rxlastsync = pos          |Timer     |
    +--------+-+----------------------------+--------------------------+----------+
    |Timer   |1|rxtimer expired             |                          |HdxLink   |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|else (rxtimer not expired)  |                          |DATA      |
    +--------+-+----------------------------+--------------------------+----------+
    |HdxLink |1|rxretries > 4 &             |hdxlink = True            |Retries   |
    |        | |txstate < REND &            |rxretries = 0             |          |
    |        | |originator == False &       |                          |          |
    |        | |hdxlink == False            |                          |          |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|else (above not the case)   |                          |Retries   |
    +--------+-+----------------------------+--------------------------+----------+
    |Retries |1|inc rxretries == 10         |Report too many errors    |Abort     |
    |        +-+----------------------------+--------------------------+----------+
    |        |2|rxretries == 1              |increase rxsyncid         |RPos      |
    |        +-+----------------------------+--------------------------+----------+
    |        |3|else (rxretries > 1)        |                          |RPos      |
    +--------+-+----------------------------+--------------------------+----------+
    |RPos    |                              |lastrxdatalen/=2 (min.64) |DATA      |
    |        |                              |txpkt RPOS (rxpos,        |          |
    |        |                              |   lastrxdatalen,rxsyncid)|          |
    |        |                              |rxtimer = timeout         |          |
    +--------+------------------------------+--------------------------+----------+
    |OkEOF   |                              |txpkt EOFACK              |FINFO     |
    |        |                              |reset rxtimer             |          |
    |        |                              |braintimer = 120          |          |
    +--------+-+----------------------------+--------------------------+----------+
    |DONE    |1|rxpkt FINFO (apparent dup)  |txpkt FINFOACK(-2)        |          |
    +--------+-+----------------------------+--------------------------+----------+

        HYDRA in FidoNet technology mailers
        =====================================================================
        HYDRA is suitable for use in FidoNet mailers. It can be implemented
        for EMSI and FTS-6 mail sessions. The FTS-6 (YooHoo) capability bit
        for HYDRA is 0x0020 (DOES_HYDRA). The EMSI and IEMSI protocol
        capability flag is HYD.

        When utilizing HYDRA in a mail session, two complete batches are
        always performed. Little else differs from a normal FTS-6 ZedZap mail
        session. The first batch is used to transmit all mail, files, and
        file requests by both sides. The second batch is always performed,
        sending nothing if there are no file requests to honor. The data
        buffers are not purged between the two batches since HYDRA ignores
        any leftovers from the previous batch (END packets, etc.).

        To integrate HYDRA into an existing mailer, the same code used for
        the ZedZap session flow can be used, but instead of one transmit and
        one receive session, two transmit sessions (or batches) are used.
        When the HYDRA end of batch is initiated it will not be terminated
        until an end of batch has been received from the remote and the end
        of session sequence has been finished.

        Fido and FidoNet are registered marks of Tom Jennings and Fido
        Software.

        Error detection using CRCs
        =====================================================================
        CRC (Cyclic Redundancy Check) values only provide their promised
        maximum error detection capability when properly applied, which
        involves calculating and transmitting low-bit first, presetting the
        CRC with all ones, and transmitting the ones' complement of the
        result. The receiver also initializes to all ones, processes all of
        the data AND the following CRC, and the result should match a "magic
        value" which is 0xf0b8 for the 16-bit CRC and 0xdebb20e3 for the
        32-bit CRC.

        The easiest and fastest way to perform CRC calculations is by using a
        table that does the algorithm's shift-operations in 8-bits at a time.

        CRC-16 error detection
        ---------------------------------------------------------------------
        16-bit CRC using the CCITT CRC-16 polynomial. This is the default at
        startup, and always used for HEX packets even if both sides are
        capable of handling 32-bit CRCs.

        This CRC-16 is not identical to the one used by the Xmodem and Zmodem
        file transfer protocols. The polynomial is the same
        (X^16+X^12+X^5+X^0 or 0x8408) but the bit-ordering is the opposite,
        and preconditioning and postconditioning is used as in 32-bit CRCs.
        This method is also used by the European version of X.25.

        The 16-bit CRC table is created as follows (pseudocode, the variable
        CRC16 and the table of 256 entries are 16-bit unsigned integers):

            FOR (i=0 TO 255)
                {
                CRC16=i
                FOR (N=1 TO 8)
                    {
                    IF (CRC16 AND 1)
                        CRC16=(CRC16 >> 1) XOR 0x8408
                    ELSE
                        CRC16=CRC16 >> 1
                    }
                CRC16TAB[i]=CRC16;
                }

        When processing data, each byte is run through the CRC calculation
        routine as follows (variable CRC stores the 16-bit CRC value/result,
        C is the next 8-bit char):

            CRC=CRC16TAB[(CRC XOR C) AND 0xff] XOR ((CRC>>8) AND 0x00ff)

        CRC-32 error detection
        ---------------------------------------------------------------------
        32-bit CRC using the CCITT CRC-32 polynomial. Support of CRC-32 is
        optional and signalled in the INIT packet.

        If both sides indicate they can handle CRC-32, all packets except
        those transmitted in HEX format use this algorithm instead of CRC-16
        to improve error detection.

        This CRC-32 is identical to the one used by the Zmodem protocol.
        The polynomial is (0xedb88320):

        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

        The principal method of calculation, transmission, and checking is
        identical to CRC-16 as described above, but the "magic value" for
        32-bit CRC is 0xdebb20e3.

        The CRC-32 table is created as follows (pseudocode, the variable
        CRC32 and the table of 256 entries are 32-bit unsigned integers):

        FOR (i=0 TO 255)
            {
            CRC32=i
            FOR (N=1 TO 8)
                {
                IF (CRC32 AND 1)
                    CRC32 = (CRC32 >> 1) XOR 0xedb88320
                ELSE
                    CRC32 = CRC32 >> 1
                }
            CRC32TAB[i] = CRC32;
            }

        When processing data, each byte is run through the CRC calculation
        routine as follows (variable CRC stores the 32-bit CRC value/result,
        C is the next 8-bit character):

            CRC=CRC32TAB[(CRC XOR C) AND 0xFF] XOR ((CRC>>8) AND 0x00ffffff)

        The authors
        =====================================================================
        The authors can be reached at the following addresses:

        Joaquim H. Homrighausen                    Arjen G. Lentz
        389, route d'Arlon                         Lentz Software Development
        L-8011 Strassen                            Langegracht 7B
        Luxembourg                                 3811 BT Amersfoort
                                                   The Netherlands
    	joho@ae.lu
        FidoNet 2:270/17                           aglentz@fido.lu
                                                   FidoNet 2:283/512

        The name HYDRA
        =====================================================================
        Hydra is a greek mythological creature (the watersnake). Like the
        Nemeic lion, Hydra is the daughter of the giant Typhon and the snake
        Echidna.

        She grew up in the marshes of Lerna near/in Argolis (Argos). There
        she ate entire herds of cattle and destroyed large cropfields. Later,
        she lived in caves on a hill near the spring of Amymone.

        Hydra is a monstrous large snake with nine heads: eight mortal ones,
        and one (the middle one) immortal. She was defeated and killed by
        Heracles (Hercules) - son of Zeus and Alcemene, grandson of Perseus -
        as the second of his twelve tasks, with the help of his cousin
        Iolaos. Every time he cut of one of the heads with his sword, two new
        heads grew in its place. So Iolaos scorched the wound of each cut off
        head with burning branches so the head couldn't grow on again.

        Heracles buried the last and immortal head under a stone nearby. He
        also dipped his arrows in Hydra's poisonous blood, thereafter the
        wounds caused by those arrows were incurable.

        Also star constellation (sign of the watersnake) in the equatorial
        zone.

        Also a type of sweetwater polip (the Hydroidea Thin, tubeshaped body
        can be full contracted, just like the six (or more) tentacles. There
        is no generation change, the gender-products grow directly on the
        body.

        The animals catch their prey with nettlecells, and are very verocious.
        They can be found in various stilstanding and flowing water and were
        first described by Anthonie van Leeuwenhoek in the year 1704.

        Also small island (spelled Idhra in modern Greek) of the Sargonic
        group in the Aegean Sea, just of the eastern tip of the Argolis
        peninsula of the Peloponesus (Attika). Its length (NE/SW) is 21 km,
        with a total area of 49,6 square km. Its highest point is 597 meters
        above sea level. Population of 2794 (latest census: 1981). Only one
        real city with the same name as the island. Once quite wooded and
        well watered, now denuded and dry, with almost no arable land
        (infertile limestone). Certain times of the year the people have to
        ship in water from the main land. Its Turkish name is Camliza which
        means "Place of Pines".

        References:
             Dutch:  Oosthoeks Encyclopedie
                     Grote Winklerprins Encyclopedie
           English:  Encyclopaedia Brittannica

Go Back