Network Working Group M. Padlipsky
Request for Comment: 666 26 November 1974
NIC: 31396
Specification of the Unified User-Level Protocol
After many discussions of my RFC 451, I discovered that the "Unified
User-Level Protocol" proposed therein had evolved into what had
always been its underlying motivation, a common command language.
There are several reasons why this latter approach satisfies the
original goals of the UULP and goes beyond them into even more useful
areas:
1. User convenience. As evidenced by the good response to the common
editor "neted", the Network Working Group has come to acknowledge the
fact that the convenience of non-system programmer users of the
Network must be served. Allowing users to invoke the same generic
functions -- including "batch" jobs -- irrespective of which Server
Host they happen to be using is surely a compelling initial
justification for a common command language. Note that the concern
with generic functions -- which "all" Servers do, one way or another
-- is intended to emphasize the common command subset aspects of the
language, rather than the "linguistic" elegance of it all. The
attempt is to specify an easy way of getting many things done, not a
complicated way of getting "everything" done.
2. "Resource sharing". Another area which is receiving attention in
the NWG of late is that of "automatic" or program-driven invocation
of resources on foreign systems. A common intermediate
representation of some sort is clearly necessary to perform such
functions if we are to avoid the old "n by m problem" of the Telnet
Protocol -- in this case, n Hosts would otherwise have to keep track
of m command languages. For the common intermediate representation
to be human-usable seems to kill two birds with one stone, as
expanded upon in the next point.
3. Economy of mechanism. In RFC 451, I advanced the claim that a
single user-level protocol which connected via socket 1 and Telnet
would offer economy of mechanism in that new responders would not be
required to service Initial Connection Protocols on socket after
socket as protocol after protocol evolved. This consideration still
applies, but an even greater economy is visible when we consider the
context of resource sharing. For if the common command language is
designed for direct employment by users, as the present proposal is,
there is no need for users on terminal support "mini-Hosts" (e.g.,
ANTS and TIPs) to require an intermediary server when all they
actually want is to work on a particular Server in the common
Padlipsky [Page 1]
RFC 666 Unified User-Level Protocol November 1974 language. (This is especially true in light of the fact that many such users are not professional programmers -- and are familiar with no command language.) That is, if resource sharing is achieved by an intermediate language which is only suitable for programs, you would have to learn the native command language of Server B if you didn't want to incur the expense of using Server A only to get at generic functions on Server B. (And you might still have to learn the native language of Server A, even if the expense of using two Servers where one would do isn't a factor.) 4. Front-ending. Another benefit of the common command language proposed here is that it is by and large intended to lend itself to implementation by front-ending onto existing commands. Thus, the unpleasant necessity of throwing out existing implementations is minimized. Indeed, the approach taken is a conscious effort to come up with a common command language by addition to "native" command languages rather than by replacement, for the compelling reason that it would be unworkable as well as ill-advised to attempt to legislate the richness represented by existing command languages out of existence. Further, as it is a closed environment, no naming conflicts with native commands would arise. 5. Accounting and authentication. As evidenced by the spate of RFCs about the implications of the FTP in regard to both accounting for use of Network services and authenticating users' identifications (Bressler's RFC 487, Pogran's RFC 501, and my RFC 505 -- and even 491), this area is still up in the air. The generic login command proposed here should help matters, as it allows the Server to associate an appropriate process with the connection while actuating appropriate accounting and access control as well, if it chooses. 6. Process-process functions. By enabling the invocation of foreign object programs, the present proposal offers a rubric in which such process-to-process functions as "parallelism" can be performed. (See the discussion of the "call" command, below.) Note that the UULP is not being advanced as a panacea: It is assumed that the actual transactions carried out are most likely not going to be in the common command language (although some certainly could be); however, what is furnished is a known way of getting the presumably special- cased programs executing elsewhere. Also, it offers a convenient environment into which can be placed such new functions, which we would like to have become generic, as Day's File Access Protocol. All of which seems to be a fair amount of mileage to get out of a distaste for remembering whether you find out who's logged in by saying "systat", "users", "s.who:c", "listf tty", or "who".... Padlipsky [Page 2]
RFC 666 Unified User-Level Protocol November 1974 Context Although ultimately intended to become the general responder to the Initial Connection Protocol, the UULP is initially to be a Telnet Protocol "negotiated option". When the option is enabled, the Server Host will furnish a command environment which supports the common conventions and commands discussed herein. In a sense, the UULP is a "selector". That is, the common command subset includes commands to exit from the common command environment and enter various other environments, along the lines of CCN's current Telnet Server. To exit from the UULP environment to the "native" command processor, the UULP command is "local" (see also the discussion of Case, below). Note that all commands terminate in Telnet "Newline" (currently cr-lf), unless altered by the "eol" command (below); internal separator is space (blank). (Entrance into other environments -- such as the FTP Server -- is discussed below.) There are two reasons for introducing a mechanism other than the apparently natural one of simply de-negotiating the option: First, it is bound to be more convenient for the user to type a command than to escape to his User Telnet program to cause the option disabling. Second, it is hoped that eventually the UULP will be legislated to be the default environment encountered by any Network login, in which case the natural way to enter the Server's "native" command environment would be by UULP command. Note: all UULP commands discussed herein are listed in Appendix 1, categorized as to optionality, with brief descriptions given. The appendix may be taken as a first-pass UULP Users' Manual. Responses Any optional commands which are not supported by a particular Server are to be responded to by a message of the form "Not implemented: commandname.", where the variable is the name of the command which was requested. Note that throughout this document, all literals must be sent exactly as specified, so as to allow for the possibility of Servers' being driven by programs (including "automata" or "command macros") in addition to "live" users. In general, the view has been taken here that a small number of literal, constrained responses is superior to a vast variety of numerically coded responses in which text may vary. Again, the motivation is to achieve an economy of mechanism. For on the coded model, there must be a coordinator of code assignments, which is just as well avoided. Further, as has been experienced in the use of the FTP, when there are many codes there are many ambiguities. (The sender may have a perfectly valid case for choosing, say, 452, while Padlipsky [Page 3]
RFC 666 Unified User-Level Protocol November 1974 the receiver may have an equally good interpretation of the codes' definitions for expecting, say, 453.) Experience with a related "error table" mechanism on Multics also bears out the assertion that coded responses create both managerial and technical problems. A final objection to numeric codes might be considered irrelevant by live some, but I think that the aesthetics of the situation do merit some attention. And when the common command language is being employed by live users, it seems to me that they would only be distracted by all those numbers flying around. (Nor can we assume that the numbers could be stripped by their "User UULP", for one of the basic goals here is to make it straightforward enough for a user at a TIP to deal with.) Arguments During the review process, it became evident that some global comments on arguments were in order. Two areas in particular appear to have led to some confusion: the strategy of specification of arguments on the command line, and the question of "control arguments". On the first score, the goal of "front-endability" must be recalled. Consider two native implementations of a particular command, one of which (A) expects to collect its arguments by interrogation of the user, and the other of which (B) expects to receive them on invocation (being invoked as a closed subroutine). Now, it is easy to imagine that a "Server UULP" could feed the arguments to A as needed without requiring A to be rewritten, but it is quite difficult to see how B could be made to interrogate for arguments without extensive rewriting. Therefore, a "least common denominator" approach of specifying arguments in advance incurs the minimum cost in terms of reworking existing implementations. On the second score, I have borrowed a notion from the Multics command language's convention called "control arguments" because it seems to be quite convenient in actual practice. The key is that some arguments are meant as literals, usually specifying a mode or control function to the command, while others are variables, specifying something like a particular file name or user identifier. A common example is a "mail" command, where the variables are the user identifiers and the Host identifiers, and the "control argument" is the designator that user identifiers have ceased and Host identifiers have begun. The convention used here is to begin the control argument with a hyphen, as this character never seems to be used to begin variable arguments. Thus, we use "-at" in the mail example. Although it is not a deep philosophical point, this approach does relieve argument lists of order-dependency, and feels right to me. Padlipsky [Page 4]
RFC 666 Unified User-Level Protocol November 1974 Case Although it appears to have been legislated out of existence by the specification of the Network Virtual Terminal's keyboard in the Telnet Protocol, the question of what to do about users at upper- case-only terminals remains a thorny one in practice. There are two aspects to consider: the alphabetic case of commands, and the ability to cause "case-mapping" in order to allow lower-case input. Some Servers have no local problems with the first aspect, as they operate internally in all upper-case or all lower-case and merely map all input appropriately. (Problems do arise, though, when one is using the User FTP on such a system to deal with a mixed-case system, for example.) Other Servers, however, attach the normal linguistic significance to case. (E.g., Smith's name is "Smith" -- not "SMITH", and not "smith".) To minimise superfluous processing for those Servers which are indifferent to case, all UULP commands are to be recognized as such whether they arrive as all upper-case or all lower-case. (They will be shown here as all lower merely for typing convenience.) Note that arbitrarily mixed case is not recognized, as it is an unwarranted assumption about local implementation to suppose that input will necessarily be case-mapped. On the second aspect, any Server which does distinguish between upper- and lower-case in commands' arguments (a.k.a. parameters) must furnish a UULP "map" command as specified in Appendix 2 in order to support logins from upper-case-only terminals attached to User Hosts which either do not support the Telnet Protocol's dictum that all 128 ASCII codes must be generable, or support it awkwardly. This seems a simpler and preferable solution than the alternative of legislating that upper-case Network-wide personal identifiers (and perhaps even Network Virtual Path Names) be pre-conditions to a usable common command subset. (As noted below, these latter concepts will fit in smoothly when they are agreed upon. The point here, though, is that we need not deprive ourselves of the benefits of a UULP until they are agreed upon.) User Names As implied above, the various Servers have their various ways of expressing users' names. Clearly, the principle of economy of memory dictates that there should be a common intermediate representation of names in and for the Network. It is probably also clear that this representation will be based upon the Network Information Center's "NIC ID's". However, it is unfortunately amply clear than an acceptable mechanism for securing up-to-date information cannot be legislated here - much less a mechanism for securely updating the implied data base. Therefore, at this stage it seems to be the Padlipsky [Page 5]
RFC 666 Unified User-Level Protocol November 1974 sensible thing to specify only the UULP syntax for conveying to the Server the fact that it is to treat a user name as a Network-wide name rather than as a local name, and let the supporting mechanisms evolve as they may. The prefacing of a name with an asterisk ("*") denotes a Network-wide name. (Such names may be either all upper-case or all lower-case, as with UULP commands' names.) The name "*free" is explicitly reserved to mean that (in the context of logging in) a login is desired on a supported or sampling account, if such an account is available. The response if no such account is available is to be "Invalid ident: *free." When Network-wide names are generally available Servers will either map them into local names or cause them to be registered as local names as they prefer. The point is that a Network-wide name will be "made to work" by the Server in the context of the UULP. Special Characters and Signals Another area in which the facts of life must outweigh the letter of the Telnet Protocol if the user's convenience is to be served is that of "erase" and "kill" characters. It is possible that User Telnets will uniformly facilitate the transmission of the Telnet control codes for generic character erase and generic line kill. It is certain, however, that User Telnets will differ -- and users will, if they use more than one User Telnet, be again placed in the uncomfortable position of having to develop too many sets of reflexes. Therefore, the UULP will optionally support the following commands: "erase char" and "kill char", where char is a printable ASCII character (to avoid possible conflicts with "control characters" which are recognized in the innermost areas of particular operating systems). Presumably, unwary users can be instructed not to choose an alphabetic, so as to avoid being placed in a position where they cannot invoke certain commands (erase and kill themselves, for example, in which case they couldn't be changed). These commands are supplements to the related Telnet control codes, and have the same meanings. The point here is that it may be far more convenient for a user to be able to say "erase #" and get the "#" to be recognized as the erase character by the Server than for the user to get his User Telnet to send the Telnet equivalent. The commands are designated as optional because they may lead to severe implementation problems on some Servers, and because the equivalent functions do, after all, exist in Telnet. Note: the erasing is assumed to be performed "as early as possible". That is, the sequence "erase x" "erase x" should come out equivalent to "erase x" "erase" -- the second appearance of Padlipsky [Page 6]
RFC 666 Unified User-Level Protocol November 1974 "x" resulting in the erasing of the space in the command line. Presumably, this is a sufficiently uncommon path that anomalous results would be tolerated by the user community, but the intent ought to be clear. The Telnet "synch" and "break" mechanisms are, by their very nature, best left to Telnet. End of line, however, might well be a different story. Therefore, as a potential convenience, the UULP optionally supports "eol char" to ask the Server to treat char as the end of line character thenceforth. To revert to Telnet Newline, "eol" (i.e., no argument, current terminator). Prompts Another aspect in which Servers vary while being the same is how they indicate "being at command level". Some output "ready messages"; others, "prompt characters". For the UULP, where some functions will be performed by means of a command's logging in to another system, the ability to specify a known prompt character is extremely desirable. The UULP command is "prompt char" where char is the character which is to be sent when the user's process (on the Server) is at command level. It is explicitly permitted to prefix char to a line consisting of a "native" prompt or ready message. Also, this command is explicitly acknowledged to be permissible prior to login. (Again, warning must be made of the bad results which can ensue if an alphabetic character is chosen.) Note: "prompt", "eol", "erase", and "kill" may all be re-invoked with a new value of char in order to change the relevant setting; all may be turned off by invocation with no argument. Login Perhaps the stickiest wicket of them all is the attempt to specify a generic login, but here we go. The UULP login command is "login userident", where userident is either a locally-acceptable user identifier or a Network-wide identifier as discussed above. Note that for utility in contexts to be discussed later, the locally- acceptable form must not contain spaces. Servers may respond to the login attempt with arbitrary text (such as a "message of the day"), but some line of the response must be one of the following: a prompt (as discussed above; indicating, in the present context, successful login); "Password:"; or "Invalid ident: userident." When passwords are required, it is the Server's responsibility either to send a mask or to successfully negotiate the Hide Your Input option. Padlipsky [Page 7]
RFC 666 Unified User-Level Protocol November 1974 Note that "login *free" is specifically defined to require no password. (If a "freeloader" has access to a User Telnet and has learned of the "*free" syntax, it is fruitless to assume that he couldn't have also read the common password.) If a password must be given, acceptable responses are arbitrary text containing a line beginning either with a prompt or with "Login unsuccessful." or with "Account:". If an account is requested, the responses must be either the "Login unsuccessful" message or the text containing a prompt already described. If any errors occur during the login sequence, users are to re-try by starting from the login command. (I.e., it is not required that the Server "remember" idents or passwords.) It is explicitly acknowledged that an acceptable response to "login *free" is "Limited access only." (followed by a prompt). This is intended to warn (human) users that the free account on the Server in question exists only to allow such functions as accepting mail and telling if a particular user happens to be logged in. (For objections to "loginless" performance of such tasks, see RFC 491. Note also that nothing here says that a Server must do anything other than return a prompt in response to "login *free" in the event that loginless operation is natural to it.) Given the UULP login discipline and the "prompt" command, it is reasonably straightforward for a program to login on a free account and perform one of these functions, for if the login command succeeded, the program will "see" a guaranteed prompt character. To make life simpler for those Hosts which normally have some sort of "daemon" process service mail and the like, a further expansion to login is in order. The point here is that some Hosts may not know what sort of process to pass an unqualified "login *free" to, whereas they'd be sure what to do with an explicit request to process mail, do a who command, or set up console to console communications. Therefore, UULP "login" will allow a "control argument" (as discussed above) of either "-mail", "-who", or "-concom", and the respective UULP commands involved must use the respective strings in any login line they transmit. Again, nothing is being said about what a Server has to do with the information, but some Servers need/want it. Usage Information Most Servers offer some sort of on-line documentation, from calling sequences of commands to entire users' manuals. There are two sorts of information of interest in the UULP environment: "normal" system information, and information about the particular Server's UULP implementation. To learn how to get descriptions of "native" commands, the UULP command is "help -sys" (abbreviation: "?"). Note that "-sys" is viewed as a "control argument" and as such prefaced by Padlipsky [Page 8]
RFC 666 Unified User-Level Protocol November 1974 a hyphen ("-") to facilitate distinction from other sorts of name (e.g., command names). To get a description of the Server's UULP implementation, "help -uulp". To get a description of a particular UULP command's implementation, "help comname". To be reminded of how to use the help command, "help". Note: as with command names and Network-wide user names, control arguments may be either all upper-case or all lower-case. It is specifically acknowledged that "No peculiarities." is an appropriate response to "help comname" if nothing of interest need be said about the Server's implementation of the UULP command in question. (After all, we're sparing users the necessity of studying a dozen or so users' manuals; the least they can do is to read the UULP command list.) Appropriate information for less taciturn Hosts to furnish would be such data as local command invoked (if such be the case), argument syntax (e.g., pathname description, or name of help file about pathnames), "To be implemented.", or even "Not to be implemented." "Mail" Even though a separate mail protocol is being evolved for general purposes, the UULP needs to address this topic as, by virtue of being login based, it allows systems which do access control and sender authentication on mail to make these abilities available to users within its framework of generic functions. Therefore, to read one's mailbox, the UULP command is "readmail". To have "live" input collected and sent to a local user, "mail userident"; to a remote user, "mail userident -at hostname", where the arguments have the "obvious" meanings. To send a previously-created file, "mail -f filename userident -at hostname". Several useridents may be furnished; the delimiter is space (blank). Similar considerations apply to hostnames. If both are lists, they sould be treated pairwise. (A more elaborate syntax could be invented to deal with the desire to send to several users at a given host and then to other users at other hosts, but it seems unnecessary to do so at this point, for multiple invocations would get the job done.) The mail command prefaces the message with a line identifying the sender (Host and time desirable, but not mandatory). For "live" collection, the end of message is indicated by a line consisting of only a period (".") followed by the regnant line terminator (usually the Telnet Newline, but see also the discussion of the eol command). If remote mail is not successfully transmitted, it is to be saved in a local file and that file's name is to be output as part of the failure message. ("Queueing" for later transmission is admired, but Padlipsky [Page 9]
RFC 666 Unified User-Level Protocol November 1974 not required.) The transmission mechanism will follow the general mail protocol. Note that when invoked with a "-at" clause, the mail command will send "login *free -mail" to the remote Host(s), followed by a mail command with no "-at" clause. A desirable, but not required, embellishment to "readmail" would be the accepting of a Host name ("-at hostname") to cause the local Host to go off to the named Host (via "login *free -mail") and check for mail there. Several hostnames could, of course, be specified. A further embellishment, which would probably be quite expensive, would be to accept "-all" as a request to check all Hosts (or, perhaps, all Hosts known to have a free account for the purpose) for mail. Direct Communication The ability to exchange messages directly with other logged in users is apparently greatly prized by many users. Therefore, despite the fact that there is a sense in which this function is not within the purview of the UULP, we will address it, after a digression. Digression: The UULP assumes that there can be straightforward "front ends" at the various Servers which translate generic function calls in a common spelling to calls for specific, pre- existing "native" functions. In the area of console to console communications, however, this premise does not really hold. The problem is that both major "native" implementations known to the author are seriously flawed. The TENEX "link" mechanism is both insecure (you've got no business seeing everything I type even if I'm careless enough to let you) and inconvenient (why should I be forced to remember that pesky semi-colon? how do I get back into phase after I've forgotten one?). It is also likely to be extremely difficult to simulate on systems which do not force Network I/O through local TTY buffers, even if the user interface were not subject to criticism. The Multics "send_message" mechanism, on the other hand, has a more sophisticated design, but is absurdly expensive. Therefore, the UULP mechanism to be described assumes that, for this function, new local implementations will be developed to support it. To permit console to console communications: "concom -on"; to refuse, "concom -off". Default is off. To enter message-sending mode: "concom userident -at hostname" ("-at" clause is optional). To exit from message-sending mode, type a line consisting of only a period (cf. Mail, above). While in message-sending mode, each line will be transmitted as a unit. The first message sent by concom must be prefaced by an identifying line, beginning "From:" and containing an appropriate address to which to reply. The closing period-only line Padlipsky [Page 10]
RFC 666 Unified User-Level Protocol November 1974 should be transmitted, so as to allow the other concom to close as well. Acceptable error response is "Not available: userident." (which neither confirms nor denies the existence of the particular user -- a matter of concern on the security front). The command must, of course, do whatever is necessary to transmit the messages; i.e., if locally invoked, access the local mechanism, and if invoked for remote communications, access the remote Host's concom command (via "login *free -concom"). Thus, a user at a TIP would use the local form of concom on the Host of the other party if this is convenient, or would use the remote form on his "usual" Server if the direct use is inconvenient for some reason (such as having no account there, say). The prerequisites for establishing communications are to find out if the user is logged in, and what "address" to use if so. The mechanism for gathering this information is an expanded "who" command. (Note that "who" is the UULP command to invoke the generic who's logged in function, with no constraints on format of reply.) The syntax is "who userident -at hostname", where both arguments may be multiple. If no "-at" clause, then check local Host only. Response must begin "From hostname: userident:" followed by either an appropriate address (e.g., "ll" if local "concom" uses TTY numbers and userident is logged in on TTY ll), or "Not available." As with mail, a "-all" embellishment might be pleasant. Note that the search for the specified user(s) -- whether or not "-all" is used -- still assumes that a "login *free -who" login will be used on the appropriate remote Host(s), followed by "who userident". This is why responses to the expanded who command must be so rigidly specified. Note also that regardless of whether the inquiry is made in terms of Network-wide or local user name, the response must be appropriate for use in "concom". "Good" concom implementations will presumably do an expanded who command automatically, so as to spare the user the necessity of having to do it separately. Indeed, the -concom control argument to login is defined to imply the ability to do a who as well as a concom to cater to this possibility. It is tempting to legislate that such an approach be the rule, but the implementation implications are not quite clear enough to do so. The implicit who should be viewed as a strong hint to implementers, though. File Creation and Manipulation The common command subset must furnish the ability to create and manipulate files. Creation is necessary in order to send mail on the one hand, and to produce source files for subsequent compilation on the other hand. Manipulation (such as copying, renaming, typing out, Padlipsky [Page 11]
RFC 666 Unified User-Level Protocol November 1974 and the like) is necessary both as a convenience aspect for users who seek to operate only in the common command language and as a means of performing desired batch functions (see below). For file manipulation commands, the user could enter the File Transfer Protocol environment. However, the FTP user interface is constrained by a very high degree of program-drivability. It is also lacks abbreviations and suffers from the lack of mnemonicity dictated by limiting command names to four characters. Further, some valuable functions (such as causing a file to be typed out) are not dealt with. Therefore, various UULP file manipulation commands are given in Appendix 1. They need not be addressed in detail here. However, some context would be useful: The file manipulation commands assume that all Servers have some notion roughly corresponding to "the user's working directory". All file names, whether the yet to be invented Network Virtual Pathname or the "local" variety, are taken to refer to files in this directory unless otherwise indicated. That is, the user should not have to furnish "dsk:" or the like; it is taken as given that when he refers to file "x" he means "the file named 'x' in my current working directory" and the Server "knows" what that means. At the present stage of development of the UULP, it does not seem fruitful to go into a reasoned explication of the following statement. For now, suffice it to say that those file manipulation commands (a copy of a foreign file, for example) which need to employ the FTP do employ the FTP and let it go at that. As the context and implications of the protocol become more widely understood, the detailed implementation notes will be added to the file commands -- and refined for the other commands, doubtless. In a way, the common file commands may be viewed as a kind of "User FTP" of known human interface when they deal with foreign files. (And, of course, until there's a Network virtual pathname, the issue doesn't really arise.) I expect that an "identify" command might be desirable, so that UULP commands which have to access other Servers in turn on behalf of the specific current user can have the necessary login information available to them. Such a command is included in Appendix 1, but should rank as speculation for now. On the topic of file creation, matters are rather complicated. It is clear that the ability to create files in the UULP environment is extremely desirable. It is also clear that using mail to a fake address to get the file created, then renaming the "unsent mail" file is too byzantine to expect users to do. Unfortunately, it is not clear exactly what the alternative is. That is, it's fairly clear that we need a common editor, but it's not at all clear which editor it should be. Padlipsky [Page 12]
RFC 666 Unified User-Level Protocol November 1974 Two widely-known editors come to mind: TECO and QED. However, not everybody has them. Even if everybody did, the "dialects" problem is bound to be a large one. Even if all the relevant system programmers could agree, there remains the question of whether the intended user population would be willing to bother learning a language as complex as TECO or QED. Therefore an optional UULP command to be called "neted" is proposed. (See also RFC 569.) This editor is a line- oriented context editor (no "regular expressions", but also no line numbers). It is copiously documented in Chapter 4 or the Multics Programmers' Manual, including an annotated listing of the (PL/I) source code. A simple user's guide has been prepared (see Appendix 3). Several implementations already exist, and commitments have been made for more. It may also be repugnant to some of the system programmers who would be called upon to implement it -- which is why it is optional, until and unless higher authority makes it mandatory. Other Protocols The nominal initial impetus for proposing a UULP was to allow new Network user protocols to be invokable through a common mechanism, rather than requiring a new responding mechanism to be built for a new contact socket for each new protocol. Although this goal has been shunted into the background by the admission of the true goal of the UULP, it has not been dropped completely. Therefore, to enter the FTP Server environment, the UULP command is "ftp"; to enter the RJE Server environment, the UULP command is "rje". Exit is as per the respective protocols. (Where possible, exit should be back to the UULP environment.) Invoking Foreign Programs There are two broad contexts in which it is desirable to cause a specific local program to be invoked from the common command environment: The User side of the connection may itself be a program, and the desired Server side program a specifically cooperating one; this is the more sophisticated context, of course. The less sophisticated context assumes that the User side is a "live" user, and the desire is to invoke a compiler or an object program the user has already compiled in the common language -- again as a convenience to the user so that he may operate in a sort of "Server-transparent" mode. (The latter case also covers "batch" use of the Server; see below.) In both contexts, the important role of the UULP is to specify the mechanisms through which the particular programs may be invoked, irrespective of the idiosyncrasies of the Servers' command languages. Padlipsky [Page 13]
RFC 666 Unified User-Level Protocol November 1974 Programming languages are much too big a problem to tackle here. However, assuming that a user somehow manages to create a source program, he still wants some commonality of spelling in invoking the appropriate compiler, or even the object program. As an optional but strongly recommended UULP command, then, "call name" should invoke object program name (where the named program may be a "native" command with arguments specified as appropriate). The values "pl1", "-basic", "-fortran", "-lisp", etc., should be recognized as requesting the invocation of the appropriate language processor (to operate on a named source file or interpretively/interactively if no source file was named), with "reasonable" defaults in effect. Note that this all is meant to imply that "native" commands are not directly invokable from the UULP environment (other than by "call"), to avoid potential naming conflicts between system commands and new UULP commands. Note that the "call" command in the UULP environment constitutes a rubric for "parallel" computation, given any ad hoc convention for the return of completion information. (Writing on the Telnet write socket plus 2 would seem appropriate, provided the initiator has the ability to "listen" for the rfc; but even a response in the data stream as a special-cased program is assumed on the "user"side anyway.) Other Matters The topic of "batch" mode merits some attention. As with the file manipulation commands, more consultation is necessary for a firm spec. However, I suspect that a "-batch" control argument to login should initiate batch mode processing by the Server, and given the call and identify commands all we might then require is a convention for designating the output file in order to return it via a copy command in the "job" itself (if output is to be returned rather than stored at the Server). Of course, -batch will probably need some substructure as to password and timing matters. More details will emerge in this area in future iterations. An admittedly fictionalized scenario might look like this: login Me -batch -pw xxx -shift 3 copy *452<me>source.text source.pl2 call -pl2 source call source input output identify Me2 yyy copy output *555>root>Me>output452 logout Padlipsky [Page 14]
RFC 666 Unified User-Level Protocol November 1974 where user "Me" wants the Server receiving the commands (either directly from him at a TIP or perhaps from some other Server on which he has created a file containing them) to set up a batch job for him, with password "xxx", to be run on Shift 3 (whenever that is). The job first copies file "source.text" from directory "<me>" on Host 452 into local file "source.pl2", then compiles it with the local PL2 compiler, executes it (assuming a "Not found" response would go into a known file if compilation had failed) with specified arguments (presumably the names of files for input and output), then copies the "output" file to Host 555's file hierarchy at the indicated place, using the user identifier "Me2" and the password "yyy". It's not elegant, but it ought to work. Finally, on the topic of logging out, the UULP command is "logout". The Server must close the Telnet connection after doing whatever is appropriate to effect a logout. To retain the Telnet connection, "logout -save". Having the Server close is viewed as a convenience for the user, in that it spares him the necessity of causing his User Telnet to close. It is also desirable for program-driven applications, so as not to leave the connections "dangling" and not to require possibly complex negotiations with the User side to break the connection. APPENDIX 1. THE COMMON COMMAND SUBSET Syntax Opt I. "Set-up" Commands login id arg The id may be Network-wide or Host-specific. "*free" is reserved. The arg may be "-mail", "-who", "-concom", "-batch", or may be absent. Result is to be either logged in or passed off to appropriate daemon. prompt char Specifies that char is to become or precede the normal prompt message. Acceptable prior to login. erase char X Specifies that char is the erase character. Invocation with no argument reverts to default. kill char X Padlipsky [Page 15]
RFC 666 Unified User-Level Protocol November 1974 Specifies that char is the kill character. Invocation with no argument reverts to default. eol char X Specifies that char is the newline character. Invocation with no argument reverts to default. local Enter the local command environment. ftp Enter the FTP environment. rje Enter the RJE environment. logout Logout and sever the Telnet connection. logout -save Logout but keep the Telnet connection. map Apply the case-mapping conventions of Appendix 2. Required on Hosts to which case is significant. identify id arg X Specifies that id is to be used as the user identifier in any "fanout" logins required. If arg is specified, it is to be either the password to be used in such logins or "-pw", in which case the Server will furnish a mask or negotiate the Hide Your Input Telnet option; if no arg, then no password is to be furnished on fanout logins. Default id is "*free". II. Communications Commands readmail Type out "mailbox". readmail (id) -at host X Type out "mailbox" on remote Host host. Multiple Hosts may be specified, separated by spaces (blanks). Padlipsky [Page 16]
RFC 666 Unified User-Level Protocol November 1974 Implies ability to change working directory at host to directory implied by known user identifier, or (optionally) by id. readmail -all XX Search for mail. Extremely optional. mail id Collect input until line consisting of only a period (".") for mailing to local user specified by id. mail -f file id Send contents of specified file to specified local user. mail id -at host Collect input until line consisting of only a period (".") for mailing to remote user(s) at specified Host(s). Both id and host may be multiple, separated by spaces. (If multiple, they should be taken pairwise.) mail -f file id -at host Send contents of specified file to specified remote user(s). who The generic who's logged in command. who id Is id logged in? Constrained responses. who id -at host Is the specified user logged in at the specified host. Constrained responses. concom -on Enable console to console communications. concom -off Disable console to console communications. concom id Send messages to specified local user until line consisting of only a period ("."). Padlipsky [Page 17]
RFC 666 Unified User-Level Protocol November 1974 concom id -at host Send messages to specified remote user. III. File Commands type path Type out the contents of the specified file. Pathname may be local or Network-wide. Default to current working directory. listdir List the contents of the current working directory. (Local format acceptable.) listdir path List the contents of the specified directory. rename old new Change the specified file's name as indicated. addname old new X Give the specified file the specified extra name. delete path Get rid of the specified file. ("Expunge" if necessary.) copy from to Make a copy of the file specified by the first pathname at the second pathname. link from to X If your file system has such a concept, make a "link" between the two pathnames. If no second argument, use same entry name in working directory. status path st X If your file system has such a concept, give status information about the specified file or directory. changewd path X If no argument, return to the "home" directory. typewd Type out the pathname of the current working directory. neted path Padlipsky [Page 18]
RFC 666 Unified User-Level Protocol November 1974 See Appendix 3. IV. Invoking "Native" Programs call name (args) Invoke the specified program with the specified arguments (if any). The following names are reserved to indicate the invocation of the corresponding language processor: "-pl1", "-basic", "-fortran", "-lisp". (If no source file indicated, invoke "interpretively" if possible.) V. On-line Documentation help name Type out information about the specified UULP command. If name is "-sys", type out information about how to use the local system's help mechanism; if "uulp", about the local system's UULP implementation. If no name given, describe the command itself. APPENDIX 2. MAP COMMAND CONVENTIONS This appendix will eventually contain the case-mapping conventions detailed in RFC 411. APPENDIX 3. EDIT COMMAND REQUESTS This appendix will eventually contain descriptions of the neted command requests (a draft of which now exists), or a reference to the Resource Notebook version, if that gets published first. For now, it should be sufficient to point out that the requests are basically locate, next, top, change, save, and quit -- i.e., it's the "old- fashioned" flavor of context editor. [Optical character recognition and initial proofreading performed 11/20-21/04 by The Author. A few original typos were corrected; some may remain.] Padlipsky [Page 19]
mirror server hosted at Truenetwork, Russian Federation.