RFC 54

Official Protocol Proffering

📅 published June 1970, from ietf

RFC 54: An Official Protocol Proffering 🎀

Okay bestie, let's dive into RFC 54! 💖 It's from the Network Working Group and it's Request for Comments # 54 ✨. It's titled An Official Protocol Proffering and dated June 18, 1970 🌸. The authors are Steve Crocker (UCLA), Jon Postel (UCLA), John Newkirk (Harvard), and Mike Kraley (Harvard) 🫶. This one doesn't list a category or any obsoletes or updates, so there's nothing else to report up top 💅.

I. INTRODUCTION ✨

As advertised in NEW/RFC #53, we're putting this protocol out there for criticism, comments, and all that jazz 🦋. We intend for it to become the initial official protocol, so we'd be happiest if no serious objections get raised 🥺. Still, we'll entertain all kinds of criticism until July 13, 1970, and that criticism SHOULD be published as a NWG/RFC or sent directly to the first author 💜.

After July 13, a decision will be made about whether to adopt this protocol (or a slight variation) or to redesign it and resubmit it for criticism 👑.

Only the Protocol 🌸

Here's the tea: in earlier discussions of protocol, nobody clearly separated the network-wide specs from local strategies 🫠. So we're stating it clearly right here. The only network-wide issues are message formats and restrictions on message content. Implementing a Network Control Program (NCP) and choosing system calls are strictly local issues 🍓.

This document only covers network-wide issues, so it won't touch system calls or NCP tables 📚. But honestly, a protocol is useless without an NCP and a set of system calls, so we put a ton of effort into a prototypical NCP 😭. That work is reported in NWG/RFC #55, and the reader SHOULD correlate the protocol here with the suggestions for using it over there. Just remember that the content of NWG/RFC #55 is only suggestive, and competitive proposals SHOULD be examined before you choose an implementation 🔍.

Flow Control 💜

Okay, so flow control turned out to be way more complex than we imagined 🙈. We now think flow control techniques will be one of the hot topics as network traffic grows 📈. We were inspired by some ideas from Richard Kaline and Anatol Holt, so we modified the flow control procedure 🫶. (Any defects in our scheme are, of course, only our fault 💀.) The new procedure has demonstrable limitations, but it's more cleanly implementable and will support initial network use. It's the only substantive change from the protocol already agreed upon ✨.

The new flow control mechanism has the receiving host allocate buffer space for each connection and tell the sending host how much space, in bits, is available 🧚. The sending host keeps track of how much room is left and never sends more text than it believes the receiver can accept 🎀.

Here's how the sending host does it: it keeps a counter for each connection. The counter starts at zero, goes up when control commands arrive from the receiving host, and goes down by the text length of every message sent over the connection. The sending host is prohibited from sending text longer than the counter's value, so the counter never dips below zero 🌈.

Ideally, the receiving host allocates some buffer space as soon as the connection is established 🌸. The amount allocated MUST NOT exceed what the receiver can guarantee to accept. Incoming text fills up that allocated space. When the receiving process absorbs waiting text from the buffer, the NCP sends back a fresh allocation of space for that connection 💅. The NCP MAY allocate space even if the receiving process hasn't absorbed waiting text, if it thinks the extra buffer space is appropriate. Similarly, the NCP MAY decide not to reallocate buffer space after the receiving process frees it up 🦋.

The control command that allocates space looks like this:

ALL     <link>  <space>

This command is sent only from the receiving host to the sending host 📨.

This formulation of flow control makes the RSM and SPD commands in NWG/RFC #36 obsolete, and also makes the Host-to-Imp message type 10 and the Imp-to-Host message types 10 and 11 in the current revision of BBN Report 1822 unnecessary 🙃.

The obvious limitation here is that the receiving host isn't allowed to rely on average buffer usage, so worst case is always assumed 😬. If only a few connections are open, there probably won't be much savings. But with more than a few connections, average buffer usage will be way less than the allocated buffer space 📉. We've looked at extensions that would add adaptive allocation, and we think that's feasible ✨. For now this limited scheme seems best, and we're excited to talk about fancier schemes later 🤩. The old scheme of special RFNM's, etc. is still under discussion 🧐.

To answer questions and talk through details, we'll hold a pair of network meetings 🎀. The first is on June 29 at Harvard, and the second is on July 1 at UCLA. We request that no more than one programmer per host attend a meeting, and that hosts be represented at only one of these meetings 🙏. J.N. and S.C. will be at both meetings 💜.

To make reservations for the Harvard meeting, contact:

   Mrs. Margi Robison
   (617) 495-3989
      or 495-3991

To make reservations for the UCLA meeting, contact Mrs. Benita Kirstel at (213) 825-2368 🌸.

II. THE PROTOCOL 🦋

The idea of a connection from NWG/RFC #33 runs through this whole protocol 💖. A connection is a simplex communication path, meant to sit between two processes 🔗.

