⟦cf69b28b0⟧

TextFile


                   How to use DFS Kermit on the R1000

                   Gerry Smith (GJS)   March 10, 1993


Introduction
============
Kermit is a file transfer protocol which allows the transfer of ASCII or
binary files over some asynchronous communications medium.  DFS Kermit
uses the R1000's internal 1200 baud phone line for a communications port
and transfers program, text, or kernel files between the DFS File System
and some other machine running Kermit as well.  This document assumes the
'other' machine is a R1000 running the Environment but in fact it could be
any machine with Kermit and access to a originating 1200 baud modem.  


Operation
=========
DFS Kermit is very simple to use, but it does require a person to be
present at both the DFS and Environment machines.  All that is required
is starting DFS Kermit at the remote machine (see #1 below) and building
a series of Kermit.commands in a Environment command window (see #2 below).
From then on all operations are controlled from the Environment machine
by these commands and some minimal user interaction with the remote DFS
Kermit over the communications line.

It is important to start the remote DFS Kermit befor initiating the phone
call.  If this is not done the DFS Kermit may not start correctly and you 
will need to wait out several Environment end timeouts. 

A typical file transfer consists of the following.

1. At the remote DFS machine:
-----------------------------
   - attach a phone line to the R1000's built in modem
   - "Enable Modem ANSWER" in BOOT/CRACH/MAINTENANCE options
   - boot machine to CLI>
   - give the command: x kermit <return>
   
   At this point the DFS Kermit will start waiting for a phone call.  Once
   received, it will then wait for commands from the Environment user and
   no further intervention should be needed at the console.  As each file
   transfer completes, DFS kermit waits for another command.  If the phone
   connection is broken, DFS kermit will wait for another call.
   There is a 5 minute timeout when DFS kermit is waiting for input from
   the Environment machine's user.  Unattentive users may find that it has
   announced itself, hung up the phone, and is waiting for another call.

   
2. At the local Environment machine:
------------------------------------
   Build and promote the following series of Kermit commands:
   - kermit.call     Makes connection to the local modem bank via Telnet
   - kermit.connect  Provides communications with modem and remote machine
   - kermit.options  Required for binary transfers, omitted for text transfers
   - kermit.send     Causes the local Environment Kermit to send a file
       or  .receive  Causes the local Environment Kermit to receive a file
   - kermit.clear    Closes Telnet connection and hangs up phone
   
   During execution of the Connect command, the user will be prompted for
   a phone number by the modem, and for commands by the remote DFS Kermit
   as follows:
            
   Modem:       CDS >d 9w14085551234            { dials (408) 555-1234 } 

   DFS Kermit:  Rational DFS Kermit 1.0    { DFS kermit command prompt }
                Send, Receive, Quit ?       
                
     S  -  starts remote Send operation, prompts user for file_name
     R  -  starts remote Receive operation, prompts user for file_type         
     Q  -  Quits  remote DFS Kermit, returns to CLI> prompt. 
   
   Note:  The SEND and RECEIVE notation is relative to each machine.
          Therefor, going to the DFS machine requires a Environment SEND
          and a DFS RECEIVE and going to the Environment machine require 
          a Environment RECEIVE and a DFS SEND.

   

Examples
========
1. Send two Binary files to DFS Machine
---------------------------------------                   User filled in fields
                                                                          |
declare                                                                   |
    use Editor, Text, Common;                                             V
begin
    Kermit.Call (To => "DIAL_24");                                       <--
    Kermit.Connect (Port => Kermit.Port,
                    Terminal_Port => Kermit_Defs.Current_Port,
                    Escape => Kermit.Escape,
                    Log => "",
                    Local_Echo => False,
                    Options => Kermit.Options.Physical,
                    Terminal_Options => Kermit_Defs.Default.Physical);
    Kermit.Options.Kind := Kermit.Binary;                                <--
    Kermit.Options.Binary := '&';                                        <--
    Kermit.Send (Source => "FILE_NAME1",                                 <--
                 Target => "FILE.NAME1",                                 <--
                 Port => Kermit.Port,
                 Options => Kermit.Options);
    Kermit.Connect (Port => Kermit.Port,
                    Terminal_Port => Kermit_Defs.Current_Port,
                    Escape => Kermit.Escape,
                    Log => "",
                    Local_Echo => False,
                    Options => Kermit.Options.Physical,
                    Terminal_Options => Kermit_Defs.Default.Physical);
    Kermit.Send (Source => "FILE_NAME2",                                 <--
                 Target => "FILE.NAME2",                                 <--
                 Port => Kermit.Port,
                 Options => Kermit.Options);
    Kermit.Clear (Port => Kermit.Port);
end;  


2. Get text file from DFS machine
---------------------------------

declare
    use Editor, Text, Common;
begin
    Kermit.Call (To => "DIAL_24");                                       <--
    Kermit.Connect (Port => Kermit.Port,
                    Terminal_Port => Kermit_Defs.Current_Port,
                    Escape => Kermit.Escape,
                    Log => "",
                    Local_Echo => False,
                    Options => Kermit.Options.Physical,
                    Terminal_Options => Kermit_Defs.Default.Physical);
    Kermit.Receive (Target => "FILE_NAME",                               <--
                    Port => Kermit.Port,
                    Options => Kermit.Options);
    Kermit.Clear (Port => Kermit.Port);
end;



Kermit Notes
============
1. DFS Kermit operates on the assumption that the communication medium uses
   7 data bits plus parity, (parity being ignored).  Binary file transfers
   use a mechanism called "eigth bit prefixing" along with the normal "control
   character prefixing" to get around this communications line restriction.
   
2. DFS Kermit was written specifically to communicate with Rational's
   Environment Kermit.  Many of the file transfer parameters are "hard wired"
   to be compatable with the defaults of that version.  Using DFS Kermit
   with other machines might require some experimenting to find the correct
   values.
   
3. Kermit uses a packet protocol which is checksum protected and requires
   confirmation of proper reception on a packet by packet basis.  This can
   be somewhat slow but provides quite reliable data transfers.  As each 
   packet is processed a packet type identifier is displayed on the console
   terminal.
   
4. DFS Kermit has two troubleshooting modes which may be turned on or off
   from the console by interrupting normal program flow with a Ctl-C.
   One mode, Trace, is mainly for program debugging and shows program flow
   thru the various procedures.  The other, Display, outputs communications
   line characters on the console as they come and go.  This helps locate
   protocol or communication line problems.  It is helpfull to understand
   Kermit packet makeup to use this later mode.

5. For additional information on Kermit:
   - USING KERMIT, by John Kristian, Rational, (Jan-1989).
   - "How to use Kermit on the R1000" by Mike Milburn, (Feb-89).
   - !tools.kermit.rev2_5_spec.units.kermit'spec'v(1)
   - KERMIT, the book, by Frank da Cruze, Digital Press«nul»
DataMuseum.dk

Rational R1000/400 DFS Tapes

⟦cf69b28b0⟧ HLP, TextFile

Derivation

TextFile
