Network Working Group G. Deloche
Request for Comments: 11 UCLA
 August 1969
 Implementation of the Host - Host
 Software Procedures in GORDO
TABLE OF CONTENTS
 Chapter Page
 ------- ----
 1. Introduction . . . . . . . . . . . . . . . . . . . . . . . 1
 2. HOST - HOST Procedures . . . . . . . . . . . . . . . . . . 2
 2.1 Generalities . . . . . . . . . . . . . . . . . . . . 2
 2.2 Connections and Links . . . . . . . . . . . . . . . . 2
 2.2.1 Definitions . . . . . . . . . . . . . . . . . 2
 2.2.2 Connection types . . . . . . . . . . . . . . . 3
 2.3 Message Structure . . . . . . . . . . . . . . . . . . 5
 2.4 User Transactions . . . . . . . . . . . . . . . . . . 6
 2.4.1 List of transactions . . . . . . . . . . . . 7
 2.4.2 HOST-HOST protocol and control messages . . . 8
 3. Implementation in GORDO . . . . . . . . . . . . . . . . . 11
 3.1 Introduction to GORDO . . . . . . . . . . . . . . . . 11
 3.1.1 GORDO file system . . . . . . . . . . . . . . 11
 3.1.2 GORDO process . . . . . . . . . . . . . . . . 12
 3.2 Software Organization Overview . . . . . . . . . . . 12
 3.3 Software Description . . . . . . . . . . . . . . . . 13
 3.3.1 Data structures . . . . . . . . . . . . . . . 13
 3.3.1.1 Allocation tables . . . . . . . . . . 13
 3.3.1.2 Buffer pages . . . . . . . . . . . . 16
 3.3.2 Programs . . . . . . . . . . . . . . . . . . . 18
 3.3.2.1 Handler . . . . . . . . . . . . . . . 18
 3.3.2.2 Network . . . . . . . . . . . . . . . 19
 3.4 Software Procedures . . . . . . . . . . . . . . . . . 20
 3.4.1 Description of some typical sequences . . . . 20
 Appendix A: Flowcharts . . . . . . . . . . . . . . . . . . . 23
 [[RFC Editor Note: [s] represents subscript s]]
1. INTRODUCTION
 This technical note concentrates upon (1) the HOST-HOST procedures
 and (2) the implementation of the corresponding programs in GORDO
 (Operating System of the UCLA HOST).
 The first section is closely related to the BBN reports No. 1822 and
 1763[1] and specifies the HOST functions for exchanging messages. It
 mostly deals with links and connections, message structure,
 transactions, and control messages.
 The second section is software oriented; it explains how the HOST
 functions are implemented and integrated into GORDO. It is involved
 with data structures, programs, buffers, interrupt processing, etc.
 [1] Parts of this section are taken from or referred to those
 reports.
2. HOST-HOST PROCEDURES
2.1 Generalities
 The basic idea is that several users, at a given HOST, should
 simultaneously be able to utilize the network by time-sharing its
 physical facilities.
 This implies that within each HOST operating system, there must exist
 a special program that multiplexes outgoing messages from the users
 into the network and distributes incoming messages to the appropriate
 users. We will call this special program the Network program.
