cckkeerrmmiitt -- Command

Interactive inter-system communication and file transfer
cckkeerrmmiitt [-aabbccddeeffgghhiikkllppqqrrssttwwxx] [ _f_i_l_e ... ]

cckkeerrmmiitt  implements  the  kkeerrmmiitt  communications  protocol.   It  lets  you
communicate with other systems via  modem or network, and to exchange files
with other systems that  have also implemented the kkeerrmmiitt protocol.  Unlike
the kkeerrmmiitt command also included  with the COHERENT system, cckkeerrmmiitt uses an
interactive shell to remove some of the pain from the process of exchanging
files.  The name  cckkeerrmmiitt relects the fact that this  command is written in
the  C language,  and so  has been  ported to  many different  machines and
operating systems.

You can  run cckkeerrmmiitt  in either _i_n_t_e_r_a_c_t_i_v_e  _m_o_d_e or _c_o_m_m_a_n_d  _m_o_d_e.  Simply
typing the command

    ckermit

invokes cckkeerrmmiitt  in interactive mode: cckkeerrmmiitt displays  a prompt, waits for
your command, executes, then prompts  you for its next command.  Typing the
command line  plus one or  more arguments invokes cckkeerrmmiitt  in command mode:
cckkeerrmmiitt then  reads the arguments from the command  line and executes them.
After execution of the commands, cckkeerrmmiitt returns to interactive mode.

cckkeerrmmiitt's command-line options  name either actions or settings.  An action
option tells cckkeerrmmiitt to send a file, receive a file, or connect to a remote
system.  The  command line may contain  no more than one  action option.  A
settings option changes one or more of the internal values that control how
cckkeerrmmiitt operates;  for example,  one setting option  lets you set  the baud
rate of  the serial port  that cckkeerrmmiitt will  be using.  A  command line can
contain any number of settings options.

_C_o_m_m_a_n_d-_L_i_n_e _O_p_t_i_o_n_s
cckkeerrmmiitt recognizes the following command-line options:

-aa _f_i_l_e_n_a_m_e
        Give an alternate name  to a file being  transferred.  For example,
        the command

            ckermit -s foo -a bar

        transmits the file  ffoooo to  a remote system,  but tells  the remote
        system that the file is named bbaarr. Likewise, the command

            ckermit -ra baz

        stores the first incoming file under the name bbaazz.

        If more than  one file arrives or  is sent, only the  first file is
        affected by the -aa option.

-bb _b_a_u_d_r_a_t_e
        Set the baud rate of the device to _b_a_u_d_r_a_t_e.

-cc      Connect to serial port, and pass all subsequent typing to that port
        To resume talking to  your local system, type  the escape character
        followed by the letter `c'.  The escape character is set by default
        to <ccttrrll-\>, although you can change it if you wish.

-dd      Debug mode -- record debugging information in the file ddeebbuugg.lloogg in
        the current directory.

-ee _n    Set the length of the  packet to _n where _n is  a number between ten
        and about  1,000.   Lengths  of  95  or  greater require  that  the
        implementation of  kkeerrmmiitt on  the remote  system support  the long-
        packet extension to the kkeerrmmiitt protocol.

-ff      Send a ``finish'' command to a remote server.

-gg _f_i_l_e
        Ask a remote system  to send _f_i_l_e or _f_i_l_e_s. The  file name must use
        the remote  system's  own  syntax; you  must  quote all  characters
        normally expanded by the COHERENT shell, e.g.:

            ckermit -g x\*.\?

-hh      Help -- display a brief synopsis of the command-line options.

-ii      The ``image'' option:  specify that  the file being  transmitted or
        received is an  eight-bit binary file, and  therefore no conversion
        should be performed upon the data being received.

-kk      Passively receive file or files, copying them to standard output.

-ll _d_e_v_i_c_e
        Name the serial device to be used.  For example

            ckermit -l /dev/com2l

        tells cckkeerrmmiitt to use device /ddeevv/ccoomm22ll.

-nn      Like -cc, but used  after a protocol transaction  has occurred.  You
        can use both -cc and -nn in the same command.

-pp _x    Set parity, where _x is one of ee, oo, mm, ss, or nn (respectively, even,
        odd, mark, space,  or none).   If parity is  other than  none, then
        cckkeerrmmiitt uses the eighth-bit prefixing  mechanism to transfer binary
        data, provided  the impementation  of kkeerrmmiitt  on the  remote system
        agrees.  The default parity is none.

-qq      Quiet -- suppress screen update during  file transfer; for example,
        this lets you transfer a file in the background.

-rr      Receive a file or files.  Wait passively for files to arrive.

-ss _f_i_l_e
        Send the specified _f_i_l_e  or _f_i_l_e_s. If _f_n is  `-' then cckkeerrmmiitt sends
        from standard input, which may come from a file:

            ckermit -s - < foo.bar

        or come from a parallel process:

            ls -l | ckermit -s -

        You cannot use this mechanism to send text typed from the keyboard.
        To send a file named `-', precede it with a path name, e.g.:

            ckermit -s ./-

-tt      Specify half  duplex,  line turnaround  with XON  as the  handshake
        character.

-ww      Write-Protect -- avoid file-name collisions for incoming files.

-xx      Begin server operation.  This option can be used in either local or
        remote mode.

If  cckkeerrmmiitt is  in local mode, shows the progress  of the file transfer.  A
dot is printed for every four data packets; other packets are shown by type
(e.g., `S' for  Send-Init); `T' is printed when there's  a timeout; and `%'
is printed for each retransmission.

