ckermit -- Command

Interactive inter-system communication and file transfer
ckermit [-abcdefghiklpqrstwx] [ file ... ]

ckermit  implements  the  kermit  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 kermit protocol.  Unlike
the kermit command also included  with the COHERENT system, ckermit uses an
interactive shell to remove some of the pain from the process of exchanging
files.  The name  ckermit 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 ckermit  in either interactive  mode or command  mode.  Simply
typing the command

    ckermit

invokes ckermit  in interactive mode: ckermit 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 ckermit  in command mode:
ckermit then  reads the arguments from the command  line and executes them.
After execution of the commands, ckermit returns to interactive mode.

ckermit's command-line options  name either actions or settings.  An action
option tells ckermit 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
ckermit operates;  for example,  one setting option  lets you set  the baud
rate of  the serial port  that ckermit will  be using.  A  command line can
contain any number of settings options.

Command-Line Options

ckermit recognizes the following command-line options:

-a filename
        Give an alternate name  to a file being  transferred.  For example,
        the command

            ckermit -s foo -a bar

        transmits the file  foo to  a remote system,  but tells  the remote
        system that the file is named bar. Likewise, the command

            ckermit -ra baz

        stores the first incoming file under the name baz.

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

-b baudrate
        Set the baud rate of the device to baudrate.

-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 <ctrl-\>, although you can change it if you wish.

-d      Debug mode -- record debugging information in the file debug.log in
        the current directory.

-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  kermit on  the remote  system support  the long-
        packet extension to the kermit protocol.

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

-g file
        Ask a remote system  to send file or files. 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      Help -- display a brief synopsis of the command-line options.

-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      Passively receive file or files, copying them to standard output.

-l device
        Name the serial device to be used.  For example

            ckermit -l /dev/com2l

        tells ckermit to use device /dev/com2l.

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

-p x    Set parity, where x is one of e, o, m, s, or n (respectively, even,
        odd, mark, space,  or none).   If parity is  other than  none, then
        ckermit uses the eighth-bit prefixing  mechanism to transfer binary
        data, provided  the impementation  of kermit  on the  remote system
        agrees.  The default parity is none.

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

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

-s file
        Send the specified file  or files. If fn is  `-' then ckermit 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      Specify half  duplex,  line turnaround  with XON  as the  handshake
        character.

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

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

If  ckermit 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:

<ctrl-F>
        Interrupt the current file and go on to the next, if any.

<ctrl-B>
        Interrupt the entire batch of files and terminate the transaction.

<ctrl-R>
        Resend the current packet.

<ctrl-A>
        Display a status report for the current transaction.

These   interrupt  characters   differ  from   the   ones  used   in  other
implementations  of ckermit  to avoid  conflict  with the  COHERENT shell's
interrupt characters.

Interactive Operation

When  you invoke  ckermit in  interactive mode,  it displays  the following
prompt.

    C-Kermit>

Type  any valid  ckermit command;  the set of  valid commands  is described
below.  ckermit 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 send. 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.,  send,  receive,  connect)  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.

<esc>
        Request  completion  of  the  current  keyword  or  file  name,  or
        insertion of a default  value.  ckermit will beep  if the requested
        operation fails.  <tab> does the same thing.

<del>
        Delete the previous character  from the command.  <backspace>
        does the same thing.

<ctrl-W>
        Erase the rightmost word from the command line.

<ctrl-U>
        Erase the entire command.

<ctrl-R>
        Redisplay the current command.

<space>
        Delimit fields (keywords, filenames, numbers) within a command.

<return>
        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 <return> lets  you continue
        the command on the next line.

ckermit recognizes the following interactive commands:

! command
        Execute a shell command.  A space must follow the !.

%       A comment.  ckermit ignores everything that follows the %.

bye     Terminate and log out a remote kermit server.

close   Close a log file.

connect
        Connect to the remote system.

cwd directory
        Change the working directory to directory.

dial    Dial a telephone number.

directory
        Display a directory listing.

echo    Display arguments literally.  Useful in take-command files.

exit    Exit from the program, closing any open logs.

finish  Instruct a remote  kermit server to exit, but not log out.

get     Get files from a remote  kermit server.

hangup  Hang up the telephone.

help    Display a help message for a given command.

log     Open a log file -- debugging, packet, session, transaction.

quit    Same as exit.

receive
        Passively wait for files to arrive.

remote  Issue file-management commands to a remote kermit server.

script  Execute a login script with a remote system.

send file
        Send file to the remote kermit server.

server  Begin server operation.

set     Set various internal parameters.

show    Display values of parameters, program version, etc.

space   Display current disk space usage.

statistics
        Display statistics about most recent transaction.

take    Execute commands from a file.

Interactive   ckermit  accepts commands  from  files as  well  as from  the
keyboard.   Upon  startup, ckermit  looks  for the  file  .kermrc first  in
directory $HOME 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 set  command lets you  set the internal  parameters by
which  ckermit   operates.   The  set  command   recognizes  the  following
arguments:

block-check
        Level of packet error detection.

delay   Time to wait before sending first packet.

duplex  Specify which side echoes during connect mode.

escape-character
        Character to prefix escape commands during connect mode.

file    Set various file parameters.

flow-control
        Communication line full-duplex flow control.

handshake
        Communication line half-duplex turnaround character.

line    Communication-line device name.

modem-dialer
        Type of modem-dialer on communication line.

parity  Communication line character parity.

prompt  Change the  ckermit program's prompt.

receive
        Set various parameters for inbound packets.

retry   Set the packet retransmission limit.

send    Set various parameters for outbound packets.

speed   Communication line speed.

Remote Commands

ckermit also has a suite of commands that are sent to the remote system for
execution.  They are as follows:

cwd     Change remote working directory (also, remote cd).

delete  Delete remote files.

directory
        Display a listing of remote file names.

help    Request help from a remote server.

host    Issue a command to the remote host in its own command language.

space   Display current disk space usage on remote system.

type    Display a remote file on your screen.

who     Display  the  users  logged  in  to   the  remote  system,  or  get
        information about a user.

Files

.kermrc -- ckermit initialization commands

See Also

commands,
kermit,
uucp

Notes

The kermit  protocol was  developed at  the Columbia University  Center for
Computing  Activities.  ckermit  is  copyright ©  by  the Trustees  of
Columbia University.

On some remote  systems, the command hangup does not  hang up the telephone
properly.  If this occurs, add the following macro to file $HOME/.kermrc:

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

This create  a macro named  myhangup, which you  can invoke to  hang up the
remote telephone.  To test the proper load of the macro, type the following
at the ckermit prompt:

    show macro myhangup

It should show the command sequence.   If it is intact, you can execute the
new hangup command by typing myhangup.

Please note that ckermit 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.
Caveat utilitor.

© 2012 by Stephen A. Ness