


      KKKKEEEERRRRMMMMIIIITTTT((((1111))))                  ((((CCCCoooolllluuuummmmbbbbiiiiaaaa UUUU))))                 KKKKEEEERRRRMMMMIIIITTTT((((1111))))



      NNNNAAAAMMMMEEEE
           kermit - file transfer, virt. terminal over tty link

      SSSSYYYYNNNNTTTTAAAAXXXX
           kkkkeeeerrrrmmmmiiiitttt cccc[hhhhiiiillllbbbbeeee] [_l_i_n_e] [_b_a_u_d] [_e_s_c]

           kkkkeeeerrrrmmmmiiiitttt rrrr[ddddddddiiiillllbbbb] [_l_i_n_e] [_b_a_u_d]

           kkkkeeeerrrrmmmmiiiitttt ssss[ddddddddiiiillllbbbb] [_l_i_n_e] [_b_a_u_d] _f_i_l_e ...

      DDDDEEEESSSSCCCCRRRRIIIIPPPPTTTTIIIIOOOONNNN
           _K_e_r_m_i_t provides reliable file transfer and primitive virtual
           terminal communication between machines.  It has been
           implemented on many different computers, including
           microprocessors (see below).  The files transferred may be
           arbitrary ASCII data (7-bit characters) and may be of any
           length.  The file transfer protocol uses small (96
           character) checksummed packets, with ACK/NAK responses and
           timeouts.  _K_e_r_m_i_t currently uses a ten second timeout and
           ten retries.

           The arguments to _k_e_r_m_i_t are a set of flags (no spaces
           between the flags), three optional args (which, if included,
           must be in the same order as the flags which indicate their
           presence), and, if this is a Send operation a list of one or
           more files.  (It is similar in some way to the _t_a_r command
           structure).

           _K_e_r_m_i_t has three modes, Connect, Send, and Receive.  The
           first is for a virtual terminal connection, the other two
           for file transfer.  These modes are specified by the first
           flag, which should be cccc, ssss, or rrrr, respectively.  Exactly one
           mode must be specified.

           The dddd flag (debug) makes _k_e_r_m_i_t a bit more verbose.  The
           states _k_e_r_m_i_t goes through are printed along with other
           traces of it's operation.  A second dddd flag will cause _k_e_r_m_i_t
           to give an even more detailed trace.

           Use the hhhh flag (half duplex) in connect mode to make _k_e_r_m_i_t
           echo characters typed on the local keyboard, instead of
           assuming that the remote machine will do the echoing.  This
           is necessary when communicating with half duplex systems
           like IBM CMS.

           The iiii flag (image) allows slightly more efficient file
           transfer between UNIX machines.  Normally (on Kermits
           defined to run on UNIX systems) newline is mapped to CRLF on
           output, CR's are discarded on input, and bytes are masked to
           7 bits.  If this is set, no mapping is done on newlines, and
           all eight bits of each byte are sent or received.  Caution:
           this flag must not be set if the remote machine is one which



      Page 1                                                   (9010-E)






      KKKKEEEERRRRMMMMIIIITTTT((((1111))))                  ((((CCCCoooolllluuuummmmbbbbiiiiaaaa UUUU))))                 KKKKEEEERRRRMMMMIIIITTTT((((1111))))



           sends parity (8 bit characters).  This means IBM CMS
           systems.

           The llll flag (line) specifies the tty line that _k_e_r_m_i_t should
           use to communicate with the other machine.  This is
           specified as a regular filename, like "/dev/tty1".  If no llll
           option is specified, standard input is used and _k_e_r_m_i_t
           assumes it is running on the remote host (ie. NOT the
           machine to which your terminal is attached).

           The bbbb flag (baud) sets the baud rate on the line specified
           by the llll flag.  No changes are made if the bbbb flag is not
           used.  Legal speeds are: 110, 150, 300, 1200, 2400, 4800,
           9600, 19200.

           The eeee flag (escape) allows the user to set the first
           character of the two character escape sequence for Connect
           mode.  When the escape character is typed, _k_e_r_m_i_t will hold
           it and wait for the next character.  If the next character
           is cccc or CCCC, _k_e_r_m_i_t will close the connection with the remote
           host.  If the second character is the same as the escape
           character, the escape character itself is passed.  Any
           character other than these two results in a bell being sent
           to the user's terminal and no characters passed to the
           remote host.  All other typed characters are passed through
           unchanged.  The default escape character is '^'.

           The file arguments are only meaningful to a Send _k_e_r_m_i_t.
           The Receiving _k_e_r_m_i_t will attempt to store the file with the
           same name that was used to send it.  UNIX _k_e_r_m_i_ts normally
           convert outgoing file names to uppercase and incoming ones
           to lower case (see the ffff flag).  If a filename contains a
           slash (/) all outgoing kermits will strip off the leading
           part of the name through the last slash.

      EEEEXXXXAAAAMMMMPPPPLLLLEEEE
           For this example we will assume two UNIX machines.  We are
           logged onto "unixa" (the local machine), and want to
           communicate with "unixb" (the remote machine).  There is a
           modem on "/dev/tty3".

           We want to connect to "unixb", then transfer "file1" to that
           machine.

           We type:   kermit clb /dev/tty3 1200

           Kermit answers:   Kermit: connected...

           Now we dial the remote machine and connect the modem.
           Anything typed on the terminal will be sent to the remote
           machine and any output from that machine will be displayed
           on our terminal.  We press RETURN, get a "login:" prompt and



      Page 2                                                   (9010-E)






      KKKKEEEERRRRMMMMIIIITTTT((((1111))))                  ((((CCCCoooolllluuuummmmbbbbiiiiaaaa UUUU))))                 KKKKEEEERRRRMMMMIIIITTTT((((1111))))



           login.

           Now we need to start a _k_e_r_m_i_t on the remote machine so that
           we can send the file over.  First we start up the remote,
           (in this case receiving) _k_e_r_m_i_t, then the local, (sending)
           one.  Remember that we are talking to unixb right now.

           We type:   kermit r
                   (there is now a Receive _k_e_r_m_i_t on unixb)

           We type ^ (the kermit escape character (shift-6)) and then cccc
           to kill the local (Connecting) _k_e_r_m_i_t.

           Kermit answers:   Kermit: disconnected.

           We type:   kermit slb /dev/tty3 1200 file1

           Kermit answers: Sending file1 as FILE1

           When the transmission is finished, _k_e_r_m_i_t will type either
           "Send complete", or "Send failed.", depending on the success
           of the transfer.  If we now wanted to transfer a file from
           unixb (remote) to unixa (local), we would use these
           commands:

                   kermit clb /dev/tty3 1200
                     (connected to unixb)
                   kermit s file9
                   ^c (up-arrow c not control-c)
                     (talking to unixa again)
                   kermit rl /dev/tty3 1200

           After all the transfers were done, we should connect again,
           log off of unixb, kill the Connect _k_e_r_m_i_t and hang up the
           phone.

           Detail on other implementations and on the protocol is given
           in the _K_e_r_m_i_t _U_s_e_r_s _G_u_i_d_e, and the _K_e_r_m_i_t _P_r_o_t_o_c_o_l _H_a_n_d_b_o_o_k.

      FFFFEEEEAAAATTTTUUUURRRREEEESSSS
           The KERMIT Protocol uses only printing ASCII characters,
           Ctrl-A, and CRLF.  Ctrl-S/Ctrl-Q flow control can be used
           "underneath" the Kermit protocol (IXOFF line discipline on
           System V UNIX).

           Since BREAK is not an ASCII character, _k_e_r_m_i_t cannot send a
           BREAK to the remote machine.  On some systems, a BREAK will
           be read as a NUL.

           This _k_e_r_m_i_t does have timeouts when run under UNIX, so the
           protocol is stable when communicating with "dumb" kermits
           (that don't have timeouts).



      Page 3                                                   (9010-E)






      KKKKEEEERRRRMMMMIIIITTTT((((1111))))                  ((((CCCCoooolllluuuummmmbbbbiiiiaaaa UUUU))))                 KKKKEEEERRRRMMMMIIIITTTT((((1111))))



      OOOOTTTTHHHHEEEERRRR IIIIMMMMPPPPLLLLEEEEMMMMEEEENNNNTTTTAAAATTTTIIIIOOOONNNNSSSS
           See the _K_e_r_m_i_t _U_s_e_r_s _G_u_i_d_e.

      SSSSEEEEEEEE AAAALLLLSSSSOOOO
           stty(1);
           _K_e_r_m_i_t _U_s_e_r_s _G_u_i_d_e, Fourth Edition (4 May 83), Frank da
           Cruz, Daphne Tzoar, Bill Catchings; _K_e_r_m_i_t _P_r_o_t_o_c_o_l _M_a_n_u_a_l,
           Protocol Version 3 (29 April 83), Frank da Cruz, Bill
           Catchings.  Both documents are from the Columbia University
           Center for Computing Activities, New York, New York, 10027,
           (212) 280-3703.

      AAAAUUUUTTTTHHHHOOOORRRRSSSS
           KERMIT kernel by Bill Catchings, Columbia University Center
           for Computing Activities.  KERMIT-UNIX adaptation by Chris
           Maio and Bob Cattani, Columbia University Computer Science
           Dept.  Local mods for v6, System III, and System V by Walter
           Underwood. Includes bug fixes from Jim Guyton at RAND-UNIX.
           Enhanced for better use with System V by Ridge Computers.

      DDDDIIIIAAAAGGGGNNNNOOOOSSSSTTTTIIIICCCCSSSS
           cannot open _d_e_v_i_c_e
                The file named in the _l_i_n_e argument did not exist or
                had the wrong permissions.

           bad line speed
                The _b_a_u_d argument was not a legal speed.

           Could not create _f_i_l_e
                A Receive _k_e_r_m_i_t could not create the file being sent
                to it.

           nothing to connect to
                A Connect _k_e_r_m_i_t was started without a _l_i_n_e argument.

      BBBBUUUUGGGGSSSS AAAANNNNDDDD CCCCAAAAVVVVEEEEAAAATTTTSSSS
           There is no locking on the use of the outgoing line.
           Several users could run _k_e_r_m_i_t (or anything else) on the
           line simultaneously.

           The acronym (_KL10 _Error-free _Reciprocal _Micro _Interconnect
           over _TTY lines) is charming, but strained.

           This implementation does not send or process error-message
           packets.

           Eight-bit quoting is not implemented.








      Page 4                                                   (9010-E)