2.2 Links and Connections (See figure 1)
 2.2.1 Definitions
 It is convenient to consider the Network as a black box - a system
 whose behavior is known but whose mechanisms are not - for
 communicating messages between remote users rather than between pairs
 of HOST computers.
 (a) Logical connections
 We define a logical connection as being a communication path
 linking two users at remote HOST[s].
 With that concept, a user (user program) in a HOST computer can
 (1) establish several logical connections to any remote HOST
 users, and (2) send or receive messages over those connections.
 Connections appear to users as full duplex.
 One of the purposes of the Network program is to serve the
 users in establishing, identifying, and maintaining these
 connections.
 (b) Logical links
 Each logical connection is made of a pair of directional links:
 one for transmitting, the other for receiving.
 Those links, called logical links, are established by the
 Network programs and used by them.
 Note here that users are only interested in connections and are
 completely unaware of links. Relationships between links and
 connections are carried out by the Network program.
 One of the advantages to define a connection as a pair of
 directional links is that a HOST will have the capability to
 loop himself through its IMP (it opens a connection to
 himself). This feature can be useful for debugging purposes.
 Further on through this paper we will not use any more the
 attribute logical when referring either to links or
 connections.
 2.2.2 Connection types
 In order to reach a high flexibility in utilizing the Network there
 is advantage to classify the connections.
 Three types of connections are distinguished: (a) control
 connection, (b) primary connection, and (c) auxiliary connection.
 (a) Control connection
 This connection has a special status and is unique between a pair
 of HOST[s], e.g., if the Network includes x HOST[s], there are at
 most x control connections issued from one HOST.
 This connection is used by remote Network programs for passing
 control messages back and forth. Control messages are basic to
 the establishment/deletion of standard connections. (See 2.4.2)
 Note here that this control connection is the only connection
 which is not used by the HOST users.
 Let us describe now the standard connections.
 (b) Primary connection
 These connections connect remote users.
 A primary connection:
 * Is unique between a pair of users and is the first to be
 established.
 * Is "teletype-like", i.e.:
 - ASCII characters are transmitted;
 - Echoes are generated by the remote HOST;
 - The receiving HOST[s] scan for break characters;
 - The transmission rate is slow (less than 20
 characters/sec).
 * Is mainly used for transmitting control commands, e.g.,
 for log-in into a remote HOST operating system.
 (c) Auxiliary connection
 These connections also connect remote users:
 An auxiliary connection:
 * Is opened in parallel to a primary connection and is not
 unique, i.e., several auxiliary connections can be
 established between users.
 * Is used for transmitting large volumes of data (file
 oriented).
 * Is used either for binary or character transmission.
 [Figure 1 - Links and Connections - see PDF file]
2.3 Message Structure
 The HOST[s] communicate with each other via messages. A message may
 vary in length up to 8095 bits (See down below the structure).
 Larger transmission must therefore be broken up by HOST users into a
 sequence of such messages.
 A message structure is identified on figure 2.
 It includes the following:
 (1) A leader (32 bits): Message type, Source/Destination HOST,
 link number. (See BBN report No. 1822, pp 13, 17)
 (2) A marketing (32 bits when sent by the Sigma 7) for starting a
 message text on a word boundary. (See BBN report No. 1822,
 pp. 17, 19)
 (3) The message text (Max: 8015 bits for the Sigma 7). It mostly
 consists of user's text. However, it may represent
 information for use by the Network programs. (Control
 messages, see 2.4.2)
 (4) A checksum (16 bits). Its purpose is to check, at the HOST
 level, the right transmission of a message. (Changes in bit
 pattern or packet transposition; packets are defined in BBN
 report No. 1763, p. 13) See down below for checksum
 calculation.
 (5) A padding for solving word length mismatch problems. (See BBN
 report No. 1822, p. 17, 19.). As far as software is
 concerned, padding is only involved at message reception for
 delineating message ends. (At transmission the hardware takes
 care of the padding.)
 Remark:
 Checksum calculation:
 The last 16 bits of every message sent by a HOST is a checksum.
 This checksum is computed on the whole message including any
 marking, but excluding the 32 bit leader and any padding. To
 compute the checksum:
 1. Consider the message to be padded with zeroes to a length of
 8640 bits.
 2. Section the 8640 bits into six 1440-bit segments, S0, S1...S5.
 3. Section each 1440-bit segment S into 90 16-bit elements, T0,
 T1...T89.
 4. Define a function [(+)], which takes two 16-bit elements as
 inputs and outputs a 16-bit element. This function is defined
 by
 Tm [(+)] Tn = Tm [(+)] Tn, if Tm + Tn < 2[exp 16]
 Tm [(+)] Tn = Tm [(+)] Tn - 2[exp 16] + 1, if Tm + Tn >= 2[exp
 16]
 5. For each 1440-bit segment Si compute Ci = K(Si), where
 K(S) = T0 [(+)] T1 + ..... T89
 6. Computer C =
 C0[(+)]C1[(+)]C1[(+)]C2[(+)]C2[(+)]C2[(+)]C2....[(+)]C5
 (Notice that C1[(+)]C1 is just C1 rotated left one bit)
 The number C is the checksum. The reason the Ci are rotated by i
 bits is to detect packet transposition.
 [Figure 2 - Format of a message sent by the Sigma 7 - see PDF file]
