Home   A   B   C   D   E   F   G   H   I   J   K   L   M   N   O   P   Q   R   S   T   U   V   W   X   Y   Z  

Proposed protocol for connecting host computers to ARPA-like networks via front end processors :: RFC0647

Network Working Group                                    M. A. Padlipsky
Request for Comments: 647                                      MITRE-TIP
NIC: 31117                                                 November 1974

                          FRONT END PROCESSORS

                          by Michael Padlipsky

                with the advice and general agreement of

     Jon Postel and Jim White (SRI-ARC), Virginia Strazisar (MITRE)

                      and the general agreement of

   Tom Boynton (ISI), Frank Brignoli (NSRDC), John Day (CAC), Bob Fink
   (LBL), Carl Ellison (UTAH), Eric Harslem (RAND), Wayne Hataway
   (AMES-67), John McConnell (I4-TENEX), Ari Ollikainen (UCLA), Dave
   Retz (SCRL), Al Rosenfeld (CASE), Stan Taylor (BRL), Doug Wells

   All affiliations are shown only for identifying ARPANET involvement,
   and do not necessarily denote organizational approval of the
   positions taken here.

   No -- repeat NO -- expression of general agreement should be taken to
   apply to Appendix 2, which is exclusively a personal viewpoint.

Padlipsky                                                       [Page 1]
RFC 647                                                    November 1974


   As this proposal is written, in the fall of 1974, the ARPA network
   has achieved sufficient acceptance that a rather large number of
   organizations are currently planning either to attach their general
   purpose computer systems directly to the ARPANET or to interconnect
   their systems employing "ARPANET technology".  The authors have been
   in touch with efforts sponsored by the Air Force systems command, the
   Naval Ship Research and Development Center, the Defense
   Communications Agency ("PWIN" -- the Prototype World-Wide Military
   command and Control system Intercomputer Network), ARPA (The National
   Software Works), the AEC, and other government agencies.  A common
   characteristic of these networks and the sub-networks is the presence
   of a number of systems which have no counterparts on the current
   ARPANET; thus, hardware "special interfaces" (between the host and
   the network Interface Message Processor) and -- more important --
   Network Control Programs cannot simply be copied from working
   versions.  (Systems include CDO 6600's, XDS Sigma 9's, Univac 494's,
   1107's, 1108's, 1110's, and IBM 370's running operating systems with
   no current ARPANET counterparts.)  Because it is also widely accepted
   that the design and implementation of an NCP for a "new" system is a
   major undertaking, an immediate area of concern for networks which
   employs as much off-the-shelf hardware and software as is
   practicable.  This paper addresses two such approaches, one which
   apparently is popularly assumed as of now to be the way to go and
   another which the authors feel is superior to the more widely known


   In what might be thought of as the greater network community, the
   consensus is so broad that the front-ending is desirable that the
   topic needs almost no discussion here.  Basically, a small machine (a
   PDP-11 is widely held to be most suitable) is interposed between the
   IMP and the host in order to shield the host from the complexities of
   the NCP.  The advantages of this fundamental approach are apparent:
   It is more economic to develop a single NCP.  "Outward" (User Telnet)
   network access is also furnished by the front end acting as a mini-
   Host.  The potentiality exists for file manipulations on the mini-
   Host.  Two operating systems are in advanced stages of development on
   the ARPANET for PDP-11's which will clearly serve well as bases for
   network front ends; thus, the hardware and software are copiable.  So
   if we consider a model along the following lines

   Host *** Front End --- IMP --- Network

   everything to the right of the asterisks may almost be taken as

Padlipsky                                                       [Page 2]
RFC 647                                                    November 1974

   (Caveat: Note the "almost" well in last sentence neither ANTS nor ELF
   -- the two systems alluded to above -- is a completely finished
   product in the estimation of either their respective developers or of
   the knowledgeable ARPANET workers who have contributed to this
   report.  Both are capable of being brought to fruition, though, and
   in a reasonable amount of time.  We will assume ELF as the actual
   front-end system here for two reasons: apparent consensus, and
   current activity level of the development team.  However, we have no
   reason to believe that readers who prefer ANTS would encounter
   substantive difficulties in implementing our proposal on it.)

   (Explanatory notes: ANTS is an acronym for ARPA Network Terminal
   Support system; it was developed at the Center for Advanced
   Computation (CAC), University of Illinois.  ELF is not an acronym (It
   is said to be German for "eleven"); it was designed at the Speech
   Communications Research Lab (SCRL), Santa Barbara, California.)


   Referring back to the model above, the popular view of the asterisks
   is to have the front-end system simulate a well known device for each
   Host (typically a remote job entry station along the lines of the
   200UT on the CDC 6600), effectively requiring no software changes on
   the Host system.  We characterize this approach as "rigid" because an
   immediate implication is that the Host system is constrained to
   handle data to and from the network only in fashions which its system
   already provides.  (E.g., if you simulate a card reader, your data
   will necessarily be treated as batch input if a terminal, necessarily
   as time-sharing input.)  Now, it may be argued that Host software
   changes are only being shunned in order to "get on the air" quickly,
   and may be introduced at a later date in order to allow unconstrained
   channelling of network data within the Host; but this reasoning may
   surely be refuted if it can be shown that an alternative exists which
   is essentially as quick to implement and does not require the waste
   motion of constructing known-device simulation hardware and software
   for each new Host, only to eventually avoid the simulation in the

   The major advantage which might be claimed for the rigid front-end
   approach other than quickness to implement would be embarrassing if
   true.  That is, the possibility exists that either the "new" Host's
   operating systems or system programming staffs are so intractable
   that avoiding Host software changes is a necessity rather than a
   desire.  We certainly hope neither is the case and have no reason to
   believe it to be so, but we must acknowledge that such possibilities
   exist as meta-issues to this report.