The protocol's main jobs are:

establishment of connections,
regulation of flow over connections, and
termination of connections.

On top of that, it has some ancillary functions, like sending simulated interrupt pulses and echoing test messages 🧚.

To give connection info a place to travel, we designate specific links (link one between each pair of hosts) as control links 🛤️. Traffic on control links consists only of control commands, which we'll define below 💅.

Connections are named by a pair of sockets 👑. Sockets are 40 bit names known throughout the network. Each host gets a private subset of these names, and a command that requests a connection names one socket local to the requesting host and one local to the receiver of the request 🫶.

Sockets are polarized: even-numbered sockets are receive sockets, and odd-numbered ones are send sockets. One of each is REQUIRED to make a connection 🎀.

Each connection also gets its own unique link for moving information. So one step in establishing a connection is assigning a link 🌈. Of the non-control links, zero is reserved for intra-network use, and links 32 to 255 are reserved for experiment and expansion. That leaves only links 2 through 31 for regular use ✨. Link assignment MUST either always be done by the receiver or always by the sender. We've (almost) arbitrarily chosen the receiver to handle it 🙈.

All regular messages have a 32 bit leader, marking, text, and padding 📦. Marking is a (possibly null) run of zeroes followed by a 1. Padding is a 1 followed by a (possibly null) run of zeroes 🔢.

A regular message sent over the control link (link 1) is called a control message 📨. Its text is an integral (possibly zero) number of control commands in the form described below, and this text MUST end on a command boundary 🧱.

The commands used to set up a connection are STR and RTS 💫. The STR command goes from a prospective sender to a prospective receiver. Its <my socket> field holds a send socket local to the prospective sender, and its <your socket> field holds a receive socket local to the prospective receiver 🦋. The RTS command is the mirror image, but it also has a <link> field for link assignment 🪞. Together these are called requests-for-connection (RFC). A STR and an RTS match if the <my socket> field of one is identical to the <your socket> field of the other, and vice versa 💜. A connection is established once a matching pair of RFC's has been exchanged 🎉.

Hosts are prohibited from making more than one connection to any local socket 🚫. So a host can't use a socket in the <my socket> field of an RFC if that socket was already mentioned in a previous RFC and that connection isn't terminated yet 🙅.

The command for ending a connection is CLS 🔚. Each side MUST send and receive a CLS command before the connection is fully terminated and its sockets are free to join other connections 💅. Both RFC's don't have to be exchanged before a connection can be terminated 🌸. More termination details come later 👀.

Once a connection is established, the receiving host sends an ALL command to allocate space for the connection ✨. The sender keeps track of how much space the receiving host has available, and it doesn't send more text than the receiver can accept, as explained above 🫶. The sender is also limited by its local IMP: it can't send a message over a connection until the RFNM for the previous message comes back 🚦.

After a connection is established, CLS commands from the receiver and from the sender have slightly different effects 🌗. A CLS sent by the sender means no more messages will be sent over the connection. This command MUST NOT be sent if a message is still in transit over the connection 🛑.

A CLS sent by the receiver acts as a demand that the sender stop transmitting 📣. But since there's a delay in getting that CLS to the sender, the receiver MUST expect its buffers to fill up to the limit given in ALL commands 🪣.

While a connection is established, either side MAY send INR or INS commands. What these commands do is a local matter, but in general they'll provide an escape function 🚪.

Note that the ALL, INR, and INS commands MAY be sent only after the connection is established and before a CLS command is sent ⏰.

There's a very simple test facility with the ECO and ERP commands 🧪. When a host receives an ECO command, it MUST change the first eight bits to ERP and send it back 🔁. These commands have nothing to do with connections 🙅‍♀️.

The NOP command is included for convenience. It's coded as zero to make command messages easier to build 🧩.

Last but not least, the ERR command lets a foreign host know it has (apparently) made an error 🚨. Right now no specific list of errors is defined, and no action is defined for receiving ERR commands 🤷‍♀️. Hosts SHOULD log ERR commands when they receive them, so system programmers can diagnose the trouble 🔍. A host MAY generate an ERR command at any time and for any reason 💫. It's advised that each host publish an exhaustive list of the ERR commands it may send, along with their interpretations 📜.

NETWORK CONTROL COMMANDS 💅

Here's a detailed description of the structure and format of each control command 🎀.

To make socket descriptions clearer, we've adopted these conventions 🌈:

<my socket> and <your socket> are used in the command descriptions. <my socket> is local to the originator of the command. <your socket> is local to the receiver of the command 🫶.

CONTROL COMMAND FORMATS 🎀

okay bestie, here are the control command shapes, and yes they're giving very minimalist 💅

No Operation

                   _______
                  |       |
                  |  NOP  |
                  |_______|

Request Connection, Receiver to Sender

                   ______________________________________________
                  |       |             |               |        |
                  |  RTS  |  my socket  |  your socket  |  link  |
                  |_______|_____________|_______________|________|