2.4 User Transactions
 From what has been discussed until here, the Network appears to a
 user as a bunch of connections. Let us now explain how one can make
 use of these connections.
 First, we are going to describe the set of transactions that a user
 should be able to access for utilizing the connection facilities.
 Then, we are going to explain the role of the Network program for the
 execution of these transactions. This will cover a HOST-HOST
 protocol in which control messages are exchanged between network
 programs.
 For explanation purposes those transactions are represented, at the
 user level, in the form of subroutine calls and parameters. However,
 this does not imply at all that the implementation will closely
 follow this pattern. (We are more involved here with the description
 than the implementation aspect, see chapter 3.)
 2.4.1 List of transactions
 Listed below are the descriptions of subroutines that could be at
 user's disposal for creating/breaking connections and
 transmitting/receiving data over them. This set of subroutines can
 be considered as a kind of interface between the user level and the
 network program level.
 (a) Open primary connection:
 OPENPRIM (CONNECTID, HOSTID, BUFFADDR, [OPT])
 CONNECTID: Connection identification #
 HOSTID: Remote HOST identification #
 BUFFADDR: Buffer address for incoming messages.
 OPT: Options such as message required after successful
 connection establishment, "full echo" (each message is
 transmitted back by the remote HOST for checking purpose),
 etc.
 Remark: [ ] means optional
 (b) Open auxiliary connection
 OPENAUX (CONNECTID, BUFFADDR, N, [OPT])
 CONNECTID: Connection identification #, i.e., the
 identification of the corresponding primary
 connection (First a user has to open a primary
 connection).
 BUFFADDR: Same meaning as above.
 N: Number of auxiliary connections that should be opened.
 OPT: Same meaning as above.
 (c) Transmission over connection
 TRANSM (CONNECTID, NO, BUFFADDR, N, [OPT])
 CONNECTID: Connection identification #
 NO: Connection #. The primary connection is always referred to
 as being NO=0. An auxiliary connection number corresponds
 to the order in which it has been established. (The first
 auxiliary opened is referred to by NO=1, the second by
 NO=2, etc.)
 BUFFADDR: Buffer address of the message to be transmitted.
 N: Message size (byte number)
 OPT: Options such as data type (characters vs. binary), trace
 bit, etc.
 (d) Close connection
 CLOSE (CONNECTID, [N], [NO])
 CONNECTID: Connection identification #.
 N: Number of connections to be closed. If omitted all
 connections in use by the user, included the primary link,
 are closed.
 NO: In case of N different from zero this number indicates the
 auxiliary connection # to be closed.
 2.4.2 HOST-HOST protocol and control messages
 The HOST-HOST protocol is carried out by the Network programs. It
 mainly involves the execution of the previous transactions (initiated
 by users) and covers a HOST-HOST dialogue.
 This dialogue fulfills control procedures for opening or breaking
 connections and consists in exchanging control messages over the
 control link. A control message has a structure identical to that of
 a regular message; it only differs from it by the text which is for
 use by Network programs instead of users.
 Let us insist that this control procedure is completely unrelated to
 transmission control procedures implemented in the IMP computers. We
 are here at the HOST level (Network programs), and therefore control
 messages, that are going to be described below, are transmitted over
 the IMP[s] like regular messages.
 Consider now the previous transactions and describe for each of them
 which messages are exchanged over which links. Each case will be
 explained by means of trivial examples.
 We suppose that a HOST(x) user wants to a remote HOST(y) program
 called URSA.
 (a) Open a primary connection: (OPENPRIM)
 The HOST (x)'s Network program, waken up (See 3.3) by a use for
 opening a primary connection, starts a dialogue with the HOST
 (y)'s Network program.
 (i) HOST(x) sends the following control message:
 HOST(x) Control link HOST(y)
 -------------------->
 ENQ PRIM 0 1 2
 ENQ: Enquiry for connection establishment (one ASCII
 character)
 PRIM: Connection type: primary (one special character)
 0 1 2: Outgoing link #. It is a decimal number (3 ASCII
 characters), e.g., link #12.
 This link # has been determined by the HOST(x)
 Network program (See implementation: 3.3)
 (ii) HOST(y) acknowledges by sending back the following control
 message:
 HOST(x) Control link HOST(y)
 <------------------------
 ACK ENQ PRIM 0 1 2 0 1 5
 ACK: Positive acknowledgment (one ASCII character)
 ENQ PRIM 0 1 2: Same meaning as above. This part of the
 message is returned for checking purposes.
 0 1 5: Incoming link #. It follows the same pattern as
 the outgoing link #. This link # has been
 determined by the HOST(y) Network program.
 Now the connection is established; it will use
 links #12 and 15 for exchanging user messages.
 The connection is said to be in a pre-log-in
 state, i.e., the remote HOST(y) expects its
 standard log-in procedures.
 (b) Transmission over primary connection: (TRANSM)
 By means of TRANSM subroutines referring to the primary
 connection, the HOST(x) user is able to sign-in into the
 HOST(y) operating system and then to call for the URSA program
 (HOST(y) user program).
 The Network programs at both ends will use the link #12 and #15
 for passing along messages. These messages are standard
 messages whose contents serve for log in sequence.
 A trivial example could be:
 HOST(x) Prim. Link #12 HOST(y)
 ---------------------------->
 ! S I G N - I N : X X
 HOST(x) Prim. Link #15 HOST(y)
 <--------------------------
 ! ! R E A D Y
 HOST(x) Prim. Link #12 HOST(y)
 ---------------------------->
 ! U R S A
 (c) Open an auxiliary connection: (OPENAUXI)
 In a very similar manner as (a) an auxiliary connection is
 established between HOST(x) and HOST(y). For so doing control
 messages are exchanged over the control link.
 HOST(x) Control link HOST(y)
 ------------------------------>
 ENQ AUX 0 2 5
 HOST(x) Control link HOST(y)
 <--------------------------------
 ACK ENQ AUX 0 2 5 0 2 1
 Now the auxiliary connection is established, it will use links
 #25 and 21 for exchanging standard messages.
 (d) Transmission over auxiliary connection: (TRANSM)
 By means of TRANSM subroutines referring to the auxiliary
 connection, the users at both ends can exchange data:
 HOST(x) Aux. Link #25 HOST(y)
 -------------------------------->
 X X ..... X X
 HOST(x) Aux. Link #21 HOST(y)
 <--------------------------------
 X ......... X
 etc.......
 (e) Close connections: (CLOSE)
 This is carried out in a similar manner as (a). The user calls
 a CLOSE subroutine and then the Network programs at both ends
 exchange control messages.
 HOST(x) Control Link HOST(y)
 ----------------------------->
 EOT 0 0 1 0 1 2
 EOT: End of transmission (one ASCII character)
 0 0 1 : No. of connections to be closed (3 decimal ASCII
 characters)
 0 1 2 : Outgoing link # to be closed.
 Then HOST(y) acknowledges back as in (a).
 HOST(x) Control Link HOST(y)
 <-----------------------------
 ACK EOT 0 0 1 0 1 2 0 1 5
 Remark 1 - In (a), (c), and (e) HOST(y) may answer back a
 message including a negative acknowledgement character NAK
 instead of ACK. This for many various reasons such as: wrong
 sequence, connection already opened, and so forth. The message
 could be NAK IND, where IND is an alphanumerical character
 indicating, in a coded form, why the previous block has been
 refused. Upon receiving back such acknowledgments HOST(x) will
 repeat its message until HOST(y) accepts it. An emergency
 procedure will take place if too many successive "NAK messages"
 occur.
 Remark 2 - On each of the above illustrations (arrows) only the
 message text is represented. In fact, complete messages (with
 leader, marking, padding...) are exchanged over these links.
