

ckermit                      Command                      ckermit




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.

***** Command-Line Options *****

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





COHERENT Lexicon                                           Page 1




ckermit                      Command                      ckermit



        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







COHERENT Lexicon                                           Page 2




ckermit                      Command                      ckermit



        ckermit -l /dev/com2


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

-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


COHERENT Lexicon                                           Page 3




ckermit                      Command                      ckermit



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.

***** Interactive Operation *****

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)  hhaavvee
ssppeecciiaall  nnoonn-uunniiqquuee aabbbbrreevviiaattiioonnss  (rreessppeeccttiivveellyy,  `ss', `rr',  aanndd
`cc').

CCeerrttaaiinn   cchhaarraacctteerrss  hhaavvee   ssppeecciiaall  ffuunnccttiioonnss   iinn  iinntteerraaccttiivvee
ccoommmmaannddss:

?    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


COHERENT Lexicon                                           Page 4




ckermit                      Command                      ckermit



     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.




COHERENT Lexicon                                           Page 5




ckermit                      Command                      ckermit



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.

***** The set Command *****

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:




COHERENT Lexicon                                           Page 6




ckermit                      Command                      ckermit



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.

***** Remote Commands *****

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.



COHERENT Lexicon                                           Page 7




ckermit                      Command                      ckermit



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.

***** Files *****

.kkeerrmmrrcc -- cckkeerrmmiitt initialization commands

***** See Also *****

ccoommmmaannddss, kkeerrmmiitt, uuuuccpp

***** Notes *****

The  kkeerrmmiitt protocol  was  developed at  the Columbia  University
Center for Computing Activities.
































COHERENT Lexicon                                           Page 8


