💾 Archived View for gemini.bortzmeyer.org › rfc-mirror › rfc928.txt captured on 2024-05-12 at 18:43:21.
⬅️ Previous capture (2021-11-30)
-=-=-=-=-=-=-
Network Working Group M. A. Padlipsky
Request for Comments: 928 Mitre Corp.
December 1984
INTRODUCTION TO PROPOSED DOD STANDARD H-FP
Status Of This Memo
This RFC suggests a proposed protocol for the ARPA-Internet
community, and requests discussion and suggestions for improvements.
Distribution of this memo is unlimited.
Important Prefatory Note
The broad outline of the Host-Front End Protocol introduced here and
described in RFC 929 is the result of the deliberations of a number
of experienced H-FP designers, who sat as a committee of the DoD
Protocol Standards Technical Panel under the author's chairmanship.
The particular protocol to be described is, however, the result of
the deliberations of a small, ad hoc group, who sat as a de facto
subcommittee of the H-FP committee, also under the author's
chairmanship. The protocol, then, follows the consensus of the full
group as to what the new H-FP should "look like," but has not
benefitted from painstaking study by a large number of experienced
H-FP designers and implementers. (It has been looked at before
release as an RFC by several of them, though.) Even if that were not
the case, it would still be the intent of the designers that the
protocol be subjected to multiple test implementations and probable
iteration before being agreed upon as any sort of "standard".
Therefore, the first order of business is to declare that THIS IS A
PROPOSAL, NOT A FINAL STANDARD, and the second order of business is
to request that any readers of these documents who are able to do
test implementations (a) do so and (b) coordinate their efforts with
the author (617-271-2978 or Padlipsky@USC-ISI.ARPA.).
Historical/Philosophical Context
Late in May of 1971, the author was presenting a status report on
whether the Multics ARPANET implementation would be ready by the
July 1 deadline declared by the sponsor earlier that month. Some
controversy developed over the fact that the Multics "NCP" (Network
Control Program--actually a blanket term covering the Host-Host and
Host-IMP protocol interpreters) did not queue requests for
connections. As the specification explicitly declared the topic to
be one of implementors' choice, the author attempted to avoid the
argument by asking the interrogator what he was up to these days.
The answer was, "Oh, I'm working on the High-Speed Modular IMP now"
(later the Pluribus IMP). And the proverbial coin dropped: The
author replied, "I've got a great idea. Now that we've got some
space to program in the IMP, why don't we separate out most of the
Padlipsky [Page 1]
RFC 928 December 1984
Introduction to H-FP
NCP and do it outboard: the only thing that really matters in the
Host is associating sockets with processes, and if we had common
implementations of all the bit-diddling stuff in the IMPs, we
wouldn't have disputes over the interpretation of the spec and we'd
also save a lot of Host CPU cycles!"
As far as the author knows, that incident was the beginning of what
came to be called "Network Front-Ends" and, more recently, "Outboard
Processing Environments." (The name change, by the way, was
motivated by a desire to prevent further confusion between NETWORK
Front Ends--always conceived of as distributed processing mechanisms
for the offloading of intercomputer networking protocols from
Hosts--and traditional communications front-ends, which have no
connotation of bearing protocol interpreters invokable by Host-side
programs.) At least, the idea was original to him and he later was a
principal designer and the primary author of the first Host-Front End
Protocol. So, on the one hand, the present document might be marred
for some readers by undertones of parental pride, but on the other
hand, if you like primary sources....
The evolution of the outboard processing idea has been dealt with
elsewhere [1]. For present purposes, it should suffice to observe
that some half-a-dozen implementors of "NFE's" of various sorts are
known to the author to have met with success. The topic of why use
an explicit protocol in the first place (as opposed to emulating a
device, or devices, already known to the Host/operating system)
deserves a word or two here, however. ([2] deals with it in more
general terms.) The crucial consideration is that in the general
case you wind up "not doing real networking" if you attach a Host to
a network by known device emulation, where real networking is taken
to mean what has been called "resource sharing" in the ARPANET
literature, and what appears to be dubbed "open system
interconnection" in the ISO literature: Operating systems' built-in
assumptions about known devices--whether terminals, terminal
controllers, or RJE stations--tend to get in the way of the sort of
process-process and eventually procedure-procedure communications
that serve as the basis for applications more interesting than simple
remote login. To those unfamiliar with the outboard processing
approach, the premise that the way to attach is via an explicit
protocol may be difficult to accept, but to those who have done it,
it makes almost perfect sense.
To those, by the way, who have worked in intercomputer networking
from the perspective of inboard (Host-side) implementations of
protocol suites, the outboard processing idea often seems to lead to
less than optimal results, especially as to maximizing throughput.
And it is difficult to argue that if a given Host were well and truly
Padlipsky [Page 2]
RFC 928 December 1984
Introduction to H-FP
fine-tuned to "do networking" the insertion of an extra processor
could somehow lead to better networking. However, for Hosts where
conservation of CPU cycles is an issue, or even where memory is
scarce (i.e., where it's desirable to conserve the resources being
shared), outboarding is clearly the way to go. For that matter,
viewing outboard processing aright (as a form of distributed
processing) it can be argued that even for extremely powerful
"intelligent work stations"/"personal computers" which have the
resources to spare it still makes sense to outboard in order not to
have to do new implementations of entire protocol suites for each new
such system--always assuming, of course, that the Host-Front End
protocol in play is noticeably less complex than the offloaded
protocols.
None of this is meant to imply that outboard processing is the ONLY
way to do intercomputer networking, of course. It is, however, meant
to suggest that outboard processing can be advantageous in a number
of contexts. Indeed, given the joint advents of microprocessors and
Local Area Networks, a generic bus interface unit which also plays
the role of a NFE (that is, is an Outboard Processing Environment)
even allows for the original intent of "offloading to the IMP" to be
realized, so that a free-standing, possibly fairly expensive NFE need
not be interposed between Host and net. Note, by the way, that
nothing in the OPE approach requires that ALL Hosts employ OPEs. That
is, the only protocols "seen" beyond the Comm Subnet Processor are
the common intercomputer networking protocols (e.g., all DDN IMPs see
and read IP datagrams). H-FP is strictly a matter between a Host and
its OPE.
It is also important to be aware that, given the advent of several
different suites of protocols in the networking world, it might well
be the case that the only reasonable way to achieve
"interoperability" might well be to use a suitable H-FP (such as the
one to be presented in the companion RFC) and an Outboard Processing
Environment which is capable of parallel invocation of protcol suites
(with the choice of suite for a given connection being dependent, of
course, on the native suite of the desired target Host and/or
application).
The unquestionable advantages, then, of the approach, based on ten or
more years of experience and analysis, would seem to be as
follows--always recalling the assumption that the work to implement
and execute the H-FP in play is small compared to the full protocol
suite in question: As noted, common implementation of a protocol
suite has the automatic advantage of mutual consistency; further,
particularly in the DOD context, it's far easier to procure common
Padlipsky [Page 3]
RFC 928 December 1984
Introduction to H-FP
implementations of standard protocols than to procure different ones
on a per-Host type basis. Also as noted, if the resources to be
shared are viewed as being the participating Hosts'
CPU cycles and memories, these resources are conserved by doing as
much as possible of the networking protocols in an OPE rather than in
the mainframe. Another, less evident advantage is that having an OPE
effectively insulates a Host against changes in the
outboarded/offloaded protocols--or even changes of the protocols,
should the nascent international protocol standards ever mature
sufficiently to supplant the in-place DOD standards. (That is, given
an abstract enough interface--in the spirit of the Principle of
Layering--a Host could, for example, go from doing TCP as its
"Host-Host" protocol to, say, ECMA Class 4 as its "Transport"
protocol without taking any particular cognizance of the change,
however unattractive such a change would be to advocates of the
APRANET Reference Model such as the author. See [3] for more on the
implied "Reference Model" issues.) Finally, although a few rather
specialized points could also be adduced, it should be noted that for
network security architectures which are predicated on the ability to
control all means of egress from and ingress to "the net", uniform
use of OPEs is clearly desirable.
If we can stipulate that an OPE is/can be a good thing, then the
remaining problem is just what the protocol interpreted by a Host and
its OPE ought to be, once it's observed that a standard protocol is
desirable in order to allow for as much commonality as possible among
Host-side interpreters of the protocol. That is, we envision the
evolution of paradigmatic H-FP PIs which can more or less
straightforwardly be integrated with various operating systems, on
the one hand, and the ability simply to transplant an H-FP PI from
one instance of a given operating system to other instances of the
same system, much as is currently being attempted in the DODIIS NFE
program. Again, the major motivation in the DOD context is the
minimizing of procurement problems.
Technical Context
As noted, some half-a-dozen Host-Front End protocols have been seen
by the author. Indeed, in December of 1982, a meeting was convened
to allow the developers of those H-FPs to compare their experiences,
with an eye to coming up with a proposal for a DOD standard H-FP;
this paper is a direct result of that meeting. In the current
section, we present the consensus of the meeting as to the broad
outline of the protocol; in the accompanying document, the current
version of the proposed protocol will be presented, as detailed by
the author and Richard Mandell and Joel Lilienkamp (both of SDC).
Padlipsky [Page 4]
RFC 928 December 1984
Introduction to H-FP
Note, by the way, that in some sense we should probably have changed
the name from H-FP to H-OPEP (or something), but the habit of saying
"H-FP" seems too deeply engrained, despite the fact that it does seem
worthwhile to stop saying "NFE" and start saying "OPE." (Besides,
H-OPEP looks rather silly.)
A final preliminary: all the designers and implementors of H-FPs
present at the December meeting concurred that the true test of any
protocol is how well it implements. Therefore, until several
implementations of the "new" protocol have been performed and
assessed, it must be understood that the proposed protocol is
precisely that: a proposal, not a standard.
Not too surprisingly, the first point on which consensus was reached
is that there are three separable aspects (or "layers") to an H-FP:
At bottom, there must be some physical means for conveying bits from
Host to OPE and from OPE to Host. As it has always been a premise of
outboard processing that the Host's convenience is paramount, just
what this physical layer is can vary: typically, a bit-serial
interface is customary, but parallel/DMA interfaces, if available for
the Host and interfaceable to a given OPE, are fair game. (So would
teleporting the bits be, for that matter.)
In the middle, there must be a layer to manage the multiplexing of
network "connections" and the control of the flow between Host and
OPE. If we agree to call the lowest layer the Link and the middle
layer the Channel, one thing which must be noted is that between the
two of them, the Link and Channel layers must be responsible for
reliably conveying the bits between Host and OPE. After all, an OPE'd
Host should not be "weaker" than one with an inboard implementation
of a robust Host-Host protocol such as TCP. It should be noted that
any Host which "comes with" a suitable implementation of the X.25
interface protocol (where the definition of "suitable" is rather too
complex to deal with here) could, given an OPE conditioned to accept
it, quite cheerfully satisfy the requirements of the lower two
layers. This is not to say that X.25 "is" the mechanization of H-FP's
Link and Channel layers, however; merely that it could be used. The
protocol spec itself will detail an alternative, less cumbersome
channel layer for Hosts which don't have or want X.25.
The top layer of H-FP is the most important: we refer to it as the
Command layer. Here is where the peer H-FP modules in a given Host
and OPE communicate with each other. Indeed, the segregation of JUST
multiplexing and flow control (plus reliability) into the Channel
Layer is done--in addition to making it easier for Hosts that possess
preexisting software/hardware which could be turned to the
purpose--so as to clarify "what the H-FP is": it's the commands and
Padlipsky [Page 5]
RFC 928 December 1984
Introduction to H-FP
responses of the Command layer wherewith the Host's processes are
able to manipulate the outboard implementations of the members of a
protocol suite. The use of the phrase "commands and responses" is
rather significant, as it happens. For in the protocol to be proposed
for DOD standardization, unlike all but one of its predecessors,
binary encoded "headers" are not employed; rather, the H-FP commands
are indeed ASCII strings, and the responses (following the practice
of ARPANET FTP) ASCII-encoded numbers.
There are various reasons for this departure, which initially stemmed
from a desire to have the same NFE be usable for terminal traffic as
well as Host offloading, but the one that seemed to dominate when
consensus was arrived on it as the basis for the new standard is that
it is very much in the original spirit of H-FP. That is, if you want
to "make things as easy as possible for the Host", it makes a great
deal of sense to offload in a fashion that only requires some sort of
scenario or script ("exec-com"/"command file"/"shell command" are
approximations on some systems) in the Host, rather than requiring a
program, possibly of more complexity than we would like. This is not
to say that we envision all--or even most--Hosts will take the
scenario approach to H-FP mechanization, but rather that the command
orientation chosen allows for the possibility. (It would be useful to
recall that the Channel layer does all the necessary
multiplexing/demultiplexing, so that each channel's metaphorical
state machine--at least on the Host side--really has very little to
worry about other than "doing its thing.")
It should be noted that the proposed protocol provides a mechanism
for offloading "all" protocols. That is, although most "first
generation NFEs" only handled ARPANET Reference Model Layers II and I
(Host-Host and Network Interface--approximately ISO levels 4-1, with
some of L5's functionality included when it comes to service
identifications being handled via Well-Known Sockets in L II), it is
assumed that OPEs will be evolved to handle L III offloading as well
(ISO 5-7). Indeed, it should also be noted that what is being
addressed here is "the protocol", not "the" OPE. More will be said
on this topic below, and in the protocol spec itself, but it is
important to realize from the outset that the H-FP being proposed is
intended to be implementable by any number of OPE suppliers/vendors,
so "an" OPE may or may not choose to implement, say, a given file
transfer protocol, but provided it says so in proper H-FP terms and
does offload some other protocols it's still an OPE in our sense of
the term. (Cf. "Issues" and "Non-Issues", below.)
Padlipsky [Page 6]
RFC 928 December 1984
Introduction to H-FP
Issues
The following items are either in some sense still open issues or
bear special emphasis:
Command Approach
The most striking feature of the new H-FP, especially to those who
have seen older H-FPs, is the decision to employ
character-oriented commands rather than the more conventional
binary-oriented headers at the Command Layer. As noted, the
primary motivation was the report that the approach worked well
when it was employed in an H-FP for the Platform Network called
NAP (Network Access Protocol) [4]. In discussions with NAP's
originator, Gerry Bailey, the author was convinced of the
fundamental reasonableness of the approach, but of course that
doesn't have to convince others. Additional rationales emerged in
discussions with Gary Grossman, the originator of the DCA/DTI
H-FP [5], which is probably the best-known current H-FP and which
furnished the default Channel Layer for the new one: In the first
place, the text approach makes parsing for the ends of
variable-length parameters easier. In the second place, it allows
for the possibility of creating a terminal-supporting OPE in a
very straightforward fashion should any OPE developer elect to do
so. (See below for more on the distinction between OPE developers
and H-FP implementors.) Finally, there's nothing sacred about
binary headers anyway, and just because the text approach is
different doesn't make it "wrong". So, although it's not out of
the question that the new protocol should back off from the text
approach if reviewers and/or implementors come up with compelling
reasons for doing so, the already frequently encountered reaction
of "it feels funny" isn't compelling. (It was, indeed, the
author's own initial reaction.) Besides, "nobody" (not even Gary)
really liked the top layer of the DCA/DTI H-FP.
X.25 Appropriateness
Of more concern than how text "feels" is whether X.25 "works".
That is, we understand that many system proprietors would greatly
prefer being able to use "off-the-shelf" software and hardware to
the greatest extent feasible and still be able to do intercomputer
networking according to DOD Standards, which is a major reason why
we decided to take the H-FP commands out of the Channel Layer of
the DCA/DTI H-FP even before we decided to encode them as text.
However, it is by no means clear that any old vendor supplied
"X.25" will automatically be usable as a new H-FP Channel and Link
layer mechanization. As noted, it all depends upon how Host
Padlipsky [Page 7]
RFC 928 December 1984
Introduction to H-FP
programs (the Command Layer/H-FP Protocol Interpreter in
particular) are able to invoke X.25 on particular systems. Also,
there might be peculiarities in the handling of some constructs
(the Group and Member fields--or whatever they're called--are a
strong candidate) which could militate against getting JUST
demultiplexing and flow control out of X.25-as-Channel
Link/Layers. For that matter, it's conceivable that on some
systems only one process can "own" the presumed DCE, but there's
no interprocess communication available between it and the
processes that want to use H-FP. What that all amounts to, then,
is that we don't pretend to be sufficiently versed in the vagaries
of vendor-idiosyncratic X.25 implementations to claim more than
that we THINK the new H-FP Command Layer should fit "on top of"
X.25 in a Host such that a suitably crafted OPE could look like a
DCE to the low-level Host software and still be an OPE in our
sense of the term. Finally, some reports on bit-transfer rates
attainable through typical X.25 interfaces give rise to concern as
to whether such a lash-up would be "good" even if it were
feasible.
DCA/DTI Channel Layer Appropriateness
The Channel Layer of the DCA/DTI H-FP has been implemented for a
few Host types already, and is being implemented for others (in
particular, as part of the DODIIS NFE project). A delicate
decision is whether to alter the header structure (e.g.--and
perhaps i.e.--to remove the now-superfluous command and response
fields). On the "con" side are the considerations that
implementations DO exist, and that it's well specified. On the
"pro" side are that keeping the header as it is is in some sense
"wasteful" and that somebody's going to have to go over the spec
again anyway, to remove that which no longer applies. (It should
be noted that Gary Grossman was initially tempted to scuttle the
Group and Member trick, but the presence of a similar
dichotomizing in X.25 seems to rule that out.) One of the
interesting issues during the review phase of the new H-FP, then,
will be the decision about which way to go on the Channel Layer
header in its non-X.25 version. (NOBODY considers going X.25
only, be it noted.) By the time the protocol is finalized, it
will, of course, be made clear in the protocol spec, but I'll
probably leave this in the final version of the Introduction just
for historical interest anyway.
Syntax
Another point which probably needs close scrutiny during the
review process is the "syntax" of the command lines. Basically,
Padlipsky [Page 8]
RFC 928 December 1984
Introduction to H-FP
we just took our best shot, but without any claims that it's the
best possible way to express things. So comments and/or
alternatives are earnestly solicited on this one.
L III Offloading
Contrary to the expectations of some, we are allowing for the
offloading of Process/Applications Layer (ARPANET Reference Model
L III) protocols. Both Bailey and Grossman reported favorably on
the feasibility of this. Two points should be made, however: It's
perfectly fair for a GIVEN OPE implementation not to offload a
given L III protocol, although it would presumably not sell as
well as ones which did. That is, we're not claiming that by
inventing a mechanization of the feature in the spec we levy a
constraint on everybody who implements "the protocol", (Cf.
Fabrication under Non-Issues, below). Just as we were feeling our
way on syntax in general, we're really feeling our way when it
comes to the L III stuff. (I'm not even sure I managed to convey
what I meant for "mediation level" to Joel and Dick.) Again,
suggestions are solicited.
Security
During the detailed design pass, we had an intensive discussion
with some of the Blacker design team on the interplay between the
new H-FP and a meant-to-be multilevel-secure OPE such as Blacker.
The conclusion was that by and large "Security" is to be an aspect
of an enhanced H-FP, rather than the standard one. The reasoning
was rather involved, but seems to amount to the following: Hosts
that are NOT MLS (or "Compartmented") have two significant
properties in our context: They're in the vast majority of
present-day systems. They have no legitimate need even to tell
their OPEs what they "think" their current System High or
Dedicated Mode level is; that information should be furnished by
some trusted portion of a network security architecture (e.g., a
security enhanced OPE, or a table in a "secure" comm subnet
processor).
Thus, even having the optional security label/level field in the
Begin command is in some sense overkill, because we're not sure of
any sensible circumstances in which it would be useful, but we put
it in "just in case". On the other hand, Hosts that ARE
MLS/Compartmented by definition can be permitted to assert what
the level of a given transmission (or perhaps of a given
connection) should be, and their OPEs need to have a mechanism for
learning this. But it is by no means clear that a given Host (or
even a given OPE) will be so structured as to make the H-FP PI,
Padlipsky [Page 9]
RFC 928 December 1984
Introduction to H-FP
the Channel PI, and the Link PI ALL trustworthy--as they'd have to
be if the security labeling were part of H-FP. So, we envision
the labeling's being handled by trusted code in both Host and OPE
that will be inserted into the normal processing route at the
appropriate point for the given architecture (presumably "at the
very bottom" of the Host, and "the very top" of the OPE), and that
will place the label in a convenient, known position in the
Host-OPE transmission "chunk" (block/packet/data unit) as the
circumstances dictate. (It's likely--but we wouldn't swear to
it--that a good place would be just before the H-FP command, and
if that's the case then semi-clearly the security enhanced H-FP
PIs would have to "make room" for it in the sense of handing the
Channel Layer a suitably lengthened "chunk".)
The Host and its OPE should be viewed as a single entity with
regard to labeling requirements in the non-MLS/C case, and either
the OPE will be conditioned to emit the right label or the CSNP
will "know" anyway; in the MLS/C Host and OPE case (and it should
be noted that it's just about impossible to envision a MLS/C Host
which IS outboarded which DOESN'T have a MLS/C OPE) it will depend
on the given security architectures as to whether each "chunk"
needs labeling (i.e., there COULD be trusted H-FP, Channel, and
Link PIs, so that only at channel establishment time does the
label need to be passed), but it seems likely each "chunk" would
need labeling, and we can see how that would happen (as sketched
above).
This is all, of course, subject to reappraisal when the full-time
Security folks get in the act, but for now, H-FP per se is viewed
as playing no direct role in "Security"--except indirectly, as
noted below under the Symmetric Begins Non-Issue. (In case
anybody's worrying about the case where the OPE is physically
remote from its Host, by the way, that line would have to be
protected anyway, so the Host/OPE-asa-single-unit view should hold
up.)
How It Implements
The final issue to take note of is that one of the central
premises of the Outboard Processing approach has always been that
H-FPs can be invented which implement more compactly on the Host
side than the code they're allowing to be offloaded. We certainly
think the new H-FP will fulfill that condition, but we'd certainly
like to hear of any evidence to the contrary.
Padlipsky [Page 10]
RFC 928 December 1984
Introduction to H-FP
Non-Issues
The following items are declared to be non-issues, in the sense that
even though some people have expressed concern over them we believe
that they are either "not part of the protocol" or resolved already
for reasons that were overlooked by those worried about them:
Fabrication
Who builds OPEs isn't within our purview, except to the extent of
hoping a few volunteers come forward to do testcase
implementations of what is, at present, only a paper protocol.
However, beyond agreeing that a few points should be marked as
"Notes to Entrepreneurs" in the spec, we didn't attempt to dictate
how an OPE vendor would behave, beyond the explicit and implicit
dictates of the protocol per se. For example, if a given OPE
doesn't offload SMTP, it jolly well ought to respond with the
appropriate "Function not implemented" code, and if a vendor
claims to accept X.25 for Channel and Link disagreements over what
X.25 "is" are the province of the vendor and the customer, not of
the H-FP spec. As OPE'S are supposed to be offloading COMMON
protocols in a COMMON fashion, a given OPE should be able to
interoperate with another Host irrespective of whether that Host
even has an OPE, much less whose OPE it is if it's there. Thus,
for example, even though you'd expect to find OPEs that "come
with" their own LANs as a fairly frequent product, we don't appeal
to the notion in the conceptual model; nor do we attempt to
dictate "chunk" sizes at the Channel level. A protocol spec isn't
an implementation spec.
Symmetric Begins
For almost as long as there have been H-FPs, there has been
disagreement over whether only the Host can begin a connection or
if the OPE can also take the initiative. I am delighted to be
able to resolve this one finally: It turns out there IS a
compelling reason for insisting that THE PROTOCOL include
provision for OPE --> Host Begins, so it's "in" the protocol--but
any Host that doesn't need to deal with them doesn't have to (just
"spell" the "Function not implemented" response code correctly).
(In case anybody cares, the compelling reason is that if you HAD
an MLS OPE which happened to use a security kernel and a process
per level, you'd need IT to be listening for incoming connection
requests "from the net" rather than having the Host tell it to do
so, for various esoteric reasons--but in order to cater to the
possibility, we want the function in the protocol from the
Padlipsky [Page 11]
RFC 928 December 1984
Introduction to H-FP
beginning, on the grounds that we can envision SOME other uses for
it even in non-MLS environments [unlike the security labeling
trick discussed above, which only seems to make sense for MLS
Hosts/OPEs--that is, it doesn't burden the Host to reject a Begin
every once in a while but it would to go around labeling "chunks"
unnecessarily all the time].)
Routing
Concern has been voiced over the issue of what provisions the
protocol should make to deal with the situation where a Host,
probably for traffic/load reasons, has multiple OPEs and the
question arises of which OPE to use/route to. I claim this is a
non-issue at the protocol level. If the Host-side H-FP PI gets a
"No resources" response to a Begin, it can go off to another OPE
if it wants to. "Not our department". The conceptual model is
that of a Host and AN OPE--which "ought to" be expandable to carry
more load at some level. If you want multiple links for some
reason, the simplest solution would seem to be to have multiple
Channel Layers as well, but the whole thing just gets too iffy to
have anything sensible to prescribe in the protocol. In other
words, extending the concept to deal with discrete multiple OPEs
is either a Fabrication sort of thing, or a Notes to Host-side
Implementors sort of thing on a per specific OPE basis.
Operator Interface
It's probably implicit in the foregoing, but it might be worth
saying explicitly that the operator interface to a specific OPE is
a non-issue in terms of the protocol, beyond the provision we're
made for "Shutdown coming" responses as a reflection of a probable
operator interface action we imagine most operator interfaces
would provide. (It might also be worth noting that if your Host
does "color changes", your OPE had better have a trustworthy way
of being told to change the label it plops on all IP datagrams it
emits, but that comes under the heading of an Aside to Specialized
Implementors.)
Padlipsky [Page 12]
RFC 928 December 1984
Introduction to H-FP
Fine Points
There are a couple of known "loose ends" which are exceedingly fine
points in some sense that do bear separate mention:
The Allocate Event
While mentally testing to see if the new H-FP would indeed
off-load TCP, we came up against an interesting question: Viewing
H-FP as "just an interface at a distance" to a TCP PI, what about
the Allocate "Interface Event" in the TCP spec? As far as I'm
concerned, this could be classed as a non-issue, because I submit
that the spec is wrong in declaring that there is such a thing as
a MANDATORY Interface Event whereby the user of a TCP PI lets the
PI know how much data it can take. Granted, you might find such a
thing in most implementations, but what if you were in a virtual
memory environment with segment sharing (or a distributed
supervisor) and you wanted to avoid copies, so all that passed at
the interface to the PI (or even at the interface from the PI) was
a pointer? That is, the "DOD version" of the TCP spec has fallen
into the trap of assuming things about the execution environment
that it shouldn't have.
One moral of this is that
AN INTERFACE TO AN INTERPRETER OF A PROTOCOL IS N*O*T "THE
PROTOCOL".
Another moral is that the interface to the Host-side H-FP PI is
hard to say much about, but is where the equivalent functionality
will be found if you've offloaded TCP. That is, it's reasonable
to let the user "tell" the outboard PI at Begin time if big or
small buffers are expected to be in play "net-ward" as part of the
protocol, but the outboard PI is expected to deliver bits to the
Host as they come unless throttled by the Channel Layer, or by
some to-be-invented other discipline to force the OPE to buffer.
(For present purposes, we envision letting the Channel Layer
handle it, but nifty mechanizations of encouraging the OPE to
"make like a buffer" would be at least looked at.) As a
Fabrication issue, it is the case that "equity" has to be dealt
with with regard to the use of the OPE's resources (especially
buffers) across H-FP connections/channels, but that's a different
issue anyway, touched upon in the final fine point.
Padlipsky [Page 13]
RFC 928 December 1984
Introduction to H-FP
Precedence
Clearly, the existence of a notion of Precedence in DOD protocols
has to get reflected in the outboard PI's implementations. Just
what, if any, role it has in the H-FP, per se, is, however, by no
means clear. That is, if the Host doesn't take Begins from the
OPE and is "full up" on the number of Server Telnet connections
it's willing to handle, what should happen if a high precedence
SYN comes in on the Telnet Well-Known Socket (in present day
terms)? Probably the OPE should arbitrarily close a low
precedence connection to make room for the new one, and signal the
Host, but even that assumes the Host will always hurry to be
prepared to do a new passive Begin. Perhaps we've stumbled across
still another argument in favor of "Symmetric Begins".... At any
rate, Precedence does need further study--although it shouldn't
deter us from making "the rest" of the protocol work while we're
waiting for inspiration on how to handle Precedence too.
A Note on Host Integration
The most important thing about Hosts in any intercomputer network is
that they furnish the resources to be shared. The most significant
obstacle to sharing those resources, however, is the fact that almost
invariably they were designed under the assumption that the Host was
a fully autonomous entity. That is, few operating systems currently
deployed "expect" to be members of a heterogeneous community of
operating systems. In many cases, this built-in insularity goes so
far as to have applications programs cognizant of the particular type
of terminal from which they will be invoked.
Intercomputer networking protocols attempt to resolve the problems of
heterogeneity by virtue of presenting appropriate common intermediate
representations (or "virtualizations") of the constructs and concepts
necessary to do resource sharing. A Host-Host protocol such as TCP
"is" a virtual interprocess communication mechanism; a virtual
terminal protocol such as Telnet obviously is a mechanism for
defining and dealing with virtual terminals; FTP offers common
representations of files; and so on. It cannot be stressed strongly
enough, though, that this entire approach to intercomputer networking
is predicated on the assumption that the modules which interpret the
protocols (PIs, as we'll refer to them often) will be PROPERLY
integrated into the various participating operating systems. Even in
the presence of powerful OPEs, wherein the bulk of the work of the
various PIs is performed outboard of the Host, the inboard "hooks"
which serve to interface the outboard PIs to the native system must
not only be present, they must be "right". The argument parallels
the analysis of the flexible vs. rigid front-ending attachment
Padlipsky [Page 14]
RFC 928 December 1984
Introduction to H-FP
strategy issue of [1]; to borrow an example, if you attempt to
integrate FTP by "looking like" a native terminal user and the
operator forces a message to all terminals, you've got an undetected
pollution of your data stream. So the key issue in attaching Hosts to
networks is not what sort of hardware is required or what sort of
protocol is interpreted by the Host and the OPE (or comm subnet
processor, for that matter), but how the PIs (full or partial) are
made to interrelate with the pre-existing environment.
It would be well beyond the scope of this document to attempt even to
sketch (much less specify) how to integrate H-FP PIs into each type
of operating system which will be found in the DoD. An example,
though, should be of use and interest. Therefore, because it is the
implementation with which we are most intimately familiar, even
though it's been several years, we propose to sketch the Multics
operating system integration of the original ARPANET Network Control
Program (NCP)--which is functionally equivalent to an H-FP PI for
offloading ARM L II and L I--and Telnet. (A few comments will also
be made about FTP.) Note, by the way, that the sketch is for a
"full-blown" H-FP; that is, shortcuts along the lines of the
scenario-driven approach mentioned above are not dealt with here.
One of the particularly interesting features of Multics is the fact
that each process possesses an extremely large "segmented virtual
memory". That is, memory references other than to the segment at
hand (which can itself be up to 256K 36-bit words long) indirect
through a descriptor segment, which is in principle "just another
segment", by segment number and offset within the segment, so that a
single process--or "scheduling and access control entity"--can
contain rather impressive amounts of code and data. Given that the
code is "pure procedure" (or "re-entrant"), a "distributed
supervisor" approach is natural; each process, then, appears to have
in its address space a copy of each procedure segment (with
system-wide and process-specific data segments handled
appropriately). Without going too far afield, the distributed
supervisor approach allows interrupts to be processed by whichever
process happens to be running at a given time, although, of course,
interprocess communication may well be a consequence of processing a
particular interrupt.
A few other necessary background points: A distinguished process,
called the Answering Service, exists, originally to field interrupts
from terminals and in general to create processes after
authenticating them. Other shared resources such as line printers
are also managed by distinguished processes, generically known as
"Daemons". Device driver code, as is customary on many operating
systems, resides at least in part in the supervisor (or hard core
Padlipsky [Page 15]
RFC 928 December 1984
Introduction to H-FP
operating system). Finally (for our purposes, at least), within a
process all interfaces are by closed subroutine calls and all I/O is
done by generic function calls on symbolically named streams; also,
all system commands (and, of course, user written programs which need
to) use the streams "user_input" and "user_output" for the obvious
purposes. (At normal process creation time, both user I/O streams
are "attached" to the user's terminal, but either or both can be
attached to any other I/O system interface module instead--including
to one which reads and writes files, which is handy for consoleless
processes.)
All that almost assuredly doesn't do justice to Multics, but equally
likely is more than most readers of this document want to know, so
let's hope it's enough to make the following integration sketch
comprehensible. (There will be some conscious omissions in the
sketch, and doubtless some unconscious ones, but if memory serves, no
known lies have been included.)
Recalling that NCP is functionally equivalent to H-FP, let's start
with it. In the first place, the device driver for the 1822 spec
hardware interface resides in the supervisor. (For most systems, the
PI for H-FP's link protocol probably would too.) In Multics,
interrupt time processing can only be performed by supervisor
segments, so in the interests of efficiency, both the IMP-Host (1822
software) Protocol PI and the multiplexing/demultiplexing aspects of
the Host-Host Protocol PI also reside in the supervisor. (An H-FP PI
would probably also have its multiplexing/demultiplexing there; that
is, that portion of the Channel Layer code which mediates access to
the OPE and/or decides what process a given message is to be sent to
might well be in the supervisor for efficiency reasons. It is not,
however, a hard and fast rule that it would be so. The system's
native interprocess communications mechanism's characteristics might
allow all the Channel Layer to reside outside of the supervisor.)
Even with a very large virtual memory, though, there are
administrative biases against putting too much in the supervisor, so
"everything else" lives outside the supervisor. In fact, there are
two places where the rest of the Host-Host Protocol is interpreted on
Multics, although it is not necessarily the case that an H-FP PI
would follow the same partitioning even on Multics, much less on some
other operating system. However, with NCP, because there is a
distinguished "control link" over which Host-Host commands are sent
in the NCP's Host-Host protocol, the Multics IMP-Host Protocol PI
relegates such traffic to a Network Daemon process, which naturally
is a key element in the architecture. (Things would be more
efficient, though, if there weren't a separate Daemon, because other
processes then have to get involved with interprocess communication
Padlipsky [Page 16]
RFC 928 December 1984
Introduction to H-FP
to it; H-FP PI designers take note.) To avoid traversing the Daemon
for all traffic, though, normal reads and writes (i.e., noncontrol
link traffic) are done by the appropriate user process. By virtue of
the distributed supervisor approach, then, there is a supervisor call
interface to "the NCP" available to procedures (programs) within user
processes. (The Daemon process uses the same interface, but by virtue
of its ID has the ability to exercise certain privileged primitives
as well.)
If a native process (perhaps one meaning to do "User Telnet", but not
limited to that) wanted to use the network, it would call the open
primitive of "the NCP", do reads and writes, and so on. An
interesting point has to do with just how this interface works: The
reads are inherently asynchronous; that is, you don't know just when
the data from the net are going to be available. In Multics, there's
an "event" mechanism that's used in the NCP interface that allows the
calling process to decide whether or not it will go blocked waiting
for input when it reads the net (it might want to stay active in
order to keep outputting, but need to be prepared for input as well),
so asynchrony can be dealt with. In the version of Unix (tm) on
which an early NFE was based, however, native I/O was always
synchronous; so in order to deal with both input from the terminal
and input from the net, that system's User Telnet had to consist of
two processes (which is not very efficient of system resources).
Similar considerations might apply to other operating systems
integrating H-FP; native I/O and interprocess communication
disciplines have to be taken into account in designing. (Nor can one
simply posit a brand new approach for "the network", because Telnet
will prove to rely even more heavily on native mode assumptions.)
The other aspect of NCP integration which we should at least touch
on--especially because process-level protocols make no sense without
it--is how "Well-Known Sockets" (WKSs) work. In broad terms, on
Multics the Network Daemon initially "owns" all sockets. For
Well-Known Sockets, where a particular process-level protocol will be
in effect after a successful connection to a given WKS, code is added
to the Answering Service to call upon the NCP at system
initialization time to be the process "listening" on the WKSs. (This
is a consequence of the fact that the Answering Service is/was the
only Multics process which can create processes; strategies on other
systems would differ according to their native process creation
disciplines.) How to get the "right kind of process" will be
sketched in the discussions of the process level protocols, but the
significant notion for now is that typically SOME sort of prior
arrangement would be done by any networked Host to associate the
right kind of process with a WKS.
Padlipsky [Page 17]
RFC 928 December 1984
Introduction to H-FP
Now, we don't expect that the foregoing will enable even the world's
greatest system jock to go out and design the integration of an H-FP
PI for a system that had never been networked (in the ARPANET style
of networking) before. But we propose to stop there and turn to some
comments on process level protocols, for two reasons: In the first
place, it would take us much too far afield to go into significantly
greater detail; and in the second place, because of the functional
equivalence of H-FP and NCP combined with the number of operating
systems which have integrated NCP and, for that matter, TCP/IP, which
are also functionally equivalent to H-FP (used for offloading L II
and L I), models are available in the ARPANET community and concerned
H-FP PI implementors can follow them.
Turning to Telnet integration, and returning to Multics as an
example, we note that "User Telnet" is straightforward. "All you
need" (for small values of "all") from an INBOARD User Telnet is a
command that gives the user some sort of interface, converts between
the native Multics character set and terminal discipline and the
Network Virtual Terminal equivalents (and as Multics is very generic
when it comes to I/O, that's not hard), and writes and reads "the
net" (more accurately, calls upon the Host-Host protocol PI--or upon
the H-FP PI to get at the H-HP--appropriately). (One point that's
not obvious: make the Well-Known Socket "on the other side" a
parameter, defaulting to the Telnet WKS, because you'll want to use
the same command to get at other process-level protocols.) If
there's an OPE in play which offloads User Telnet, however, things
can be even simpler: the inboard command just reads and writes the
terminal and lets the OUTBOARD User Telnet PI handle the conversion
to and from the Virtual Terminal form (presumably, from and to the
desired local form).
When it comes to the incoming ("Server") aspects of Telnet, life can
get complicated on some systems for an inboard implementation.
However, fortunately for our purposes,
Multics' native mechanisms lend themselves readily to integration; an
awareness of the inboard issues will be useful even if in response to
a connection attempt on the Telnet WKS, the (Server) Host is
obligated to associate the connection (the actual logic is somewhat
more complex under the ARPANET Host-Host Protocol, which employs
paired simplex connections) with a process that is prepared to
translate between Telnet and native mode representations and
otherwise "look like" a local user process--that is, in particular
the connection becomes an I/O source/sink to the native command
processor on time-sharing systems. As indicated, process creation is
taken care of in Multics by having the Answering Service process
listen on the WKS. Because the Answering Service is in some sense
Padlipsky [Page 18]
RFC 928 December 1984
Introduction to H-FP
just another Multics process, it too does user I/O through the normal
system mechanisms. So while for local terminals the user I/O streams
are attached through a module called "ttydim" (where "dim" stands for
"device interface module"), NVTs are attached through a functionally
equivalent and identically invoked module called "nttydim" (the
Answering Service knows which DIM to use based on the symbolic
designator of the "line" on which it received the interrupt, as it
happens).
[The notion of "attaching" the streams bears a bit more explanation:
Attach is a primitive of the Multics generic I/O mechanism which
associates a stream name and a particular DIM (or I/O system
interface module in later terminology); the other I/O primitives
(read, write, etc.) are invoked with the stream name as a parameter
and an I/O "switch" causes the entry point corresponding to the
primitive to be invoked in whichever DIM the stream is currently
attached to. So a Server Telnet process starts life attached
through nttydim to a particular network connection, while a local
process starts life attached through ttydim to a particular physical
line, and both processes proceed indistinguishably (viewed from
outside the I/O switch, anyway).]
The pre-existing orderliness that makes things easy on Multics does
not, unfortunately, appear in all operating systems. Indeed,
delicate choices occasionally have to be made as to WHICH native
terminal to map to on systems that don't do generic I/O in native
mode, and it is likely that for some systems the particular mapping
to bring into play in Server Telnet might be determined by the
particular application program invoked. This issue can become very
touchy when the application "expects" a "data entry terminal", say.
The Server Telnet for such a system would naturally attempt to
negotiate the "DET" option with the corresponding User Telnet. But
the user might be at a physical terminal that isn't a member of the
DET class, so that User Telnet must either refuse to negotiate the
option or--and we would recommend this alternative strongly, as it
seems to be within the "spirit" of the protocol--offer some sort of
simulation, however crude, of the behavior of a DET. Also,
something sensible has to be done on systems where there is no clear
analog of the command processor expected to be managing the Server
process. (Say, when a "menu" of applications is always displayed on
an available terminal in native mode.)
A final Telnet integration issue (although other points could be
noted, we're not pretending to be exhaustive and this should be
enough to "give the flavor"): The Telnet Interrupt Process generic
function calls for particularly careful integration. Here, the
intent of the function is to virtualize what is called the "quit
Padlipsky [Page 19]
RFC 928 December 1984
Introduction to H-FP
button" on some systems. That is, the user wants the system to
interrupt his process (which may, for example, be in a loop) and get
back to the command processor (or "the system" itself). On native
character-at-a-time systems, the native mechanism is usually the
entering of a particular "control character"; on native
line-at-a-time systems, the native mechanism is usually the striking
of the "ATTN" or Interrupt button or the "Break" key (sometimes more
than once, to distinguish it from a communication to the executing
program). But the native mechanisms typically involve interrupt time
code, and Server Telnet typically wouldn't be executing at that
level, so the solution (omitting the intricacies of the interaction
with the NCP or the H-FP PI, which also get into the act) would be to
make use of--in the Multics case--a pre-existing INTRAprocess signal,
or to add such a mechanism (unless the architecture chosen has a
Server Telnet Daemon of some sort, in which case an INTERprocess
signal would be needed).
The extension of the foregoing to an outboard Server Telnet may not
be obvious, but we won't expend a great deal of time on it here.
Even if "the protocol" is being handled in an OPE, the Host-side
software must be able to associate an H-FP connection with the
command language interpreter of a user process and to respond
appropriately to an H-FP Signal command if it arrives, and the OPE
must know not only the desired character set but also the local
equivalents of Erase and Kill, at the minimum.
We'll skip FTP integration, on the grounds that this note is already
too lengthy, except to mention that in the OUTBOARD case it's still
going to be necessary to convey the name of the appropriate file and
directory to/from some appropriate Host-side code. (Similar problems
must be dealt with for outboard handling of "mail" if it's not part
of FTP.)
One other "integration" issue, which has been hinted at earlier and
about which not much can be said beyond some general guidelines: The
"top edge" of a Host-side H-FP protocol interpreter (i.e., the Host
user program interface, for
Hosts that are "doing real networking" rather than just using the OPE
to get at User Telnet and/or FTP and to offer Server Telnet and/or
FTP [and maybe "mail"], presumably in the "scenario-driven" fashion
sketched earlier) MUST BE APPROPRIATE TO THE HOST. In other words,
on Multics, where "everything" is closed subroutines, there would
presumably be a closed subroutine interface with event channels for
reads, pointers to buffers, and all that sort of thing, but on some
other style of operating system, the interface to the H-FP PI might
turn out to be "all" interprocess communication, or to "look like" a
Padlipsky [Page 20]
RFC 928 December 1984
Introduction to H-FP
device of some special class, or "all" system
calls/JSYSs/EOTs/Whatevers. We can't be much more specific, but we'd
be remiss to convey any impression that H-FP is a "free lunch". As
noted, an H-FP PI requires the same kind of integration as a generic
NCP--it's just smaller, and serves as insulation against changes (in
the offloaded protocols in general, or in the proximate comm subnet
in particular).
References
(References [1]-[3] will be available in M. A. Padlipsky's "The
Elements of Networking Style", Prentice Hall, 1985.)
[1] Padlipsky, M. A., "The Host-Front End Protocol Approach", MTR
3996, Vol. III, MITRE Corp., 1980.
[2] Padlipsky, M. A., "The Elements of Networking Style", M81-41,
MITRE Corp., 1981.
[3] Padlipsky, M. A., "A Perspective on the ARPANET Reference Model",
M82-47, MITRE Corp., 1982.
[4] Bailey, G., "Network Access Protocol", S-216,718, National
Security Agency Central Security Service, 1982.
[5] Day, J. D., G. R. Grossman, and R. H. Howe, "WWMCCS Host to Front
End Protocol", 78012.C-INFE.14, Digital Technology Incorporated,
1979.
Padlipsky [Page 21]