3. IMPLEMENTATION IN GORDO
3.1 Introduction to GORDO
 GORDO is a time-sharing system implemented on SDS Sigma 7. We
 outline below some of the characteristics relevant to our paper.
 3.1.1 GORDO file system
 The file system is page oriented. It is composed of files and
 directories. A file consists of a heading and a number of pages
 which compose the body of the file. A directory consists of a number
 of entries that point to either files or other directories.
 3.1.2 GORDO process
 * A process is a program (procedures and data) plus its logical
 environment. In other words a process is a program which is known
 and controlled by the GORDO scheduler.
 * A user (a job) may have several processes as different as
 compiler, loader, editor, application program, etc. A process is
 created through a system call (FORK).
 * The space a process can refer to is the Virtual Space of 128k word
 length. A part (8k) of it is reserved for the operating system,
 the other part (120k) is directly accessed by the user. This
 later may fill or modify its part of the virtual space upon
 'coupling'. (See below: service calls) pages taken from different
 files. Figure 3 illustrates this coupling.
 * A process can request for services by means of system calls. The
 system calls relevant to our paper are:
 WAKE for awaking (set active) a sleeping process
 SLEEP for putting asleep another process (or itself)
 COUPLE for coupling a page from the file space to the virtual
 space.
 * A process ordinarily runs in slave mode. However if it is set up
 as an I/O process it can access privileged instructions.
 * Processes can share data through files attached to "mail box"
 directories.
 Remark: Through this note the words process and program are used
 inter-changeably.
 [Figure 3 - Virtual Space and Coupling - see PDF file]