Padlipsky                                                       [Page 3]
RFC 647                                                    November 1974


   The rigidity argument sketched above merits some amplification.  The
   major disadvantage of interfacing with the Host only in fixed ways
   lies in a loss of functionality.  Granted that "Telnet" and "RJE"
   functions can be performed (though we have deep reservations about
   file transfer) by simulating a known device there are more things in
   practice and in theory than just using the Hosts' time-sharing and
   batch monitors.  "Teleconferencing" is an instance which comes
   immediately to mind.  Graphics is another.  Neither fits naturally
   into the setting a typical operating system is likely to assume for a
   Telnet or RJE connection.  Further, the ARPANET is just beginning to
   evolve a view of "process-to-process" protocols where cooperating
   programs on dissimilar systems communicate over network sockets in a
   true use of sockets as interprocess communication media.  It is
   difficult to conceive of viewing a (simulated) line printer as an
   abstract "port" without considerable contortion of the extant
   operating system.  To attempt to summarize this cluster of
   objections, a simulation of a known device may be cheaper than a
   large enough number of phone calls, but it's not networking.

   For that matter, it is by no means clear that the goal of Host
   software changes can even met.  In the case of one particular system
   on the ARPANET where a PDP-15 was employed as a front end to a PDP-
   10, one of the authors discovered that on attempting to login over
   the net he was confronted by an interrogation as to the type of
   terminal he was at -- the front end having been attached at the wrong
   point in the PDP-10's terminal handling code.  (Being a battle-
   scarred veteran of Telnet protocol development, he gave suitable
   answers for describing a "Network Virtual Terminal".  Unfortunately,
   however, the NVT apparently had no counterpart in the Hosts' normal
   complement of local terminals.  And when he tried such Telnet control
   functions as "don't echo, I'm at a physically half-duplex terminal"
   things really got confused).  As it happens, he later found himself
   in the neighbrohood of the Host in question, and found himself
   spending an afternoon attempting to explain the philosophy and
   importance to the Telnet protocol of the NVT.  The site personnel
   were both appreciative and cooperative, and although we have not had
   occasion to verify it, we assume that the site is probably now usable
   from the ARPANET.  The important point, though, is that operating
   systems tend to make extensive, very often unconscious, assumptions
   about their operating environments.  This observation is particularly
   true when it comes to terminal types, and the problem is that there
   is simply no guarantee that the several systems in question could
   even "do the right thing" if they were front-ended by simulating a
   known device -- unless, of course, the simulation of the device in
   the mini were so painstaking that all we'd get would be an expensive
   way of adding an RJE station, period.