During file transfer, you can type the following ``interrupt'' commands:

<ccttrrll-FF>
        Interrupt the current file and go on to the next, if any.

<ccttrrll-BB>
        Interrupt the entire batch of files and terminate the transaction.

<ccttrrll-RR>
        Resend the current packet.

<ccttrrll-AA>
        Display a status report for the current transaction.

These   interrupt  characters   differ  from   the   ones  used   in  other
implementations  of cckkeerrmmiitt  to avoid  conflict  with the  COHERENT shell's
interrupt characters.

_I_n_t_e_r_a_c_t_i_v_e _O_p_e_r_a_t_i_o_n
When  you invoke  cckkeerrmmiitt in  interactive mode,  it displays  the following
prompt.

    C-Kermit>

Type  any valid  cckkeerrmmiitt command;  the set of  valid commands  is described
below.  cckkeerrmmiitt executes the command and then prompts you for another.  The
process continues until you tell it to quit.

Commands begin with a keyword, normally  an English verb, such as sseenndd. You
can  abbreviate any  keyword,  as long  as  you type  enough characters  to
distinguish  it from  all other keywords.   Certain commonly  used keywords
(e.g.,  sseenndd,  rreecceeiivvee,  ccoonnnneecctt)  have  special  non-unique  abbreviations
(respectively, `s', `r', and `c').

Certain characters have special functions in interactive commands:

?       Print a message that  explains what is possible  or expected at the
        current point within  a command.   Depending upon the  context, the
        message may be  a brief phrase,  a menu of  keywords, or a  list of
        files.

<eesscc>   Request  completion  of  the  current  keyword  or  file  name,  or
        insertion of a default  value.  cckkeerrmmiitt will beep  if the requested
        operation fails.  <ttaabb> does the same thing.

<ddeell>   Delete the previous  character from the  command.  <bbaacckkssppaaccee> does
        the same thing.

<ccttrrll-WW>
        Erase the rightmost word from the command line.

<ccttrrll-UU>
        Erase the entire command.

<ccttrrll-RR>
        Redisplay the current command.

<ssppaaccee>
        Delimit fields (keywords, filenames, numbers) within a command.

<rreettuurrnn>
        Execute the command.

\       Insert any of the above characters into the command, literally.  To
        enter a  literal backslash,  type two  backslashes  in a  row (\\).
        Typing one  backslash immediately  <rreettuurrnn> lets  you  continue the
        command on the next line.

cckkeerrmmiitt recognizes the following interactive commands:

! _c_o_m_m_a_n_d
        Execute a shell command.  A space must follow the !.

%       A comment.  cckkeerrmmiitt ignores everything that follows the %.

bbyyee     Terminate and log out a remote kkeerrmmiitt server.

cclloossee   Close a log file.

ccoonnnneecctt
        Connect to the remote system.

ccwwdd _d_i_r_e_c_t_o_r_y
        Change the working directory to _d_i_r_e_c_t_o_r_y.

ddiiaall    Dial a telephone number.

ddiirreeccttoorryy
        Display a directory listing.

eecchhoo    Display arguments literally.  Useful in take-command files.

eexxiitt    Exit from the program, closing any open logs.

ffiinniisshh  Instruct a remote  kkeerrmmiitt server to exit, but not log out.

