Columbia Kermit/kermit.zip/cmsoriginal/cmsv2.mss

Text File | 2020-01-01 | 26KB | 686 lines

@Part(CMSKERMIT,root="KER:KUSER")
@string(-cmsversion="@q<2.01>")
@Chapter<IBM VM/CMS KERMIT>

@Begin<Description,Leftmargin +12,Indent -12,spread 0>
@i(Program:)@\Daphne Tzoar, Columbia University; contributions from
Bob Shields (U. of Maryland), Victor Lee (Queens U.), Gary Bjerke (U.
of Texas at Austin), Greg Small (UC Berkeley)

@i(Language:)@\CMS Assembler

@i(Documentation:)@\Daphne Tzoar, Columbia University

@i(Version:)@\@value(-cmsversion)

@i(Date: )@\May 1985
@end<Description>

@subheading<CMS Kermit Capabilities At A Glance:>
@begin<format,leftmargin +2,above 1,below 1>
@tabclear()@tabset(3.5inches,4.0inches)
Local operation:@\No
Remote operation:@\Yes
Transfers text files:@\Yes
Transfers binary files:@\Yes (fixed format)
Wildcard send:@\Yes
@q<^X/^Y> interruption:@\Yes
Filename collision avoidance:@\Yes
Can time out:@\No
8th-bit prefixing:@\Yes
Repeat count prefixing:@\Yes
Alternate block checks:@\Yes
Terminal emulation:@\No
Communication settings:@\No
Transmit BREAK:@\No
Transaction logging:@\Yes
Session logging:@\No
Raw transmit:@\No
Act as server:@\Yes
Talk to server:@\No
Advanced server functions:@\No
Advanced commands for servers:@\No
Local file management:@\Yes
Handle Attribute Packets:@\No
Command/init files:@\Yes
Command macros:@\No
@end<format>

@Index[IBM]
@Index[VM/CMS]
Kermit-CMS is a program that implements the KERMIT file transfer
protocol for IBM 370-series mainframes (System/370, 303x, 43xx, 308x,
etc.) under the VM/CMS operating system.  It is written in IBM 370
assembly language.  This program runs only over ASCII (asynchronous)
lines attached to a 3705-style front end or a Series/1 running the
Yale ASCII Terminal Communication System.  The program should also
work on the IBM 7171 ASCII Device Control Unit and the 4994, although
this has not been verified as of this writing.  For more details on
this, see the section SET SERIES1.

These systems have several peculiarities that users should be aware
of.  These are half duplex systems; the communication line must "turn
around" before any data can be sent to it.  The fact that a packet has
been received from the IBM system is no guarantee that it is ready for
a reply.  Thus any Kermit talking to this system must wait for the
line turnaround character (XON) before transmitting the next
character.  It is up to the user to tell the other Kermit that it
is talking to an IBM mainframe.

Also, a program running under VM/CMS is unable to interrupt a read on
its "console".  This means that the CMS version of Kermit cannot
timeout.  The only way to "timeout" CMS Kermit is from the other side:
typing a carriage return to the local Kermit causing it to retransmit
its last packet, or an automatic timeout as provided by most other
Kermits.

@Section<The VM/CMS File System>

The features of the CMS file system of greatest interest to Kermit
users are the format of file specifications and the concept of
records.

@subsection<File Specifications>

The VM/CMS file specification is in the form
@example<FILENAME FILETYPE FILEMODE>
(often abbreviated FN FT FM).  FILENAME and FILETYPE are at most 8
characters in length each.  The name field is the primary identifier
for the file.  The type is an indicator which, by convention, tells
what kind of file we have.  For instance @q<TEST FORTRAN> is the
source of a FORTRAN program named TEST.  @q(MODULE) is the normal
suffix for executable programs.  Although some operating systems
consider the FILETYPE optional, VM/CMS requires a valid type.
Therefore, Kermit-CMS supplies a default type of "X" if one is
not provided by the remote system.

The FILEMODE, which consists of a letter and a number, is similar
to a device specification on microcomputer systems: @w<@q[FN FT FM]>
would translate to @q<FM:FN.FT> in CP/M or MS-DOS.  If FILEMODE is
omitted from a file specification when sending, a FM of "*" is used.
In this case, the users disks are scanned according to the search
order and the first occurrence of the file is the one that is sent.
If FILEMODE is omitted from a file spec when receiving, a default of
"A1" is used.

