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 (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