RFC 187
Network/440 Protocol Concept
A NETWORK/440 PROTOCOL CONCEPT 🎀
Okay bestie, this one is by Douglas B. McKay and Donald P. Karp from the IBM Thomas J. Watson Research Center in Yorktown Heights, New York. It's Request for Comments #187 (NIC #7131) in the Network Working Group. It's filed under categories C3, C4, C5, C6 and D7, and it doesn't update or obsolete anything. There's no date printed on this copy, so I'm not guessing one 🙈
This RFC is being circulated as an information RFC. Its intent is to convey some of the thinking and philosophy that went into IBM's network protocol and overall network design. 💜
INTRODUCTION ✨
Network/44O is an experimental project in computer netting that the Computer Science Department of IBM Research took on. The main goals were to understand netting, figure out the design problems, and actually build solutions to them. 🧠
Those goals have been met! A network has been built and the project is still running it. The team also talked things through with another department at Research so they could pin down a realistic user system interface. The protocol for the project's network is also the foundation for running an IBM OS network. 🔥
The Network/44O project also dug into the philosophy and architecture of network systems. The core idea behind all of it is the logical network machine.(1) The big theme is to treat every system in the network as one part of a single (large) multiprocessor system. A lot of the ideas started out as hypotheticals, but just as many came from running the actual network and learning from it. 👑
This paper describes the philosophy and definition of a network protocol that isn't tied to any particular physical configuration. That's why a big chunk of these ideas show up in IBM's two major operational networks, one of which is distributed and the other a star configuration. ⭐
(1) Intenet - Report 2, February 1, 1970, Computer Science Department, IBM Corporation, T. J. Watson Research Center, Yorktown Heights, New York.
BASIC ASSUMPTIONS 🧚
Setting up a working protocol meant spelling out a lot of network functions. These included switching control, buffer control, message control and operating control. Operating control gets extra complicated because the user can program the network as if it were one single operating system. The protocol also had to be broken down into detailed functions so it could handle error recovery and error handling. 😭
The first plan was to have two basic realms of control. Net control is the higher-level function. It recognizes and controls everything about net jobs and the execution of job steps on the network machine. There's also a communication control facility (called an "Express Interpreter") that gives fast service to every message that moves between user systems without needing the net controller to step in. 💅
---------------
| NC |
--------------- ^
| /
----> in | out /
--------------------------------
| Express Exchange |
<---- --------------------------------
out in ^
\
\That figure shows the two main functions. Messages travel in both directions and go straight through the Express Exchange, unless the Net Controller needs to act on them. We'll get into those messages later. 🦋
These two functions can run on any system in any physical configuration, as long as the control information reflects that configuration so everything keeps working. The paper doesn't mention physical configuration at all, because the protocol is flexible enough to fit any setup. For example, in a distributed net the Express Exchange passes messages straight to the next station with zero 'NC' overhead. The 'NC' only comes into play at the final destination, and for the same reason it doesn't have to be present at every station. Iconic efficiency 🌈
DEFINITIONS 💅
Before we get into protocol and control, we need the basic message content and concepts locked in. Obviously. 🙄
A transmission block is a physical entity made up of a header and text. A message (a logical thing) is made up of many transmission blocks. 🍓
------------------------------------
| Header | Text |
------------------------------------The whole point of the network is to deliver messages from one user system to another in an orderly, controlled way. To give it everything it needs to stay in control, the header carries a set of operational functions. Here they are, each with its rationale. 🫶
Action Code
This code picks the immediate destination for the transmitted blocks. The data can go directly to the user described in the DSID field, get sent to 'NC', or be handled by 'EE'. If there's any conflict between this field and any other header field, an error message goes back to the originating station. The AC does a similar job at the receiving system. It tells the communications interface (CI) whether the data block is meant for a user routine or holds control information for the CI. [The CI is the function that talks directly to the local operating system.] 🎀
Transmission Block Number
Every block in the network has a sequential number put in by the transmitting station. As the block moves through the network, each station writes its own number over the previous station's number. The point of this sequential number is to guarantee that no messages get lost in the physical communications process. 🔥
Network Job Identifier
This field ties a transmission block to the network job it belongs to. The identifier is assigned to the network job, and to each related transmission block, by either the user system or the 'NC'. To make sure every job has a unique name inside the network, the user node identifier (the name of the user system that started the net job) gets concatenated with a number generated by the originating user system. 🧩
Job Step (Marker)
This field uniquely identifies a job step inside a network job. The NC assigns this name, since it keeps control of all network jobs. 👑
Originating System Identifier
To route a block of data from one user system to another, every user system needs a unique name. The network control group assigns that name when the user system is accepted as a network participant. Any station sending a block of data puts its assigned identification in this field of every block that starts from its system. 💖
Message Priority
This field shows the transmission priority of a block within the queue for a particular user system. Don't mix it up with processing priority, because they're different things! ✨
Destination System Identifier
This works like the originating system identifier, except the identification inserted is for the node the block is headed to. 🦋
Logical Message Flags
The message flags mark the first and last blocks of a message. All the blocks in between are identified by not having either flag. Together with the logical message sequence number, the flag field lets the user figure out if any blocks are missing from a message. It also gives an identifier that can be used to recover the missing blocks. When the first and last indicators are both on in a single block, the whole message fits in that one block. 🌸
Logical Message Sequence Number
This field numbers the blocks within a message in sequence. The first block (the one marked by the LMID) holds the lowest number assigned in the message, which isn't necessarily 1. The last block holds the highest number. Unlike the TBN, this number stays the same for the whole trip through the network. It's used for error detection and recovery, together with the logical message flag. 🧠
Logical Message Identifier
Every communications line in the network can be multiplexed, which means blocks from one message get interleaved with blocks from other messages. So each message needs an identifier to put it back together at the user destination. That's why every block in a message carries an identifier unique to that message. When the message fits in one block, the identifier does nothing. 🙈
When a message spans multiple blocks, the LMID lets the user reassemble it. Any logical message can be made of any number of physical message blocks. It's important that this LMID gets used in the messages the CI generates in response to NC commands. 💅
Length of Text
This field holds a binary number equal to the number of characters in the text portion of the transmission block. There are other ways to get this number, but it's included in the header for redundancy check purposes. 🌈
Logical Message Structuring
The network controller keeps control over every user job submitted under its NJID. The hierarchy below sets up the message configuration. Any message for any step in a network job can be tracked and retransmitted if needed. It maps the logical structure of any network job onto its matching message configuration. Slay 🧚
Net Controller
-------------------------------
| | |
NJID(1) NJID(2) - - - NJID(N)
---------------------- . . . . .
| |
Stepname Stepname
-------------------------------
| | |
LMID(1) LMID(2) LMID(n)
-----------------------------------
| |
LMSN(1) LMSN(2) LMSN(n)The Express Exchange is a combination of functions. Basically it's a communication handler and a store-and-forward switch. The 'EE' can keep track of every message in the network by TEN (defined earlier), so it's possible to record and reflect the entire status of the network down to whatever level of detail you want. Main character energy 👑
PROTOCOL 🫶
Running a network system takes different levels of control. The 'EE' has to exercise control over the communication link between any pair of stations. The NC keeps control at the net job level. The functions each unit performs also combine to handle special control cases. We'll talk through these complementary functions as they come up in the protocol discussion. 🦋
First up, a series of initialization messages has to go from one station to another before any real message transmission happens. These messages go between each pair of stations, and positive acknowledgments must come back before the initial handshake is complete. 🤝
During message transmission, an error can happen at any point, and it gets detected by a negative acknowledgment. The message in error gets retransmitted several times. If the error persists, the
line gets timed out and will be retried later 🕐 The idea is that the line might just be temporarily noisy, so we give it some time to quiesce (aka settle down and chill) 🌸
When a station gets an initialization message, it can respond in a few different ways depending on what's going on with the user system 💅 There are four options:
- The station can acknowledge that it's ready to receive and transmit ✨
- It can be temporarily unable to receive certain logical messages (the actual data transmissions), but still able to receive special control messages 🎀 This lets a user system selectively process net jobs as its facilities become available.
- It can be unable to receive traffic at all (in other words, the user system is logically or physically disconnected from the network) 💀
- It can be unable to receive new network job requests, but still able to handle traffic for jobs already in progress 🦋 The user system may have several jobs in progress that are sending and receiving messages, and this acknowledgement lets those jobs keep processing normally.
The last option gives the CI at each user system a way to selectively demultiplex itself down to handling one logical message 🧚 The source text gets cut off mid-sentence right here, so all I can say for sure is that the logical message is temporarily deactivated 🙈
Thus, all user systems can selectively halt messages throughout the entire network 🛑 The destination system can selectively halt all messages for a given NJID, or selectively halt logical messages within a net job. The adjacent system would keep accepting messages until its buffers filled up to some operational threshold limit. That limit must be maintained to keep the network from coming to a complete standstill 😱 At that point, it would issue selective halts to the systems sending to it. It's conceivable that the message blocks of one logical message would be stored in distributed segments throughout the network 🗺️
The same selective halt mechanism can be applied in reverse through a resume message ⏯️ The resume message can apply to an entire set of messages for a net job, or to selected logical messages within a job. Transmission gets reinitiated between any two stations that want to allow more message blocks to be sent 🚀 The destination station must resume on a particular logical message so that message can reach its final destination and finish transmitting through the network. The LMID in the message header lets the EE and NC cooperate on controlling and cleaning up network operation 🤝 This cooperation between logical levels doesn't just cut down on duplicated effort, it also makes the control realistic and practical. Completely separating communications and control functions could lose useful information that can't be obtained any other way 🧠
For example, say a file transmission consisted of many blocks, and a transmission error happened that the network couldn't recover from 💥 The EE would tell the NC about the error on that file transmission, then the NC would send purge messages to the EEs for those particular logical message blocks 🧹 This gives a general clean-up and management of all file transmissions ✨
There's also the case where a receiving system goes down 📉 When that happens, there may be a number of net jobs involved with that user system. If the user system stays down for an extended period and the EE buffer resources fill up to the threshold limit, it may be necessary to purge pending message blocks 🗑️ The EE will notify the NC that the user system is down, and the NC will issue purge commands to the EE for all pending messages of the net jobs involved with that down user system. However, in the current implementation, the EE uses disk storage as a logical extension of core for message buffering 💾 That makes freeing real core buffers simple: you just move the messages onto disk for later retrieval. In some transmissions, a file may be stored in segments at several locations until the receiving system is able to take it 🧩 Network buffer resources are treated as one logically simple entity, even though they may be physically distributed 🌐
When the user system comes back on the air, the involved net job gets restarted by issuing resume transmit commands to the EE ☀️ If the user is an interactive user controlling the network, they'd be notified of the problem and the status of their file transmission. They could then reinstate their command at a later time 💌 The batch net job would be restarted at a point where no unnecessary retransmission occurs 🎉
It hasn't been determined how long files should stay in a store-and-forward node before being purged from the network ⏳ If a backing storage device is available to network operation, the file can stay around longer, but still not indefinitely 🙃
NC PROTOCOL 💖
The File Transmission Protocol of the NC is mainly concerned with controlling and transferring user files for storage, temporary use at a remote system, and execution 📁
The commands and status messages that pertain to the second-level logic of the NC are sent and interpreted by the sending and receiving systems 📨 All file transfers start from direct user commands to the NC 👑
The sending system gets interrogated first to determine whether the file is resident there 🔍 The user has to provide the information needed to locate the file if it isn't catalogued at that system. This information includes physical attributes, such as volume and serial number 🗂️ A negative acknowledgement to this message results in termination of the net job step, with the reason for termination returned to the originator 🚫
When a positive acknowledgement is received by the NC, it has two options 💁 It must first determine how much unused buffer space there is in the EE. Then, based on the size of the file to be transferred, it decides whether to have the data set sent immediately or to wait for an acknowledgement to the receive message ⏱️
If the NC decides to move the file regardless of the state of the receiving system, it issues a send or receive message to both systems simultaneously 📤📥 A negative response to the receive message is taken as a definite refusal by the receiving system to accept the data transmission 🙅 This may result from insufficient resources to handle the job. If the file was transmitted from the receiving system and is resident in the network storage facilities, the user will be notified of its exact location so they can move it from that point at a later time 📍 If the NC chose the second option, the file would still be resident at the originating system 🏠
A positive acknowledgement lets the file continue its normal flow through the network 🌊 Queuing in the EE is always done so that receive messages get sent before the actual data files ✅ The possibilities include loading the file directly into the job stream (this assumes the appropriate JCL is included in the text of the files) 🧑💻, cataloguing the file at the remote system, or storing it for temporary immediate use. All network files are catalogued with a unique name that includes the User ID (unique at their home node), the home node ID (unique in the network), and their own data name, which is unique within their own work 🏷️ The receive message may also contain special instructions to print or punch a file 🖨️
When the sending and receiving stations have completed the file transfer, they send status messages back to the NC indicating the completed action ✔️ These status messages let the NC keep a record of user net job steps and their progress through the network 📒 They play an important part in making sure checkpoint restart works properly for the network 🔁
Files routed specifically for execution require a third status message from the receiving user system 🏁 The system must indicate when and how the job completed execution. This status message also contains the appropriate accounting information, so network user and system accounting can be updated dynamically 💰 It's not clear yet what should be accounted for in the network, but it's an area of prime concern to operational networks 🤔
An error in the second logic level can occur during the file transmission 😬 There may be an error moving files from devices into the line buffers, or reading from the line buffers. When this happens, the operating system must pass this information to the NC. The NC will then terminate the task involved in this job step and purge all the network buffers containing blocks of this message transmission 🧽
When the NC receives the file error message, it immediately sends a release message to all the network tasks supporting this job step 🚨 This makes the user systems end all pending tasks associated with this net job step. In addition, a purge message for that job step is sent to the EE to purge the message from its buffers. If more than one EE is involved, the purge message is passed to all the other EEs 🔄
This is another example of theEEandNCcombining their functional capabilities and providing effective management of network traffic 💪 Mapping the message into the job step lets theNCselectively choose all the messages it wishes to purge 🎯
The protocol the user must use for interactive use of the network is different 💬 There are some standard message types provided for interactive use, so messages are recognized properly from one system to another. Terminal-type traffic is sent across the network through the normal netting interface 📟 The control information that a terminal sends to the operating system must be incorporated into the network protocol by the CI 🛠️
The interactive user can request a direct connection to the remote system through the NC 📞 The NC notifies the remote system of the user's request and establishes the user's direct link. The NC becomes a monitor of the conversation, but it no longer gets involved with the messages 👀 Other conversational messages are sent back and forth through the EE with no interaction by the NC 💬 If one of the systems goes down and breaks the logical link, the NC must notify the other system to terminate the waiting task. In most cases a user system will be isolated from the second user system by other stations, so the NC is a convenient way of notifying other user systems about the "disaster" 💀
Once the user's connection is established, three types of messages may be generated 📨 These messages are identified by the AC field in the header. The three basic transmission types covered by the protocol are: a response requested (with or without text included in the message), a text message that is simply a response to the first or just data to be printed at the user's terminal, and finally, an interrupt message, which indicates the user wishes to stop a task or talk directly to the operating system 🛑
It's really important to note that no matter what conditions exist, there are always enough buffers left to receive an interrupt message and terminate or flush any existing task and the associated operation it may be supporting 🚨✨
CONCLUSION 🎓
The protocol concepts discussed in this paper were developed to facilitate the transfer of data between two or more independent systems 🤝 The protocol is able to handle the various pathological cases that may arise during network operation 🧪 A fundamental design consideration was maintaining complete recovery from any recoverable error condition 💯
Many of the concepts have been used in an operational star network, with a single EE and NC located in the central system and a CI located at each participating system ⭐ The successful operation of the network has proven the feasibility of this protocol 🎉
ACKNOWLEDGMENT 🫶
The authors wish to acknowledge the design and implementation effort of
the whole squad over in the Computer Science Department at the T. J. Watson Research Center 🫶 they put in the work and it shows, bestie ✨
[ This RFC was put into machine readable form for entry ]
[ into the online RFC archives by Tim Buck 5/97 ]📦 where this page comes from
- ietf: rfc187 1971-07
- 💖 girlified by claude-haiku-5-5 on : a language model's rewrite of the original, under its terms