Padlipsky                                                       [Page 4]
RFC 647                                                    November 1974

   Less abstract considerations also apply.  For one thing, a mini-
   computer -- even with "third-generation" software -- is not as free
   and convenient an environment to program in as a full-scale Host
   therefore, implementing the several simulations will not be trivial
   pieces of software engineering.  Further, if the simulation software
   is prepared by front-end experts, they will encounter repeated
   start-up transients in learning enough about the expectations of the
   several Host in order to perform their tasks.  For that matter, it is
   clear that if personnel from the several Host are barred from active
   participation in attaching to the network there will be natural (and
   understandable) grounds for resentment of the "intrusion" the network
   will appear to be; systems programmers also have territorial
   emotions, it may safely be assumed.

   On a still more practical level, it should be noted that the
   potential need to simulate more than one known device -- and even the
   potential complexity of any single device simulation -- may well lead
   to a requirement for a larger PDP-11 configuration than would
   otherwise be reasonable.  And although there are other reasons for
   arguing that each front-end processor ought to be as big a
   configuration as possible, we must acknowledge that dollars do
   matter.  Also on the topic of numbers, it should be further noted
   that the line speed available for known-device simulations can be
   quite low.  The 200UT, for example, is on a 4800 baud line, which is
   rather a mismatch with a 50,000 baud communication subnet.  (Of
   course, there's always the 40,800 baud line into the 6600 -- but it
   is'nt expected to have interactive devices on it, so the extant
   software won't send the data to the "right place"....)  And no
   experienced ARPANET protocol designer would be willing to overlook
   the possibility that there will probably have to be a flow control
   discipline between the Host and the front-end processor anyway, so
   the no change to Host software goal becomes rather dubious of

   After all that, it is perhaps gratuitously cruel to point out still
   another level of difficulty, but we feel quite strongly that it
   should be addressed.  For, it must be admitted, the question must be
   asked as to who will do the front-end implementations.  This sort of
   thing is scarcely within the purview of CAC of SCRL.  But, as will be
   urged in Appendix 2, it is of the outmost importance that whoever
   performs the task already have ARPANET expertise, for we know of no
   case where "outsiders" have successfully come aboard without having
   become "insiders" in the process, which is neither an easy nor cost
   effective way to proceed.

Padlipsky                                                       [Page 5]
RFC 647                                                    November 1974

   In light of the above, it is at least reasonable to consider an
   alternative to the rigid front-end approach, for regardless of the
   weight the reader may attach to any particular cited disadvantage, in
   total they at least suggest that the known-device simulation tactic
   is not a panacea.


   Our alternative approach is based on a principle which actually has
   been around since at least a month before the ARPANET began running
   User and Server Telnets on a regular basis.  The principle is that it
   would be nice to off-load as much as possible of the NCP from the
   Host, because Hosts are supposed to have better things to do with
   their cpu cycles than field control messages from other Hosts --
   especially when 90% of the control messages are merely ALL(ocate)
   commands.  This insight led to the notion that all a Host "really"
   has to do is associate sockets with processes (and, of course, pass
   data along socket connections).  And the flexible front-end approach
   is no more than an updating of these 1971 ideas to the following:
   Drop the hard and fast goal that there will be NO changes to Host
   software in favor of the more realistic goal of making MINIMAL
   changes to the Host attach the front-end processor to any convenient
   high-speed "channel" ( / "port" / "multiplexer" / "line" / "cable");
   let the fro nt-end processor handle the NCP; define an extremely
   compact protocol for the Host and front-end to follow (the H-FP); and
   let the Host H-FP module distribute the data appropriately within its
   operating system, because the H-FP will make it clear where the data
   should go and if you have to ram the data into the teletype buffers,
   it's still cleaner than trying to do interprocess communication over
   a card reader.  (The H-FP is detailed in less bald terms in Appendix
   1).  Now that might sound rather uncompromising -- and almost surely
   sounds rather cryptic -- but between the advantages it engenders and
   the more comprehensive description which follows, we feel that it
   does represent a superior basis for solving the overriding problem of
   how best to attach "new" Hosts to an ARP-like net.


   The primary advantage of the flexible front-end alternative is
   precisely its flexibility: Although minimal implementations may be
   envisioned on given Hosts, the most minimal of the implementations is
   still as powerful as the rigid front-end approach; and as the need
   for more functions is perceived, they may be coded for quite easily
   with our approach.  This is so because programs in the Host can "get
   their hands on" data from the net (and send data to the net) in a
   natural fashion -- it is not the case that only those things done on
   a given system with the data from, say, a card reader, can
   conveniently be done here.  Thus, in contrast to the rigid front-end

Padlipsky                                                       [Page 6]
RFC 647                                                    November 1974

   approach, the flexible front-end approach "is networking".  Indeed,
   it should be noted that a major "real" ARPANET server site has
   expressed an interest in implementing the H-FP based on some five
   minutes' worth of the blackboard explanation with two of the authors.

   Another advantage of our new approach is that it involves personnel
   at the various new sites in the process of coming aboard the network.
   Not only does this involvement have merit psychologically (if known-
   device simulation were employed, the network could represent an alien
   intrusion forced upon them, to site systems types), but it is also
   technically preferable to have per-site coding done by "experts",
   which would not be the case if the per-site tailoring were done
   exclusively in the mini.  Recall the PDP-15 to PDP-10 attempt
   discussed earlier.  That case may fairly be viewed as one of the
   front-ending's having been performed in ignorance of the conventions
   of both the Host's operating system and of the ARPANET?  Not only
   should that sort of thing be avoided by the expedient of involving
   experts on the target operating systems in the process of attaching
   to the network but there are practical considerations as well: we
   estimate that adding a minimal Host-Front End Protocol routine in a
   given operating system would require no longer than the same few man
   months to develop than would the adding of a new known-device
   simulation package to the mini.  So that we foresee scheduling
   advantages in addition to the more abstract ones already asserted.
   Further, it ought to be a more friendly environment to program in on
   the Host than in the mini.  (This is not to say the ELF does not
   appear to be good environment to program in; rather, it is to make
   the "obvious" claim that if the big systems did not furnish
   convenient programming environments we wouldn't have them.)

   As touched on earlier, another point which bears further examination
   is the area of flow control.  The known-device simulation approach
   appears to assume that this too will be handled by the mini, and that
   the simulation will be aware of whatever flow control discipline the
   host and the physical device being simulated follow.  However, when
   the one device "everybody knows" will be simulated (CDC 200UT)
   operates on a 4800 bit-per-second line, and the IMP subnetwork
   operates on a 50,000 bps lines, some attention must be paid to the
   mismatch -- especially in view of the fact that only one process in
   the Host is typically associated with a known device, but the network
   actually transmits data on behalf of many processes.  Our approach,
   on the other hand, allows for a very direct, simple flow control
   discipline to be imposed, without getting involved in per-Host
   idiosyncrasies.  (The option to go more elaborate -- potentially more
   efficient -- flow control disciplines is also provided.)  Thus, we
   can simply pick the beat line speed available on a particular Host,
   and attach to it.

Padlipsky                                                       [Page 7]
RFC 647                                                    November 1974

   Notice one other level of practical advantages: The min's H-FP module
   can be furnished along with its operating system by the same network
   "insiders" who are furnishing the operating system itself.  Thus, a
   critical task need not be subjected to the perils of subcontracting.
   Indeed, this approach lends itself far more readily to subcontracting
   than other, if subcontracting must be done for the per-cost software
   for with the PDP-11 being almost always the same, network "insiders"
   can be used in conjunction with site personnel to build Host H-FP
   modules either through commercial consulting contracts or even from
   within the ARPANET community.  (The latter possibilities exists
   because another fact about system programmers is that -- although
   they resent "invasions" -- they tend to enjoy getting inside new and
   different systems, if only to feel superior to them in contrast with
   their own.)

   The strengths of the flexible front-end approach, then, tend to arise
   in exactly those areas of weakness of the rigid front-end approach.
   Perhaps most important of all, though, is the fact that it "makes
   sense" to almost every single experienced member of the ARPANET
   community with whom it has been discussed.  So, we might reason, if
   the ARPANET is desirable, it is desirable because efforts of those
   who made it work and if they have gained insights into networking in
   general in the process, their opinions deserve particular attention.


   The protocol specified in Appendix 1 is felt to be around 90%
   complete.  We are aware that we have not specified all the codes that
   will be needed to describe conditions of which the Host and Front-End
   must apprise each other, for example.  But we think that, in general
   the protocol "Woks".  We stand willing to discuss it with cognizant
   decision makers in the various interested organizations, and, for
   that matter, to continue to debate it with our technical peers.  At
   this stage, however, the dominant makers avert the apparent stampede
   to the rigid front-end approach and evaluate the flexible front-end
   alternative in light of the preceding arguments and the following
   protocol specification.



   The physical connection of the front end (FE) to the Host is assumed
   to be made over the "best" port (or channel, line, etc.) available on
   the Host, where "best" covers both line speed and quality of software
   available to physically manage the line.  The choice should be made
   by site personnel.  Hardware interfacing capability is assumed to be
   straightforward; it is, at least, no more complex for the H-FP than

Padlipsky                                                       [Page 8]
RFC 647                                                    November 1974

   for known-device simulation.  The connection is assumed to be
   sufficiently closely coupled that a simple, explicit acknowledgment
   H-FP command will offer satisfactory flow control.  That is,
   distances are assumed to be short and bit rates high; thus, the same
   assumptions are made here as are made in the case of Local IMP-Host
   interfaces:  that error checking and flow control are not first-order

   On the software level, buffering is assumed to be adequate in the
   Host to accept at least a full (8096 bit) IMP-IMP message-- although
   the FE could probably get around this constraint if it absolutely had
   to.  Given only a minimal H-FP module in the Host, the FE will allow
   the same level of Telnet and RJE functioning as would the known-
   device simulation, as follows: The FE will always shield the Host
   from the NCP commands and the simplex sockets they deal with, dealing
   instead with a repertoire of but five H-FP commands and conversing
   over duplex data streams with the appropriate management of Network
   sockets left to the FE.  (The commands are described below; we
   continue with the discussion of assumptions here, but some readers
   may prefer to study the commands before continuing with the balance
   of this section.) For Telnet, although subsequent analysis may lead
   to a more sophisticated treatment, the present assumption is that the
   FE will normally refuse all "negotiated options" and strip all Telnet
   control codes from the data it passes to the Host (unless the Host
   orders it to pass an unaltered Telnet stream); on a pre-installation
   basis, the FE will also map from Telnet ASCII to the Host's desired
   character set.  Telnet "interrupt process" controls are handled by an
   H-FP command, discussed below.

   For RJE, because the ARPANET RJE Protocol is only known to have been
   implemented on one Host in the ARPANET and is generally considered to
   be too cumbersome, the standard socket for RJE will be reserved for
   future use, and a special designator will indicate to the Host that
   input on the given connection is to be treated as data in the format
   and job control language of its own "batch" system.  Again, character
   set mapping will be available on a per-installation basis.

   For file transfer, however, a further assumption must be made about
   Host software.  This is because the FE cannot be expected to
   manipulate  the Host's file system; therefore, if the host whishes to
   participate in file transfer activities its H-FP module must be able
   to access the Host's file system for both sending and receiving
   files.  Again, the FE will be able to shield the Host from the
   details of the underlying protocols to a large extent; but the Host
   must be able to handle FTP "stor" and "retr" commands, which will be
   passed over the (single) connection opened between the FE and the
   Host for file transfer.  (FTP "user" and "pass" commands might also
   be desirable.  As with Telnet, the FE will manage the Various Network

Padlipsky                                                       [Page 9]
RFC 647                                                    November 1974

   sockets involved so as to allow the Host to operate on only the H-FP
   connection, and will again optionally perform character set mapping.
   Note that Hosts may refuse to open FTP connections until and unless
   they choose to, with no impact on the FE.

   The Host's H-FP module, in short, will interpret the commands of the
   protocol, distribute Telnet data to and from the appropriate points
   within its operating system where terminal I/O is expected,
   distribute RJE data like manner, and when it is able to do so handle
   FTP as sketched above and amplified on below.  It will, also on a
   when-desired basis, support calls from its system's user processes
   for unspecified purposes I/O on ARPANET sockets to allow for such
   functions as teleconferencing and other process exploitations of the
   Net.  Our overriding assumption is that the initial H-FP module for a
   given Host (which does not require FTP or unspecified socket
   capability) will not be appreciably harder to implement than a
   known-device simulation; that it will offer extensibility to more
   interesting uses of the network than the alternative has been
   sketched here and will be returned to after the H-FP commands are


   All communication between FE and Host is performed in terms of H-FP
   commands.  The fields of the several commands are one or more
   "bytes", where a byte is per-installation parameter of 8, 9, 12, 16,
   18, 32, 36, 48, 60 or 64 bits width, according to the coding
   convenience of the given Host's H-FP module implementers? (6 bit
   bytes are not supported because they do not offer enough room to
   express all the values anticipated for certain code fields machines
   with 6 bit internal byte structure can specify 12 bit H-FP bytes and
   still be able to use their natural byte oriented instructions.)
   Values for fields will be right-justified within their (potentially
   several) byte widths.  Note that the list of byte sizes is 1) not
   meant to be exhaustive, and 2) probably unnecessarily extensive -- as
   8,9, and 12 are probably the only "reasonable" sizes in actual
   practice (but if a particular machine is better suited for handling
   whole words rather than fractions thereof, the FE can certainly make
   life more convenient for it.)

   Although the commands are given names for documentation purposes, the
   value transmitted in the first byte of each command will be the
   binary representation of the number shown before its name in the next
   section.  (i,e., the command field is one byte wide.)


   (Note that all commands may be sent by either the FE or the Host.)

