RFC index | STD index | BCP index | FYI index
Plain text | gzipped plain text | A4 postscript | A4 postscript, 2 up | A4 postscript, 4 up
Network Working Group 22 April 1971 Request for Comments: 129 E. E. Harslem-Rand NIC 5845 J. F. Heafner-Rand E. Meyer-MIT A REQUEST FOR COMMENTS ON SOCKET NAME STRUCTURE INTRODUCTION This RFC is in answer to a request (made at the February NWG Meeting at the University of Illinois) that we comment on several suggested socket name structures. We apologize for the delay in getting out these comments and we hope that you will respond more quickly with your reactions. Please direct your replies via the standard RFC mechanism. Two structures are presented in this RFC as shown below. 31 1 +-------------------------------+-+ 1. | Arbitrary | | <-- gender +-------------------------------+-+ 24 7 1 +------------------------+------+-+ 2. | User ID | tag | | <-- gender +------------------------+------+-+ Three variations are given for the way in which socket names are assigned, as examples of use of the first structure. 1. Users pick the arbitrary number arbitrarily and associate it with a process. 2. A logger chooses the arbitrary number dynamically and associates it with a process via a directory. 3. The arbitrary number is assigned outside of a logger but may be issued by a logger to the remote party. [Page 1]
The second format shown above associates sockets specifi- cally with users as opposed to processes. The following discussion covers three different schemes of socket identifier assignment using a simple example. User A at Host A has agreed (by letter, telephone, etc.) with User B at Host B for their respective processes to establish a connection through the Network at a particular time. User B is to be waiting for the connection attempt initiated by User A. The issues to be faced are those of addressing (how is User A to know to which socket to connect?), and of security (how are both users to be confident that they are talking each other, and not some interloper?). A fourth scheme follows which addresses another concept of Network use--that connections are made between processes and that processes not users should be identified via Socket names. FREELY SELECTED RANDOM SOCKET IDENTIFIERS (Scheme 1) Under this scheme a user is able to use any 32-bit socket identifier he chooses. Two restrictions apply: the least significant bit denotes the socket's gender (0-read, 1-write), and no more than one socket bearing a given iden- tifier can be active at a host at a time. The two users select suitably random identifiers ("a" and "b"). User A will attempt to activate his socket with identifier "a" an connect it to socket "b" at Host B. There is the possibility that somebody other than User B has activated socket "b" at Host B so that User A will address the wrong party. However, the possibility that some other user has accidentally picked this particular identifier is reasonably small, since there are about a billion different identifiers. When the connection request from A gets to User B, he examines the identifier of the calling socket. If for some reasom it is not "a" or not from Host A, he rejects the request, because it is likely to be from some [Page 2]
outside party. If the calling socket is named, "a" and from Host A, User B can be reasonably sure that it is from User A. It is very unlikely that some other party will accidentally address socket "b" from a socket named "a". The advantages of this scheme are: simplicity and reasonable security in a non-malicious environment. The disadvantages are that there are possibilities from annoy- ingly unavoidable conflicts with other users and that each pair of users must conduct a prior confidential private communication (as opposed to a broadcast announcement in more secure schemes). HOST-SELECTED IDENTIFIERS PLUS DIRECTORY (Scheme 2) This system uses the same socket identifier structure as presented above, except that the Host picks the identi- fier at the time the socket is assigned, and the user has no no prior knowledge or control of the assignment. By itself, this system would be totally unusable, because there would be no way for User A to address User B. However, it allows certain service functions (such as the Network logger) to have specifically assigned sockets. One of these is a Network Directory service. This serves to relate a socket identifier at a particular host to the name of the user operating it. This might either be a single distributed service, or there might be a separ- ate service at each host. Under this scheme, each user, A and B, first activates his socket (or somehow gets his host to assign and tell him of a socket identifier). Then he gets the Directory module at his host to associate his name with the identi- fier of the socket just activated. Following this, User A in some manner gets the Directory Service at Host B to tell him the socket identifier assigned to User B. Then User A dispatches a connection request for this socket. [Page 3]
When User B gets the request, he similarly calls on the Directory service at Host A to find out the name of the user who is operating the socket User B was called by. If the name is that of User A, User B can safely accept the request. Otherwise, he rejects. This scheme is rather cumbersome, but some directory services must exist for Host-selected socket identifiers to work. On advantage of the Directory Service is thst it allows symbolic addressing. A sizeable disadvantage in view of its complexity is that it does not provide absolute security. (For exemple, after User A gets the identifier of the socket he is to address, User B could deactivate it, and somebody else could come along and get the same-named socket.) ADMINISTRATIVELY ASSIGNED USER IDENTIFIERS (Scheme 3) This is the system that is put forth on page 5 of Protocol Document 1(8/3/70). Under it a user is permanently assigned a user identifier by his home host. There is a user identifier subfield within the socket identifier, and a user is permitted by an NCP to operate only those sockets bearing his uder identifier. This gives the user a selec- tion of 256 sockets operable by him. In arranging for the connection the two Users A and B tell each other their user identifiers (alternatively a user ID could be read from a directory), and User B specifies which of his sockets ("b") that he will "listen" on. At connection time, User A selects one of his sockets and requests connection for it to socket "b" specified by User B. By protocol only User B can operate socket "b", so User A can be certain of reaching the right party. When User B receives the connection request, he examines the user identifier subfield of the calling socket identifier. If it is the user identifier of User A, User B accepts the connection request, confident that it is actually User A at the other end. Otherwise B rejects the request. [Page 4]
The advantages of this scheme are that if both hosts involved in a connection enforce the user ID assignment, the misconnection aspect of security is solved and there can be no socket naming conflict between users. Also, arrangements can be made openly and publicly between many potential communicators. A disadvantage to this scheme is that some systems may be incapable of insuring user ID integrity. A VIEW OF SOCKET NAME MEANING (Scheme 4) Another view of Network use is that programs will con- nect to programs, via NCPs. Some of these programs may be multi-access subsystems that are really agents for local consoles (and TELNETs). Consoles will generally communicate through some such software agent rather than directly to an NCP. Programs, then, must have a fixed, unique identifier, known to its remote users and perhaps to its local logger. The identifier is constant; it does not change from day to day. If such a program is to allow multiple concurrent connections (for many or a single user) then it must have a range of variable identifiers as well. It makes sense to group these sockets in a contiguous range. The variable identifiers are transient and are dynamically associated with Network logical connections. +--------------------- ---------------------+ | | | Fixed, unique / / Variable | | Identifier / / Identifier | | | +--------------------- ---------------------+ _________ _________/ _________ _________/ / / Identifies the Identifies a particular program uniquely connection of the program [Page 5]
The above premise is that the program (or agent) is doing the communicating with an NCP and thus needs to be identified for message traffic routing from an NCP. In the past it has been said that users can be mobile, i.e., log on from different sites, and thus it is the user that needs identification. In many typical on-line systems the user first requests a service and then identifies himself to the service for purposes of accounting, etc. User IDs can be transmitted after requesting a service and can thus be elevated above the meaning of socket names. A program might typically associate the terminals, for which it is an agent, with the variable part of the identi- fier, i.e., the particular connection(s). For example, the Network Services Program (NSP) at Rand now uses the following format for socket names. The first 24 bits are administratively assigned and would be known to a logger. The multiplex code is normally chosen randomly. Predefined, fixed multiplex codes are possible also. 24 7 1 +------------------------+---------+-+ | Program Number |Multiplex| | <-- Gender | | Code | | +------------------------+---------+-+ The Socket name structure #1 (page 1) thus accomodates the above example as well as other exploratory socket name structures and various "standards" superimposed on the arbi- trary field. [ This RFC was put into machine readable form for entry ] [ into the online RFC archives by Simone Demmel 4/97 ] [Page 6]