To provide compatibility with most other operating systems, Kermit-CMS
sends only the FILENAME and FILETYPE.  It also converts the
intervening blank to a period.

The FN and FT may contain, in any order, uppercase letters, digits, and
the special characters @qq<$> (dollar sign), @qq<#> (pound sign),
@qq<@@> (at sign), @qq<+> (plus), @qq<-> (dash), @qq<:> (colon), and
@qq<_> (underscore).  Other characters may be not be included.  If an
invalid character is found in the FN or FT field, it is replaced by
the letter "X".

@index<Wildcard>
VM/CMS allows a group of files to be specified in a single file
specification by including the special "wildcard" characters, @qq<*>
and @qq<%>.  A @qq<*> matches any string of characters from the
current position to the end of the field, including no characters at
all; a @qq<%> matches any single character.  Here are some examples:

@Begin(Description,spread 0.5,leftmargin +10, indent -8)
@q<* COBOL A>@\All files of type @q<COBOL> (all COBOL source files) on
the A disk.

@q<F* *>@\All files whose names start with F.

@q<% * B>@\All files on the B disk whose FN is exactly one character long.
@End(Description)

@subsection<File Formats>

Several differences exist between VM/CMS files and those of most other
operating systems.  One distinction is that CMS encodes its data using
the EBCDIC character set.  The operating system, VM, translates all
incoming characters from ASCII to EBCDIC.  Kermit-CMS then translates
the data it reads back to ASCII (characters not representable in ASCII
are replaced by a null).  This is done in order to correctly calculate
the checksum, the method used to guarantee error-free transfer.  When
Kermit-CMS sends packets, it converts all data back to EBCDIC.  Note
that the translate tables used by Kermit must correspond to the ones
used by the system (VM).  The ASCII to EBCDIC translations can be
found in the Appendix.

Another difference is that VM/CMS stores files as records rather than
byte streams.  VM/CMS Kermit has to worry about assembling incoming
data packets into records and appending carriage return-linefeed to
outgoing records.

@section<Program Operation>

Kermit-CMS can be invoked at the command line or from an exec.
Commands consist of one or more fields, separated by spaces.  Each
field must be eight characters or less.  Fields longer than the
maximum length are truncated.

Upon initial startup, the program looks for two special initialization
files, SYSTEM KERMINI and (USERID) KERMINI (that is, the userid of the
person running CMS-Kermit.)  These files can be placed on any disk.
The purpose of these files is to allow Kermit to be customized for a
particular system and for a user's specific settings without changing
the source code.  The file SYSTEM KERMINI should be placed on a
publicly accessible disk by a systems programmer.  The file would
contain commands that all users would need to issue in order for
Kermit to run on the system, such as commands to modify the
ASCII-to-EBCDIC and EBCDIC-to-ASCII tables used by Kermit-CMS.  The
file (USERID) KERMINI would contain commands that the user generally
issues every time Kermit is run.  Kermit-CMS executes any commands
found in these files as though they were typed at the terminal.
Here is a sample init file:
@begin(example)
* Asterisk in column one is a comment.
set debug on

set warning on
set block 3
@end(example)

Three CP SET parameters MSG, IMSG and WNG are always set OFF during
the actual file transfer (and restored afterwards) to prevent CP from
interrupting any I/O in progress.

@subheading(Interactive Operation:)

To run Kermit-CMS interactively, invoke the program from CMS by
typing "KERMIT".  When you see the command's prompt,
@example(KERMIT-CMS>.)
you may type Kermit commands repeatedly until you are ready to exit the
program, for example:
@Begin(Example)
.@ux[KERMIT]

Kermit CMS Version @value(-cmsversion)
Enter ? for a list of valid commands

KERMIT-CMS>.@ux[send foo *]

  @i(Files with fn FOO are sent)

KERMIT-CMS>.@ux[receive test spss]

  @i(File is received and called TEST SPSS A1)

KERMIT-CMS>.@ux[exit]
@end[example]

During interactive mode, you may use the help (@qq<?>) feature while
typing Kermit-CMS commands.  A question mark typed at almost any point
in a command, followed by a carriage return, produces a brief
description of what is expected or possible at that point.

@subheading(Command Line Invocation:)