ggeett     Get files from a remote  kkeerrmmiitt server.

hhaanngguupp  Hang up the telephone.

hheellpp    Display a help message for a given command.

lloogg     Open a log file -- debugging, packet, session, transaction.

qquuiitt    Same as eexxiitt.

rreecceeiivvee
        Passively wait for files to arrive.

rreemmoottee  Issue file-management commands to a remote kkeerrmmiitt server.

ssccrriipptt  Execute a login script with a remote system.

sseenndd _f_i_l_e
        Send _f_i_l_e to the remote kkeerrmmiitt server.

sseerrvveerr  Begin server operation.

sseett     Set various internal parameters.

sshhooww    Display values of parameters, program version, etc.

ssppaaccee   Display current disk space usage.

ssttaattiissttiiccss
        Display statistics about most recent transaction.

ttaakkee    Execute commands from a file.

Interactive   cckkeerrmmiitt  accepts commands  from  files as  well  as from  the
keyboard.   Upon  startup, cckkeerrmmiitt  looks  for the  file  .kkeerrmmrrcc first  in
directory $HHOOMMEE and then in the current directory; if it finds the file, it
executes  all  commands  it  finds  therein.   These commands  must  be  in
interactive format.  Command files may be nested to any reasonable depth.

_T_h_e _s_e_t _C_o_m_m_a_n_d
As noted  above, the sseett  command lets you  set the internal  parameters by
which  cckkeerrmmiitt   operates.   The  sseett  command   recognizes  the  following
arguments:

bblloocckk-cchheecckk
        Level of packet error detection.

ddeellaayy   Time to wait before sending first packet.

dduupplleexx  Specify which side echoes during connect mode.

eessccaappee-cchhaarraacctteerr
        Character to prefix _e_s_c_a_p_e _c_o_m_m_a_n_d_s during connect mode.

ffiillee    Set various file parameters.

ffllooww-ccoonnttrrooll
        Communication line full-duplex flow control.

hhaannddsshhaakkee
        Communication line half-duplex turnaround character.

lliinnee    Communication-line device name.

mmooddeemm-ddiiaalleerr
        Type of modem-dialer on communication line.

ppaarriittyy  Communication line character parity.

pprroommpptt  Change the  cckkeerrmmiitt program's prompt.

rreecceeiivvee
        Set various parameters for inbound packets.

rreettrryy   Set the packet retransmission limit.

sseenndd    Set various parameters for outbound packets.

ssppeeeedd   Communication line speed.

_R_e_m_o_t_e _C_o_m_m_a_n_d_s
cckkeerrmmiitt also has a suite of commands that are sent to the remote system for
execution.  They are as follows:

ccwwdd     Change remote working directory (also, rreemmoottee ccdd).

ddeelleettee  Delete remote files.

ddiirreeccttoorryy
        Display a listing of remote file names.

hheellpp    Request help from a remote server.

hhoosstt    Issue a command to the remote host in its own command language.

ssppaaccee   Display current disk space usage on remote system.

ttyyppee    Display a remote file on your screen.

wwhhoo     Display  the  users  logged  in  to   the  remote  system,  or  get
        information about a user.

_F_i_l_e_s
.kkeerrmmrrcc -- cckkeerrmmiitt initialization commands

_S_e_e _A_l_s_o
ccoommmmaannddss, kkeerrmmiitt, uuuuccpp

_N_o_t_e_s
The kkeerrmmiitt  protocol was  developed at  the Columbia University  Center for
Computing Activities.  cckkeerrmmiitt is copyright (c) by the Trustees of Columbia
University.

On some remote  systems, the command hhaanngguupp does not  hang up the telephone
properly.  If this occurs, add the following macro to file $HHOOMMEE/.kkeerrmmrrcc:

    define myhangup sleep 2,output +++,sleep 2,output ATH0\13

This create  a macro named  mmyyhhaanngguupp, which you  can invoke to  hang up the
remote telephone.  To test the proper load of the macro, type the following
at the cckkeerrmmiitt prompt:

    show macro myhangup

It should show the command sequence.   If it is intact, you can execute the
new hhaanngguupp command by typing mmyyhhaanngguupp.

Please note that cckkeerrmmiitt is provided in binary form per the licensing terms
set forth  by its  copyright holders.   It is distributed  as a  service to
COHERENT customers,  as is.  It is not supported  by Mark Williams Company.
_C_a_v_e_a_t _u_t_i_l_i_t_o_r.