Padlipsky                                                      [Page 10]
RFC 647                                                    November 1974


   The begin command establishes a "connection" between the Host and the
   FE.  Regardless of internal representation, the duplex data stream
   the connection represents will be referred to by the value specified
   in the next (INDEX) field that is, for example, the FE will send
   input from and receive output for a given Telnet connection "on" a
   given INDEX, even though it is actually managing two "sockets" for
   the purpose in its dealings with the Network.

   a) INDEX is a two-byte field.  Both the Host and the FE may choose
   arbitrary values for it when opening connection with a BEGIN command
   (H-FP implementations will probably simply increment INDEX by 1
   whenever they need a new connection); however, the value of 0 is
   reserved to apply to the "global" connection between the Host and the
   FE -- thus, when either machine "come up" the first thing it does is
   send a BEGIN for INDEX=0.  (The END and ACKNOWLEDGE commands also
   follow this convention; for that matter, there is no reason why the
   MESSAGE command could not also, should it be desired to extend the
   FE's functions in the future.  At present, however, this is merely a
   potential extension.)  Note that all other fields should be set to 0
   for INDEX 0 BEGINS.

   b) HOST is a two-byte field.  It specifies the Host number associated
   with the socket in the next field.  On FE to Host BEGINS this is
   purely informational.  However, on Host to FE BEGINS it is necessary
   to enable the FE to identify the foreign Host with which to
   communicate at the NCP level.

   c) SOCKET is a four-byte field.  If SOCKET=1, a Telnet connection is
   to be established.  If SOCKET=3, an FTP connection is to be
   established.  If SOCKET=5, an ARPANET RJE Protocol connection is to
   be established (no known current utility).  If SOCKET=77, a Host-
   specific connection is to be established for RJE/batch.  All other
   values are for connections for unspecified purposes, to be opened at
   the NCP level according to the CONNECTION-TYPE field.  Note that
   sockets 1, 3, 5 and 77 are "known about" and special-cased by the FE.

   d) TRANSLATION-TYPE is a one-byte field.  From FE Host, it is
   informational.  From Host to FE, it specifies character set mapping
   if desired, or characterizes the data to be transmitted over the
   connection.  0 request / specifies ASCII data 1; binary data (note
   that this value will not be sent from FE to Host under current
   assumptions, and that word size is to be a per-installation
   parameter); 2, mapping of ASCII to/from local character set.  Other
   types will be defined if needs are identified.

