kermit.columbia.edu/kermit.columbia.edu.tar/kermit.columbia.edu/uniflex/ufhelp.txt

Text File | 1993-08-22 | 20KB | 523 lines

~~~bye

This command will cause Kermit-09 (when in local mode)  to  tell  the
other  Kermit  (which  should  be in server mode) to exit from Kermit
and, if applicable, terminate  its  job  (or  process,  etc.).   When
Kermit-09  receives  the  acknowledgement that this is being done, it
will exit to UniFLEX.

           UF-Kermit>bye
~~~chd

This command  will change  the current directory.  If no directory is
specified, the login directory will be selected.

           UF-Kermit>chd [directory]

Where "directory" is any valid UniFLEX directory specification.
~~~connect

The  'connect' command  will allow  you to  connect in  as a  virtual
terminal over the line  that was specified by the 'set line' command,
or to the terminal line specified in the command.
When connected,  the following options are available after the escape
character has been given:

    B      Send a 'BREAK' signal.
    C      Close the connection and return to the local KERMIT.
    H      Show availability.
    S      Show status of the connection.
    0      (zero) Send a NUL (0) character.
    Q      Quit logging session transcript.
    R      Resume logging session transcript.
    ?      List all the possible single-character arguments.
    ^      (or whatever you have set the escape character to be)
           Typing the escape character twice sends one copy of it
           to the connected host.
    other  Passed to remote kermit.

           UF-Kermit>connect [device]

Where "device" is the (optional) terminal device to be used.
~~~exit

The 'exit' command will cause Kermit to return to the UniFLEX command
level. It is the same as the 'quit' command.

           UF-Kermit>exit
~~~finish

This command will cause Kermit-09 (when in local mode)  to  tell  the
other  Kermit  (which  should be in server mode) to exit from Kermit.
After  receiving  the  acknowledgement  that  this  is  being   done,
Kermit-09 will prompt for another command.

           UF-Kermit>finish
~~~free

This  command  shows  the number  of free  blocks  and  bytes on  the
specified  device.  If no device is specified,  the current device is
used. If a file is specified, the device on which the file resides is
used.

           UF-Kermit>free [device or file]
~~~general

Type ctrl-X to abort a  single file  transfer in progress,  or ctrl-Z
to abort the current file and all coming files.

Typing a ctrl-D during file transfer will toggle debug mode on / off.
An open debug log file will be closed.

A ctrl-\ during file transfer will  be treated  as an emergency exit.
All files will be closed,  the communication port will be closed, and
kermit will terminate.

Wild cards known in filespecs are '*',  which stands  for  "match all
characters" or '?', which stands for "match one character".
~~~get

This command will cause the other Kermit (which should be running  in
server mode)  to transmit one or  more files to Kermit-09.  Kermit-09
must be running as a local Kermit (i.e., no 'set line remote' command
may  be done).  Kermit-09  will then  request  the  other  Kermit  to
transfer the specified file (or set of files) to Kermit-09.  The file
specification must be in the format of the system on which the server
Kermit is running.

           UF-Kermit>get file-spec [,file-spec...]

Where  "file-spec" is any  valid file specification on the  system on
which the server Kermit is running.
~~~help

This command  shows help  about a  requested subject.  If no topic is
specified, all currently available topic's will be displayed.

           UF-Kermit>help [topic] [,topic...]

Where "topic" as any topic about which help can be given.
~~~local

This command provides the  user with a possibility to execute UniFLEX
commands.

           UF-Kermit>local [command]

Where "command" is a legal  UniFLEX  command string.  If no string is
given, a separate shell will be started.
~~~quit

The 'quit' command will cause Kermit to return to the UniFLEX command
level. It is the same as the 'exit' command.

           UF-Kermit>quit
~~~receive

The 'receive' command  is used  to put  Kermit-09  into receive  mode
waiting   for  a  single  file  transfer  transaction.   If  no  file
specification  is given,  Kermit-09  will  store  the incoming  files
under the names specified in the received packets. If one filespec is
given,  the incoming  file will be stored  under  that name,  so that
strange filenames can be overruled.

           UF-Kermit>receive [file-spec]

Where "file-spec" is a valid UniFLEX file specification.
~~~send

The 'send' command will allow you  to send  a file(s)  to  the  other
Kermit. The 'send' command will allow file wild card processing as is
found in UNIX. If Kermit-09 is running in remote mode, the file  will
be  sent on the controlling terminal line after waiting the number of
seconds  specified by  the 'set delay'  command. This  gives the user
time to escape  back to the other Kermit and issue a receive command.
If  Kermit-09  is running  in  local  mode,  the  file  will be  sent
immediately to the terminal line specified by the 'set line' command.

           UF-Kermit>send file-spec [,file-spec...]