3.2 Software Organization Overview
 Figure 4 illustrates the overall organization.
 The system is based upon two main programs: the "Network" and the
 "Handler".
 The Handler is an I/O interrupt routine closely related to the IMP-
 HOST hardware interface. It serves the Network process in
 transmitting an receiving network messages.
 The Network process carries out most of the work.
 Its main function is to satisfy the users' requests for opening/
 closing connections and transmitting/receiving network messages. For
 so doing,
 * it establishes, identifies, and breaks the links upon using the
 allocation tables (HOST, CONNECT, INPUT LINK; see 3.3.1.1)
 * it is aware of the presence of new users upon exploring the
 Network mail box directory;
 * it communicates with active users by means of shared pages through
 which messages and requests are exchanged (connection shared
 pages);
 * it formats incoming/outgoing messages in a working page. This
 working page has an extension (emergency ring);
 * it communicates with the Handler by means of a shared page (I/O
 communication page) which contains the I/O communication buffers.
 [Figure 4 - Software organization overview - see PDF file]
3.3 Software Description
3.3.1 Data Structures
 3.3.1.1 Allocation tables: HOST, CONNECT, INPUT LINK
 The Network program establishes, identifies, and breaks links and
 connections upon using 3 tables:
 A table sorted by remote HOST #.
 A table sorted by connection #.
 A table sorted by input link #.
 (a) HOST table (see figure 5)
 It is a bit table indicating the free outgoing links. It
 has the following characteristics:
 * Location: Disc resident
 * Coupling: Coupled to the Network process virtual space.
 * Size: As many slots as remote HOST[s].
 * Slot structure: As many bits as possible outgoing links
 to a remote HOST, i.e., 256.
 * Access: Indexing. Each slot is accessed through a remote
 HOST #.
 * Specific feature: Throughout the whole table no more
 than 64 bits can be turned on. This
 figure corresponds to the maximum
 number of outgoing links that can be
 activated at one time (No matter what
 is the number of remote HOST[s]).
 (b) CONNECT table
 This table keeps track of all the connections' environment.
 It has the following characteristics:
 * Location: Disc resident
 * Coupling: Couples to the Network process virtual space
 * Size: As many slots as connections in use.
 * Slot structure: See figure 6. Each slot is 2 word
 length
 * Access: Indexing. Each slot is accessed through a
 connection #. See 3.4 the way it is handled.
 * Specific feature 1: The slot structure corresponding to
 a primary connection is not
 identical to that of an auxiliary
 connection (See figure 7). This
 because user identifications and
 requests are done through primary
 shared pages.
 * Specific feature 2: This table is handled in parallel
 with the connection pages (See 3.3.2
 (b))
 * Specific feature 3: This table is mainly used for
 transmitting messages. (For each
 connection it contains the outgoing
 link # and remote HOST #, i.e., all
 the information required for
 transmitting a message.)
 (c) INPUT LINK table
 This table keeps track of all the incoming (input) links and
 so is closely related to the CONNECT table.
 [Figure 5 - HOST table - see PDF file]
 [Figure 6 - CONNECT table: Slot structure - see PDF file]
 [Figure 7 - INSERT LINK table: Slot structure - see PDF file]
 It has the following characteristics:
 * Location: Disc resident.
 * Coupling: Coupled to the Network process virtual space.
 * Size: As many slots as incoming links, i.e., as
 connections
 * Slot structure: See figure 7. Each slot is 1 word
 length
 * Access: Hashing. The hashed key value is mainly based
 upon the incoming link # and the remote HOST #.
 * Specific feature 1: This table is also used for
 momentarily memorizing the
 connection number while establishing
 the next connection. See 3.4 the
 way it is handled.
 * Specific feature 2: This table is primarily used upon
 receiving messages. (For each
 incoming link it contains the
 corresponding connection #, i.e.,
 indirectly the user identification
 to which the message should be
 passed along)
 3.3.1.2 Buffer pages
 All the pages that are now to be described contain two buffers
 (input and output). These buffers are used for either passing
 along or processing messages.
 The size of each of these buffers should at least be equal to that
 of a message, i.e., 8095 bits. We have chosen a buffer size of
 253 words (8096 bits) so that both of the buffers are included
 within one page (512 words). The 6 remaining words of the page
 are generally used for control.
 A typical buffer page structure is identified on figure 8.
 (a) I/O communication page
 See figure 9.
 This I/O communication page is used as an interface between the
 Handler and the Network program.
 In the buffers of this page the messages are assembled (input)
 or de-assembled (output) word by word by the Handler, e.g., a
 "ready to go" message, sorted by the Network program in the
 output buffer, is shipped out word by word by the Handler.
 Main characteristics:
 * Location: Resident in core: Locked page
 * Coupling: Coupled to the Network process virtual space
 * Content: * Input buffer (253 words) for incoming messages
 Output buffer (253 words) for outgoing messages
 * Input control zone (6 half words)
 * Output control zone (6 half words)
 * Structure: See figure 9.
 * Specific feature: * The input buffer is filled by the
 Handler (read from hardware) and emptied
 by the Network program
 * Vice versa for the output buffer
 (b) Connection shared pages (User-Network shared zone)
 General features:
 * There are as many shared pages as connections.
 * These pages shared between the network and the user
 processes constitute a communication zone for (1) passing
 the messages back and forth, and (2) exchanging control
 information, e.g., a request for establishing new
 connections.
 Main characteristics:
 * Location: Disc resident
 * Coupling: Coupled to both a user process virtual space and
 the
 network process virtual space.
 * Content: - Input buffer (253 words) for incoming messages
 - Output buffer (253 words) for outgoing messages
 - Input control zone (6 half words)
 - Output control zone (6 half words)
 * Structure: See figure 10.
 * Specific feature 1: - The input buffer is filled by the
 Network and emptied by the user.
 - Vice versa for the output buffer.
 * Specific feature 2: The control zone corresponding to a
 primary connection shared page differs
 from that of an auxiliary connection.
 This because it is via a "primary
 connection control zone" that
 auxiliary connection establishment
 requests are transmitted to the
 Network process.
 (c) Working page
 General feature:
 * This page allows the Network and the Handler programs to
 work independently on different messages and so contributes to
 an overlapping. For instance, when the Handler is busy
 transmitting a message to the hardware, the Network program can
 format (leader, marking, etc.) the reset message to be shipped
 out, so that it can reinitiate the Handler as soon as it is
 free.
 Main characteristics:
 * Location: Disc resident
 * Coupling: Coupled to the Network process virtual space
 * Content: - Input buffer (253 words) for incoming messages
 - Output buffer (253 words) for outgoing messages
 Remark:
 During reception it may happen that a user program is not ready
 to accept a new message. In that case, to avoid clogging up
 the system, the Network stores momentarily the incoming message
 in one of the buffer of the emergency ring. (If this ring is
 full a help routine will be invoked.)
 During emission all operations are synchronized with the
 RFNM[s], therefore such procedures need not be provided. (The
 Network program allows a user to re-emit only when having
 received the RFNM of the previous transmitted message.)
 [Figure 8 - Typical buffer page - see PDF file]
 [Figure 9 - I/O Communication page structure - see PDF file]
 [Figure 10 - Connection shared page structure - see PDF file]