Padlipsky                                                      [Page 11]
RFC 647                                                    November 1974

   e) CONNECTION-TYPE is a one-byte field.  For FE to Host BEGINS it is
   informational.  For Host to FE BEGINS it instructs the FE as to which
   kind of NCP connection discipline to follow.  1 requests a duplex
   connection (i.e., that the Initial Connection Protocol of the ARPANET
   be employed) 2, a simplex connection (i.e., that the appropriate
   ARPANET "request for connection" Host-Host Protocol commmand be
   employed for the gender of the socket at hand).  Note that this
   extended use of the H-FP will be of interest when (and if) User-level
   programs on the Host begin to use the Network.  (The FE will open 8-
   bit connections at the Network level unless otherwise directed.)


   The ACKNOWLDEGE command is multi-purpose.  It must be sent in
   response to all commands from the other machine (other than
   ACKNOWLEDGES, of course), and is primarily used to indicate the
   success or failure of the command just received on INDEX.  Note that
   this implies that each MESSAGE on a given INDEX must be ACKNOWLEDGEd
   before the next can be sent.

   a) INDEX is as above.

   b) CODE is a two-byte field.  CODE=0 indicates success / acceptance
   of the command most recently received for INDEX.  CODE=1 indicates
   failure /rejection of the most recent command.  (E.g., if a MESSAGE,
   buffering was unavailable so the other machine must retransmit; if a
   BEGIN, the indicated protocol / socket cannot be serviced.)  CODE=3
   indicates an invalid or inactive INDEX has been used.  CODE=4
   indicates (HOST to FE) that no mapping is to be performed on the
   connection just opened.  Other values (for such meanings as "foreign
   Host down", "undefined type requested" and the like) will be assigned
   as identified.


   The MESSAGE command is employed for the transmission of data.

   a) INDEX is as above.

   b) COUNT is a two-byte field which specifies the number of bits of
   data in the TEXT field.

   c) PAD is a 1-to-n-byte field.  Its width is a per-installation
   parameter used to enable the TEXT field to start on a word boundary
   if the local H-FP implementers so desire.  (This is not only a
   kindness, but it's also a placeholder if we decide to go to a flow
   control mechanism involving sequence numbers.)

