    Document: FTS-0001
    Version:  016
    Date:     30-Sep-95

                         A Basic FidoNet(r) Technical Standard
    |                                Revision 16
                          Formerly known as FSC001,  FSC-0001
    |                      Randy Bush, Pacific Systems Group
    |                             September 30, 1995

    Status of this document:

        This FTS  (FidoNet(r)  Technical  Standard)  specifies  a  standard  for
        the FidoNet community. FidoNet nodes are expected to adopt and implement
        this standard. Distribution is subject to the restrictions stated in the
        copyright paragraph below.

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

        Copyright  1986-95,  Randy  Bush.  All  rights  reserved.   A  right  to
        distribute only  without modification  and only at no charge is granted.
        Under no  circumstances is this document to be reproduced or distributed
        as  part of  or packaged with any product or other sales transaction for
        which any fee is charged.  Any and all other reproduction  or excerpting
        requires the explicit written consent of the author.

     A. Introduction

        FidoNet  has  grown  beyond  most  peoples' fantasies, and  new  FidoNet
        implementations  are appearing regularly.  Unfortunately, the  scattered
        nature of the documentation and absence of clear testing procedures have
        made  implementation  difficult.   FidoNet, in its desire to promote and
        encourage  FidoNet  implementations,  suggested  a  project  to create a
        technical  standard for  FidoNet.  The author did not  design or specify
        the data formats or protocols, only attempted to document them.

        This  document defines the  data structures and communication  protocols
        which a FidoNet implementation must provide.  The implementor of FidoNet
        compatible systems is the intended audience of this document.

        The  layered metaphor of the ISO Open Systems Interface reference  model
        has been used to view FidoNet from a standard perspective.  As with most
        prospective  ISO/OSI  descriptions, FidoNet  does not always  make  this
        easy.

        The  content of this document  was gleaned from the references given  at
        the  end.

        Please direct technical comments and errata to
    |     Randy Bush                       randy@psg.com
    |     Pacific Systems Group
          9501 S.W. Westhaven Drive
          Portland, Oregon  US-97225
    |

       1. Basic Requirements for a FidoNet Implementation

          Compatibility is a set of abilities which, when taken as a whole, make
          it safe to list a net or node in the FidoNet nodelist. In other words,
          if  another  node should attempt  contact, does it have  a  reasonable
          chance  of successful communication?  This is a social obligation,  as
          the  calling  system  pays  money  for the  attempt.   Conversely,  an
          implementation  should be able to successfully contact other  systems,
          as life is not a one-way street.

          A FidoNet implementation must be able to call other nodes and transfer
          messages and files in both directions.  This includes pickup and poll.
          A FidoNet implementation must be able to accept calls from other nodes
          and  transfer  messages and  files in both directions.  This  includes
          pickup.

          FidoNet implementations must be able to receive and process the FidoNet
          format  nodelist, and transfer nodelists to other nodes.  A  companion
          document,  FTS-0005, defines the FidoNet format nodelist  and  how  to
          interpret and process it.

          A  FidoNet implementation must route messages which do not have  files
          attached through net hosts as shown in a FidoNet format nodelist.

       2. Levels of Compliance

          This  documents represents the  most basic FidoNet implementation.   A
          future  document will define well tested extensions which are optional
          but  provide sufficient  additional function that implementors  should
          seriously   consider   them.   SEAdog(tm),  from  System   Enhancement
          Associates,  is  an  excellent  example  of such an  extended  FidoNet
          implementation.

       3. The ISO/OSI Reference Model (cribbed from "Protocol Verification via
          Executable Logic Specifications", D. P. Sidhu, in Rudin & West)

          In  the ISO/OSI model, a distributed system consists of entities  that
          communicate  with  each other  according  to a set of rules  called  a
          protocol.   The  model is  layered, and there are entities  associated
          with  each layer of the model which provide services to higher  layers
          by  exchanging information with their peer entities using the services
          of  lower layers.  The only actual physical communication between  two
          systems is at the lowest level.

          Several  techniques  have  been  used  in the  specification  of  such
          protocols.  A common ingredient in all techniques is the notion of the
          extended  finite  state automata  or machine.  Extensions include  the
          addition of state variables for the storing of state information about
          the  protocol.  The state of an  automation can change as a result  of
          one of the following events:

          o Request from an upper network layer for service

          o Response to the upper layer

          o Request to the lower network layer to perform a service

          o Response from the lower layer

          o Interaction with the system and environment in which the protocol is
            implemented (e.g. timeouts, host operating system aborts, ...)

          A  protocol  specification, in  a large part, consists  of  specifying
          state  changes  in  automata  which  model protocol  entities  and  in
          describing the data which they exchange.

          For  historical  reasons,  the  term  packet  is used  in  FidoNet  to
          represent a bundle of messages, as opposed to the more common use as a
          unit of communication, which is known as a block in FidoNet.

       4. Data Description

          A  language  specific  notation  was avoided.  Please help  stamp  out
          environmental  dependencies.   Only  you  can  prevent  PClone  market
          dominance.  Don't panic, there are rectangular record layouts too.

          (* non-terminals *)
          UpperCaseName - to be defined further on

          (* literals *)
          "ABC"         - ASCII character string, no termination implied
          nnH           - byte in hexadecimal

          (* terminals *)
          someName      - 16-bit integer, low order byte first (8080 style)
          someName[n]   - field of n bytes
          someName[.n]  - field of n bits
          someName(n)   - Null terminated string allocated n chars (incl Null)
          someName{max} - Null terminated string of up to max chars (incl Null)

          (* punctuation *)
          a b           - one 'a' followed by one 'b'
          ( a | b )     - either 'a' or 'b', but not both
          { a }         - zero or more 'a's
          [ b ]         - zero or one 'b'
          (* comment *) - ignored

          (* predeclared constant *)
          Null          = 00H

     5. Finite State Machine Notation

        .-----+----------+-------------------------+-------------------------+-----.
        |State| State    | Predicate(s)            | Action(s)               | Next|
        |  #  | Name     |                         |                         |  St |
        |-----+----------+-------------------------+-------------------------+-----|
        | fnn*|          |                         |                         |     |
        `-----+----------+-------------------------+-------------------------+-----'

        State #      - Number of this state (e.g. R13).
                       f  - FSM initial (Window, Sender, Receiver, ...)
                       nn - state number
                       *  - state which represents a lower level protocol  which
                            is represented by yet another automation.

        State Name   - Descriptive name of this state.

        Predicate(s) - Conditions which terminate the state.  If predicates are
                       non-exclusive, consider them ordered.

        Action(s)    - Action(s) corresponding to predicate(s)

        Next State   - Subsequent state corresponding to predicate(s)

        Ideally,  there  should be  a  supporting section for each  state  which
        should  give a prose description of the state, its predicates,  actions,
        etc.  So much for ideals.

     B. Application Layer : the System from the User's View

        The application layer is outside the domain of a FidoNet standard, as it
        is the layer that the user's application sees as opposed to what FidoNet
        sees.   In  recent  months,  there  has been  sufficient  confusion  and
        discussion  about  the  format  of  data at this level  to  warrant  the
        description  of the data structure, the message as it is stored by Fido,
        SEAdog, and Rover.

        Perfectly valid FidoNet systems may be implemented whose stored messages
        differ greatly from this format.

       1. Application Layer Data Definition : a Stored Message

                                   Stored Message

           Offset
          dec hex
                  .-----------------------------------------------.
            0   0 |                                               |
                  ~                 fromUserName                  ~
                  |                   36 bytes                    |
                  +-----------------------+-----------------------+
           36  24 |                                               |
                  ~                  toUserName                   ~
                  |                   36 bytes                    |
                  +-----------------------+-----------------------+
           72  48 |                                               |
                  ~                    subject                    ~
                  |                   72  bytes                   |
                  +-----------------------+-----------------------+
          144  90 |                                               |
                  ~                    DateTime                   ~
                  |                    20 bytes                   |
                  +-----------------------+-----------------------+
          164  A4 | timesRead (low order) | timesRead (high order)|
                  +-----------------------+-----------------------+
          166  A6 | destNode (low order)  | destNode (high order) |
                  +-----------------------+-----------------------+
          168  A8 | origNode (low order)  | origNode (high order) |
                  +-----------------------+-----------------------+
          170  AA |   cost (low order)    |   cost (high order)   |
                  +-----------------------+-----------------------+
          172  AC | origNet (low order)   | origNet (high order)  |
                  +-----------------------+-----------------------+
          174  AE | destNet (low order)   | destNet (high order)  |
                  +-----------------------+-----------------------+
          176  B0 | destZone (optional)   | destZone (optional)   |
                  +-----------------------+-----------------------+
          178  B2 | origZone (optional)   | origZone (optional)   |
                  +-----------------------+-----------------------+
          180  B4 | destPoint(optional)   | destPoint(optional)   |
                  +-----------------------+-----------------------+
          182  B6 | origPoint(optional)   | origPoint(optional)   |
                  +-----------------------+-----------------------+
          184  B8 |  replyTo (low order)  |  replyTo (high order) |
                  +-----------------------+-----------------------+
          186  BA | Attribute (low order) | Attribute (high order)|
                  +-----------------------+-----------------------+
          188  BC | nextReply (low order) | nextReply (high order)|
                  +-----------------------+-----------------------+
          190  BE |                      text                     |
                  ~                    unbounded                  ~
                  |                 null terminated               |
                  `-----------------------------------------------'

          Message    = fromUserName(36)  (* Null terminated *)
                       toUserName(36)    (* Null terminated *)
                       subject(72)       (* see FileList below *)
                       DateTime          (* message body was last edited *)
                       timesRead         (* number of times msg has been read *)
                       destNode          (* of message *)
                       origNode          (* of message *)
                       cost              (* in lowest unit of originator's
                                            currency *)
                       origNet           (* of message *)
                       destNet           (* of message *)
                       destZone          (* of message *)
                       origZone          (* of message *)
                       destPoint         (* of message *)
                       origPoint         (* of message *)
                       replyTo           (* msg to which this replies *)
                       AttributeWord
                       nextReply         (* msg which replies to this *)
                       text(unbounded)   (* Null terminated *)

          DateTime   = (* a character string 20 characters long *)
                                         (* 01 Jan 86  02:34:56 *)
                       DayOfMonth " " Month " " Year " "
                       " " HH ":" MM ":" SS
                       Null

          DayOfMonth = "01" | "02" | "03" | ... | "31"   (* Fido 0 fills *)
          Month      = "Jan" | "Feb" | "Mar" | "Apr" | "May" | "Jun" |
                       "Jul" | "Aug" | "Sep" | "Oct" | "Nov" | "Dec"
          Year       = "01" | "02" | .. | "85" | "86" | ... | "99" | "00"
          HH         = "00" | .. | "23"
          MM         = "00" | .. | "59"
          SS         = "00" | .. | "59"

          AttributeWord   bit       meaning
                          ---       --------------------
                            0  +    Private
                            1  + s  Crash
                            2       Recd
                            3       Sent
                            4  +    FileAttached
                            5       InTransit
                            6       Orphan
                            7       KillSent
                            8       Local
                            9    s  HoldForPickup
                           10  +    unused
                           11    s  FileRequest
                           12  + s  ReturnReceiptRequest
                           13  + s  IsReturnReceipt
                           14  + s  AuditRequest
                           15    s  FileUpdateReq

                                 s - need not be recognized, but it's ok
                                 + - not zeroed before packeting

          Bits numbers ascend with arithmetic significance of bit position.

          Message Text

          Message text is unbounded and null terminated (note exception below).

          A 'hard' carriage return, 0DH,  marks the end of a paragraph, and must
          be preserved.

          So   called  'soft'  carriage  returns,  8DH,  may  mark  a   previous
          processor's  automatic line wrap, and should be ignored.  Beware  that
          they may be followed by linefeeds, or may not.

          All  linefeeds, 0AH, should be ignored.  Systems which display message
          text should wrap long lines to suit their application.

          If the first character of a physical line (e.g. the first character of
          the  message text, or the character immediately after a hard  carriage
          return (ignoring any linefeeds)) is a ^A (, 01H), then that
          line  is  not  displayed  as  it  contains  control  information.  The
          convention for such control lines is:
            o They begin with ^A
            o They end at the end of the physical line (i.e. ignore soft <cr>s).
            o They begin with a keyword followed by a colon.
            o The keywords are uniquely assigned to applications.
            o They keyword/colon pair is followed by application specific data.

          Current ^A keyword assignments are:
    |     o TOPT <pt no> - destination point address
          o FMPT <pt no> - origin point address
          o INTL <dest z:n/n> <orig z:n/n> - used for inter-zone address

          File Specifications

          If  one  or more  of FileAttached, FileRequest, or  FileUpdateReq  are
          asserted  in an AttributeWord, the subject{72} field is interpreted as
          a  list of file specifications  which may include wildcards and  other
          system-dependent data.  This list is of the form

          FileList = [ FileSpec { Sep FileSpec } ] Null

          FileSpec = (* implementation dependent file specification.  may
                        not contain Null or any of the characters in Sep. *)

          Sep      = ( " " | "," )  { " " }

          There are deviations from and additions to these specifications

          1  - Fido does not necessarily terminate the message text with a Null,
               but  uses  an empty line (0DH 0AH 0DH 0AH).  Some  Fido utilities
               use an EOF (1AH).

          2 - SEAdog zeros the message cost field when building a message.

          4 - SEAdog uses a different format for dates, e.g.

          DateTime   = (* a character string 20 characters long *)
                       (* SEAdog format Mon  1 Jan 86 02:34 *)
                       DayOfWk " " DayOfMo " " Month " " Year " " HH ":" MM Null

          DayOfWk    = "Mon" | "Tue" | "Wed" | "Thu" | "Fri" | "Sat" | "Sun"
          DayOfMo    = " 1" | " 2" | " 3" | ... | "31"  (* blank fill *)

       2. Application Layer Protocol : Schedules and Events

          At  the application level, FidoNet imposes few protocol  requirements.
          An   implementation   must   automatically   originate   and   receive
          node-to-node  FidoNet  connections.   Some implementations do this  in
          'windows'  or  time  slots.   Routing  of  messages  will  usually  be
          different and customizable for each scheduled window.

          The ability to send to and receive from any FidoNet listed node during
          the Zone Mail Hour (eg. 9:00-10:00 UCT in Z1) is considered mandatory.

          Current  implementations assemble all data for outbound connections at
          the  start of a window, and  disassemble inbound data at the end of  a
          window.   Due to performance considerations on small machines, this is
          considered  a valid optimization.   Observe that it somewhat  inhibits
          dynamic routing.

     C. Presentation Layer : the User from the System's View

       1. Presentation Layer Data Definition : the Packed Message

          To  conserve space and eliminate fields which would be meaningless  if
          sent  (e.g. timesRead), messages are packed for transmission.  As this
          is  a data structure which is actually transferred, its definition  is
          critical  to FidoNet.  A packed  message has a number of fixed  length
          fields followed by four null terminated strings.

          While  most of the string fields in a stored message are fixed length,
          to  conserve space strings are variable length when in a packet.   All
          variable  length strings are all Null terminated, including especially
          the message text.

                                    Packed Message

           Offset
          dec hex
                  .-----------------------------------------------.
            0   0 |    0     |     2      |    0      |    0      |
                  +-----------------------+-----------------------+
            2   2 | origNode (low order)  | origNode (high order) |
                  +-----------------------+-----------------------+
            4   4 | destNode (low order)  | destNode (high order) |
                  +-----------------------+-----------------------+
            6   6 | origNet (low order)   | origNet (high order)  |
                  +-----------------------+-----------------------+
            8   8 | destNet (low order)   | destNet (high order)  |
                  +-----------------------+-----------------------+
           10   A | Attribute (low order) | Attribute (high order)|
                  +-----------------------+-----------------------+
           12   C |   cost (low order)    |   cost (high order)   |
                  +-----------------------+-----------------------+
           14   E |                                               |
                  ~                    DateTime                   ~
                  |                    20 bytes                   |
                  +-----------------------+-----------------------+
           34  22 |                  toUserName                   |
                  ~                  max 36 bytes                 ~
                  |                null terminated                |
                  +-----------------------+-----------------------+
                  |                 fromUserName                  |
                  ~                  max 36 bytes                 ~
                  |                null terminated                |
                  +-----------------------+-----------------------+
                  |                    subject                    |
                  ~                  max 72 bytes                 ~
                  |                null terminated                |
                  +-----------------------+-----------------------+
                  |                      text                     |
                  ~                    unbounded                  ~
                  |                 null terminated               |
                  `-----------------------------------------------'

          Due  to routing, the origin and  destination net and node of a  packet
          are  often quite different from  those of the messages within it,  nor
          need  the origin and destination nets and nodes of the messages within
          a packet be homogenous.

          PakdMessage  = 02H 00H           (* message type, old type-1 obsolete *)
                         origNode          (* of message *)
                         destNode          (* of message *)
                         origNet           (* of message *)
                         destNet           (* of message *)
                         AttributeWord
                         cost              (* in lowest unit of originator's
                                              currency *)
                         DateTime          (* message body was last edited *)
                         toUserName{36}    (* Null terminated *)
                         fromUserName{36}  (* Null terminated *)
                         subject{72}       (* Null terminated *)
                         text{unbounded}   (* Null terminated *)

     2. Presentation Layer Protocol : a Mail Window

       .-----+----------+-------------------------+-------------------------+-----.
       |State| State    | Predicate(s)            | Action(s)               | Next|
       |  #  | Name     |                         |                         | St  |
       |-----+----------+-------------------------+-------------------------+-----|
       | W0  | WindTop  | 1 end of window reached | reset modem to not answr| exit|
       |     |          | 2 time remains in window| ensure modem can answer | W1  |
       |-----+----------+-------------------------+-------------------------+-----|
       | W1  | WindIdle | 1 incoming call         |                         | W2  |
       |     |          | 2 receive-only mode     |                         | W0  |
       |     |          | 3 send-only mode        |                         | W3  |
       |     |          | 4 60-180 secs & no call |                         | W3  |
       |-----+----------+-------------------------+-------------------------+-----|
       | W2* | WindRecv |                         | (receive call R0)       | W3  |
       |-----+----------+-------------------------+-------------------------+-----|
       | W3  | WindCall | 1 select outgoing call  | increment try count     | W4  |
       |     |          | 2 no outgoing calls     |                         | W0  |
       |-----+----------+-------------------------+-------------------------+-----|
       | W4* | WindSend |                         | (make call S0)          | W5  |
       |-----+----------+-------------------------+-------------------------+-----|
       | W5  | WindMark | 1 call successful       | remove node fr call list| W0  |
       |     |          | 2 no connect            | remove if try cnt > lim | W0  |
       |     |          | 3 call failed           | incr conn cnt, remove   | W0  |
       |     |          |                         |   if con cnt > lim      |     |
       `-----+----------+-------------------------+-------------------------+-----'

        The  length of the inter-call delay time at W1.4 is not critical.  It is
        important that this not be a constant, so two systems calling each other
        do  not incur infinite busy signals.  Sophisticated implementations  may
        vary  the  inter-call delay  depending  on number of calls to  be  made,
        window width, user specification, etc.

     D. Session Layer Protocol : Connecting to Another FidoNet Machine

        A session is a connection between two FidoNet machines.  It is currently
        assumed  to be over the  DDD telephone network via modems.  The  calling
        machine starts out as the sender and the called machine as the receiver.
        The  pickup  feature is described  by the sender and  receiver  changing
        roles  midway through the session, after the sender has transferred  the
        message  packet and any attached files.  Due to the lack of security  in
        the  pickup protocol (danger of pickup by a fake node), a change in  the
        protocol may be expected in the near future.

        Once  a connection has been established, each system should ensure  that
        the  physical connection remains  throughout the session.  For  physical
        layers  implemented  through modems,  this means monitoring the  carrier
        detect signal, and terminating the session if it is lost.

        Error  detection at the physical layer should be monitored for both sent
        and  received  characters.  Parity,  framing, and other physical  errors
        should be detected.

        Sender

       .-----+----------+-------------------------+-------------------------+-----.
       |State| State    | Predicate(s)            | Action(s)               | Next|
       |  #  | Name     |                         |                         | St  |
       |-----+----------+-------------------------+-------------------------+-----|
       | S0  | SendInit |                         | dial modem              | S1  |
       |-----+----------+-------------------------+-------------------------+-----|
       | S1  | WaitCxD  | 1 carrier detected      | delay 1-5 seconds       | S2  |
       |     |          | 2 busy, etc.            | report no connection    | exit|
       |     |          | 3 voice                 | report no carrier       | exit|
       |     |          | 4 carrier not detected  | report no connection    | exit|
       |     |          |   within 60 seconds     |                         |     |
       |-----+----------+-------------------------+-------------------------+-----|
       | S2  | WhackCRs | 1 over 30 seconds       | report no response <cr> | exit|
       |     |          | 2 ?? <cr>s received     | delay 1 sec             | S3  |
       |     |          | 3 <cr>s not received    | send <cr> <sp> <cr> <sp>| S2  |
       |     |          |                         |   delay ??? secs        |     |
       |-----+----------+-------------------------+-------------------------+-----|
       | S3  | WaitClear| 1 no input for 0.5 secs | send TSYNCH = AEH       | S4  |
       |     |          | 2 over 60 seconds       | hang up, report garbage | exit|
       |     |          |   and line not clear    |                         |     |
       |-----+----------+-------------------------+-------------------------+-----|
       | S4* | TSyncChk | 1 'C' or NAK (peeked at)| (XMODEM send packet XS1)| S5  |
       |     |          | 2 over 2 seconds        | eat noise, resend TSYNCH| S4  |
       |     |          | 3 over 30 seconds       | hang up report not Fido | exit|
       |-----+----------+-------------------------+-------------------------+-----|
       | S5  | CheckMail| 1 XMODEM successful     | (Fido registers success)| S6  |
       |     |          | 2 XMODEM fail or timeout| hang up, report mail bad| exit|
       |-----+----------+-------------------------+-------------------------+-----|
       | S6* | SendFiles|                         | (BATCH send files BS0)  | S7  |
       |-----+----------+-------------------------+-------------------------+-----|
       | S7  | CheckFile| 1 BATCH send successful |                         | S8  |
       |     |          | 2 BATCH send failed     | hang up, rept files fail| exit|
       |-----+----------+-------------------------+-------------------------+-----|
       | S8  | TryPickup| 1 wish to pickup        | note send ok            | R2* |
       |     |          | 2 no desire to pickup   | delay 5 secs            | exit|
       |     |          |                         |   hang up, rept send ok |     |
       `-----+----------+-------------------------+-------------------------+-----'

        Although  the  above  shows  the  sender  emitting only one  TSYNCH,  it is
        recommended  that a timeout of 5-20 seconds should initiate another TSYNCH.
        The receiver should tolerate multiple TSYNCHs.

        In state S4, the phrase "peeked at" means that the character is not removed
        from the buffer.  Therefore when XS1 is started the proper character for
        beginning the Xmodem transfer will be detected.

       Receiver

        The  receiving FSM is given  an external timer, the expiration of  which
        will cause termination with a result of 'no calls' (R0.2).

       .-----+----------+-------------------------+-------------------------+-----.
       |State| State    | Predicate(s)            | Action(s)               | Next|
       |  #  | Name     |                         |                         | St  |
       |-----+----------+-------------------------+-------------------------+-----|
       | R0  | WaitCxD  | 1 carrier detected      |                         | R1  |
       |     |          | 2 external timer expires| report no calls         | exit|
       |-----+----------+-------------------------+-------------------------+-----|
       | R1  | WaitBaud | 1 baud rate detected    | send signon with <cr>s  | R2  |
       |     |          | 2 no detect in ?? secs  | hang up, report no baud | exit|
       |-----+----------+-------------------------+-------------------------+-----|
       | R2  | WaitTsync| 1 TSYNCH received       | ignore input not TSYNCH | R3  |
       |     |          | 2 60 seconds timeout    | hang up, report not Fido| exit|
       |-----+----------+-------------------------+-------------------------+-----|
       | R3* | RecMail  |                         | (XMODEM rec packet XR0) | R4  |
       |-----+----------+-------------------------+-------------------------+-----|
       | R4  | XRecEnd  | 1 XMODEM successful     | delay 1 second          | R5  |
       |     |          |                         |   flush input           |     |
       |     |          | 2 XMODEM failed         | hang up, rept mail fail | exit|
       |-----+----------+-------------------------+-------------------------+-----|
       | R5* | RecFiles |                         | (BATCH rec files BR0)   | R6  |
       |-----+----------+-------------------------+-------------------------+-----|
       | R6  | ChkFiles | 1 BATCH recv successful | delay 2 secs            | R7  |
       |     |          | 2 BATCH recv failed     | hang up, report bad file| exit|
       |-----+----------+-------------------------+-------------------------+-----|
       | R7  | AllowPkup| 1 have pickup for sender| receiver becomes sender | S3* |
       |     |          | 2 nothing to pickup     | hang up, rept recv ok   | exit|
       `-----+----------+-------------------------+-------------------------+-----'

     E. Transport Layer : ?????

       1. Data Definitions

       2. Transport Layer Protocol : Routing

          FidoNet   does  not  necessarily  send  a  message  directly  to   its
          destination.   To reduce the number of network connections, mail to  a
          subset  of  the  nodelist  may  be  routed  to one  node  for  further
          distribution  within  that  subset.   In addition, custom  routing  is
          possible.  Routing of a message is determined in one of three ways.

          o If there are files attached, then a message must be sent directly to
            its destination.

          o Messages without attached files should be routed through the inbound
            host  of the destination  node's  subnet  as specified  by a FidoNet
            format nodelist.

          o To prevent overloading of inbound hosts, a system should provide for
            host routing to be disabled for a target node, or nodes.

     F. Network Layer : the Network's View of the System, Routing and Packets

       1. Network Layer Data Definition : the Packet Header

          The  packet contains messages in packed format to be transferred  over
          the  net during a connection.  As this data structure is  transferred,
          its definition is critical to FidoNet.

          A  packet may contain zero or more packed messages.  A packet  without
          messages is often generated as a poll packet.

          Every  packet begins with a  packet header.  The fields of the  packet
          header are of fixed length.

                                    Packet Header
           Offset
          dec hex
                  .-----------------------------------------------.
            0   0 | origNode (low order)  | origNode (high order) |
                  +-----------------------+-----------------------+
            2   2 | destNode (low order)  | destNode (high order) |
                  +-----------------------+-----------------------+
            4   4 |   year (low order)    |   year (high order)   |
                  +-----------------------+-----------------------+
            6   6 |  month (low order)    |  month (high order)   |
                  +-----------------------+-----------------------+
            8   8 |   day (low order)     |   day (high order)    |
                  +-----------------------+-----------------------+
           10   A |   hour (low order)    |   hour (high order)   |
                  +-----------------------+-----------------------+
           12   C |  minute (low order)   |  minute (high order)  |
                  +-----------------------+-----------------------+
           14   E |  second (low order)   |  second (high order)  |
                  +-----------------------+-----------------------+
           16  10 |   baud (low order)    |   baud (high order)   |
                  +-----------------------+-----------------------+
           18  12 |    0     |     2      |    0      |    0      |
                  +-----------------------+-----------------------+
           20  14 | origNet (low order)   | origNet (high order)  |
                  +-----------------------+-----------------------+
           22  16 | destNet (low order)   | destNet (high order)  |
                  +-----------------------+-----------------------+
           24  18 |       prodCode        |       serialNo        |
                  +-----------------------+-----------------------+
           26  1A |                                               |
                  |             password   (some impls)           |
                  |                  eight bytes                  |
                  |                  null padded                  |
                  |                                               |
                  +-----------------------+-----------------------+
           34  22 | origZone (low) (opt)  | origZone (high) (opt) |
                  +-----------------------+-----------------------+
           36  24 | destZone (low) (opt)  | destZone (high) (opt) |
                  +-----------------------+-----------------------+
           38  26 |                     fill                      |
                  ~                   20 bytes                    ~
                  |                                               |
                  +-----------------------+-----------------------+
           58  3A |                 zero or more                  |
                  ~                    packed                     ~
                  |                   messages                    |
                  +-----------------------+-----------------------+
                  |    0     |     0      |    0     |     0      |
                  `-----------------------+-----------------------'

          Packet       = PacketHeader  { PakdMessage }  00H 00H

          PacketHeader = origNode   (* of packet, not of messages in packet *)
                         destNode   (* of packet, not of messages in packet *)
                         year       (* of packet creation, e.g. 1986 *)
                         month      (* of packet creation, 0-11 for Jan-Dec *)
                         day        (* of packet creation, 1-31 *)
                         hour       (* of packet creation, 0-23 *)
                         minute     (* of packet creation, 0-59 *)
                         second     (* of packet creation, 0-59 *)
                         baud       (* max baud rate of orig and dest, 0=SEA *)
                         PacketType (* old type-1 packets now obsolete *)
                         origNet    (* of packet, not of messages in packet *)
                         destNet    (* of packet, not of messages in packet *)
                         prodCode   (* 0 for Fido, write to FTSC for others *)
                         serialNo   (* binary serial number (otherwise null)*)
                         password   (* session password  (otherwise null)   *)
                         origZone   (* zone of pkt sender (otherwise null)  *)
                         destZone   (* zone of pkt receiver (otherwise null)*)
                         fill[20]

          PacketType   = 02H 00H  (* 01H 00H was used by Fido versions before 10
                                     which did not support local nets.  The packed
                                     message header was also different for those
                                     versions *)

          prodCode     = (  00H      (* Fido *)
                         |  ...
                         |  ??H      (* Please apply for new codes *)
                         )

          The  remainder of the packet consists of packed messages.  Each packed
          message  begins  with  a  message type word 0200H.   A  pseudo-message
          beginning with the word 0000H signifies the end of the packet.

       2. Network Layer Data Description : a File with Attributes

          The  BATCH  protocol uses  the MODEM7 filename and TeLink/XMODEM  file
          transfer protocols to transfer the file with attributes.

          When  a  file is transferred via  FidoNet, an attempt is made to  also
          pass  the operating system's attributes  for the file such as  length,
          modification  date, etc.  FidoNet does this via a special prefix block
          to  the XMODEM file transfer using a protocol known as TeLink.  As the
          TeLink  protocol relies on a modification to the XMODEM file  transfer
          protocol, it is documented at the data link layer level.

          The  MODEM7 file name is redundant if there is also a TeLink block, in
          which case the name may be taken from either or both.

                                  FileName as Sent
           Offset
          dec hex
                  .-----------------------------------------------.
            0   0 |                   fileName                    |
                  ~                   8  bytes                    ~
                  |           left adjusted blank filled          |
                  +-----------------------+-----------------------+
            8   8 |                    fileExt                    |
                  ~                    3  bytes                   ~
                  |           left adjusted blank filled          |
                  `-----------------------------------------------'

     3. Network Layer Protocol : BATCH File Finite State Machines

        BATCH File Sender

       .-----+----------+-------------------------+-------------------------+-----.
       |State| State    | Predicate(s)            | Action(s)               | Next|
       |  #  | Name     |                         |                         | St  |
       |-----+----------+-------------------------+-------------------------+-----|
       | BS0*| MoreFiles| 1 more files to send    | (MODEM7 FName send MS0) | BS1 |
       |     |          | 2 no more files to send |                         | BS3 |
       |-----+----------+-------------------------+-------------------------+-----|
       | BS1 | CheckFNm | 1 MODEM7 Filename ok    | (TeLink send file XS0)  | BS2 |
       |     |          | 2 MODEM7 Filename bad   | report name send bad    | exit|
       |-----+----------+-------------------------+-------------------------+-----|
       | BS2 | CheckFile| 1 TeLink send ok        |                         | BS0 |
       |     |          | 2 TeLink send bad       | report file send bad    | exit|
       |-----+----------+-------------------------+-------------------------+-----|
       | BS3 | EndSend  | 1 rec NAK for next file | send EOT, report send ok| exit|
       |     |          | 2 10 seconds no NAK     | send EOT, report no NAK | exit|
       `-----+----------+-------------------------+-------------------------+-----'

        When  no files remain, the sender responds to the receiver's NAK with an
        EOT.  The EOT is not ACK/NAKed by the receiver.

        Filenames  must be upper case ASCII.  The data link layer uses "u" as  a
        control character.

        BATCH File Receiver

       .-----+----------+-------------------------+-------------------------+-----.
       |State| State    | Predicate(s)            | Action(s)               | Next|
       |  #  | Name     |                         |                         | St  |
       |-----+----------+-------------------------+-------------------------+-----|
       | BR0*| RecvName |                         | (MODEM7 FName recv MR0) | BR1 |
       |-----+----------+-------------------------+-------------------------+-----|
       | BR1 | CheckFNm | 1 MODEM7 no more files  | report files recd ok    | exit|
       |     |          | 2 MODEM7 Filename ok    | (TeLink recv file XR0)  | BR2 |
       |     |          | 2 MODEM7 Filename bad   | report name recv bad    | exit|
       |-----+----------+-------------------------+-------------------------+-----|
       | BR2 | CheckFile| 1 TeLink recv ok        |                         | BR0 |
       |     |          | 2 TeLink recv bad       | report file recv bad    | exit|
       `-----+----------+-------------------------+-------------------------+-----'

     G. Data Link Layer : Error-Free Data Transfer

       1. Data Link Layer Data Definition : XMODEM/TeLink Blocks

          XMODEM  transfers  are  in  blocks  of 128  uninterpreted  data  bytes
          preceded  by  a three  byte header  and followed by either a one  byte
          checksum  or a two byte crc remainder.  XMODEM makes no provision  for
          data  streams  which  are  not  an  integral number  of  blocks  long.
          Therefore,  the sender pads streams whose length is not a multiple  of
          128 bytes with the end-of-file character (^Z for MS-DOS), and use some
          other  means  to convey  the  true data length to the  receiver  (e.g.
          TeLink file info block).

          Data blocks contain sequence numbers so the receiver can ensure it has
          the  correct block.  Block  numbers are sequential unsigned eight  bit
          integers  beginning with 01H and wrapping to 00H, except that a TeLink
          block is given sequence number 00H.

          For  files which are attached to the mail packet, not the mail  packet
          itself,  if the sending system is aware of the file attributes as they
          are  known to the operating system, then the first block of the XMODEM
          transfer  may be a special TeLink block to transfer that  information.
          This  block  differs  in that  the  first byte is a SYN  character  as
          opposed  to an SOH, and it is always sent checksum as opposed to CRC.
          Should the receiver be unwilling to handle such information, after two
          NAKs (or "C"s), the sender skips this special block and goes on to the
          data itself.

                            XMODEM Data Block (CRC mode)
           Offset
          dec hex
                  .-----------------------------------------------.
            0   0 |        SOH  -  Start Of Header -  01H         |
                  +-----------------------------------------------+
            1   1 |                 BlockNumber                   |
                  +-----------------------------------------------+
            2   2 |               BlockComplement                 |
                  +-----------------------------------------------+
            3   3 |                128 bytes  of                  |
                  ~                uninterpreted                  ~
                  |                    data                       |
                  +-----------------------------------------------+
          131  83 |             CRC high order byte               |
                  +-----------------------------------------------+
          132  84 |             CRC  low order byte               |
                  `-----------------------------------------------'

                          XMODEM Data Block (Checksum mode)
           Offset
          dec hex
                  .-----------------------------------------------.
            0   0 |        SOH  -  Start Of Header -  01H         |
                  +-----------------------------------------------+
            1   1 |                 BlockNumber                   |
                  +-----------------------------------------------+
            2   2 |               BlockComplement                 |
                  +-----------------------------------------------+
            3   3 |                128 bytes  of                  |
                  ~                uninterpreted                  ~
                  |                    data                       |
                  +-----------------------------------------------+
          131  83 |                Checksum byte                  |
                  `-----------------------------------------------'

                           TeLink File Descriptor Block
           Offset
          dec hex
                  .-----------------------------------------------.
            0   0 |       SYN  -  File Info Header -  16H         |
                  +-----------------------------------------------+
            1   1 |                     00H                       |
                  +-----------------------------------------------+ data offset
            2   2 |                     FFH                       |  dec  hex
                  +-----------------------------------------------+
            3   3 |     File Length, least significant byte       |  0    0
                  +-----------------------------------------------+
            4   4 | File Length, second to least significant byte |  1    1
                  +-----------------------------------------------+
            5   5 |  File Length, second to most significant byte |  2    2
                  +-----------------------------------------------+
            6   6 |      File Length, most significant byte       |  3    3
                  +-----------------------------------------------+
            7   7 |            Creation Time of File              |  4    4
                  |                "DOS Format"                   |
                  +-----------------------------------------------+
            9   9 |            Creation Date of File              |  6    6
                  |                "DOS Format"                   |
                  +-----------------------------------------------+
           11   B |                 File  Name                    |  8    8
                  ~                  16 chars                     ~
                  |        left justified  blank filled           |
                  +-----------------------------------------------+
           27  1B |                    00H                        | 24   18
                  +-----------------------------------------------+
           28  1C |            Sending Program Name               | 25   19
                  ~                  16 chars                     ~
                  |         left justified  Null filled           |
                  +-----------------------------------------------+
           44  2C |            01H (for CRC) or 00H               | 41   29
                  +-----------------------------------------------+
           45  2D |                    fill                       | 42   2A
                  ~                  86 bytes                     ~
                  |                  all zero                     |
                  +-----------------------------------------------+
          132  84 |                Checksum byte                  |
                  `-----------------------------------------------'

          XMODEMData   = XMODEMBlock      (* block of data with header and
                                             trailer *)
                         | TeLinkBlock    (* TeLink File Descriptor Block *)
                         | ACK            (* acknowledge data received ok *)
                         | NAK            (* negative ACK & poll 1st block *)
                         | EOT            (* end of xfer, after last block *)
                         | "C"            (* 43H *)

          XMODEMBlock  = SOH              (* Start of Header, XMODEM Block *)
                         blockNumber[1]   (* sequence, i'=mod( i+1, 256 ) *)
                         blockCompl[1]    (* one's compl of BlockNumber *)
                         data[128]        (* uninterpreted user data block *)
                         (CRC | Checksum) (* error detect/correction code *)

          TeLinkBlock  = SYN              (* File Info Header *)
                         00H              (* block no, must be first block *)
                         FFH              (* one's complement of block no *)
                         fileLength[4]    (* length of data in bytes *)
                         CreationTime[2]  (* time file last modified or zero *)
                         CreationDate[2]  (* date file last modified or zero *)
                         fileName(16)     (* name of file, not vol or dir *)
                         00H              (* header version number *)
                         sendingProg(16)  (* name of program on send side *)
                         crcMode[1]       (* 01H for CRC 00H for Checksum *)
                         fill[87]         (* zeroed *)
                         Checksum         (* error detect/correction code *)

          ACK          = 06H              (* acknowledge data received ok *)
          NAK          = 15H              (* negative ACK & poll 1st block *)
          SOH          = 01H              (* start of header, begins block *)
          SYN          = 16H              (* start of TeLink file info blk *)
          EOT          = 04H              (* end of xfer, after last block *)

          CRC          = crc[2]           (* CCITT Cyclic Redundancy Check *)

          Checksum     = checksum[1]      (* low 8 bits of sum of data bytes
                                             using unsigned 8 bit arithmetic *)

          CreationDate = year[.7]         (* 7 bits, years since 1980, 0-127  *)
                         month[.4]        (* 4 bits, month of year, 1-12 *)
                         day[.5]          (* 5 bits, day of month, 1-31 *)

          CreationTime = hour[.5]         (* 5 bits, hour of day, 0-23 *)
                         minute[.6]       (* 6 bits, minute of hour, 0-60 *)
                         biSeconds[.2]    (* 6 bits, seconds/2, 0-29 *)

          Note  that the crcMode is always set to 01H in current implementations
          as  all TeLink/XMODEM implementations use the CRC method.   Therefore,
          it is always set to 01H by the sender, and is ignored by the receiver.

     2. Data Link Layer Protocol : XMODEM/TeLink Finite State Machines

        The  protocol is receiver driven, the receiver polling the sender  for
        each  block.   If the receiver polls  for the first block using a  "C"
        (43H)  as  the poll character,  it would prefer to have the  CRC-CCITT
        polynomial  remainder error detection code at the end of each block as
        opposed  to a one byte unsigned checksum.  The sender will respond  to
        the  "C"  poll iff it can  comply.  If the sender chooses checksum  as
        opposed  to  CRC, it waits for  the receiver to poll with  NAK  (15H).
        Should  the  checksum method be  preferable to the receiver, it  polls
        with NAK rather than "C".

        The sender returns an EOT instead of a data block when no data remain.

        Neither  the  sender nor the  receiver should send the block or  ACK/NAK
        response  while there is data being received.  They should wait for  the
        line to settle, and possibly time out.

        It  is  suggested that one's  input buffer be cleared immediately  after
        sending  block or ACK/NAK response, before waiting for the response from
        the  other  end.  This  clears  any line garbage which  occurred  during
        transmit.

        XMODEM/TeLink Sender

       .-----+----------+-------------------------+-------------------------+-----.
       |State| State    | Predicate(s)            | Action(s)               | Next|
       |  #  | Name     |                         |                         | St  |
       |-----+----------+-------------------------+-------------------------+-----|
       | XS0 | WaitTeLnk| 1 over 40-60 seconds    | report sender timeout   | exit|
       |     |          | 2 over 2 tries          | note TeLink block failed| XS1 |
       |     |          | 3 NAK or "C" received   | send TeLink, incr tries | XS0 |
       |     |          | 4 ACK received          | TeLink ok, set crc/cksm | XS2 |
       |-----+----------+-------------------------+-------------------------+-----|
       | XS1 | WaitStart| 1 over 40-60 seconds    | report sender timeout   | exit|
       |     |          | 2 over 20 tries         | report send failed      | exit|
       |     |          | 3 NAK received          | set checksum mode       | XS2 |
       |     |          | 4 "C" recd, I can crc   | set crc mode            | XS2 |
       |     |          | 5 "C" recd, I can't crc |                         | XS1 |
       |-----+----------+-------------------------+-------------------------+-----|
       | XS2 | SendBlock| 1 more data available   | send next data block    | XS3 |
       |     |          |                         |   as checksum or crc    |     |
       |     |          | 2 last block has gone   | send EOT                | XS4 |
       |-----+----------+-------------------------+-------------------------+-----|
       | XS3 | WaitACK  | 1 10 retries or 1 minute| report send failed      | exit|
       |     |          | 2 ACK received          |                         | XS2 |
       |     |          | 3 NAK (or C if 1st blk) | resend last block       | XS3 |
       |-----+----------+-------------------------+-------------------------+-----|
       | XS4 | WaitEnd  | 1 10 retries or 1 minute| report send failed      | exit|
       |     |          | 2 ACK received          | report send successful  | exit|
       |     |          | 3 NAK received          | resend EOT              | XS4 |
       `-----+----------+-------------------------+-------------------------+-----'

        XMODEM/TeLink Receiver

       .-----+----------+-------------------------+-------------------------+-----.
       |State| State    | Predicate(s)            | Action(s)               | Next|
       |  #  | Name     |                         |                         | St  |
       |-----+----------+-------------------------+-------------------------+-----|
       | XR0 | RecStart | 1 prefer crc mode       | Send "C"                | XR1 |
       |     |          | 2 want checksum mode    | send NAK                | XR1 |
       |-----+----------+-------------------------+-------------------------+-----|
       | XR1 | WaitFirst| 1 10 retries or 1 minute| report receive failure  | exit|
       |     |          | 2 > 3 retries or 30 secs| set want checksum mode  | XR0 |
       |     |          | 3 EOT received          | delay < sec, purge input| exit|
       |     |          |                         | send ACK, report no file|     |
       |     |          | 4 TeLink block recd     | send ACK, set crc/cksm  | XR2 |
       |     |          | 5 data block recd       | send ACK, set crc/cksm  | XR2 |
       |     |          | 6 bad block or 2-10 secs| incr retry count        | XR0 |
       |-----+----------+-------------------------+-------------------------+-----|
       | XR2 | WaitBlock| 1 10 retries or 1 minute| report receive failure  | exit|
       |     |          | 2 EOT received          | send ACK, report recd ok| exit|
       |     |          |                         | send ACK, report recd ok|     |
       |     |          | 3 data block received   | send ACK                | XR2 |
       |     |          | 4 bad block or 2-10 secs| send NAK, incr retry cnt| XR2 |
       `-----+----------+-------------------------+-------------------------+-----'

        A  number of checks should be made to ensure a valid data block has been
        received.

        o  The  physical  layer  should  have encountered no errors,  e.g.  parity,
           framing, etc.

        o  The length of the block should not be less than expected.

        o  If  the blocks sequence  number does not match the  complement,  then
           respond with a NAK and attempt to read the block again.

        o  If the block's sequence number is one previous (remember wrap around)
           to that of the expected block, respond with an ACK and read again.

        o  If the sequence number fits neither of the above criteria, and is yet
           not the expected sequence number, abort the receive.

        o  The checksum or CRC should be correct.

     3. Data Link Layer Protocol : MODEM7 Filename Finite State Machines

        MODEM7 Filename Sender

       .-----+----------+-------------------------+-------------------------+-----.
       |State| State    | Predicate(s)            | Action(s)               | Next|
       |  #  | Name     |                         |                         |  St |
       |-----+----------+-------------------------+-------------------------+-----|
       | MS0 | WaitNak  | 1 20 retries or 1 minute| filename send failed    | exit|
       |     |          | 2 NAK received          | send ACK & 1st ch of fn | MS1 |
       |     | (note 1) | 3 C received            | return fn skipped       | exit|
       |-----+----------+-------------------------+-------------------------+-----|
       | MS1 | WaitChAck| 1 ACK rcd, fname done   | send SUB = 1AH          | MS2 |
       |     |          | 2 ACK rcd, fname ~done  | send next ch of fname   | MS1 |
       |     |          | 3 other char or 1 sec   | send "u", incr retry cnt| MS0 |
       |-----+----------+-------------------------+-------------------------+-----|
       | MS2 | WaitCksm | 1 cksum recd and ok     | send ACK, report fn ok  | exit|
       |     |          | 2 cksum recd but bad    | send "u", incr retry cnt| MS0 |
       |     |          | 3 no cksum in 1 sec     | send "u", incr retry cnt| MS0 |
       `-----+----------+-------------------------+-------------------------+-----'

        MODEM7 Filename Receiver

       .-----+----------+-------------------------+-------------------------+-----.
       |State| State    | Predicate(s)            | Action(s)               | Next|
       |  #  | Name     |                         |                         |  St |
       |-----+----------+-------------------------+-------------------------+-----|
       | MR0 | SendNak  | 1 20 tries or 1 minute  | report filename failure | exit|
       |     |          | 2                       | send NAK, incr try cnt  | MR1 |
       |-----+----------+-------------------------+-------------------------+-----|
       | MR1 | WaitAck  | 1 rcd ACK               |                         | MR2 |
       |     |          | 2 rcd EOT               | report no files remain  | exit|
       |     |          | 3 5 secs & no ACK/EOT   |                         | MR0 |
       |-----+----------+-------------------------+-------------------------+-----|
       | MR2 | WaitChar | 1 recd EOT (can happen?)| report no files remain  | exit|
       |     |          | 2 recd SUB              | send checksum byte      | MR3 |
       |     |          | 3 recd "u"              |                         | MR0 |
       |     |          | 4 recd char of name     | send ACK                | MR2 |
       |     |          | 5 no char in 1 second   |                         | MR0 |
       |-----+----------+-------------------------+-------------------------+-----|
       | MR3 | WaitOkCk | 1 recd ACK within 1 sec | report recd filename ok | exit|
       |     |          | 2 recd "u" or other char|                         | MR0 |
       `-----+----------+-------------------------+-------------------------+-----'

        SUB  is the ASCII character ^Z or 1AH.  The checksum is the unsigned low
        order eight bits of the sum of the characters in the transferred filename
        including the SUB.

        Although  one second timeouts are used successfully by Fido and  SEAdog,
        some fear that this is too small a timeout for some satellite and packet
        network links.

        Note 1 - MS0.3 is a common addition to accommodate a common noncompliance.
                 Support of MS0.3 is optional for a compliant mailer.  This hack
                 also requires modification of a number of state tables, see
                 FSC-0011.

     H. Physical Layer : the Actual Connection of Two FidoNet Systems

        Will  one of the more hardware-oriented comm types give me some idea  of
        what's needed here?  Can we leave it open enough to allow implementation
        over a non-dial net?  Thanks.

     I. Revisions since FTS-0001

        89 Oct 25 (rev 13)
          o packet header: optional serialNo, password, and orig/dest zone
          o stored message to/from zone/point info added as option per
            Fido-12 and Dutchie
          o XR1 and XR2 changes per FSC-0011
          o reference to FSC-0011 for the MODEM7-avoidance hack, MS0.3
          o dropped enumeration of product codes
          o S4 modification from FSC-0011
          o Nodelist and EID reference appropriate documents
          o various cosmetics
        90 July 1-5 (rev 14)
          o spelling errors caught by Ray Gardner
          o references to the now dead IFNA elided
          o offset at end of Packed Message was 10 as opposed to 20 bytes
          o Packed Message and Packet Header corrections by Roland Gautschi
          o Offsets in TeLink header caught by Rick Moore
        90 August 30 (rev 15)
          o corrected offsets in packet header
        95 September 30 (rev 16)
          o TOPT corrected
          o contact info changed

     J. Acknowledgements

        Ben  Baker,  Thom  Henderson,  Tom  Jennings,  Ken Kaplan, and  Gee Wong
        suggested, informed,  reviewed, and  encouraged.   Tom  and Thom gave me
        all the basics, and even allowed me to look at actual code.  Bob Hartman
        was  foolish  enough  to implement  the  specification, and was generous
        with useful feedback.  Ray  Gardner caught  my  spelling errors <blush>,
        and Roland Gautschi and Rick Moore found offset and length errors.

        My employer, Pacific Systems Group was kind enough to donate my time to
        research and to write this document.

        Fido and FidoNet are registered trademarks of Tom Jennings.

        SEAdog is a trademark of System Enhancement Associates.

     K. Bibliography

        Documentation  for the protocols  and data formats are scattered.   Some
        are  unattributed, some even untitled.

        Anonymous, changes to MODEM to implement CRC option  XMDM-CRC.TXT

        Baker, Ken and Moore, Rick, Nodelist Definition, currently FTS-0005

        Christensen, Ward, "MODEM Protocol Overview" of 1 January 82  XMODEM.TXT

        Hartman, Bob, "Some thoughts that I had on FSC001", FSC-0011

        Henderson, Thom, "SEAdog Electronic Mail System Version 3" of April 86

        International  Standards Organization,  "Data Processing - Open  Systems
        Interconnection - Basic Reference Model"  ISO/DIS 7498  April 82

        Jennings,   Tom,  "FidoNet  Electronic  Mail  Protocol"  8  February  85
        FIDOMAIL.DOC

        Jennings,   Tom,  "Fido's  Internal  Structures"  of  13  September  85
        STRUCT.TXT aka STRUCT.APX

        Jennings, Tom, "Extending XMODEM/MODEM File Transfer Protocol to support
        DOS" 20 September 83   FILEXFER.DOC

        Jordan, Larry, "XMODEM File Transfer Protocol"  XMDM-LJ.TXT

        Rudin,   H   and   West,  C,  "Protocol  Specification,   Testing,   and
        Verification,  III" Proceedings of  the IFIP WG 6.1 Third  International
        Workshop   on   Protocol  Specification,  Testing,   and   Verification,
        Rueschlikon Switzerland 31 May - 2 June 1983.

        Tanenbaum, Andrew, "Computer Networks" Prentice Hall 1981

        Messages generated by Fido 11w, SEAdog 3.8, and QMail 1.01

Go Back