Where  "file-spec"  is any normal  UniFLEX file  specification.  Wild
cards are fully supported.
~~~server

This command will cause Kermit-09 to enter server  mode.   The  other
Kermit  can  then  issue  server  commands  to send and receive files
without having  to  give 'semd' or 'receive' commands  to  Kermit-09.
Kermit-09  may  be  put  into  server  mode while running as either a
remote Kermit (transmitting over the controlling terminal  line),  or
as  a local  Kermit (transmitting over a terminal specified by a 'set
line' command).  Note that in order to correctly receive binary files
while  in  server mode, a  'set filetype binary'  must be done  first
(unless  'attribute packets are used).  If these are  not used,  then
there is no way for  Kermit-09 to determine  whether an incoming file
is ascii or binary.

           UF-Kermit>server
~~~set
.
The 'set' command is used to set various parameters in Kermit.

           UF-Kermit>set command
~~~show

The 'show' command will allow you to show the various parameters that
are set with the 'set' command.

Commands available:

all            baud             block_check_type configuration  debug
delay          duplex           eight_bit_quote  end_of_line    escape
filetype       handshake        incomplete       line           log
mapping        packet_length    padchar          padding        quote
repeat_quote   retry            start_of_packet  timeout        warning

           UF-Kermit>show command
~~~statistics

The transfer statistics of Kermit-09 will be displayed. This includes
the  number of characters  that have been sent  and received from the
remote Kermit.  Also included  is an estimate of the effective  baud-
rate of  the transfer.  This number is not  intended to be exact, but
only an indication of what range of throughput has been provided.

           UF-Kermit>statistics
~~~take

This command allows Kermit commands to be executed from a file.  This
makes a quick change of parameters possible. The file may contain any
valid Kermit commands, including other 'take' commands.

           UF-Kermit>take file-spec

Where "file-spec" is a valid UniFLEX file specification.
~~~transmit

This command allows you to send a file "as it is", without  protocol.
That might be useful if the other side doesn't have a Kermit.

           UF-Kermit>transmit file-spec

Where "file-spec" is a valid UniFLEX file specification.
~~~.set/attributes

This  command enables  or disables  the use of  kermit's  'attribute'
packets.  If it is set to 'on', then kermit will try to use this type
of  packets if the other kermit agrees on that.  It enables automatic
selection of binary  or ascii modes,  setting of the file protection,
setting of the file date, checking in advance whether there is enough
disk  space  available to  store  the  incoming  file,  and show  the
percentage of the received data. The default is 'on'.

           UF-Kermit>set attributes state

Where "state" is 'on' or 'off'.
~~~.set/auto_recover

This command sets the method of error recovery used when the extended
packet length protocol is selected. If it is set off, then the packet
length will remain the same after an error has occurred.  If on, then
the packet length will  be shortened automatically to recover from an
eventual buffer  size error from a  device on the communication line.
The packet size will not be shortened below 40 bytes.

           UF-Kermit>set auto_recover state

Where "state" is 'on' or 'off'.
~~~.set/baud

This command sets the baud rate to use for communications.

           UF-Kermit>set baud n

Where n is one of  50, 75, 110, 135, 150, 300, 600, 1200, 1800, 2400,
3600, 4800, 7200, 9600, 19200. (If the hardware supports it).
~~~.set/block_check_type

The 'set block_check_type' command is used to  determine the  type of
block  check  sequence  which  will be used during transmission.  The
block check sequence is used to detect  transmission  errors.   There
are  three  types  of  block  check  available.  These are the single
character checksum (default), the two  character  checksum,  and  the
three character CRC (cyclic redundancy check).  This command does not
ensure that the desired type of block check will be used, since  both
Kermit's involved in the transfer must agree on the block check type.
Kermit-09 will request that the type  of  block  check  set  by  this
command be used for a transfer.  If the other Kermit has also had the
same block check type requested, then the desired  block  check  type
will be used.  Otherwise, the single character checksum will be used.
(See Kermit protocol manual for more information.)

           UF-Kermit>set block_check_type n

Where n is a number of 1 - 3.
~~~.set/configuration

This command determines the type of parity and the data length to use
on  the transmission line.  Kermit  normally  uses  characters  which
consist of eight data bits  with no  parity  bit.  For  systems which
require  a  specific parity  type or  data  length,  Kermit can  send
characters as seven data bits plus a parity bit.

           UF-Kermit>set configuration number

Where "number" is one of:

0.  Seven data bits, even parity and two stop bits.
1.  Seven data bits, odd parity and two stop bits.
2.  Seven data bits, even parity and one stop bit.
3.  Seven data bits, odd parity and one stop bit.
4.  Eight data bits, no parity and two stop bits.
5.  Eight data bits, no parity and one stop bit (default).
6.  Eight data bits, even parity and one stop bit.
7.  Eight data bits, odd parity and one stop bit.
~~~.set/debug

The  'set debug' command  is used to set  the debug type  out on  the
user's terminal.  The command will  accept either  the keywords 'on',
'off' or 'log'. Kermit-09 can only do debugging type out when running
as  a local  Kermit  (no 'set line remote'  command  done).  This  is
because the debugging type-out would interfere with the file transfer
if it were  sent to the controlling  terminal line in remote mode. If
'log' is specified,  a filename must  be given.  All debug  info will
then be displayed on the screen as well as in the log file.  This can
be very handy  in debugging  transfer problems.  An eventual open log
file will be closed if 'on' or 'off' is specified.

           UF-Kermit>set debug state
 or
           UF-Kermit>set debug log file-spec

Where "state" is either 'on' or 'off',  and "file-spec" is any valid
UniFLEX file spcification.
~~~.set/delay

The 'delay' parameter is the number of seconds to wait before sending
data after a 'send' command is given.  This is used when Kermit-09 is
running in remote mode to allow the user time to escape back  to  the
other Kermit and give a 'receive' command.

           UF-Kermit>set delay number-of-seconds

Where "number-of-seconds" is the (decimal) number of  seconds to wait
before sending data.
~~~.set/duplex

The  'set duplex'  command  specifies  whether characters  should  be
echoed locally  when connecting to another system. If 'duplex' is set
to  'on',  any  character  typed  on  the  terminal  will  be  echoed
immediately  to the  terminal,  as  well  as being  sent to the other
system.  If 'duplex' is set to 'off' (the  default),  the  characters
typed on the terminal  are only sent to the other system (which would
normally be echoing the characters).

           UF-Kermit>set duplex keyword

Where "keyword" is either 'on' or 'off'.
~~~.set/eight_bit_quote

This command sets the character to be used (when necessary) to  quote
characters  which  have the eight bit (parity bit) set.  This is used
to transfer eight-bit bytes  on  a  transmission  medium  which  only
supports  seven  data  bits.  The  default value  is $26 (ASCII "&").
Eight-bit quoting will only be used if both Kermit's can  handle  it,
and the transmission  medium  does  not transmit  eight data bits (as
indicated by the 'set configuration' command).

           UF-Kermit>set eight_bit_quote n

Where n is the ASCII character to  use  for quoting  characters which
have  the eight  bit set.  The character  'n' will disable  eight_bit
quoting.
~~~.set/end_of_line

This will set the end of line  character  the  Kermit-09  expects  to
receive  from  the  remote  Kermit.   This  is  the  character  which
terminates a packet.  The default value is $13 (ASCII CR, CTRL-M).

           UF-Kermit>set end_of_line n

Where  n is the  value of the  character to  use for the end of  line
character (in hex).
~~~.set/escape

This  command  will  set  the  escape  character  for  the  'connect'
processing.   The  command will take the ascii value of the character
to use as the escape character.  This is the character which is  used
to  "escape" back  to Kermit-09 after using the 'connect' command. It
defaults  to  ^ (hex 5E).  It is usually a  good  idea  to  set  this
character  to  something which is not used (or at least not used very
much) on the system being to which Kermit-09 is connecting.

           UF-Kermit>set escape character

Where character is the ASCII character to use as escape character.
~~~.set/filetype

This command will set the file type that Kermit is receiving.  A file
type  of 'ascii' should be used to receive text files which are to be
used  as text  files on the  UniFLEX system.  The file type  'binary'
should be used  for binary files,  which need to be  kept in a format
that allows the file to be returned without any changes.

           UF-Kermit>set filetype type

Where "type" is either 'ascii' or 'binary'.
~~~.set/handshake

This  command sets the  characters used to synchronize the data flow.
If the  input buffers  become full,  the stop character will be sent.
The  start character will be  sent if Kermit is  able to receive data
again.  The defaults  are XOFF (hex 19)  and XON (hex 17).  If either
character is zero, handshaking will not be used.

           UF-Kermit>set handshake start stop

Where "start" and "stop" are hexadecimal numbers.
~~~.set/incomplete

The  'set incomplete' command allows  the user to  determine  what is
done with a file that is not  completely received. If the disposition
is 'keep', all files received will be kept, even if only a portion of
the file is received. If the  disposition is 'discard' (the  default),
files which are not completely received are discarded.

           UF-Kermit>set incomplete keyword

Where "keyword" is either 'discard' or 'keep'.
~~~.set/line

This will set the terminal line that you are using.  It may be either
a  device name,  or 'remote'  to indicate  that the  line from  which
Kermit gets it's commands will be used.

           UF-Kermit>set line device

Where  "device" is either 'remote' or the  terminal device name to be
used.
~~~.set/log

This will open a log file  where the data from  the 'connect' command
will be stored. The file will be closed when Kermit is terminated, or
when the filespec is a dash ('-').

           UF-Kermit>set log file-spec

Where "file-spec" is a valid UniFLEX file specification.
~~~.set/mapping

This will set the filename case mapping flag.  If Kermit is receiving
a file with the  mapping flag  on, the case of that  filename will be
mapped to lower case.  If Kermit is sending a file, the filename send
to the other Kermit will be mapped to upper case. If the flag is off,
the existing file case will be used. The default is 'on'.

           UF-Kermit>set mapping state

Where "state" is 'on' or 'off'.
~~~.set/packet_length

This will set the packet length. The value for this parameter must be
between 10 and 94 for normal use.  A length greater than 94 will tell
Kermit to negotiate for extended packet length.  If the remote kermit
can handle this  protocol extension,  it will be used.  Otherwise the
maximum  of 94 will be used.  The maximum length value is 2048 bytes.
The default value is 94.

           UF-Kermit>set packet_length n

Where n is a decimal number.
~~~.set/padchar

This parameter is the padding character that is sent  to  the  remote
Kermit. The parameter must be a decimal number  in the range of 0  to
31. The default value is 0  (an ASCII NUL).

           UF-Kermit>set padchar n

Where n is the  value of the character to be used as a  pad character
(in decimal).
~~~.set/padding

This command will set the number of padding characters that  will  be
sent to the other Kermit.  The default value is 0.

           UF-Kermit>set padding n

Where n is the decimal number of padding characters to use.
~~~.set/prompt

This command allows you to set the prompt of Kermit.  This is  useful
if you are working  with two Kermit's  and get confused to  which one
you are talking to.

           UF-Kermit>set prompt string

Where "string" is any character string up to twenty characters.
~~~.set/quote

This will set the quoting character that  Kermit-09  will  expect  on
incoming  messages.   This  is  the  character  used to quote control
characters.  The default value is $23 (ASCII "#").

           UF-Kermit>set quote n

Where n is the ASCII character to be used as a quoting character.
~~~.set/repeat_quote

This command sets the character to be used as the  lead-in  character
for  a  repeat sequence (a string of characters which represents some
number of characters which are repeated in the data).  Both  Kermit's
must  support  repeat  compression  for  this  to  be in effect.  The
character set by this command must be in the range $21  ("!")  to $3E
(">") or $7B ("{") to $7E ("~") or $60 ("`"). The character will only
be  used on  files  which are being transmitted  by  Kermit-09.   The
'repeat quote' character used for incoming files is decided on by the
other Kermit. The default value is $7E ("~").

           UF-Kermit>set repeat_quote character

Where "character" is  the  ASCII  character  for  the  repeat quoting
character. The character 'n' will disable repeat compression.
~~~.set/retry

This command sets the maximum number of times Kermit-09 should try to
send or receive a specific packet. The default value is 10.

           UF-Kermit>set retry n

Where n is the decimal number of retries to attempt.
~~~.set/start_of_packet

This command will set the start of packet character for Kermit.   The
start  of packet character  must be in the range of 0 to 31  decimal.
The default value is 1 (ASCII SOH, CTRL-A).  This value  should  only
be changed if absolutely  necessary.  It must be set the same in both
Kermit's.

           UF-Kermit>set start_of_packet n

Where n is the value of the character to be used as a start character
(in hex).
~~~.set/timeout

This will set the number of seconds before Kermit-09  will  time  out
the  attempt  to  receive a message.  This time out is used to handle
transmission errors which totally lose a message.  The default  value
is 5 seconds.

           UF-Kermit>set timeout n

Where n is the number of seconds to wait for a message (in decimal).
~~~.set/warning

This  will set  the  filename conflict  warning flag.  If  Kermit  is
directed to store an incoming file under a name which already exists,
and the warning is on,  an attempt will be made  to create a new  and
non-existing filename.  If the flag is off, the existing file will be
overwritten. The default is 'on'.

           UF-Kermit>set warning state

Where "state" is 'on' or 'off'.