Padlipsky                                                      [Page 12]
RFC 647                                                    November 1974

   d) TEXT is a field wherein byte structure is coincidental.  It
   consists of COUNT bits of data to be sent to the process implicitly
   associated with INDEX by a BEGIN command (which has not been ENDed.)


   The INTERRUPT command, when sent from the FE to the Host, indicates
   that an FCP interrupt command (INS or INR) has been received for the
   process associated with INDEX; the Host should interrupt the
   associated process and whatever fashion is "normal" to it.  (The most
   common use of the NCP is in Telnet, where it is defined as being the
   functional equivalent of having struck a terminal's ATTN, INT, of
   BREAK key, or input a "control-c" on certain character-at-a-time
   systems; essentially, it requests a "quit button" push.  Note that
   the FE will take care of the associated Telnet control code in the
   input stream.)  When sent from the Host to the FE (in process to
   process applications), it will indicate that an appropriate NCP
   interrupt be sent, according to the gender of the socket associated
   with INDEX.


   The END command is used to terminate a connection.  It may be sent
   either because one system or the other is about to go down, or
   because the FE have received an NCP "CLS" command or because the
   destination system or IMP has gone down, or at the behest of a Host
   user process.

   a) INDEX is as above.  Note that if INDEX=0 the END refer to the
   "global" connection between the Host and the FE in such case, the
   high-order bit of CODE will be set to 1 and the low-order bits will
   specify the number of the minutes to shutdown if this information is
   available.  (Furnished because the associated IMP often informs the
   FE of such a condition.)

   b) CODE is a two-byte field.  CODE=1 indicates the general "close"
   case (either received or ordered) 2, foreign systems has gone down;
   3, foreign IMP has gone down; 4, local IMP has gone down.  Other
   values will be assigned as identified.


   Simplicity and compactness being major goals of the protocol, the
   small repertoire of commands just presented represent "all there is".
   Recall that we are specifically omitting from consideration such
   issues as error and flow control, which could turn the H-FP into
   another Host-Host Protocol.  (should error and flow control prove

Padlipsky                                                      [Page 13]
RFC 647                                                    November 1974

   desirable in practice, we have, of course, thought of some suitable
   mechanism within the H-FP framework; but they are not considered
   germane in the present context.) The primary intention here is to
   specify a protocol, which lends itself to minimal initial
   implementations in the Hosts, on the same time scale as would have
   otherwise been required for known-device simulations -- but which
   offers great flexibility in the use of the network than would be
   achieved through known-device simulation.

   The astute reader will have noticed that most of the commands have
   been specified with an eye toward the future.  Because the same
   protocol, which allows the Host and the FE to communicate can easily
   allow user processes on the Host to use the Network, we have tried to
   encourage this desirable end by furnishing all the necessary hoods
   and handholds for it in the FE's H-FP module through the broad
   definitions of the commands.  A Hosts's H-FP module can furnish a
   trivial interface for user programs in terms of a very few entry
   points (open, read, write, and close appear to be the minimal set)
   and allow the user program considerable flexibility in its use of the
   net.  For example, a "User" FTP program could be straightforwardly
   created even for a Host, which did not choose to field the BEGINs on
   socket 3 (necessary for "Server" FTP capability), and files could
   still be "pulled" to the Host even if they could not be "pushed" to
   it.  (the FE will be required to recognize and special-case BEGINs on
   socket 3, but that's a small price to pay).  So, if the specification
   of the h-FP command repertoire seems somewhat more complex than it
   need be, remember that not all of it has to coped with on any given
   Host -- and that any give host ca take advantage of more functions as
   it desires.  (Although it's not really within the present scope, we
   stand willing to invent per-Host H-FP to user program interfaces on


   To amplify a bit on the problem of file transfer, it must be observed
   that in general only a file system can manage its files.  This
   borders on tautology and is difficult to deny.  Therefore, although
   the FE can shield the Host from a great deal of the mechanism
   included in the FTP for functions not directly germane to the
   transferring of files, Host's operating system and place or extract a
   given file, even though it "has" the file's name available to it.
   There is no in-principle reason why the H-FP module on the Host can't
   invoke an appropriate routine when it receives a BEGIN on socket 3,
   though.  (The FE will handle all the type and mode negotiations, pass
   the "stor" or "retr" line along, and be ready to transmit or receive
   on the appropriate socket but "somebody" in the Host has to receive
   or transmit the MESSAGE to or from the right place.)  But if that
   seems hard to do on any particular Host, its H-FP module can merely

Padlipsky                                                      [Page 14]
RFC 647                                                    November 1974

   negatively ACKNOWLEDGE any BEGINs for socket 3.  The real point to be
   noted is that the H-FP still allows in principle for User  FTP, as
   explained above, even so -- and that the simulation of known device
   offers neither (User nor Server FTP) function.

   (Files could, of course, be transferred into the FE, then somehow
   gotten into the Host "later" -- perhaps by faxing up a batch job --
   but that route requires either an awful lot of buffering in the mini
   or a very sophisticated file system there, or both.  It also requires
   an awful lot of per-Host information in each FE -- or perhaps human
   intervention.  We're not saying it can't be done... eventually.  But
   it's not going to be clean, or quick, or easy, or cheap.)


   Several important themes have unavoidably been dealt with piecemeal
   in the foreign attempt to specify the H-FP in the abstract.  To
   gather the threads together, it might be useful to consider the
   various ways in which the protocol can be employed, in the context of
   their ARPANET counterparts.  A. "SERVER" FUNCTIONS: There are, in
   essence, three levels on which a Host can use the H-FP to fulfill
   ARPANET "Server" functions.  1) For Hosts which choose to take FULL
   advantage of the flexibility of the H-FP, all "fourth level" (user
   process to user process)  protocols can be managed by the Host.  The
   FE will perform NCP (Host-Host protocol) and IMP-Host protocol
   functions (the associated IMP will, of course, perform IMP-IMP
   protocol functions), thus shielding the Host from the necessity of
   implementing a full-blown NCP with the attendant complexity of being
   aware of the 11 to 14 "states" of a socket, flow control,
   retransmission, and the like (as well as shielding it from the IMP-
   Host protocol, with the attendant complexity of mapping "links"
   to/from "sockets", dealing with message types forming and parsing
   "leaders", and the like).  This mode of use is effected by giving the
   "no mapping" code when the Host acknowledge a BEGIN on socket 1 and 3
   (and by simply accepting BEGINs on all other sockets).  2) For Hosts
   which choose to take PARTIAL advantage of the flexibility of the H-
   FP, many aspects of the fourth level protocols (in particular Telnet
   and FTP) can be managed by the FE on the Host's behalf, by virtue of
   making assumptions about which Telnet and/or FTP "commands" are to be
   permitted and only referring search matter as the association of data
   which processes and/or file names to the Host.  (Note that the CODE
   field of the ACKNOWLEDGE command furnishes the mechanism for
   conveying such error information as "file not found" from the Host to
   the FE, which in turn will send out appropriate FTP error messages.)
   This mode of use is effected by simply accepting (with code 0) BEGINs
   on sockets 1 and/or 3 (and doing as one chooses for all other
   sockets); that is, fourth level shielding is anticipated to be
   commonplace, and is the FE's default case.  3) For Hosts which choose

Padlipsky                                                      [Page 15]
RFC 647                                                    November 1974

   to take NO advantage of the flexibility of the H-FP, the "private"
   RJE/batch connection type will still provide for the desirable
   functions of load sharing and transferring files even though other
   fourth level protocols were to be rejected by a given Host (by
   refusing BEGINs on all sockets other than 77).  Even in this most
   restricted case, the ability to upgrade to either of the broader base
   is additively implicit in the H-FP, with no changes required to the
   FE's own H-FP module -- whereas it would entail considerable
   alteration of the Host's operating system had the first step been a
   known-device simulation.  B. "USER" FUNCTIONS: 1) On the "User" side,
   a Host could again elect to handle such fourth level protocols as
   Telnet and FTP itself.  However, particularly in the Telnet case,
   there is no real need for this, as a User Telnet "comes with" the FE
   and it is unnecessary to burden the Host with such use unless so many
   of its local terminals are hardwired that it would be expensive to
   access the FE directly.  (Note that for a User FTP, the Host's H-FP
   module would, as discussed above, in all likelihood require a user
   program callable interface.) 2) On a less ambitious level, the FE
   could be induced to perform the same shielding as it offers the
   Server FTP (cf. case A2, above), given an "FTP mapping" TRANSLATION-
   TYPE on the BEGIN command or the previously suggested special casting
   by the FE on socket 3.  3) Finally, "User" functions could be
   completely finessed, as per case A3.C. PROCESS TO PROCESS FUNCTIONS:
   Irrespective of the positions taken in A and B, given only a user
   program callable interface to the Host's H-FP module, all other
   fourth level protocols which might evolve -- or, simply, general use
   of sockets as interprocess communication ports -- can be achieved
   directly.  Again, this would fundamentally be an "add-on" to the
   system, not an alteration of existing software.



   This appendix represents strictly the personal views of one of the
   authors; I (now that I can admit to being Mike Padlipsky) have not
   even permitted the other authors to agree with the views expressed
   here, much less disagree with them, for they are insights which I've
   gained the hard way during nearly four years of involvement with the
   ARPANET and I feel they need saying -- regardless of the polite
   fiction of refraining from finger pointing.  Please note at the
   outset, however, that I am motivated not by a sense of vindictiveness
   -- nor even of righteous indignation -- but rather by a desire to
   present some history in the hope that the reader will not be
   condemned to repeat it.  Note also that even though it makes the
   prose more convoluted than it might otherwise have been, the
   convention will be observed of "naming no names".  I am not, I