3.3.2 Programs
 3.3.2.1 Handler program
 General features:
 It is an I/O interrupt routine which drives the IMP/HOST hardware
 interface in order to transmit or receive messages. Transmission
 and reception are carried out in a full duplex mode.
 Main characteristics:
 * Location: Core resident. The Handler is in the same memory
 zone as the operating system and can be considered
 as part of it.
 * Initiation: By the IMP-HOST hardware interrupt. This interrupt
 is triggered either:
 * during transmission when a message word is
 completely sent to the IMP
 * during reception when a message word has been
 completely received from the IMP
 * during idle time when the hardware received
 either a 'start input' or 'start output' order
 from the Sigma 7 CPU. Those orders are issued by
 the Network program for provoking interrupts back
 (consequently for indirectly initiating the
 Handler).
 * Main functions: * Empties the output buffer upon transmitting
 its content (outgoing message to the IMP.
 This operation is carried out word by word
 (32 bits) and makes use of "Write" orders for
 driving the HOST-IMP hardware.
 * Fills the input buffer with data received
 from HOST-IMP hardware (incoming message).
 This operation is also carried out word by
 word and makes use of "Read" orders for
 driving the HOST-IMP hardware.
 * Wakes up the Network program when any of the
 previous operations is complete.
 3.3.2.2 Network program
 General features:
 This program serves the user for opening/closing connections and
 transmitting/receiving messages. It uses the Handler as an aid
 for inter-facing with the hardware.
 For the GORDO point of view it is a regular process and treated as
 such.
 Main characteristics:
 * Location: Disc resident. More precisely it is on disc when
 asleep and called in core when awakened by a
 program.
 * Initiation: It is initiated through 'WAKE' service calls
 issued either by a user process or by the Handler.
 * Main functions: * Establishes/deletes outgoing connections upon
 users' requests. For so doing it sends
 control messages (see 2.4.2) to remote
 HOST[s] in order to get links
 established/released; it then notifies back
 the users.
 * Insures the processing of incoming control
 messages (transmitted over control links),
 e.g., for contributing to
 establishments/deletions of connections
 (those requested by remote HOSTS).
 * Prepares transmission of outgoing messages.
 It picks up text messages from shared pages
 (the messages are stored there by users),
 formats them (adds leader, marking,
 checksum..), and passes them along to the
 Handler for transmission.
 * Insures delivery of incoming messages. It is
 the opposite of the above operation. The
 users to which the messages should be
 delivered are identified through the leaders.
 * Virtual space configuration: See figure 11.
 * Specific feature: It is integrated as an I/O process, so that
 it can access privileged instruction (RD/WD
 for indirectly initiating the Handler).
 [Figure 11 - Network Process Virtual Space - see PDF file]
3.4 Software Procedures
 The detailed software procedures are given on the flowcharts attached
 with Appendix A.
 However, to get a quick understanding of the implementation we list
 below some typical software procedures.
3.4.1 Description of some typical sequences
 Consider some of the transactions at user's disposal (See 2.4) and
 point out the basic software procedures they imply. For each case we
 will delineate (i) what the user program does and (ii) what the
 Network program does.
 (a) Open a primary link (See also 2.4.2)
 (i) What the user program does[1]:
 * it stores in the Network mail box directory the name of
 a file, e.g., DATA;
 * it couples the first page of this file to its virtual
 space;
 * it stores information in this page (its job/process #,
 the remote HOST #, e.g., (i));
 * it wakes up the Network process;
 * it goes to sleep.
 (ii) What the Network program does:
 * it explores the Network mail box directory and accesses
 the file DATA;
 * it couples the first page of this file to its virtual
 space (Shared Zone, see 3.3.1.2). Suppose this page to
 be kth in the shared zone; k is the internal connection
 #;
 * it explores the ith slot of the new HOST table (See
 3.3.1.1 (a)) and selects the first bit = 0, e.g., the
 (alpha)th bit; alpha corresponds to the outgoing link
 #;
 * it stores information (job/process #, remote HOST #
 (i), outgoing link # (alpha)) in the kth slot of the
 CONNECT table (See 3.3.1.2).
 * it momentarily stores the connection # (k) in the INPUT
 LINK table. This is carried out upon creating an entry
 in this table (Hashing the key value: "outgoing link #
 (alpha) + remote HOST # (i) + outgoing flag".);
 * it prepares the message text ENQ PRIM 0 0 a and formats
 a complete message in adding leader, marking, checksum,
 etc.;
 * it checks the Handler state (bit in I/O locked page).
 If the Handler is free, it stores the 'ready to go'
 control message in the output buffer of the I/O locked
 page, initiates the Handler, and goes to sleep. Else
 it goes to sleep.
 After a while the Handler wakes up the Network process because it has
 received a complete message. We suppose this message be the control
 message sent by the remote HOST for acknowledging the establishment
 of the connection. The message text should be:
 ACK ENQ PRIM 0 0 alpha 0 0 beta
 where beta is the incoming link #. (See 2.4.2)
 Let's see now what the Network program does when receiving the above
 control message:
 * it retrieves the connection # previously stored in the
 INPUT LINK table upon re-hashing the same key value
 (See above). Also it deletes this entry;
 * it creates an entry in the INPUT LINK table for the
 incoming link. For so doing it hashes the key value:
 "incoming link # (beta]) + remote HOST # (i) +
 "incoming flag". In this entry it stores the HOST #
 (i), the incoming link # (beta), and connection # (k);
 * it updates the kth slot of the CONNECT table in storing
 the incoming link # (beta);
 * it turns on the 'net-user' bit in the kth shared page
 (page corresponding to the primary connection that has
 just been opened) and wakes up the user process;
 * it goes to sleep.
 (b) Transmit a message over primary link
 (i) What the user program does[1].
 * it stores the message text in the output buffer of the
 primary connection shared page (see 3.3.1.2);
 * it turns on the 'user-net' bit of this page and wakes
 up the Network process;
 * it goes to sleep.
 (ii) What the Network program does:
 * it looks for user request, i.e., it explores in
 sequence the connection shared pages and selects the
 one that has its 'user-net' bit turned on. Suppose k
 be the selected page # on the shared list, K is the
 connection #;
 * it determines the request type in testing the 'request
 bits' of the shared page k. It finds out that it is a
 request for transmitting a message.
 * it takes the message text from the output buffer of the
 shared page k, formats it into a complete message and
 transmits to the Handler in a very similar way as above
 (See Open a primary link).
 * it goes to sleep.
 [1] Remark: In a first phase the user will directly write the
 network functions in his program. Later on
 subroutines will be put at user's disposal. These
 subroutines will be very close to those described in
 2.4.
APPENDIX A
 Flowcharts
 [see PDF file for flowcharts]
 [ This RFC was put into machine readable form for entry ]
 [ into the online RFC archives by Bob German 8/99 ]