Request Connection, Sender to Receiver

                   _____________________________________
                  |       |             |               |
                  |  STR  |  my socket  |  your socket  |
                  |_______|_____________|_______________|

Close

                   _____________________________________
                  |       |             |               |
                  |  CLS  |  my socket  |  your socket  |
                  |_______|_____________|_______________|

Allocate

                   __________________________
                  |       |        |         |
                  |  ALL  |  link  |  space  |
                  |_______|________|_________|

Interrupt Sent by Receiving Process

                   _______________
                  |      |        |
                  | INR  |  link  |
                  |______|________|

Interrupt Sent by Sending Process

                  _______________
                 |      |        |
                 | INS  |  link  |
                 |______|________|

Echo Request

                  ____________________________   _________
                 |       |                    \  \        |
                 |  ECO  |  length            /  /  text  |
                 |_______|____________________\  \________|

Echo Reply

                  ____________________________   _________
                 |       |                    \  \        |
                 |  ERP  |  length            /  /  text  |
                 |_______|____________________\  \________|

Error Detected

                  ____________________________   _________
                 |       |                    \  \        |
                 |  ERR  |  length            /  /  text  |
                 |_______|____________________\  \________|

Okay so the host is specified in the leader ✨ The <link> field is 8 bits, and <space> is 32 bits long and is an unsigned integer 🔥 <length> is an unsigned 16 bit integer. <text> is as long as the length, which means the whole command is 24 bits longer than the length. The maximum length is one message, and that's on purpose, so command decoding and manipulation stays easy 🧚

All control command codes are 8 bits long:

          NOP = 0
          RTS = 1
          STR = 2
          CLS = 3
          ALL = 4
          INR = 5
          INS = 6
          ECO = 7
          ERP = 8
          ERR = 9

<my socket> and <your socket> are 32 bits long each 💜

                 _______________________
                |               |       |
                |  User number  |  AEN  |
                |_______________|_______|

That's 24 bits for the user number and 8 bits for AEN. iykyk 🙈

III. Conclusion 🌈

Extensions to the Protocol

Some issues haven't been properly handled in the current protocol yet 😭 We have a few topics in mind that we want to think through more carefully, and maybe try out in practice.

More Sophisticated Flow Control. Other flow control schemes are still being considered 👀 Apart from the fact that we need some form of it, we're honestly not sure what the real problem is. It could turn out the present scheme is totally fine, or it could turn out we need something way more complex.
Error Detection and Recovery. As we get more experience with the network, we'll understand better what errors can happen and, even more importantly, what to do about them 🔥 We expect the protocol to change as our understanding of error control grows.
Start Up and Shut Down Procedures. We haven't thought hard enough about a host that only joins the network part-time, one that stops normal network operation but stays on for special purposes, or one that recovers from a system failure 💀 These issues are critical for robust network operation and are possibly our highest priority.
Query and Response. A host-to-host status test would be a super valuable tool, but it isn't clear yet what's appropriate to provide 🍓

Coming onto the Network

We suggest hosts come onto the network gingerly 🧸 First, each host should thoroughly exercise connections to itself. Then it should set up experiments with some other host that's already functioning. Finally, it can start exercising the facilities of other hosts. It isn't clear right now which host will be in the best position to help other hosts first, but UCLA will attempt to serve this function 🫶

Private Networking

A common move is to use the IMP to connect several local computers, where one or more of them isn't available to the whole network. For example, Harvard is connecting its PDP-1 to its PDP-10 via an IMP. Lincoln Laboratories is connecting its TSP to the 360/67 and the TX2 via an IMP. And UCLA is doing something similar, connecting an XDS 920 to its Sigma-7 ✨ In each of these cases, the small machine won't initially provide services to the network.

Even though there should be no unwanted traffic going to any of these extra hosts, it's still desirable that they conform minimally to the network protocol 💖 As long as they never initiate a connection or send out spurious control commands, it's enough for a host to respond to CLS commands with acknowledging CLS commands, and to respond to ECO commands with ERP commands 🦋

Acknowledgments 🫶

The work presented above is only a small part of the concurrent effort 🌸 Most of the related effort will be reported in immediately forthcoming RFCs. A bunch of people gave us extremely valuable help over the last two weeks, and we're especially grateful to Professor George Mealy of Harvard for supporting four of his students to come westward and work on the network. Thank you to Robert Uzgalis for making access to CCN at UCLA easier, and to the secretarial staff of the Computer Science Division of the University of Utah, especially Peggy Tueller and Marcella Sanchez, for excellent help preparing these documents 👑

[ This RFC was put into machine readable form for entry ] [ into the online RFC archives by Eitetsu Baumgardner 3/97 ]

📦 where this page comes from

ietf: rfc54 1970-06
💖 girlified by claude-haiku-5-5 on 2026-10-17: a language model's rewrite of the original, under its terms