Padlipsky                                                      [Page 16]
RFC 647                                                    November 1974

   repeat, out to get these guys; merely to get away from them and their
   like in the future.  (The reader can stop here with no loss to the
   main argument of the paper.)


   Consider first the tale already told of the PDP 15/PDP 10 front
   ending effort.  Having been involved in the writing of both the "old"
   (1971) and the "new" (1973) Telnet Protocols, I feel a certain sense
   of shame by the association that they were not so compellingly clear
   that the power of the Network Virtual Terminal / common intermediate
   representation approach could not have been missed, ever by system
   programmers operating in pretty much of a vacuum with respect to
   contact with knowledgeable ARPANET workers.  Having said that -- and
   meant it -- I still feel we did a good enough job for average-plus
   system types to cope with.  (The fact that numerous Hosts are on the
   Net is evidence of this.) Unfortunately, however, average-minus
   system types do exist and must also be contended with.  Therefore, if
   we do not make a concerted effort to "idiot proof" our protocols, we
   may anticipate further repetitions of the sad state the site under
   discussion found itself in before it happened upon them.  (And, it
   must regretfully be observed, support of the "real" ARPANET has
   deteriorated to the point that the massive effort required to over-
   explain ourselves probably could not be launched in the prevailing
   climate.  More on this point later.)

   Case in point number two is potentially far graver than a mere
   "philosophical" muddle over bringing one site aboard.  It involves an
   attempt by one of the Armed Services to network a large number of
   large machines using the ARPANET as a model.  The implementation of
   the software house with no known ARPANET expertise.  The
   communications subnet and the hardware interfacing to the Hosts was
   subcontracted to a well-known hardware manufacturer with no known
   ARPANET expertise.  (As an aside, but because it's so startling I
   can't forbear, the "system architect" for the target network is still
   another well-known hardware manucfacturer (!), with, of course, no
   known ARPANET expertise.) To make a long, continuing story short, it
   is currently the case that the "real" ARPANET system whose hardware
   corresponds most closely to the machines being netted here (even
   though it is benchmarked at a rather lower "mips" (million
   instructions per second) rate than the target net's machines) can
   transfer files at rates in excess of 28,000 bits per second
   (following the rather cumbersome full ARPANET FTP) from a small
   configuration developement machine to a lightly loaded (but still
   running in excess of 20 users) service machine one Network "hop"
   away, while the new system achieves rates which I am apparently not
   permitted to quantify but are very considerably lower even though
   only one process is being run on each machine -- also one "hop" away

Padlipsky                                                      [Page 17]
RFC 647                                                    November 1974

   --  and the protocol for file transfer is nowhere near so general as
   in the ARPANET.  Given a year or two, the situation can presumably be
   rectified, but at present it is fair --  if somewhat fanciful -- to
   say that if the Japanese were capable of only like level of
   technology transfer they'd still be trying to make up their balance
   of trade with those cute little parasols on matchsticks.

   Yet what has gone amiss here in Horror Story 2? I submit that the
   choice of subcontractors was based upon a misapprehension of the
   level of technological sophistication associated with the ARPANET,
   and that what was (is?) needed is a subcontract to a knowledgeable
   ARPANET source (and I don't mean to the usual, profit-marking place
   -- though I guess I trust them for the subnet), rather than to
   "outsiders".  (I don't even mean to any particular place on the Net;
   maybe what's needed is to form a meta-place out of the whole Net.
   More on this, too, later.)  The real point is that the model was
   essentially ignored by the putative model-followers, and --
   demonstrably -- it shouldn't have been.

   Case three should go a long way toward dispelling any impressions
   that might be building in the reader's mind that I'm some sort of
   hardcore ARPANET chauvinist.  For even "insiders" have blown some.
   This is actually a dual case, for it involves two unsuccessful
   attempts to furnish terminal support mini-Hosts for the Net.  In one
   case, the choice of machine was faulty; even with additional core
   memory field retrofitted, buffers cannot be furnished to support
   reasonable data rates without imposing considerable unnecessary Host
   overhead in the processing of too frequent Host-Host Allocation
   commands.  Nor is there enough room to furnish more than a
   rudimentary command language in the mini.  Now these were
   knowledgeable, reasonably well managed "insiders" -- but they were
   contractually not in a position to heed the technical intuitions of
   several of themselves and the technical intuitions of many of their
   colleagues throughout the Network Working Group that they'd been
   painted into a corner.

   In the second sub-case, the hardware and contractual obligations
   appear to have been right, but ill-considered choice of
   implementation language and inadequate management have prevented the
   project's full completion to this time (some two years after its
   inception).  Again, there was forewarnings from the NWG, in that we
   had tried to alert them quite early about the language issue.  (On
   the management level, we could only sympathize -- and in some cases
   empathize -- but it is at least a tentacle position to take that the
   ARPANET as a whole happened despite, not because of, management.)  (I
   guess I am an ace system programmer chauvinist.)

   The final case to be cited here involves another military effort.

