RFC 819
The Domain Naming Convention for Internet User Applications
RFC 819: The Domain Naming Convention for Internet User Applications ✨
Part 1 of 3 🎀
RFC number: 819 Authors: Zaw-Sing Su (SRI) and Jon Postel (ISI) 💖 Date: August 1982 📅 Working group: Network Working Group 🌸 Category/status: not stated in the header 🤷♀️ Obsoletes/updates: the header doesn't list any RFCs it obsoletes or updates 🦋
1. Introduction ✨
Okay so, for years the <user>@<host> naming convention has been the ARPANET's go-to for mail, and the <host> part got reused for other apps too, like file transfer (FTP) and terminal access (Telnet) 💅. Then network interconnection showed up, and this naming convention needed a total glow-up to handle internetworking 🌈. The decision was made to swap the simple <host> field for a composite <domain> field [2] 🔥. This note is basically our attempt to clarify this generalized naming convention, the Internet Naming Convention, and to explore what adopting it means for Internet name service and user applications 🧚.
Here's the change, side by side 👑:
ARPANET Convention: Fred@ISIF
Internet Convention: Fred@F.ISI.ARPAThe vibe is that Internet names should form a tree-structured hierarchy that's based on administration, not strictly on topology 🌳. Read left to right, the name components go from most specific to most general. The root of the tree, the administrative universe, sits on the right 💜.
The name service that makes this work is assumed to be application independent 🫶. It isn't part of any one particular application. Instead, one independent name service serves all the different user applications 🎀.
2. The Structural Model 🦋
The Internet naming convention is built on the domain concept 💖. A domain's name is a concatenation of one or more <simple names>. You can think of a domain as a region where names get assigned and where name-to-address translation is someone's responsibility. All the domains together form a hierarchy 🌸.
To picture it, we can use graph theory and model the hierarchy as a directed graph ✨. A directed graph is a set of nodes plus a collection of arcs, where each arc is an ordered pair of distinct nodes [1]. Each node stands for a domain. An ordered pair (B, A), which is an arc from B to A, means that B is a subdomain of domain A, and B is a simple name that's unique within A. We call B a child of A, and A a parent of B 🧚. The graph that best describes the naming hierarchy is called an "in-tree". That's a rooted tree where every arc points toward the root (Figure 1) 🌳. The root represents the naming universe, the ancestor of every domain. The endpoints (or leaves) of the tree are the lowest-level domains 🍓.
U
/ | \
/ | \ U -- Naming Universe
^ ^ ^ I -- Intermediate Domain
| | | E -- Endpoint Domain
I E I
/ \ |
^ ^ ^
| | |
E E I
/ | \
^ ^ ^
| | |
E E E
Figure 1
The In-Tree Model for Domain HierarchyHere's the thing about child names 🙈. A child's simple name has to be unique within its parent domain. And since the parent's simple name is unique within the grandparent domain, the child can be uniquely named in its grandparent domain by writing its simple name followed by its parent's simple name 💅.
For example, if the simple name of a child is "C1" then no other
child of the same parent may be named "C1". Further, if the
parent of this child is named "P1", then "P1" is a unique simple
name in the child's grandparent domain. Thus, the concatenation
C1.P1 is unique in C1's grandparent domain.Similarly, every element of the hierarchy is uniquely named in the universe by its complete name. That's its simple name joined with the names of every domain along the trail leading up to the naming universe 🌈.
This hierarchical structure is what lets naming authority be decentralized and name service capability be distributed 🫶. We assume there's a naming authority and a name server associated with each domain. Sections 5 and 6 cover the name service and the naming authority, respectively 👑.
Inside an endpoint domain, unique names get assigned to <user>, which stands for user mailboxes. You can think of user mailboxes as children of their respective domains 💜.
Now, reality is messy 😭. Anomalies can exist that break the in-tree model. Overlapping domains imply multiple parentage, which means an entity in the naming hierarchy is a child of more than one domain. It's totally conceivable that ISI is a member of the ARPA domain and also a member of the USC domain (Figure 2) ✨. That kind of relation is an anomaly to the rule of one-connectivity between any two points of a tree. The common child and the sub-tree below it become descendants of both parent domains 🦋.
U
/ | \
/ . \
. . ARPA
. . | \
USC | \
\ | .
\ | .
ISI
Figure 2
Anomaly in the In-Tree ModelSome issues that come from multiple parentage are addressed in Appendix B 🎀. The general implications of multiple parentage are still a subject for further investigation 🔍.
3. Advantage of Absolute Naming 💎
Absolute naming means the (complete) names are assigned with respect to a universal reference point 🌟. The big perk is that a name assigned this way can be universally interpreted relative to that reference point 🧚. The Internet naming convention does absolute naming, with the naming universe as its universal reference point 👑.
Relative naming is different 🌸. Here, an entity gets named based on where the naming entity is positioned relative to the named entity. A set of hosts running the "unix" operating system exchange mail using a method called "uucp". The uucp naming convention is a textbook example of relative naming 🐚. The recipient is usually named with a source route that identifies a chain of locally known hosts linking the sender's host to the recipient's. A destination name can look like this 💜:
"alpha!beta!gamma!john"Here, "alpha" is presumably known to the originating host, "beta" is known to "alpha", and so on 🫶.
uucp has shown us a lot of the problems that come with relative naming 😬. When host names can only be interpreted locally, routing optimization becomes impossible 🚫. A reply message may have to travel the reverse route back to the original sender before it can be forwarded to other parties 🔁.
Even worse, if a message gets forwarded by one of the original recipients, or passed along as the text of another message, the frame of reference for the relative source route can be completely lost 💀. Relative naming schemes have severe problems for many of the uses we depend on in the ARPA Internet community 🔥.
4. Interoperability 🌈
To interoperate with a different naming convention, we need to accommodate the names that a foreign naming convention assigns 🤝. Since domains are autonomous, a foreign naming environment can be incorporated as a domain anywhere in the hierarchy 🦋. Inside the naming universe, a domain's name service is provided within that domain, so a foreign naming convention can stay independent of the Internet naming convention 💅. Basically, no standard naming convention has to be imposed in order for heterogeneous naming environments to interoperate ✨.
Let's look at a few examples 🎀. Say there's a naming convention in the FOO world that looks something like <user>%<host>%<area>. You can reach an entity in that environment from the Internet community by just tacking .FOO onto the end of the name in that foreign convention 🧚:
John%ISI-Tops20-7%California.FOOHere's another one 💜. One way to accommodate the "uucp world" from the last section is to declare it a foreign system. So a uucp name like "alpha!beta!gamma!john" might be known in the Internet community as:
"alpha!beta!gamma!john.UUCP"Talking to a complex subdomain is another case that can be treated as interoperation 👑. A complex subdomain is a domain with a complex internal naming structure that's presumably unknown to the outside world (or the outside world just doesn't care about its complexity) 🫠.
For the mail system, names embedded in the message text are often used by the destination, for example to reply to the original message 📬. So those embedded names may need to be converted for the benefit of the name server in the destination environment 🔄.
Converting names on the boundary between heterogeneous naming environments is a complicated topic 😵💫. Here's an example of some of the tricky parts 🌸. Say a message goes from the Internet community to the FOO environment. It might carry "From" and "To" fields like these:
From: Fred@F.ISI.ARPA
To: John%ISI-Tops20-7%California.FOOIn that example, "FOO" is a domain independent of the Internet naming environment ✨. The interface on the boundary between the two environments might be a software module 🧩. We can assume that interface is an entity of the Internet community and also an entity of the FOO community 🫶. For the FOO environment's benefit, the "From" and "To" fields need to be modified when the message arrives at the boundary 💅. You can treat naming as a separate layer of protocol and think of conversion as a protocol translation 🦋. It gets even more complicated when the message is sent to more than one destination in different naming environments, or when it's headed to an environment that doesn't share a boundary with the originating naming environment 😱.
The general subject of conversion is beyond the scope of this note 🙃, but a few questions are raised in Appendix D 💜.
5. Name Service 💖
okay so name service is basically the network service that turns a name into an address 🫶. There are a few ways to make it happen. In a simple networking setup, you can use one single central database that holds the name-to-address matches for all the relevant network entities, like hosts.
With the old ARPANET host names, that central database was copied into every individual host ✨. When the originating module of an application process needed a destination, it would ask the local name service (for example, by making a system call) to get the network address for the destination host. But as networks multiplied and more and more hosts joined in, the database kept growing, needed frequent updates, and had to be spread out to everyone. That made the whole approach unmanageable 💀.
The hierarchical structure of the Internet naming convention is the real MVP here 👑. It spreads naming authority across many domains and distributes the name service work too. It handles growth of the naming universe with ease, and it allows an arbitrary number of hierarchical layers. Adding a new domain barely adds any complexity to an existing Internet system 🌈.
The name service at each domain is assumed to be provided by one or more name servers. There are two models for how a name server completes its work, which might be called "iterative" and "recursive" 🦋.
- Iterative name server: There may be two kinds of responses. The first kind is a destination address. The second kind is the address of another name server. If the response is a destination address, the query is satisfied. If the response is the address of another name server, the query must be repeated using that name server, and so on until a destination address is obtained.
- Recursive name server: There is only one kind of response, which is a destination address. This puts an obligation on the name server to actually make the call on another name server if it can't answer the query itself.
It is noted that looping can be avoided, since the names presented for translation can only be of finite concatenation. However, care should be taken when employing mechanisms such as a pointer to the next simple name for resolution 🙈.
We believe that some name servers will be recursive, but we don't believe that all will be. This means the caller must be prepared for either type of server 💅. Further discussion and examples of name service are given in Appendix C.
The basic name service at each domain is the translation of simple names to addresses for all of its children. However, if only this basic name service is provided, the use of complete (or fully qualified) names would be required, and that requirement can be unreasonable in practice 😭. So we propose the use of partial names in the context where their uniqueness is preserved. By construction, naming uniqueness is preserved within the domain of a common ancestry. That means a partially qualified name is built by leaving out the ancestors that the communicating parties have in common. When a partially qualified name leaves its context of uniqueness, it must be additionally qualified 🎀.
Using partially qualified names places a requirement on the Internet name service. To meet it, the name service at each domain must be capable of, in addition to the basic service, resolving simple names for all of its ancestors (including itself) and their children. The required distinction among simple names for such resolution is addressed in Appendix B 🧚.
6. Naming Authority 👑
Associated with each domain there must be a naming authority to assign simple names and ensure proper distinction among simple names 💜.
Note that if the use of partially qualified names is allowed in a sub-domain, the uniqueness of simple names inside that sub-domain is insufficient to avoid ambiguity with names outside the subdomain. Appendix B discusses simple name assignment in a sub-domain that would allow the use of partially qualified names without ambiguity 🤓.
Administratively, associated with each domain there is a single person (or office) called the registrar. The registrar of the naming universe specifies the top-level set of domains and designates a registrar for each of these domains. The registrar for any given domain maintains the naming authority for that domain 🍓.
7. Network-Oriented Applications 🌸
For user applications such as file transfer and terminal access, the remote host needs to be named. To be compatible with the ARPANET naming convention, a host can be treated as an endpoint domain 🦋.
Many operating systems or programming language run-time environments provide functions or calls (JSYSs, SVCs, UUOs, SYSs, etc.) for standard services, like time-of-day, account-of-logged-in-user, and convert-number-to-string. It is likely to be very helpful if such a function or call is developed for translating a host name to an address. Honestly, several systems on the ARPANET already have facilities like this for translating an ARPANET host name into an ARPANET address based on internal tables ✨.
We recommend that this standard function or call for translating names to addresses be extended to accept names of Internet convention. This will promote a consistent interface for users of programs involving internetwork activities 🫶. The standard facility for translating Internet names to Internet addresses should include all the mechanisms available on the host, such as checking a local table or cache of recently checked names, or consulting a name server via the Internet 🔥.
8. Mail Relaying 💌
Relaying is a feature adopted by more and more mail systems. Relaying facilitates, among other things, interoperations between heterogeneous mail systems. The term "relay" describes the situation where a message is routed via one or more intermediate points between the sender and the recipient. The mail relays are normally specified explicitly as relay points in the instructions for message delivery. Usually, each of the intermediate relays assumes responsibility for the relayed message [3] 🧃.
A point should be made on the basic difference between mail relaying and the uucp naming system. Although mail relaying with absolute naming can also be considered a form of source routing, the names of each intermediate point and that of the destination are universally interpretable. The host names along a source route in the uucp convention, on the other hand, are relative and thus only locally interpretable. 👀
The Internet naming convention explicitly allows interoperations among heterogeneous systems. This implies that the originator of a communication may name a destination that resides in a foreign system. The destination network address may not be comprehensible to the transport system of the originator, so an implicit relaying mechanism is called for at the boundary between the domains. The function of this implicit relay is the same as the explicit relay 🌈.
9. Implementation ⭐
The Actual Domains
The initial set of top-level names includes:
- ARPA: This represents the set of organizations involved in the Internet system through the authority of the U.S. Defense Advanced Research Projects Agency. It includes all the research and development hosts on the ARPANET and hosts on many other nets as well. But note very carefully that the top-level domain "ARPA" does not map one-to-one with the ARPANET, because domains are administrative, not topological 🎀.
Transition
In the transition from the ARPANET naming convention to the Internet naming convention, a host name may be used as a simple name for an endpoint domain. So, if "USC-ISIF" is an ARPANET host name, then "USC-ISIF.ARPA" is the name of an Internet domain 🍓.
10. Summary 🎀
A hierarchical naming convention based on the domain concept has been adopted by the Internet community 🌸. It is an absolute naming convention defined along administrative rather than topological boundaries. This naming convention is adaptive for interoperations with other naming conventions. Thus, no standard convention needs to be imposed for interoperations among heterogeneous naming environments 💖.
This Internet naming convention allows distributed name service and naming authority functions at each domain. We have specified the functions required at each domain. We have also discussed the implications for network-oriented applications, mail systems, and administrative aspects of this convention 🫶.
APPENDIX A ✨
The BNF Specification
We present here a rather detailed "BNF" definition of the allowed form for a computer mail "mailbox" composed of a "local-part" and a "domain" (separated by an at sign). Clearly, the domain can be used separately in other network-oriented applications 💅.
<mailbox> ::= <local-part> "@" <domain>
<local-part> ::= <string> | <quoted-string>
<string> ::= <char> | <char> <string>
<quoted-string> ::= """ <qtext> """
<qtext> ::= "\" <x> | "\" <x> <qtext> | <q> | <q> <qtext>
<char> ::= <c> | "\" <x>
<domain> ::= <naming-domain> | <naming-domain> "." <domain>
<naming-domain> ::= <simple-name> | <address>
<simple-name> ::= <a> <ldh-str> <let-dig>
<ldh-str> ::= <let-dig-hyp> | <let-dig-hyp> <ldh-str>
<let-dig> ::= <a> | <d>
<let-dig-hyp> ::= <a> | <d> | "-"
<address> :: = "#" <number> | "[" <dotnum> "]"
<number> ::= <d> | <d> <number>
<dotnum> ::= <snum> "." <snum> "." <snum> "." <snum>
<snum> ::= one, two, or three digits representing a decimal integer
value in the range 0 through 255
<a> ::= any one of the 52 alphabetic characters A through Z in upper
case and a through z in lower case
<c> ::= any one of the 128 ASCII characters except <s> or <SP>
<d> ::= any one of the ten digits 0 through 9
<q> ::= any one of the 128 ASCII characters except CR, LF, quote ("),
or backslash (\)
<x> ::= any one of the 128 ASCII characters (no exceptions)
<s> ::= "<", ">", "(", ")", "[", "]", "\", ".", ",", ";", ":", "@",
""", and the control characters (ASCII codes 0 through 31 inclusive
and 127)Note that the backslash, "", is a quote character, which is used to indicate that the next character is to be used literally (instead of its normal interpretation). For example, "Joe\,Smith" could be used to indicate a single nine character user field with comma being the fourth character of the field 🧐.
The simple names that make up a domain may contain both upper and lower case letters (as well as digits and hyphen), but these names are not case sensitive 🌈.
Hosts are generally known by names. Sometimes a host is not known to the translation function, and communication is blocked. To bypass this barrier, two forms of addresses are also allowed for host "names". One form is a decimal integer prefixed by a pound sign, "#". Another form, called "dotted decimal", is four small decimal integers separated by dots and enclosed by brackets, e.g., "[123.255.37.2]", which indicates a 32-bit ARPA Internet Address in four 8-bit fields. (Of course, these numeric address forms are specific to the Internet. Other forms may have to be provided if this problem arises in other transport systems.) 🦋
APPENDIX B 🧚
An Aside on the Assignment of Simple Names 💅
Okay so, picture this: there are two naming hierarchies that meet at the naming universe 'U' 🌈. One is made of domains (S, R, N, J, P, Q, B, A), and the other is (L, E, F, G, H, D, C, K, B, A). Domain B is assumed to have multiple parentage, as shown below.
U
/ \
/ \
J L
/ \
N E
/ \ / \
R P D F
/ \ | \ \
S Q C (X) G
\ / \ \
B K H
/
A
Figure 3
Illustration of Requirements for the Distinction of Simple NamesSuppose someone at A wants to start talking to destination H. The fully qualified destination name would be H.G.F.E.L.U 🦋
If you leave out the common ancestors, the partially qualified name for that destination becomes H.G.F 💖
To allow partially qualified names, the name server at A needs to resolve the simple name F. That means F has to be distinct from all the other simple names in its database 🔥
To let a domain's name server resolve simple names, a simple name for a child needs to be distinct from those of all of its ancestors and their immediate children. But that alone isn't enough for lower-level domains, because they can have multiple parentage below this level 🙈
Here's the example: say D is assigning a name to a new domain X. For D's name server to resolve simple names, the name for X must be distinct from L, E, D, C, F, and J. Then, for A to resolve simple names too, X also needs to be distinct from A, B, K, and from Q, P, N, and R 😭
Some observations, bestie:
- Simple names along parallel trails (distinct trails leading from one domain to the naming universe) must be distinct. For example, N must be distinct from E for B or A to properly resolve simple names 🧠
- No universal uniqueness of simple names is called for. For example, the simple name S doesn't have to be distinct from E, F, G, H, D, C, K, Q, B, or A 🌸
- The lower the level at which a domain occurs, the more immune it is to the requirement of naming uniqueness 🍓
To keep simple name resolution working at every level, a naming authority has to make sure each new simple name is distinct from the ones in the name server databases at the endpoint naming domains inside its domain. For example, for D to assign a simple name to X, it would need to check the databases at A and K. It's totally acceptable, though, to have simple names under domain A identical to those under K ✨
Failing to make that distinct assignment would put the naming authority's domain at risk, because it would jeopardize simple name resolution for entities within the subtree under that domain 😬
APPENDIX C 🌸
Further Discussion of Name Service and Name Servers 🎀
The name service on a system should look super simple to an application programmer, like just a system call or library subroutine. Inside that call or subroutine, there may be several methods for turning the name string into an address 💜
- First, a local table may be consulted. This table could be a complete table that gets updated often, or it could just be a cache of the few latest name-to-address mappings that were recently figured out 📒
- Second, a call may be made to a name server to resolve the string into a destination address 📞
- Third, a call may be made to a name server to resolve the string into a relay address 🦋
Whenever a name server is called, it may be a recursive server or an interactive server 🧚
If the server is recursive, the caller won't be able to tell whether the server already had the info to resolve the query or called another server recursively. The only possible clue is maybe the time it took ⏳
If the server is iterative, the caller has to be ready for either the answer to its query, or a response saying it should call a different server 🔁
It's worth noting that the main name service discussed in this memo is simply a name string to address service. Some applications may need other services too ✨
For example, even within the Internet, there are several procedures or protocols for actually transferring mail. One need is to figure out which mail procedures a destination host can use. Another need is to find the name of a relay host if the source and destination hosts don't share a common mail procedure. These more specialized services have to be specific to each application, since the answers may depend on the application. The basic name-to-address translation, though, is application independent 🥰
APPENDIX D 🦋
Further Discussion of Interoperability and Protocol Translations 💖
Translating protocols from one system to another is often really hard 😭 Here are some questions that come up when you think about translating addresses between mail systems:
- What is the impact of different addressing environments (i.e., environments of different address formats)?
- It is noted that the boundary of a naming environment may or may not coincide with the boundary of different mail systems. Should the conversion of naming be independent of the application system?
- The boundary between different addressing environments may or may not coincide with that of different naming environments or application systems. Some generic approach appears to be necessary 🌈
- If the conversion of naming is to be independent of the application system, some form of interaction appears necessary between the interface module of naming conversion and some application-level functions, such as the parsing and modification of message text 🧩
- To accommodate encryption, conversion may not be desirable at all. What then can be an alternative to conversion? 🤔
GLOSSARY 📖
address
An address is a numerical identifier for the topological location of the named entity. Basically, it's where the named thing sits in the network 📍
name
A name is an alphanumeric identifier associated with the named entity. For unique identification, a name needs to be unique in the context in which it's used. A name can be mapped to an address 🏷️
complete (fully qualified) name
A complete name is a concatenation of simple names representing the hierarchical relation of the named entity with respect to the naming universe. In other words, it's the simple names of the domain structure tree nodes, starting with its own name and ending with the top-level node name. It is a unique name in the naming universe 👑
partially qualified name
A partially qualified name is an abbreviation of the complete name that leaves out the simple names of the common ancestors of the communicating parties ✂️
simple name
A simple name is an alphanumeric identifier that's unique only within its parent domain 💅
domain
A domain defines a region of jurisdiction for name assignment and of responsibility for name-to-address translation 🗺️
naming universe
The naming universe is the ancestor of all network entities 🌌
naming environment
A networking environment that uses a specific naming convention 🎀
name service
Name service is a network service for name-to-address mapping 📬
name server
A name server is a network mechanism (e.g., a process) that realizes the function of name service 🧚
naming authority
A naming authority is an administrative entity that has the authority to assign simple names and the responsibility for resolving naming conflicts 🫶
parallel relations
A network entity may have one or more hierarchical relations with respect to the naming universe. Those multiple relations are parallel relations to each other 🦋
multiple parentage
A network entity has multiple parentage when it is assigned a simple name by more than one naming domain 🌸
REFERENCES 📚
[1] F. Harary, "Graph Theory", Addison-Wesley, Reading, Massachusetts, 1969.
[2] J. Postel, "Computer Mail Meeting Notes", RFC-805, USC/Information Sciences Institute, 8 February 1982.
[3] J. Postel, "Simple Mail Transfer Protocol", RFC-821, USC/Information Sciences Institute, August 1982.
[4] D. Crocker, "Standard for the Format of ARPA Internet Text Messages", RFC-822, Department of Electrical Engineering, University of Delaware, August 1982.
📦 where this page comes from
- ietf: rfc819 1982-08
- 💖 girlified by claude-haiku-5-5 on : a language model's rewrite of the original, under its terms