Kermit-CMS may also be invoked with command line arguments from CMS.
For instance:
@Begin(Example,below 0.5)
.@ux(KERMIT send test fortran)
@End(Example)
or
@Begin(Example,above 0.5)
.@ux(KERMIT set debug on # set file binary # server)
@End(Example)

Kermit will exit and return to CMS after completing the specified
command or commands.  Note that several commands may be given on the
command line as long as they are separated by the linend character,
which is pound sign in this case.  The command line may contain up to
130 characters.

@subheading(Exec Operation:)

@index(Batch Operation of Kermit-CMS)
Like other CMS programs, Kermit-CMS may be invoked from a CMS EXEC.
Kermit will not run under CMSBATCH or disconnected since the user does
not actually have a console.  Commands can be passed using TAKE files
and/or command line arguments.  For example, to start up Kermit-CMS
and have it act as a server, include the line:
@Begin(Example,below 0.5)
@ux(KERMIT server)
@End(Example)
To pass more than one command, they must be stacked in the order in
which they are to be executed.  To start up a Kermit-CMS server with a
three character CRC, include:
@Begin(Example,below 0.5)
@ux(&STACK set block 3 )
@ux(&STACK server )
@ux(KERMIT)
@End(Example)
Prompts and messages will still be displayed on the screen.

@Section<Kermit-CMS Commands>

Here's a brief summary of CMS Kermit commands:
@Begin(Format,spread 0)
@tabclear()@tabset(1.25inches)
@>CMS@\  executes a CMS command.
@>CP@\  executes a CP command.
@>EXIT@\  from Kermit-CMS.
@>HELP@\  about Kermit-CMS.
@>QUIT@\  from Kermit-CMS
@>RECEIVE@\  files from other Kermit.
@>SEND@\  files to other Kermit.
@>SERVER@\  mode of remote operation.
@>SET@\  various parameters.
@>SHOW@\  various parameters.
@>STATUS@\  inquiry.
@>TAKE@\  commands from file.
@>TDUMP@\  dumps the contents of a particular table.
@End(format)

The remainder of this section concentrates on the commands that have special
form or meaning for CMS Kermit.

@Heading<The SEND Command>

Syntax:  @q<SEND> @i(filespec)

The SEND command causes a file or file group to be sent from the CMS
system to the Kermit on the remote system.  @i(filespec) takes the
form:
@example(filename filetype [filemode])

@i(filespec) may contain the wildcard characters @qq<*> or @qq<%>.  If
@i{filespec} contains wildcard characters then all matching files will
be sent.  If, however, a file exists by the same name on more than one
disk, only the first one CMS Kermit encounters, according to the disk
search order, is sent.

@Index<Cancelling a File Transfer>
Although the file transfer cannot be cancelled from the CMS side,
Kermit-CMS is capable of responding to "cancel file" or "cancel batch"
signals from the local Kermit;  these are typically entered by typing
Control-X and Control-Z respectively.

@Heading<The RECEIVE Command>
@Index[RECEIVE]
Syntax: @q<RECEIVE [@i{filespec}]>

The RECEIVE command tells Kermit-CMS to receive a file or file group
from the other system.  You should then issue a SEND command to the
remote Kermit.

The format of the filespec is:
@example<filename filetype [filemode]>

If the optional filespec is not included, Kermit-CMS will use the
name(s) provided by the other Kermit.  If that name is not a legal
CMS file name, Kermit-CMS will delete excessive characters from it,
and will change illegal characters to the @w(letter X).

Use the file specification to indicate that the incoming file should
be stored under a different name.  The filespec may include a
filemode to designate the destination disk.  If none is provided,
the file will be saved with fm A1.  If you want to use the same name
but a different filemode, specify @w(@q<= = FM>).  Wildcards may not
be used in any field.

If the optional filespec is provided, but more than one file arrives, the
first file will be stored under the given filespec, and the remainder will be
stored under their own names on the A disk.  If, however, @q<= = FM>
is used, all files will be placed onto the specified disk.

When receiving files, if the record format is fixed, any record
longer than the logical record length will be split up to as many
records as necessary.  If the record format is variable, the record
length can be as high as 64K.  For sending files, the maximum record
length is 64K.  See the SET LRECL and SET RECFM commands.

@Index<Incomplete File Disposition>
If an error occurs during the file transfer, as much of the file as
was received is saved on disk.  If the sending of a file is
cancelled by the user of the remote system, Kermit-CMS will discard
whatever had arrived.

If the incoming file has the same name as a file that already
exists, and WARNING is OFF, the original file will be overwritten.
If WARNING is set ON, Kermit-CMS will change the incoming name so as
not to obliterate the pre-@|existing file.  It attempts to rename
the file by replacing the first character with a dollar sign
(@q<$>).  If a file by that name exists, it also replaces the second
character with a dollar sign.  It continues in this manner for all
characters of the filename and filetype.  If the file cannot be
renamed, the transfer fails.

@Heading<The TAKE Command>

Syntax: @q<TAKE @i{filespec}>

Execute Kermit commands from the specified file, where filespec has
the format @q<fn ft [fm]>.  The command file may include TAKE
commands.

@Heading<The SERVER Command>

Kermit-CMS is capable of acting as a server.  The user connects to the
CMS system once to set various options and to start the server.  From
then on, he need not connect to the CMS system again.  The current
version of Kermit-CMS can send files (the user on the other end types
the GET command, using either a space or a period as the delimiter
between filename, filetype, and filemode), receive files (the user
types SEND), and terminate by either returning to CMS (user types
FINISH) or logging the user out (user types BYE).

To put Kermit-CMS into server mode, first issue any desired SET
commands to select various options and then type the SERVER command.
Kermit-CMS will await all further instructions from the user Kermit
on the other end of the connection.  For example:
@Begin(Example)
KERMIT-CMS>.@ux(set warning on)
KERMIT-CMS>.@ux(set debug on)
KERMIT-CMS>.@ux(set block 3)
KERMIT-CMS>.@ux(server)
@End(Example)

@Heading<The SET Command>

Syntax: @q<SET @i{parameter} [@i{value}]>

Establish or modify various parameters for file transfer.  You can
examine their values with the SHOW command.  The following SET
commands are available in Kermit-CMS:
@Begin(Format,spread 0)
@tabclear()@tabset(2.0inches)
@>ATOE@\  Modify ASCII-to-EBCDIC table used by Kermit-CMS
@>BLOCK@\  Level of error checking for file transfer
@>DEBUG@\  Log packets sent and received during file transfer
@>END-OF-LINE@\  Packet terminator
@>ETOA@\  Modify EBCDIC-to-ASCII table used by Kermit-CMS
@>FILE@\  Type of incoming or outgoing file
@>LRECL@\  Logical Record length for incoming file
@>PACKET-SIZE@\  Maximum receive packet size
@>QUOTE@\  Use to quote outgoing control characters
@>RECFM@\  Record format for incoming files
@>SERIES1@\  Indicate if coming in via a Series/1
@>WARNING@\  Specify how to handle filename collisions
@End(format)

@Subheading<SET ATOE>
@Index<ASCII-to-EBCDIC>

Syntax: @q<SET ATOE @i(num1) @i(num2)>

This command allows you to modify the ASCII-to-EBCDIC translate table
used by Kermit-CMS to conform to your system.  Specify the offset of
the ASCII value within the table and the new value for that location.
Both @i(num1) and @i(num2) should be between 0 and 255 (decimal).
Note that the table is twice as long as necessary because the
translate instruction expects a table that contains 256 characters.

@Subheading<SET BLOCK>
@Index<Block check>

SYNTAX: @q<SET BLOCK @i{number}>

Determine the type of block check used during file transfer.  Valid
options for @i{number} are: 1 (for a one character checksum), 2 (for
a two character checksum) and 3 (for a three character CRC).

@Subheading<SET DEBUG>
@Index<Debugging>

Syntax: @q<SET DEBUG ON @i(or) OFF>
@Begin(Description,leftmargin +8,indent -8,spread 0.5)
ON@\Keep a journal of all packets sent and received in the file
KER LOG A1.  If the file already exists, it is overwritten.

OFF@\Stop logging the packets.
@End(Description)

@Subheading(SET END-OF-LINE)

Syntax: @q(SET END-OF-LINE) @i{number}

If the remote system needs packets to be terminated by anything other than
carriage return, specify the decimal value of the desired ASCII character.
@i(number) must be between 0 and 31 (decimal).

@Subheading<SET ETOA>
@Index<EBCDIC-to-ASCII>

Syntax: @q<SET ETOA @i(num1) @i(num2)>

This command allows you to modify the EBCDIC-to-ASCII translate table
used by Kermit-CMS to conform to your system.  Specify the offset of
the EBCDIC value within the table and the new ASCII value for that
location.  Both @i(num1) and @i(num2) should be between 0 and 255
(decimal).

@Subheading(SET FILE)

Syntax: @q<SET FILE BINARY @i(or) TEXT>

@Begin(Description,leftmargin +8,indent -8,spread 0.5)
BINARY@\Tells CMS Kermit to treat each character as a string of bits
and not to perform translation on the data.  Also, no carriage-return
is added to the end of outgoing records.  Incoming bytes are added to
the end of the current record which is written out when the specified
LRECL is reached.

TEXT@\Tells CMS Kermit that the file is plain text.  ASCII-to-EBCDIC
and EBCDIC-to-ASCII translation is performed on the data.  Carriage
return-linefeed are appended to outgoing records and are used to
determine the end of incoming records.
@End(Description)

@Subheading (SET LRECL)

Syntax: @q(SET LRECL @i{number})

Set the logical record length for incoming files to a @i{number}
from 1 to 65536 (64K).  This variable is used only for fixed format
files.  The default is 80.

@Subheading(SET PACKET-SIZE)

Syntax: @q(SET PACKET-SIZE @i{number})

Use the specified @i(number) as the maximum length for incoming
packets.  The valid range is 26-94, where 94 is the default.

@Subheading(SET QUOTE)

Syntax: @q(SET QUOTE @i{char})

Use the indicated printable character for prefixing (quoting) control
characters and other prefix characters.  The only reason to change this would
be for sending a very long file that contains very many @qq(#) characters (the
normal control prefix) as data.  It must be a single character in the
range: 33-62, 96, or 123-126 (decimal).

@Subheading <SET RECFM>

Syntax: @q(SET RECFM @i{option})

Set the record format to use for incoming files.  Valid @i{option}s are
@qq<F> for fixed format or @qq<V> for variable format.  The default is
variable.

@Subheading<SET SERIES1>
@Index<Series/1>

Syntax: @q<SET SERIES1 ON @i(or) OFF>

Kermit-CMS automatically determines whether you are connected via a
Series/1 emulation controller or a TTY line.  This command is provided
though so you can override Kermit-CMS.  When you SET SERIES1 ON,
Kermit disables the 3270 protocol conversion function by putting the
Series/1 into "transparent mode"; this allows Kermit packets to pass
through the Series/1 intact.

@Subheading<SET WARNING>
@Index<File Warning>@Index(File Renaming)@index(Warning)

Syntax: @q<SET WARNING ON @i(or) OFF>

@Begin(Description,leftmargin +8,indent -8,spread 0.5)
ON@\If an incoming file has the same name as an existing file on the
specified disk, Kermit will attempt to rename the incoming file so
as not to destroy (overwrite) the pre-@|existing one.

OFF@\Upon a filename collision, the existing file will be replaced
by the incoming file.
@End(Description)

@Heading[The SHOW Command]

Syntax: @q(SHOW )@i(option)

Use to display the values of all parameters that can be changed with
the SET command, except for ATOE and ETOA (see the TDUMP command).
@i(option) can be a particular parameter or the keyword @qq<ALL>.

@Heading[The STATUS Command]

Syntax: @q(STATUS)

Returns the status of the previous command.  The response will
either display the message "Kermit completed successfully", or
the last error encountered.

@Heading[The TDUMP Command]

Syntax: @q(TDUMP) @i(table-name)

Display the contents of @i(table-name) since it can be modified
using the SET command.  The ATOE and ETOA tables can presently
be 'dumped'.

@Heading[CP and CMS Commands]

Syntax: @q(CP)   @i(text of command)
@\@q(CMS)  @i(text of command)

Although Kermit-CMS does not provide explicit commands for managing
local files or interacting with the operating system, it is possible
to do so.  You can issue any CP or CMS command, though each word will
be truncated to eight characters.  You can list, type, rename or
delete files, send messages and so on.  At this time, though, you
cannot run another program from Kermit-CMS.

@Section<Before Connecting to the Mainframe>

When connecting to the CMS system as a TTY device ("line at a time"
mode) several flags must first be set on the micro version of Kermit.
You should set the LOCAL-ECHO flag to ON (this is used to indicate
half-duplex).  This is the norm but not true in every case; if each
character appears twice, set the LOCAL-ECHO flag OFF.  HANDSHAKE
should be set to XON and FLOW-CONTROL should be set to NONE.  The
parity should be set according to the system's specifications.  On
some micro versions of Kermit, all of the above is done in one step
using the DO IBM macro (or SET IBM ON).  Set the baud rate to
correspond to the line speed.

When connecting to the CMS system through the Series/1 terminal
emulation controller ("full-screen" mode), certain flags must be set
on the micro version of Kermit.  You should set the LOCAL-ECHO flag to
OFF (this is used to indicate full-duplex).  HANDSHAKE should be set
to OFF and FLOW-CONTROL should be set to XON/XOFF.  For most systems,
the PARITY should be set to EVEN.  Set the baud rate to correspond to
the line speed.  Immediately after issuing a SEND, RECEIVE or SERVER
command to Kermit-CMS, the screen will be cleared.  This is to make
sure the terminal is not stuck in a MORE or HOLDING state before
packets are sent via the full-screen I/O operation.  After the file
transfer is complete, and you re-connect to Kermit-CMS, you should
enter the Series/1 "Master Reset" sequence (probably "CTRL-G") so that
the screen is refreshed.

@Section<How to build an executable version of Kermit-CMS>

Kermit-CMS is composed of three assembly language source files that
are assembled separately and then linked together.  They are:
KERMIT, NEXTFST, and WILD.  To create a runnable version:

@begin(enumerate,spread 0.5)
GLOBAL the necessary MACLIBs.  For SP, the MACLIBs used are
DMSSP, CMSLIB and TSOMAC.

Make sure the source files are named as listed above and are saved
on disk in fixed format with a logical record length of 80.

Assemble the three source files.

Load the files into memory via: LOAD KERMIT

Create a runnable version called KERMIT MODULE via: GENMOD KERMIT

If your site's ASCII/EBCDIC translation table does not conform
to the one listed in the appendix (which in turn conforms to the
one given in the IBM System/370 Reference Summary), then enter
the appropriate SET ATOE/ETOA commands in the SYSTEM KERMINI
file.  Note that if the ASCII/EBCDIC translation is not invertible,
Kermit will not and cannot work.
@end(enumerate)

To run CMS Kermit, simply type "KERMIT" to the CMS system prompt.

@Section<What's New>
Below is a list of the more important additions in Version
@value(-cmsversion) of CMS Kermit:

@begin(enumerate,spread 0.5)
Add prefixing of the "8th bit".  This allows CMS Kermit to send or
receive fixed format binary data, such as microcomputer binary files.

The maximum record length allowed has been increased to 64K for
both incoming and outgoing files.

Repeat count prefixing has been added to speed up
transmission.  In addition, Kermit-CMS now packs as much data
as possible into an outgoing packet rather than one packet
per record (it makes a big difference).

Support for two character checksum and three character CRC.

If filetype is not supplied by the remote Kermit, use a default of
"X" rather than failing.  Also allow the option to rename an
incoming file upon filename collision.

Add debugging mode to log packets and to acknowledge the attention if
the user types a BREAK.  Add a SHOW ALL command.

Allow input to command parser from command line.  Multiple commands
should be separated by the linend character.  After execution of these
commands, Kermit returns control to CMS.

Add support for Series/1 front end.

Add server support.

Upon startup, read commands from two init files: SYSTEM KERMINI and
(USERID) KERMINI (that is the userid of the person running Kermit).
Lines with an asterisk as the first character are comments.   Add
the TAKE command.  The LRECL for these files must be 130 or less.

Implement skip file or file group when sending or receiving (in
this case, discard incoming file).

Allow system manager to change ASCII/EBCDIC translation tables to
conform to the various specifications of different systems.  Also,
bypass user translate tables when sending and receiving data.

@end(enumerate)

@Section(What's Missing)

Work on Kermit-CMS will continue.  Features that need to be
improved or added include:
@begin(itemize)
Allow timeouts so CMS Kermit does not wait forever if a packet does
not arrive in a timely fashion.

Allow any binary file to be sent and received properly, not only fixed
format binary files.

Better keyword parsing, which is rather crude at this time.

Support of the more advanced server functions.

Addition of a RUN command.

Ability to SET LINE, so that Kermit-CMS can be used as a local
Kermit, connecting to a remote host over another communication port.
@end(itemize)