Padlipsky                                                      [Page 18]
RFC 647                                                    November 1974

   This one I'm not even sure I'm supposed to know about, much less talk
   about.  But I can say that it involves a subcontractor's attempt to
   attach several special purpose machines to a major ARPANET server by
   means of an internally invented set of machines and protocols.  My
   information suggests that when asked why they failed to follow the
   apparently obvious course of using ARPANET technology (facilities for
   which do, of course, already exist on the target server), the
   subcontractors essentially replied that they hadn't felt like it.
   They also made their approach work yet, and it's been something like
   a couple of years they've been trying.

   Then three's the fad to simulate RJE terminals... but to use that as
   Horror Story 5 would be begging the question -- for now.


   Rather than search out any more dirty linen, let's pause and look for
   the lessons to be learned.  In the first place, it borders on the
   obvious that for any technical project the "right" technicians must
   be found and empowered to perform it.  Despite the generation of
   over-sell on the "power of computers", they still absolutely require
   intelligent, competent programming -- which in turn requires
   intelligent, competent programmers.  And, at the risk of gilding the
   ragweed, not all self-professed programmers are intelligent and/or

   In the second, and more interesting, place, all unknowing the ARPANET
   has attracted or engendered an "in-group" of extremely good system
   types -- who have learned through some sort of natural selection
   process to work well together despite the immense handicap of the
   heterogeneity of our various "nome" systems' assumptions.  We not
   only have developed a common tongue, but some of us even like each
   other.  (It should be noted that Appendix 1 was specified on a
   Wednesday afternoon and a little bit of a Thursday morning.  Jon and
   Jim and I had been there before.)  It seems quite clear to me that
   the organizations for whom this report is intended should avail
   themselves of the expertise which exists in the NWG; we've got a
   reasonable track record, after all, especially in comparison to
   others who have attempting networking.  Many of us also feel quite
   strongly that we didn't get a chance to finish the job on the
   ARPANET, and would like to be given the chance to "do it right" --
   especially in view of the errors which have been committed in our
   name.  (This is particularly important because the old gang is
   beginning to scatter.  For myself, I expect this will be my last RFC.
   Well, at least I've tried to make the most of it.)  The ARPANET is no
   more a finished product than ANTS or ELF -- but all of them could and
   should be.

Padlipsky                                                      [Page 19]
RFC 647                                                    November 1974

   In the final place now, a rather trite moral must be drawn: Technical
   competence is extremely difficult to assess a priori.  (I'm
   inordinately fond of saying "Don't ask me what I'm going to say, I
   haven't said it yet" myself.)  But "track records" ARE important, and
   competence CAN be demonstrated -- to a suitable jury of technical
   peers.  Therefore, beware of plausible sounding subcontractors who
   tell you "It's easy".  In our field, and particularly in getting all
   those strange machines which were developed by people who by and
   large didn't talk to each other to "talk" to each other, it's NOT
   easy.  I'm willing to claim that it will be easier letting some NWG
   types do it with the H-FP approach, but it might never be really easy
   -- where "never" means for the next 10 years or so, until "real"
   networking comes off the shelf with the operating system (which
   itself scarcely comes off the shelf today) -- but don't get me
   started on The Manufacturers.


   So it's not easy.  It's also not impossible.  Indeed, the time
   appears to be ripe right now avoiding generating a whole new
   generation of horror stories, by sensitizing decision makers to
   technical realities and "doing things right" this time around.
   Having seized this occasion to say some things to that end which I
   think are important, I must in good conscience stand ready to defend
   the assertions I've made of error in some camps and of correctness in
   what I might loosely call "our" camp.  I do so stand, with a right
   good will.  If any reader desires more corroborative detail -- or
   merely to see if I rant like this in contexts other than RFCs (or
   even to have a go at my explanation of the common intermediate
   representation principle), well, I'm still in the ARPANET Directory
   -- even though the phone number's different (try 703-790-6375).  The
   mailbox remains accurate (even though there is no "ARPANET mail
   protocol" it's marvelous how stopgaps endure).

          [This RFC was put into machine readable form for entry]
          [into the online RFC by Helene Morin, Viagenie,12/1999]

Padlipsky                                                      [Page 20]