Network Working Group P. MockapetrisRequest for Comments: 1034 ISIObsoletes: RFCs882,883,973 November 1987DOMAIN NAMES - CONCEPTS AND FACILITIES1. STATUS OF THIS MEMOThis RFC is an introduction to the Domain Name System (DNS), and omitsmany details which can be found in a companion RFC, "Domain Names -Implementation and Specification" [RFC-1035]. That RFC assumes that thereader is familiar with the concepts discussed in this memo.A subset of DNS functions and data types constitute an officialprotocol. The official protocol includes standard queries and theirresponses and most of the Internet class data formats (e.g., hostaddresses).However, the domain system is intentionally extensible. Researchers arecontinuously proposing, implementing and experimenting with new datatypes, query types, classes, functions, etc. Thus while the componentsof the official protocol are expected to stay essentially unchanged andoperate as a production service, experimental behavior should always beexpected in extensions beyond the official protocol. Experimental orobsolete features are clearly marked in these RFCs, and such informationshould be used with caution.The reader is especially cautioned not to depend on the values whichappear in examples to be current or complete, since their purpose isprimarily pedagogical. Distribution of this memo is unlimited.2. INTRODUCTIONThis RFC introduces domain style names, their use for Internet mail andhost address support, and the protocols and servers used to implementdomain name facilities.2.1. The history of domain namesThe impetus for the development of the domain system was growth in theInternet: - Host name to address mappings were maintained by the Network Information Center (NIC) in a single file (HOSTS.TXT) which was FTPed by all hosts [RFC-952,RFC-953]. The total networkMockapetris [Page 1]
RFC 1034 Domain Concepts and Facilities November 1987 bandwidth consumed in distributing a new version by this scheme is proportional to the square of the number of hosts in the network, and even when multiple levels of FTP are used, the outgoing FTP load on the NIC host is considerable. Explosive growth in the number of hosts didn't bode well for the future. - The network population was also changing in character. The timeshared hosts that made up the original ARPANET were being replaced with local networks of workstations. Local organizations were administering their own names and addresses, but had to wait for the NIC to change HOSTS.TXT to make changes visible to the Internet at large. Organizations also wanted some local structure on the name space. - The applications on the Internet were getting more sophisticated and creating a need for general purpose name service.The result was several ideas about name spaces and their management[IEN-116,RFC-799,RFC-819,RFC-830]. The proposals varied, but acommon thread was the idea of a hierarchical name space, with thehierarchy roughly corresponding to organizational structure, and namesusing "." as the character to mark the boundary between hierarchylevels. A design using a distributed database and generalized resourceswas described in [RFC-882,RFC-883]. Based on experience with severalimplementations, the system evolved into the scheme described in thismemo.The terms "domain" or "domain name" are used in many contexts beyond theDNS described here. Very often, the term domain name is used to referto a name with structure indicated by dots, but no relation to the DNS.This is particularly true in mail addressing [Quarterman 86].2.2. DNS design goalsThe design goals of the DNS influence its structure. They are: - The primary goal is a consistent name space which will be used for referring to resources. In order to avoid the problems caused by ad hoc encodings, names should not be required to contain network identifiers, addresses, routes, or similar information as part of the name. - The sheer size of the database and frequency of updates suggest that it must be maintained in a distributed manner, with local caching to improve performance. Approaches thatMockapetris [Page 2]
RFC 1034 Domain Concepts and Facilities November 1987 attempt to collect a consistent copy of the entire database will become more and more expensive and difficult, and hence should be avoided. The same principle holds for the structure of the name space, and in particular mechanisms for creating and deleting names; these should also be distributed. - Where there tradeoffs between the cost of acquiring data, the speed of updates, and the accuracy of caches, the source of the data should control the tradeoff. - The costs of implementing such a facility dictate that it be generally useful, and not restricted to a single application. We should be able to use names to retrieve host addresses, mailbox data, and other as yet undetermined information. All data associated with a name is tagged with a type, and queries can be limited to a single type. - Because we want the name space to be useful in dissimilar networks and applications, we provide the ability to use the same name space with different protocol families or management. For example, host address formats differ between protocols, though all protocols have the notion of address. The DNS tags all data with a class as well as the type, so that we can allow parallel use of different formats for data of type address. - We want name server transactions to be independent of the communications system that carries them. Some systems may wish to use datagrams for queries and responses, and only establish virtual circuits for transactions that need the reliability (e.g., database updates, long transactions); other systems will use virtual circuits exclusively. - The system should be useful across a wide spectrum of host capabilities. Both personal computers and large timeshared hosts should be able to use the system, though perhaps in different ways.2.3. Assumptions about usageThe organization of the domain system derives from some assumptionsabout the needs and usage patterns of its user community and is designedto avoid many of the the complicated problems found in general purposedatabase systems.The assumptions are: - The size of the total database will initially be proportionalMockapetris [Page 3]
RFC 1034 Domain Concepts and Facilities November 1987 to the number of hosts using the system, but will eventually grow to be proportional to the number of users on those hosts as mailboxes and other information are added to the domain system. - Most of the data in the system will change very slowly (e.g., mailbox bindings, host addresses), but that the system should be able to deal with subsets that change more rapidly (on the order of seconds or minutes). - The administrative boundaries used to distribute responsibility for the database will usually correspond to organizations that have one or more hosts. Each organization that has responsibility for a particular set of domains will provide redundant name servers, either on the organization's own hosts or other hosts that the organization arranges to use. - Clients of the domain system should be able to identify trusted name servers they prefer to use before accepting referrals to name servers outside of this "trusted" set. - Access to information is more critical than instantaneous updates or guarantees of consistency. Hence the update process allows updates to percolate out through the users of the domain system rather than guaranteeing that all copies are simultaneously updated. When updates are unavailable due to network or host failure, the usual course is to believe old information while continuing efforts to update it. The general model is that copies are distributed with timeouts for refreshing. The distributor sets the timeout value and the recipient of the distribution is responsible for performing the refresh. In special situations, very short intervals can be specified, or the owner can prohibit copies. - In any system that has a distributed database, a particular name server may be presented with a query that can only be answered by some other server. The two general approaches to dealing with this problem are "recursive", in which the first server pursues the query for the client at another server, and "iterative", in which the server refers the client to another server and lets the client pursue the query. Both approaches have advantages and disadvantages, but the iterative approach is preferred for the datagram style of access. The domain system requires implementation of the iterative approach, but allows the recursive approach as an option.Mockapetris [Page 4]
RFC 1034 Domain Concepts and Facilities November 1987The domain system assumes that all data originates in master filesscattered through the hosts that use the domain system. These masterfiles are updated by local system administrators. Master files are textfiles that are read by a local name server, and hence become availablethrough the name servers to users of the domain system. The userprograms access name servers through standard programs called resolvers.The standard format of master files allows them to be exchanged betweenhosts (via FTP, mail, or some other mechanism); this facility is usefulwhen an organization wants a domain, but doesn't want to support a nameserver. The organization can maintain the master files locally using atext editor, transfer them to a foreign host which runs a name server,and then arrange with the system administrator of the name server to getthe files loaded.Each host's name servers and resolvers are configured by a local systemadministrator [RFC-1033]. For a name server, this configuration dataincludes the identity of local master files and instructions on whichnon-local master files are to be loaded from foreign servers. The nameserver uses the master files or copies to load its zones. Forresolvers, the configuration data identifies the name servers whichshould be the primary sources of information.The domain system defines procedures for accessing the data and forreferrals to other name servers. The domain system also definesprocedures for caching retrieved data and for periodic refreshing ofdata defined by the system administrator.The system administrators provide: - The definition of zone boundaries. - Master files of data. - Updates to master files. - Statements of the refresh policies desired.The domain system provides: - Standard formats for resource data. - Standard methods for querying the database. - Standard methods for name servers to refresh local data from foreign name servers.Mockapetris [Page 5]
RFC 1034 Domain Concepts and Facilities November 19872.4. Elements of the DNSThe DNS has three major components: - The DOMAIN NAME SPACE and RESOURCE RECORDS, which are specifications for a tree structured name space and data associated with the names. Conceptually, each node and leaf of the domain name space tree names a set of information, and query operations are attempts to extract specific types of information from a particular set. A query names the domain name of interest and describes the type of resource information that is desired. For example, the Internet uses some of its domain names to identify hosts; queries for address resources return Internet host addresses. - NAME SERVERS are server programs which hold information about the domain tree's structure and set information. A name server may cache structure or set information about any part of the domain tree, but in general a particular name server has complete information about a subset of the domain space, and pointers to other name servers that can be used to lead to information from any part of the domain tree. Name servers know the parts of the domain tree for which they have complete information; a name server is said to be an AUTHORITY for these parts of the name space. Authoritative information is organized into units called ZONEs, and these zones can be automatically distributed to the name servers which provide redundant service for the data in a zone. - RESOLVERS are programs that extract information from name servers in response to client requests. Resolvers must be able to access at least one name server and use that name server's information to answer a query directly, or pursue the query using referrals to other name servers. A resolver will typically be a system routine that is directly accessible to user programs; hence no protocol is necessary between the resolver and the user program.These three components roughly correspond to the three layers or viewsof the domain system: - From the user's point of view, the domain system is accessed through a simple procedure or OS call to a local resolver. The domain space consists of a single tree and the user can request information from any section of the tree. - From the resolver's point of view, the domain system is composed of an unknown number of name servers. Each nameMockapetris [Page 6]
RFC 1034 Domain Concepts and Facilities November 1987 server has one or more pieces of the whole domain tree's data, but the resolver views each of these databases as essentially static. - From a name server's point of view, the domain system consists of separate sets of local information called zones. The name server has local copies of some of the zones. The name server must periodically refresh its zones from master copies in local files or foreign name servers. The name server must concurrently process queries that arrive from resolvers.In the interests of performance, implementations may couple thesefunctions. For example, a resolver on the same machine as a name servermight share a database consisting of the the zones managed by the nameserver and the cache managed by the resolver.3. DOMAIN NAME SPACE and RESOURCE RECORDS3.1. Name space specifications and terminologyThe domain name space is a tree structure. Each node and leaf on thetree corresponds to a resource set (which may be empty). The domainsystem makes no distinctions between the uses of the interior nodes andleaves, and this memo uses the term "node" to refer to both.Each node has a label, which is zero to 63 octets in length. Brothernodes may not have the same label, although the same label can be usedfor nodes which are not brothers. One label is reserved, and that isthe null (i.e., zero length) label used for the root.The domain name of a node is the list of the labels on the path from thenode to the root of the tree. By convention, the labels that compose adomain name are printed or read left to right, from the most specific(lowest, farthest from the root) to the least specific (highest, closestto the root).Internally, programs that manipulate domain names should represent themas sequences of labels, where each label is a length octet followed byan octet string. Because all domain names end at the root, which has anull string for a label, these internal representations can use a lengthbyte of zero to terminate a domain name.By convention, domain names can be stored with arbitrary case, butdomain name comparisons for all present domain functions are done in acase-insensitive manner, assuming an ASCII character set, and a highorder zero bit. This means that you are free to create a node withlabel "A" or a node with label "a", but not both as brothers; you couldrefer to either using "a" or "A". When you receive a domain name orMockapetris [Page 7]
RFC 1034 Domain Concepts and Facilities November 1987label, you should preserve its case. The rationale for this choice isthat we may someday need to add full binary domain names for newservices; existing services would not be changed.When a user needs to type a domain name, the length of each label isomitted and the labels are separated by dots ("."). Since a completedomain name ends with the root label, this leads to a printed form whichends in a dot. We use this property to distinguish between: - a character string which represents a complete domain name (often called "absolute"). For example, "poneria.ISI.EDU." - a character string that represents the starting labels of a domain name which is incomplete, and should be completed by local software using knowledge of the local domain (often called "relative"). For example, "poneria" used in the ISI.EDU domain.Relative names are either taken relative to a well known origin, or to alist of domains used as a search list. Relative names appear mostly atthe user interface, where their interpretation varies fromimplementation to implementation, and in master files, where they arerelative to a single origin domain name. The most common interpretationuses the root "." as either the single origin or as one of the membersof the search list, so a multi-label relative name is often one wherethe trailing dot has been omitted to save typing.To simplify implementations, the total number of octets that represent adomain name (i.e., the sum of all label octets and label lengths) islimited to 255.A domain is identified by a domain name, and consists of that part ofthe domain name space that is at or below the domain name whichspecifies the domain. A domain is a subdomain of another domain if itis contained within that domain. This relationship can be tested byseeing if the subdomain's name ends with the containing domain's name.For example, A.B.C.D is a subdomain of B.C.D, C.D, D, and " ".3.2. Administrative guidelines on useAs a matter of policy, the DNS technical specifications do not mandate aparticular tree structure or rules for selecting labels; its goal is tobe as general as possible, so that it can be used to build arbitraryapplications. In particular, the system was designed so that the namespace did not have to be organized along the lines of networkboundaries, name servers, etc. The rationale for this is not that thename space should have no implied semantics, but rather that the choiceof implied semantics should be left open to be used for the problem atMockapetris [Page 8]
RFC 1034 Domain Concepts and Facilities November 1987hand, and that different parts of the tree can have different impliedsemantics. For example, the IN-ADDR.ARPA domain is organized anddistributed by network and host address because its role is to translatefrom network or host numbers to names; NetBIOS domains [RFC-1001, RFC-1002] are flat because that is appropriate for that application.However, there are some guidelines that apply to the "normal" parts ofthe name space used for hosts, mailboxes, etc., that will make the namespace more uniform, provide for growth, and minimize problems assoftware is converted from the older host table. The politicaldecisions about the top levels of the tree originated inRFC-920.Current policy for the top levels is discussed in [RFC-1032]. MILNETconversion issues are covered in [RFC-1031].Lower domains which will eventually be broken into multiple zones shouldprovide branching at the top of the domain so that the eventualdecomposition can be done without renaming. Node labels which usespecial characters, leading digits, etc., are likely to break oldersoftware which depends on more restrictive choices.3.3. Technical guidelines on useBefore the DNS can be used to hold naming information for some kind ofobject, two needs must be met: - A convention for mapping between object names and domain names. This describes how information about an object is accessed. - RR types and data formats for describing the object.These rules can be quite simple or fairly complex. Very often, thedesigner must take into account existing formats and plan for upwardcompatibility for existing usage. Multiple mappings or levels ofmapping may be required.For hosts, the mapping depends on the existing syntax for host nameswhich is a subset of the usual text representation for domain names,together with RR formats for describing host addresses, etc. Because weneed a reliable inverse mapping from address to host name, a specialmapping for addresses into the IN-ADDR.ARPA domain is also defined.For mailboxes, the mapping is slightly more complex. The usual mailaddress <local-part>@<mail-domain> is mapped into a domain name byconverting <local-part> into a single label (regardles of dots itcontains), converting <mail-domain> into a domain name using the usualtext format for domain names (dots denote label breaks), andconcatenating the two to form a single domain name. Thus the mailboxMockapetris [Page 9]
RFC 1034 Domain Concepts and Facilities November 1987HOSTMASTER@SRI-NIC.ARPA is represented as a domain name byHOSTMASTER.SRI-NIC.ARPA. An appreciation for the reasons behind thisdesign also must take into account the scheme for mail exchanges [RFC-974].The typical user is not concerned with defining these rules, but shouldunderstand that they usually are the result of numerous compromisesbetween desires for upward compatibility with old usage, interactionsbetween different object definitions, and the inevitable urge to add newfeatures when defining the rules. The way the DNS is used to supportsome object is often more crucial than the restrictions inherent in theDNS.3.4. Example name spaceThe following figure shows a part of the current domain name space, andis used in many examples in this RFC. Note that the tree is a verysmall subset of the actual name space. | | +---------------------+------------------+ | | | MIL EDU ARPA | | | | | | +-----+-----+ | +------+-----+-----+ | | | | | | | BRL NOSC DARPA | IN-ADDR SRI-NIC ACC | +--------+------------------+---------------+--------+ | | | | | UCI MIT | UDEL YALE | ISI | | +---+---+ | | | | LCS ACHILLES +--+-----+-----+--------+ | | | | | | XX A C VAXA VENERA MockapetrisIn this example, the root domain has three immediate subdomains: MIL,EDU, and ARPA. The LCS.MIT.EDU domain has one immediate subdomain namedXX.LCS.MIT.EDU. All of the leaves are also domains.3.5. Preferred name syntaxThe DNS specifications attempt to be as general as possible in the rulesMockapetris [Page 10]
RFC 1034 Domain Concepts and Facilities November 1987for constructing domain names. The idea is that the name of anyexisting object can be expressed as a domain name with minimal changes.However, when assigning a domain name for an object, the prudent userwill select a name which satisfies both the rules of the domain systemand any existing rules for the object, whether these rules are publishedor implied by existing programs.For example, when naming a mail domain, the user should satisfy both therules of this memo and those inRFC-822. When creating a new host name,the old rules for HOSTS.TXT should be followed. This avoids problemswhen old software is converted to use domain names.The following syntax will result in fewer problems with manyapplications that use domain names (e.g., mail, TELNET).<domain> ::= <subdomain> | " "<subdomain> ::= <label> | <subdomain> "." <label><label> ::= <letter> [ [ <ldh-str> ] <let-dig> ]<ldh-str> ::= <let-dig-hyp> | <let-dig-hyp> <ldh-str><let-dig-hyp> ::= <let-dig> | "-"<let-dig> ::= <letter> | <digit><letter> ::= any one of the 52 alphabetic characters A through Z inupper case and a through z in lower case<digit> ::= any one of the ten digits 0 through 9Note that while upper and lower case letters are allowed in domainnames, no significance is attached to the case. That is, two names withthe same spelling but different case are to be treated as if identical.The labels must follow the rules for ARPANET host names. They muststart with a letter, end with a letter or digit, and have as interiorcharacters only letters, digits, and hyphen. There are also somerestrictions on the length. Labels must be 63 characters or less.For example, the following strings identify hosts in the Internet:A.ISI.EDU XX.LCS.MIT.EDU SRI-NIC.ARPA3.6. Resource RecordsA domain name identifies a node. Each node has a set of resourceMockapetris [Page 11]
RFC 1034 Domain Concepts and Facilities November 1987information, which may be empty. The set of resource informationassociated with a particular name is composed of separate resourcerecords (RRs). The order of RRs in a set is not significant, and neednot be preserved by name servers, resolvers, or other parts of the DNS.When we talk about a specific RR, we assume it has the following:owner which is the domain name where the RR is found.type which is an encoded 16 bit value that specifies the type of the resource in this resource record. Types refer to abstract resources. This memo uses the following types: A a host address CNAME identifies the canonical name of an alias HINFO identifies the CPU and OS used by a host MX identifies a mail exchange for the domain. See [RFC-974 for details. NS the authoritative name server for the domain PTR a pointer to another part of the domain name space SOA identifies the start of a zone of authority]class which is an encoded 16 bit value which identifies a protocol family or instance of a protocol. This memo uses the following classes: IN the Internet system CH the Chaos systemTTL which is the time to live of the RR. This field is a 32 bit integer in units of seconds, an is primarily used by resolvers when they cache RRs. The TTL describes how long a RR can be cached before it should be discarded.Mockapetris [Page 12]
RFC 1034 Domain Concepts and Facilities November 1987RDATA which is the type and sometimes class dependent data which describes the resource: A For the IN class, a 32 bit IP address For the CH class, a domain name followed by a 16 bit octal Chaos address. CNAME a domain name. MX a 16 bit preference value (lower is better) followed by a host name willing to act as a mail exchange for the owner domain. NS a host name. PTR a domain name. SOA several fields.The owner name is often implicit, rather than forming an integral partof the RR. For example, many name servers internally form tree or hashstructures for the name space, and chain RRs off nodes. The remainingRR parts are the fixed header (type, class, TTL) which is consistent forall RRs, and a variable part (RDATA) that fits the needs of the resourcebeing described.The meaning of the TTL field is a time limit on how long an RR can bekept in a cache. This limit does not apply to authoritative data inzones; it is also timed out, but by the refreshing policies for thezone. The TTL is assigned by the administrator for the zone where thedata originates. While short TTLs can be used to minimize caching, anda zero TTL prohibits caching, the realities of Internet performancesuggest that these times should be on the order of days for the typicalhost. If a change can be anticipated, the TTL can be reduced prior tothe change to minimize inconsistency during the change, and thenincreased back to its former value following the change.The data in the RDATA section of RRs is carried as a combination ofbinary strings and domain names. The domain names are frequently usedas "pointers" to other data in the DNS.3.6.1. Textual expression of RRsRRs are represented in binary form in the packets of the DNS protocol,and are usually represented in highly encoded form when stored in a nameserver or resolver. In this memo, we adopt a style similar to that usedMockapetris [Page 13]
RFC 1034 Domain Concepts and Facilities November 1987in master files in order to show the contents of RRs. In this format,most RRs are shown on a single line, although continuation lines arepossible using parentheses.The start of the line gives the owner of the RR. If a line begins witha blank, then the owner is assumed to be the same as that of theprevious RR. Blank lines are often included for readability.Following the owner, we list the TTL, type, and class of the RR. Classand type use the mnemonics defined above, and TTL is an integer beforethe type field. In order to avoid ambiguity in parsing, type and classmnemonics are disjoint, TTLs are integers, and the type mnemonic isalways last. The IN class and TTL values are often omitted from examplesin the interests of clarity.The resource data or RDATA section of the RR are given using knowledgeof the typical representation for the data.For example, we might show the RRs carried in a message as: ISI.EDU. MX 10 VENERA.ISI.EDU. MX 10 VAXA.ISI.EDU. VENERA.ISI.EDU. A 128.9.0.32 A 10.1.0.52 VAXA.ISI.EDU. A 10.2.0.27 A 128.9.0.33The MX RRs have an RDATA section which consists of a 16 bit numberfollowed by a domain name. The address RRs use a standard IP addressformat to contain a 32 bit internet address.This example shows six RRs, with two RRs at each of three domain names.Similarly we might see: XX.LCS.MIT.EDU. IN A 10.0.0.44 CH A MIT.EDU. 2420This example shows two addresses for XX.LCS.MIT.EDU, each of a differentclass.3.6.2. Aliases and canonical namesIn existing systems, hosts and other resources often have several namesthat identify the same resource. For example, the names C.ISI.EDU andUSC-ISIC.ARPA both identify the same host. Similarly, in the case ofmailboxes, many organizations provide many names that actually go to thesame mailbox; for example Mockapetris@C.ISI.EDU, Mockapetris@B.ISI.EDU,Mockapetris [Page 14]
RFC 1034 Domain Concepts and Facilities November 1987and PVM@ISI.EDU all go to the same mailbox (although the mechanismbehind this is somewhat complicated).Most of these systems have a notion that one of the equivalent set ofnames is the canonical or primary name and all others are aliases.The domain system provides such a feature using the canonical name(CNAME) RR. A CNAME RR identifies its owner name as an alias, andspecifies the corresponding canonical name in the RDATA section of theRR. If a CNAME RR is present at a node, no other data should bepresent; this ensures that the data for a canonical name and its aliasescannot be different. This rule also insures that a cached CNAME can beused without checking with an authoritative server for other RR types.CNAME RRs cause special action in DNS software. When a name serverfails to find a desired RR in the resource set associated with thedomain name, it checks to see if the resource set consists of a CNAMErecord with a matching class. If so, the name server includes the CNAMErecord in the response and restarts the query at the domain namespecified in the data field of the CNAME record. The one exception tothis rule is that queries which match the CNAME type are not restarted.For example, suppose a name server was processing a query with for USC-ISIC.ARPA, asking for type A information, and had the following resourcerecords: USC-ISIC.ARPA IN CNAME C.ISI.EDU C.ISI.EDU IN A 10.0.0.52Both of these RRs would be returned in the response to the type A query,while a type CNAME or * query should return just the CNAME.Domain names in RRs which point at another name should always point atthe primary name and not the alias. This avoids extra indirections inaccessing information. For example, the address to name RR for theabove host should be: 52.0.0.10.IN-ADDR.ARPA IN PTR C.ISI.EDUrather than pointing at USC-ISIC.ARPA. Of course, by the robustnessprinciple, domain software should not fail when presented with CNAMEchains or loops; CNAME chains should be followed and CNAME loopssignalled as an error.3.7. QueriesQueries are messages which may be sent to a name server to provoke aMockapetris [Page 15]
RFC 1034 Domain Concepts and Facilities November 1987response. In the Internet, queries are carried in UDP datagrams or overTCP connections. The response by the name server either answers thequestion posed in the query, refers the requester to another set of nameservers, or signals some error condition.In general, the user does not generate queries directly, but insteadmakes a request to a resolver which in turn sends one or more queries toname servers and deals with the error conditions and referrals that mayresult. Of course, the possible questions which can be asked in a querydoes shape the kind of service a resolver can provide.DNS queries and responses are carried in a standard message format. Themessage format has a header containing a number of fixed fields whichare always present, and four sections which carry query parameters andRRs.The most important field in the header is a four bit field called anopcode which separates different queries. Of the possible 16 values,one (standard query) is part of the official protocol, two (inversequery and status query) are options, one (completion) is obsolete, andthe rest are unassigned.The four sections are:Question Carries the query name and other query parameters.Answer Carries RRs which directly answer the query.Authority Carries RRs which describe other authoritative servers. May optionally carry the SOA RR for the authoritative data in the answer section.Additional Carries RRs which may be helpful in using the RRs in the other sections.Note that the content, but not the format, of these sections varies withheader opcode.3.7.1. Standard queriesA standard query specifies a target domain name (QNAME), query type(QTYPE), and query class (QCLASS) and asks for RRs which match. Thistype of query makes up such a vast majority of DNS queries that we usethe term "query" to mean standard query unless otherwise specified. TheQTYPE and QCLASS fields are each 16 bits long, and are a superset ofdefined types and classes.Mockapetris [Page 16]
RFC 1034 Domain Concepts and Facilities November 1987The QTYPE field may contain:<any type> matches just that type. (e.g., A, PTR).AXFR special zone transfer QTYPE.MAILB matches all mail box related RRs (e.g. MB and MG).* matches all RR types.The QCLASS field may contain:<any class> matches just that class (e.g., IN, CH).* matches aLL RR classes.Using the query domain name, QTYPE, and QCLASS, the name server looksfor matching RRs. In addition to relevant records, the name server mayreturn RRs that point toward a name server that has the desiredinformation or RRs that are expected to be useful in interpreting therelevant RRs. For example, a name server that doesn't have therequested information may know a name server that does; a name serverthat returns a domain name in a relevant RR may also return the RR thatbinds that domain name to an address.For example, a mailer tying to send mail to Mockapetris@ISI.EDU mightask the resolver for mail information about ISI.EDU, resulting in aquery for QNAME=ISI.EDU, QTYPE=MX, QCLASS=IN. The response's answersection would be: ISI.EDU. MX 10 VENERA.ISI.EDU. MX 10 VAXA.ISI.EDU.while the additional section might be: VAXA.ISI.EDU. A 10.2.0.27 A 128.9.0.33 VENERA.ISI.EDU. A 10.1.0.52 A 128.9.0.32Because the server assumes that if the requester wants mail exchangeinformation, it will probably want the addresses of the mail exchangessoon afterward.Note that the QCLASS=* construct requires special interpretationregarding authority. Since a particular name server may not know all ofthe classes available in the domain system, it can never know if it isauthoritative for all classes. Hence responses to QCLASS=* queries canMockapetris [Page 17]
RFC 1034 Domain Concepts and Facilities November 1987never be authoritative.3.7.2. Inverse queries (Optional)Name servers may also support inverse queries that map a particularresource to a domain name or domain names that have that resource. Forexample, while a standard query might map a domain name to a SOA RR, thecorresponding inverse query might map the SOA RR back to the domainname.Implementation of this service is optional in a name server, but allname servers must at least be able to understand an inverse querymessage and return a not-implemented error response.The domain system cannot guarantee the completeness or uniqueness ofinverse queries because the domain system is organized by domain namerather than by host address or any other resource type. Inverse queriesare primarily useful for debugging and database maintenance activities.Inverse queries may not return the proper TTL, and do not indicate caseswhere the identified RR is one of a set (for example, one address for ahost having multiple addresses). Therefore, the RRs returned in inversequeries should never be cached.Inverse queries are NOT an acceptable method for mapping host addressesto host names; use the IN-ADDR.ARPA domain instead.A detailed discussion of inverse queries is contained in [RFC-1035].3.8. Status queries (Experimental)To be defined.3.9. Completion queries (Obsolete)The optional completion services described in RFCs 882 and 883 have beendeleted. Redesigned services may become available in the future, or theopcodes may be reclaimed for other use.4. NAME SERVERS4.1. IntroductionName servers are the repositories of information that make up the domaindatabase. The database is divided up into sections called zones, whichare distributed among the name servers. While name servers can haveseveral optional functions and sources of data, the essential task of aname server is to answer queries using data in its zones. By design,Mockapetris [Page 18]
RFC 1034 Domain Concepts and Facilities November 1987name servers can answer queries in a simple manner; the response canalways be generated using only local data, and either contains theanswer to the question or a referral to other name servers "closer" tothe desired information.A given zone will be available from several name servers to insure itsavailability in spite of host or communication link failure. Byadministrative fiat, we require every zone to be available on at leasttwo servers, and many zones have more redundancy than that.A given name server will typically support one or more zones, but thisgives it authoritative information about only a small section of thedomain tree. It may also have some cached non-authoritative data aboutother parts of the tree. The name server marks its responses to queriesso that the requester can tell whether the response comes fromauthoritative data or not.4.2. How the database is divided into zonesThe domain database is partitioned in two ways: by class, and by "cuts"made in the name space between nodes.The class partition is simple. The database for any class is organized,delegated, and maintained separately from all other classes. Since, byconvention, the name spaces are the same for all classes, the separateclasses can be thought of as an array of parallel namespace trees. Notethat the data attached to nodes will be different for these differentparallel classes. The most common reasons for creating a new class arethe necessity for a new data format for existing types or a desire for aseparately managed version of the existing name space.Within a class, "cuts" in the name space can be made between any twoadjacent nodes. After all cuts are made, each group of connected namespace is a separate zone. The zone is said to be authoritative for allnames in the connected region. Note that the "cuts" in the name spacemay be in different places for different classes, the name servers maybe different, etc.These rules mean that every zone has at least one node, and hence domainname, for which it is authoritative, and all of the nodes in aparticular zone are connected. Given, the tree structure, every zonehas a highest node which is closer to the root than any other node inthe zone. The name of this node is often used to identify the zone.It would be possible, though not particularly useful, to partition thename space so that each domain name was in a separate zone or so thatall nodes were in a single zone. Instead, the database is partitionedat points where a particular organization wants to take over control ofMockapetris [Page 19]
RFC 1034 Domain Concepts and Facilities November 1987a subtree. Once an organization controls its own zone it canunilaterally change the data in the zone, grow new tree sectionsconnected to the zone, delete existing nodes, or delegate new subzonesunder its zone.If the organization has substructure, it may want to make furtherinternal partitions to achieve nested delegations of name space control.In some cases, such divisions are made purely to make databasemaintenance more convenient.4.2.1. Technical considerationsThe data that describes a zone has four major parts: - Authoritative data for all nodes within the zone. - Data that defines the top node of the zone (can be thought of as part of the authoritative data). - Data that describes delegated subzones, i.e., cuts around the bottom of the zone. - Data that allows access to name servers for subzones (sometimes called "glue" data).All of this data is expressed in the form of RRs, so a zone can becompletely described in terms of a set of RRs. Whole zones can betransferred between name servers by transferring the RRs, either carriedin a series of messages or by FTPing a master file which is a textualrepresentation.The authoritative data for a zone is simply all of the RRs attached toall of the nodes from the top node of the zone down to leaf nodes ornodes above cuts around the bottom edge of the zone.Though logically part of the authoritative data, the RRs that describethe top node of the zone are especially important to the zone'smanagement. These RRs are of two types: name server RRs that list, oneper RR, all of the servers for the zone, and a single SOA RR thatdescribes zone management parameters.The RRs that describe cuts around the bottom of the zone are NS RRs thatname the servers for the subzones. Since the cuts are between nodes,these RRs are NOT part of the authoritative data of the zone, and shouldbe exactly the same as the corresponding RRs in the top node of thesubzone. Since name servers are always associated with zone boundaries,NS RRs are only found at nodes which are the top node of some zone. Inthe data that makes up a zone, NS RRs are found at the top node of theMockapetris [Page 20]
RFC 1034 Domain Concepts and Facilities November 1987zone (and are authoritative) and at cuts around the bottom of the zone(where they are not authoritative), but never in between.One of the goals of the zone structure is that any zone have all thedata required to set up communications with the name servers for anysubzones. That is, parent zones have all the information needed toaccess servers for their children zones. The NS RRs that name theservers for subzones are often not enough for this task since they namethe servers, but do not give their addresses. In particular, if thename of the name server is itself in the subzone, we could be faced withthe situation where the NS RRs tell us that in order to learn a nameserver's address, we should contact the server using the address we wishto learn. To fix this problem, a zone contains "glue" RRs which are notpart of the authoritative data, and are address RRs for the servers.These RRs are only necessary if the name server's name is "below" thecut, and are only used as part of a referral response.4.2.2. Administrative considerationsWhen some organization wants to control its own domain, the first stepis to identify the proper parent zone, and get the parent zone's ownersto agree to the delegation of control. While there are no particulartechnical constraints dealing with where in the tree this can be done,there are some administrative groupings discussed in [RFC-1032] whichdeal with top level organization, and middle level zones are free tocreate their own rules. For example, one university might choose to usea single zone, while another might choose to organize by subzonesdedicated to individual departments or schools. [RFC-1033] catalogsavailable DNS software an discusses administration procedures.Once the proper name for the new subzone is selected, the new ownersshould be required to demonstrate redundant name server support. Notethat there is no requirement that the servers for a zone reside in ahost which has a name in that domain. In many cases, a zone will bemore accessible to the internet at large if its servers are widelydistributed rather than being within the physical facilities controlledby the same organization that manages the zone. For example, in thecurrent DNS, one of the name servers for the United Kingdom, or UKdomain, is found in the US. This allows US hosts to get UK data withoutusing limited transatlantic bandwidth.As the last installation step, the delegation NS RRs and glue RRsnecessary to make the delegation effective should be added to the parentzone. The administrators of both zones should insure that the NS andglue RRs which mark both sides of the cut are consistent and remain so.4.3. Name server internalsMockapetris [Page 21]
RFC 1034 Domain Concepts and Facilities November 19874.3.1. Queries and responsesThe principal activity of name servers is to answer standard queries.Both the query and its response are carried in a standard message formatwhich is described in [RFC-1035]. The query contains a QTYPE, QCLASS,and QNAME, which describe the types and classes of desired informationand the name of interest.The way that the name server answers the query depends upon whether itis operating in recursive mode or not: - The simplest mode for the server is non-recursive, since it can answer queries using only local information: the response contains an error, the answer, or a referral to some other server "closer" to the answer. All name servers must implement non-recursive queries. - The simplest mode for the client is recursive, since in this mode the name server acts in the role of a resolver and returns either an error or the answer, but never referrals. This service is optional in a name server, and the name server may also choose to restrict the clients which can use recursive mode.Recursive service is helpful in several situations: - a relatively simple requester that lacks the ability to use anything other than a direct answer to the question. - a request that needs to cross protocol or other boundaries and can be sent to a server which can act as intermediary. - a network where we want to concentrate the cache rather than having a separate cache for each client.Non-recursive service is appropriate if the requester is capable ofpursuing referrals and interested in information which will aid futurerequests.The use of recursive mode is limited to cases where both the client andthe name server agree to its use. The agreement is negotiated throughthe use of two bits in query and response messages: - The recursion available, or RA bit, is set or cleared by a name server in all responses. The bit is true if the name server is willing to provide recursive service for the client, regardless of whether the client requested recursive service. That is, RA signals availability rather than use.Mockapetris [Page 22]
RFC 1034 Domain Concepts and Facilities November 1987 - Queries contain a bit called recursion desired or RD. This bit specifies specifies whether the requester wants recursive service for this query. Clients may request recursive service from any name server, though they should depend upon receiving it only from servers which have previously sent an RA, or servers which have agreed to provide service through private agreement or some other means outside of the DNS protocol.The recursive mode occurs when a query with RD set arrives at a serverwhich is willing to provide recursive service; the client can verifythat recursive mode was used by checking that both RA and RD are set inthe reply. Note that the name server should never perform recursiveservice unless asked via RD, since this interferes with trouble shootingof name servers and their databases.If recursive service is requested and available, the recursive responseto a query will be one of the following: - The answer to the query, possibly preface by one or more CNAME RRs that specify aliases encountered on the way to an answer. - A name error indicating that the name does not exist. This may include CNAME RRs that indicate that the original query name was an alias for a name which does not exist. - A temporary error indication.If recursive service is not requested or is not available, the non-recursive response will be one of the following: - An authoritative name error indicating that the name does not exist. - A temporary error indication. - Some combination of: RRs that answer the question, together with an indication whether the data comes from a zone or is cached. A referral to name servers which have zones which are closer ancestors to the name than the server sending the reply. - RRs that the name server thinks will prove useful to the requester.Mockapetris [Page 23]
RFC 1034 Domain Concepts and Facilities November 19874.3.2. AlgorithmThe actual algorithm used by the name server will depend on the local OSand data structures used to store RRs. The following algorithm assumesthat the RRs are organized in several tree structures, one for eachzone, and another for the cache: 1. Set or clear the value of recursion available in the response depending on whether the name server is willing to provide recursive service. If recursive service is available and requested via the RD bit in the query, go to step 5, otherwise step 2. 2. Search the available zones for the zone which is the nearest ancestor to QNAME. If such a zone is found, go to step 3, otherwise step 4. 3. Start matching down, label by label, in the zone. The matching process can terminate several ways: a. If the whole of QNAME is matched, we have found the node. If the data at the node is a CNAME, and QTYPE doesn't match CNAME, copy the CNAME RR into the answer section of the response, change QNAME to the canonical name in the CNAME RR, and go back to step 1. Otherwise, copy all RRs which match QTYPE into the answer section and go to step 6. b. If a match would take us out of the authoritative data, we have a referral. This happens when we encounter a node with NS RRs marking cuts along the bottom of a zone. Copy the NS RRs for the subzone into the authority section of the reply. Put whatever addresses are available into the additional section, using glue RRs if the addresses are not available from authoritative data or the cache. Go to step 4. c. If at some label, a match is impossible (i.e., the corresponding label does not exist), look to see if a the "*" label exists. If the "*" label does not exist, check whether the name we are looking for is the original QNAME in the queryMockapetris [Page 24]
RFC 1034 Domain Concepts and Facilities November 1987 or a name we have followed due to a CNAME. If the name is original, set an authoritative name error in the response and exit. Otherwise just exit. If the "*" label does exist, match RRs at that node against QTYPE. If any match, copy them into the answer section, but set the owner of the RR to be QNAME, and not the node with the "*" label. Go to step 6. 4. Start matching down in the cache. If QNAME is found in the cache, copy all RRs attached to it that match QTYPE into the answer section. If there was no delegation from authoritative data, look for the best one from the cache, and put it in the authority section. Go to step 6. 5. Using the local resolver or a copy of its algorithm (see resolver section of this memo) to answer the query. Store the results, including any intermediate CNAMEs, in the answer section of the response. 6. Using local data only, attempt to add other RRs which may be useful to the additional section of the query. Exit.4.3.3. WildcardsIn the previous algorithm, special treatment was given to RRs with ownernames starting with the label "*". Such RRs are called wildcards.Wildcard RRs can be thought of as instructions for synthesizing RRs.When the appropriate conditions are met, the name server creates RRswith an owner name equal to the query name and contents taken from thewildcard RRs.This facility is most often used to create a zone which will be used toforward mail from the Internet to some other mail system. The generalidea is that any name in that zone which is presented to server in aquery will be assumed to exist, with certain properties, unless explicitevidence exists to the contrary. Note that the use of the term zonehere, instead of domain, is intentional; such defaults do not propagateacross zone boundaries, although a subzone may choose to achieve thatappearance by setting up similar defaults.The contents of the wildcard RRs follows the usual rules and formats forRRs. The wildcards in the zone have an owner name that controls thequery names they will match. The owner name of the wildcard RRs is ofthe form "*.<anydomain>", where <anydomain> is any domain name.<anydomain> should not contain other * labels, and should be in theauthoritative data of the zone. The wildcards potentially apply todescendants of <anydomain>, but not to <anydomain> itself. Another wayMockapetris [Page 25]
RFC 1034 Domain Concepts and Facilities November 1987to look at this is that the "*" label always matches at least one wholelabel and sometimes more, but always whole labels.Wildcard RRs do not apply: - When the query is in another zone. That is, delegation cancels the wildcard defaults. - When the query name or a name between the wildcard domain and the query name is know to exist. For example, if a wildcard RR has an owner name of "*.X", and the zone also contains RRs attached to B.X, the wildcards would apply to queries for name Z.X (presuming there is no explicit information for Z.X), but not to B.X, A.B.X, or X.A * label appearing in a query name has no special effect, but can beused to test for wildcards in an authoritative zone; such a query is theonly way to get a response containing RRs with an owner name with * init. The result of such a query should not be cached.Note that the contents of the wildcard RRs are not modified when used tosynthesize RRs.To illustrate the use of wildcard RRs, suppose a large company with alarge, non-IP/TCP, network wanted to create a mail gateway. If thecompany was called X.COM, and IP/TCP capable gateway machine was calledA.X.COM, the following RRs might be entered into the COM zone: X.COM MX 10 A.X.COM *.X.COM MX 10 A.X.COM A.X.COM A 1.2.3.4 A.X.COM MX 10 A.X.COM *.A.X.COM MX 10 A.X.COMThis would cause any MX query for any domain name ending in X.COM toreturn an MX RR pointing at A.X.COM. Two wildcard RRs are requiredsince the effect of the wildcard at *.X.COM is inhibited in the A.X.COMsubtree by the explicit data for A.X.COM. Note also that the explicitMX data at X.COM and A.X.COM is required, and that none of the RRs abovewould match a query name of XX.COM.4.3.4. Negative response caching (Optional)The DNS provides an optional service which allows name servers todistribute, and resolvers to cache, negative results with TTLs. ForMockapetris [Page 26]
RFC 1034 Domain Concepts and Facilities November 1987example, a name server can distribute a TTL along with a name errorindication, and a resolver receiving such information is allowed toassume that the name does not exist during the TTL period withoutconsulting authoritative data. Similarly, a resolver can make a querywith a QTYPE which matches multiple types, and cache the fact that someof the types are not present.This feature can be particularly important in a system which implementsnaming shorthands that use search lists beacuse a popular shorthand,which happens to require a suffix toward the end of the search list,will generate multiple name errors whenever it is used.The method is that a name server may add an SOA RR to the additionalsection of a response when that response is authoritative. The SOA mustbe that of the zone which was the source of the authoritative data inthe answer section, or name error if applicable. The MINIMUM field ofthe SOA controls the length of time that the negative result may becached.Note that in some circumstances, the answer section may contain multipleowner names. In this case, the SOA mechanism should only be used forthe data which matches QNAME, which is the only authoritative data inthis section.Name servers and resolvers should never attempt to add SOAs to theadditional section of a non-authoritative response, or attempt to inferresults which are not directly stated in an authoritative response.There are several reasons for this, including: cached information isn'tusually enough to match up RRs and their zone names, SOA RRs may becached due to direct SOA queries, and name servers are not required tooutput the SOAs in the authority section.This feature is optional, although a refined version is expected tobecome part of the standard protocol in the future. Name servers arenot required to add the SOA RRs in all authoritative responses, nor areresolvers required to cache negative results. Both are recommended.All resolvers and recursive name servers are required to at least beable to ignore the SOA RR when it is present in a response.Some experiments have also been proposed which will use this feature.The idea is that if cached data is known to come from a particular zone,and if an authoritative copy of the zone's SOA is obtained, and if thezone's SERIAL has not changed since the data was cached, then the TTL ofthe cached data can be reset to the zone MINIMUM value if it is smaller.This usage is mentioned for planning purposes only, and is notrecommended as yet.Mockapetris [Page 27]
RFC 1034 Domain Concepts and Facilities November 19874.3.5. Zone maintenance and transfersPart of the job of a zone administrator is to maintain the zones at allof the name servers which are authoritative for the zone. When theinevitable changes are made, they must be distributed to all of the nameservers. While this distribution can be accomplished using FTP or someother ad hoc procedure, the preferred method is the zone transfer partof the DNS protocol.The general model of automatic zone transfer or refreshing is that oneof the name servers is the master or primary for the zone. Changes arecoordinated at the primary, typically by editing a master file for thezone. After editing, the administrator signals the master server toload the new zone. The other non-master or secondary servers for thezone periodically check for changes (at a selectable interval) andobtain new zone copies when changes have been made.To detect changes, secondaries just check the SERIAL field of the SOAfor the zone. In addition to whatever other changes are made, theSERIAL field in the SOA of the zone is always advanced whenever anychange is made to the zone. The advancing can be a simple increment, orcould be based on the write date and time of the master file, etc. Thepurpose is to make it possible to determine which of two copies of azone is more recent by comparing serial numbers. Serial number advancesand comparisons use sequence space arithmetic, so there is a theoreticlimit on how fast a zone can be updated, basically that old copies mustdie out before the serial number covers half of its 32 bit range. Inpractice, the only concern is that the compare operation deals properlywith comparisons around the boundary between the most positive and mostnegative 32 bit numbers.The periodic polling of the secondary servers is controlled byparameters in the SOA RR for the zone, which set the minimum acceptablepolling intervals. The parameters are called REFRESH, RETRY, andEXPIRE. Whenever a new zone is loaded in a secondary, the secondarywaits REFRESH seconds before checking with the primary for a new serial.If this check cannot be completed, new checks are started every RETRYseconds. The check is a simple query to the primary for the SOA RR ofthe zone. If the serial field in the secondary's zone copy is equal tothe serial returned by the primary, then no changes have occurred, andthe REFRESH interval wait is restarted. If the secondary finds itimpossible to perform a serial check for the EXPIRE interval, it mustassume that its copy of the zone is obsolete an discard it.When the poll shows that the zone has changed, then the secondary servermust request a zone transfer via an AXFR request for the zone. The AXFRmay cause an error, such as refused, but normally is answered by asequence of response messages. The first and last messages must containMockapetris [Page 28]
RFC 1034 Domain Concepts and Facilities November 1987the data for the top authoritative node of the zone. Intermediatemessages carry all of the other RRs from the zone, including bothauthoritative and non-authoritative RRs. The stream of messages allowsthe secondary to construct a copy of the zone. Because accuracy isessential, TCP or some other reliable protocol must be used for AXFRrequests.Each secondary server is required to perform the following operationsagainst the master, but may also optionally perform these operationsagainst other secondary servers. This strategy can improve the transferprocess when the primary is unavailable due to host downtime or networkproblems, or when a secondary server has better network access to an"intermediate" secondary than to the primary.5. RESOLVERS5.1. IntroductionResolvers are programs that interface user programs to domain nameservers. In the simplest case, a resolver receives a request from auser program (e.g., mail programs, TELNET, FTP) in the form of asubroutine call, system call etc., and returns the desired informationin a form compatible with the local host's data formats.The resolver is located on the same machine as the program that requeststhe resolver's services, but it may need to consult name servers onother hosts. Because a resolver may need to consult several nameservers, or may have the requested information in a local cache, theamount of time that a resolver will take to complete can vary quite abit, from milliseconds to several seconds.A very important goal of the resolver is to eliminate network delay andname server load from most requests by answering them from its cache ofprior results. It follows that caches which are shared by multipleprocesses, users, machines, etc., are more efficient than non-sharedcaches.5.2. Client-resolver interface5.2.1. Typical functionsThe client interface to the resolver is influenced by the local host'sconventions, but the typical resolver-client interface has threefunctions: 1. Host name to host address translation. This function is often defined to mimic a previous HOSTS.TXTMockapetris [Page 29]
RFC 1034 Domain Concepts and Facilities November 1987 based function. Given a character string, the caller wants one or more 32 bit IP addresses. Under the DNS, it translates into a request for type A RRs. Since the DNS does not preserve the order of RRs, this function may choose to sort the returned addresses or select the "best" address if the service returns only one choice to the client. Note that a multiple address return is recommended, but a single address may be the only way to emulate prior HOSTS.TXT services. 2. Host address to host name translation This function will often follow the form of previous functions. Given a 32 bit IP address, the caller wants a character string. The octets of the IP address are reversed, used as name components, and suffixed with "IN-ADDR.ARPA". A type PTR query is used to get the RR with the primary name of the host. For example, a request for the host name corresponding to IP address 1.2.3.4 looks for PTR RRs for domain name "4.3.2.1.IN-ADDR.ARPA". 3. General lookup function This function retrieves arbitrary information from the DNS, and has no counterpart in previous systems. The caller supplies a QNAME, QTYPE, and QCLASS, and wants all of the matching RRs. This function will often use the DNS format for all RR data instead of the local host's, and returns all RR content (e.g., TTL) instead of a processed form with local quoting conventions.When the resolver performs the indicated function, it usually has one ofthe following results to pass back to the client: - One or more RRs giving the requested data. In this case the resolver returns the answer in the appropriate format. - A name error (NE). This happens when the referenced name does not exist. For example, a user may have mistyped a host name. - A data not found error. This happens when the referenced name exists, but data of the appropriate type does not. For example, a host addressMockapetris [Page 30]
RFC 1034 Domain Concepts and Facilities November 1987 function applied to a mailbox name would return this error since the name exists, but no address RR is present.It is important to note that the functions for translating between hostnames and addresses may combine the "name error" and "data not found"error conditions into a single type of error return, but the generalfunction should not. One reason for this is that applications may askfirst for one type of information about a name followed by a secondrequest to the same name for some other type of information; if the twoerrors are combined, then useless queries may slow the application.5.2.2. AliasesWhile attempting to resolve a particular request, the resolver may findthat the name in question is an alias. For example, the resolver mightfind that the name given for host name to address translation is analias when it finds the CNAME RR. If possible, the alias conditionshould be signalled back from the resolver to the client.In most cases a resolver simply restarts the query at the new name whenit encounters a CNAME. However, when performing the general function,the resolver should not pursue aliases when the CNAME RR matches thequery type. This allows queries which ask whether an alias is present.For example, if the query type is CNAME, the user is interested in theCNAME RR itself, and not the RRs at the name it points to.Several special conditions can occur with aliases. Multiple levels ofaliases should be avoided due to their lack of efficiency, but shouldnot be signalled as an error. Alias loops and aliases which point tonon-existent names should be caught and an error condition passed backto the client.5.2.3. Temporary failuresIn a less than perfect world, all resolvers will occasionally be unableto resolve a particular request. This condition can be caused by aresolver which becomes separated from the rest of the network due to alink failure or gateway problem, or less often by coincident failure orunavailability of all servers for a particular domain.It is essential that this sort of condition should not be signalled as aname or data not present error to applications. This sort of behavioris annoying to humans, and can wreak havoc when mail systems use theDNS.While in some cases it is possible to deal with such a temporary problemby blocking the request indefinitely, this is usually not a good choice,particularly when the client is a server process that could move on toMockapetris [Page 31]
RFC 1034 Domain Concepts and Facilities November 1987other tasks. The recommended solution is to always have temporaryfailure as one of the possible results of a resolver function, eventhough this may make emulation of existing HOSTS.TXT functions moredifficult.5.3. Resolver internalsEvery resolver implementation uses slightly different algorithms, andtypically spends much more logic dealing with errors of various sortsthan typical occurances. This section outlines a recommended basicstrategy for resolver operation, but leaves details to [RFC-1035].5.3.1. Stub resolversOne option for implementing a resolver is to move the resolutionfunction out of the local machine and into a name server which supportsrecursive queries. This can provide an easy method of providing domainservice in a PC which lacks the resources to perform the resolverfunction, or can centralize the cache for a whole local network ororganization.All that the remaining stub needs is a list of name server addressesthat will perform the recursive requests. This type of resolverpresumably needs the information in a configuration file, since itprobably lacks the sophistication to locate it in the domain database.The user also needs to verify that the listed servers will perform therecursive service; a name server is free to refuse to perform recursiveservices for any or all clients. The user should consult the localsystem administrator to find name servers willing to perform theservice.This type of service suffers from some drawbacks. Since the recursiverequests may take an arbitrary amount of time to perform, the stub mayhave difficulty optimizing retransmission intervals to deal with bothlost UDP packets and dead servers; the name server can be easilyoverloaded by too zealous a stub if it interprets retransmissions as newrequests. Use of TCP may be an answer, but TCP may well place burdenson the host's capabilities which are similar to those of a realresolver.5.3.2. ResourcesIn addition to its own resources, the resolver may also have sharedaccess to zones maintained by a local name server. This gives theresolver the advantage of more rapid access, but the resolver must becareful to never let cached information override zone data. In thisdiscussion the term "local information" is meant to mean the union ofthe cache and such shared zones, with the understanding thatMockapetris [Page 32]
RFC 1034 Domain Concepts and Facilities November 1987authoritative data is always used in preference to cached data when bothare present.The following resolver algorithm assumes that all functions have beenconverted to a general lookup function, and uses the following datastructures to represent the state of a request in progress in theresolver:SNAME the domain name we are searching for.STYPE the QTYPE of the search request.SCLASS the QCLASS of the search request.SLIST a structure which describes the name servers and the zone which the resolver is currently trying to query. This structure keeps track of the resolver's current best guess about which name servers hold the desired information; it is updated when arriving information changes the guess. This structure includes the equivalent of a zone name, the known name servers for the zone, the known addresses for the name servers, and history information which can be used to suggest which server is likely to be the best one to try next. The zone name equivalent is a match count of the number of labels from the root down which SNAME has in common with the zone being queried; this is used as a measure of how "close" the resolver is to SNAME.SBELT a "safety belt" structure of the same form as SLIST, which is initialized from a configuration file, and lists servers which should be used when the resolver doesn't have any local information to guide name server selection. The match count will be -1 to indicate that no labels are known to match.CACHE A structure which stores the results from previous responses. Since resolvers are responsible for discarding old RRs whose TTL has expired, most implementations convert the interval specified in arriving RRs to some sort of absolute time when the RR is stored in the cache. Instead of counting the TTLs down individually, the resolver just ignores or discards old RRs when it runs across them in the course of a search, or discards them during periodic sweeps to reclaim the memory consumed by old RRs.Mockapetris [Page 33]
RFC 1034 Domain Concepts and Facilities November 19875.3.3. AlgorithmThe top level algorithm has four steps: 1. See if the answer is in local information, and if so return it to the client. 2. Find the best servers to ask. 3. Send them queries until one returns a response. 4. Analyze the response, either: a. if the response answers the question or contains a name error, cache the data as well as returning it back to the client. b. if the response contains a better delegation to other servers, cache the delegation information, and go to step 2. c. if the response shows a CNAME and that is not the answer itself, cache the CNAME, change the SNAME to the canonical name in the CNAME RR and go to step 1. d. if the response shows a servers failure or other bizarre contents, delete the server from the SLIST and go back to step 3.Step 1 searches the cache for the desired data. If the data is in thecache, it is assumed to be good enough for normal use. Some resolvershave an option at the user interface which will force the resolver toignore the cached data and consult with an authoritative server. Thisis not recommended as the default. If the resolver has direct access toa name server's zones, it should check to see if the desired data ispresent in authoritative form, and if so, use the authoritative data inpreference to cached data.Step 2 looks for a name server to ask for the required data. Thegeneral strategy is to look for locally-available name server RRs,starting at SNAME, then the parent domain name of SNAME, thegrandparent, and so on toward the root. Thus if SNAME wereMockapetris.ISI.EDU, this step would look for NS RRs forMockapetris.ISI.EDU, then ISI.EDU, then EDU, and then . (the root).These NS RRs list the names of hosts for a zone at or above SNAME. Copythe names into SLIST. Set up their addresses using local data. It maybe the case that the addresses are not available. The resolver has manychoices here; the best is to start parallel resolver processes lookingMockapetris [Page 34]
RFC 1034 Domain Concepts and Facilities November 1987for the addresses while continuing onward with the addresses which areavailable. Obviously, the design choices and options are complicatedand a function of the local host's capabilities. The recommendedpriorities for the resolver designer are: 1. Bound the amount of work (packets sent, parallel processes started) so that a request can't get into an infinite loop or start off a chain reaction of requests or queries with other implementations EVEN IF SOMEONE HAS INCORRECTLY CONFIGURED SOME DATA. 2. Get back an answer if at all possible. 3. Avoid unnecessary transmissions. 4. Get the answer as quickly as possible.If the search for NS RRs fails, then the resolver initializes SLIST fromthe safety belt SBELT. The basic idea is that when the resolver has noidea what servers to ask, it should use information from a configurationfile that lists several servers which are expected to be helpful.Although there are special situations, the usual choice is two of theroot servers and two of the servers for the host's domain. The reasonfor two of each is for redundancy. The root servers will provideeventual access to all of the domain space. The two local servers willallow the resolver to continue to resolve local names if the localnetwork becomes isolated from the internet due to gateway or linkfailure.In addition to the names and addresses of the servers, the SLIST datastructure can be sorted to use the best servers first, and to insurethat all addresses of all servers are used in a round-robin manner. Thesorting can be a simple function of preferring addresses on the localnetwork over others, or may involve statistics from past events, such asprevious response times and batting averages.Step 3 sends out queries until a response is received. The strategy isto cycle around all of the addresses for all of the servers with atimeout between each transmission. In practice it is important to useall addresses of a multihomed host, and too aggressive a retransmissionpolicy actually slows response when used by multiple resolverscontending for the same name server and even occasionally for a singleresolver. SLIST typically contains data values to control the timeoutsand keep track of previous transmissions.Step 4 involves analyzing responses. The resolver should be highlyparanoid in its parsing of responses. It should also check that theresponse matches the query it sent using the ID field in the response.Mockapetris [Page 35]
RFC 1034 Domain Concepts and Facilities November 1987The ideal answer is one from a server authoritative for the query whicheither gives the required data or a name error. The data is passed backto the user and entered in the cache for future use if its TTL isgreater than zero.If the response shows a delegation, the resolver should check to seethat the delegation is "closer" to the answer than the servers in SLISTare. This can be done by comparing the match count in SLIST with thatcomputed from SNAME and the NS RRs in the delegation. If not, the replyis bogus and should be ignored. If the delegation is valid the NSdelegation RRs and any address RRs for the servers should be cached.The name servers are entered in the SLIST, and the search is restarted.If the response contains a CNAME, the search is restarted at the CNAMEunless the response has the data for the canonical name or if the CNAMEis the answer itself.Details and implementation hints can be found in [RFC-1035].6. A SCENARIOIn our sample domain space, suppose we wanted separate administrativecontrol for the root, MIL, EDU, MIT.EDU and ISI.EDU zones. We mightallocate name servers as follows: |(C.ISI.EDU,SRI-NIC.ARPA | A.ISI.EDU) +---------------------+------------------+ | | | MIL EDU ARPA |(SRI-NIC.ARPA, |(SRI-NIC.ARPA, | | A.ISI.EDU | C.ISI.EDU) | +-----+-----+ | +------+-----+-----+ | | | | | | | BRL NOSC DARPA | IN-ADDR SRI-NIC ACC | +--------+------------------+---------------+--------+ | | | | | UCI MIT | UDEL YALE |(XX.LCS.MIT.EDU, ISI |ACHILLES.MIT.EDU) |(VAXA.ISI.EDU,VENERA.ISI.EDU, +---+---+ | A.ISI.EDU) | | | LCS ACHILLES +--+-----+-----+--------+ | | | | | | XX A C VAXA VENERA MockapetrisMockapetris [Page 36]
RFC 1034 Domain Concepts and Facilities November 1987In this example, the authoritative name server is shown in parenthesesat the point in the domain tree at which is assumes control.Thus the root name servers are on C.ISI.EDU, SRI-NIC.ARPA, andA.ISI.EDU. The MIL domain is served by SRI-NIC.ARPA and A.ISI.EDU. TheEDU domain is served by SRI-NIC.ARPA. and C.ISI.EDU. Note that serversmay have zones which are contiguous or disjoint. In this scenario,C.ISI.EDU has contiguous zones at the root and EDU domains. A.ISI.EDUhas contiguous zones at the root and MIL domains, but also has a non-contiguous zone at ISI.EDU.6.1. C.ISI.EDU name serverC.ISI.EDU is a name server for the root, MIL, and EDU domains of the INclass, and would have zones for these domains. The zone data for theroot domain might be: . IN SOA SRI-NIC.ARPA. HOSTMASTER.SRI-NIC.ARPA. ( 870611 ;serial 1800 ;refresh every 30 min 300 ;retry every 5 min 604800 ;expire after a week 86400) ;minimum of a day NS A.ISI.EDU. NS C.ISI.EDU. NS SRI-NIC.ARPA. MIL. 86400 NS SRI-NIC.ARPA. 86400 NS A.ISI.EDU. EDU. 86400 NS SRI-NIC.ARPA. 86400 NS C.ISI.EDU. SRI-NIC.ARPA. A 26.0.0.73 A 10.0.0.51 MX 0 SRI-NIC.ARPA. HINFO DEC-2060 TOPS20 ACC.ARPA. A 26.6.0.65 HINFO PDP-11/70 UNIX MX 10 ACC.ARPA. USC-ISIC.ARPA. CNAME C.ISI.EDU. 73.0.0.26.IN-ADDR.ARPA. PTR SRI-NIC.ARPA. 65.0.6.26.IN-ADDR.ARPA. PTR ACC.ARPA. 51.0.0.10.IN-ADDR.ARPA. PTR SRI-NIC.ARPA. 52.0.0.10.IN-ADDR.ARPA. PTR C.ISI.EDU.Mockapetris [Page 37]
RFC 1034 Domain Concepts and Facilities November 1987 103.0.3.26.IN-ADDR.ARPA. PTR A.ISI.EDU. A.ISI.EDU. 86400 A 26.3.0.103 C.ISI.EDU. 86400 A 10.0.0.52This data is represented as it would be in a master file. Most RRs aresingle line entries; the sole exception here is the SOA RR, which uses"(" to start a multi-line RR and ")" to show the end of a multi-line RR.Since the class of all RRs in a zone must be the same, only the first RRin a zone need specify the class. When a name server loads a zone, itforces the TTL of all authoritative RRs to be at least the MINIMUM fieldof the SOA, here 86400 seconds, or one day. The NS RRs markingdelegation of the MIL and EDU domains, together with the glue RRs forthe servers host addresses, are not part of the authoritative data inthe zone, and hence have explicit TTLs.Four RRs are attached to the root node: the SOA which describes the rootzone and the 3 NS RRs which list the name servers for the root. Thedata in the SOA RR describes the management of the zone. The zone datais maintained on host SRI-NIC.ARPA, and the responsible party for thezone is HOSTMASTER@SRI-NIC.ARPA. A key item in the SOA is the 86400second minimum TTL, which means that all authoritative data in the zonehas at least that TTL, although higher values may be explicitlyspecified.The NS RRs for the MIL and EDU domains mark the boundary between theroot zone and the MIL and EDU zones. Note that in this example, thelower zones happen to be supported by name servers which also supportthe root zone.The master file for the EDU zone might be stated relative to the originEDU. The zone data for the EDU domain might be: EDU. IN SOA SRI-NIC.ARPA. HOSTMASTER.SRI-NIC.ARPA. ( 870729 ;serial 1800 ;refresh every 30 minutes 300 ;retry every 5 minutes 604800 ;expire after a week 86400 ;minimum of a day ) NS SRI-NIC.ARPA. NS C.ISI.EDU. UCI 172800 NS ICS.UCI 172800 NS ROME.UCI ICS.UCI 172800 A 192.5.19.1 ROME.UCI 172800 A 192.5.19.31Mockapetris [Page 38]
RFC 1034 Domain Concepts and Facilities November 1987 ISI 172800 NS VAXA.ISI 172800 NS A.ISI 172800 NS VENERA.ISI.EDU. VAXA.ISI 172800 A 10.2.0.27 172800 A 128.9.0.33 VENERA.ISI.EDU. 172800 A 10.1.0.52 172800 A 128.9.0.32 A.ISI 172800 A 26.3.0.103 UDEL.EDU. 172800 NS LOUIE.UDEL.EDU. 172800 NS UMN-REI-UC.ARPA. LOUIE.UDEL.EDU. 172800 A 10.0.0.96 172800 A 192.5.39.3 YALE.EDU. 172800 NS YALE.ARPA. YALE.EDU. 172800 NS YALE-BULLDOG.ARPA. MIT.EDU. 43200 NS XX.LCS.MIT.EDU. 43200 NS ACHILLES.MIT.EDU. XX.LCS.MIT.EDU. 43200 A 10.0.0.44 ACHILLES.MIT.EDU. 43200 A 18.72.0.8Note the use of relative names here. The owner name for the ISI.EDU. isstated using a relative name, as are two of the name server RR contents.Relative and absolute domain names may be freely intermixed in a master6.2. Example standard queriesThe following queries and responses illustrate name server behavior.Unless otherwise noted, the queries do not have recursion desired (RD)in the header. Note that the answers to non-recursive queries do dependon the server being asked, but do not depend on the identity of therequester.Mockapetris [Page 39]
RFC 1034 Domain Concepts and Facilities November 19876.2.1. QNAME=SRI-NIC.ARPA, QTYPE=AThe query would look like: +---------------------------------------------------+ Header | OPCODE=SQUERY | +---------------------------------------------------+ Question | QNAME=SRI-NIC.ARPA., QCLASS=IN, QTYPE=A | +---------------------------------------------------+ Answer | <empty> | +---------------------------------------------------+ Authority | <empty> | +---------------------------------------------------+ Additional | <empty> | +---------------------------------------------------+The response from C.ISI.EDU would be: +---------------------------------------------------+ Header | OPCODE=SQUERY, RESPONSE, AA | +---------------------------------------------------+ Question | QNAME=SRI-NIC.ARPA., QCLASS=IN, QTYPE=A | +---------------------------------------------------+ Answer | SRI-NIC.ARPA. 86400 IN A 26.0.0.73 | | 86400 IN A 10.0.0.51 | +---------------------------------------------------+ Authority | <empty> | +---------------------------------------------------+ Additional | <empty> | +---------------------------------------------------+The header of the response looks like the header of the query, exceptthat the RESPONSE bit is set, indicating that this message is aresponse, not a query, and the Authoritative Answer (AA) bit is setindicating that the address RRs in the answer section are fromauthoritative data. The question section of the response matches thequestion section of the query.Mockapetris [Page 40]
RFC 1034 Domain Concepts and Facilities November 1987If the same query was sent to some other server which was notauthoritative for SRI-NIC.ARPA, the response might be: +---------------------------------------------------+ Header | OPCODE=SQUERY,RESPONSE | +---------------------------------------------------+ Question | QNAME=SRI-NIC.ARPA., QCLASS=IN, QTYPE=A | +---------------------------------------------------+ Answer | SRI-NIC.ARPA. 1777 IN A 10.0.0.51 | | 1777 IN A 26.0.0.73 | +---------------------------------------------------+ Authority | <empty> | +---------------------------------------------------+ Additional | <empty> | +---------------------------------------------------+This response is different from the previous one in two ways: the headerdoes not have AA set, and the TTLs are different. The inference is thatthe data did not come from a zone, but from a cache. The differencebetween the authoritative TTL and the TTL here is due to aging of thedata in a cache. The difference in ordering of the RRs in the answersection is not significant.6.2.2. QNAME=SRI-NIC.ARPA, QTYPE=*A query similar to the previous one, but using a QTYPE of *, wouldreceive the following response from C.ISI.EDU: +---------------------------------------------------+ Header | OPCODE=SQUERY, RESPONSE, AA | +---------------------------------------------------+ Question | QNAME=SRI-NIC.ARPA., QCLASS=IN, QTYPE=* | +---------------------------------------------------+ Answer | SRI-NIC.ARPA. 86400 IN A 26.0.0.73 | | A 10.0.0.51 | | MX 0 SRI-NIC.ARPA. | | HINFO DEC-2060 TOPS20 | +---------------------------------------------------+ Authority | <empty> | +---------------------------------------------------+ Additional | <empty> | +---------------------------------------------------+Mockapetris [Page 41]
RFC 1034 Domain Concepts and Facilities November 1987If a similar query was directed to two name servers which are notauthoritative for SRI-NIC.ARPA, the responses might be: +---------------------------------------------------+ Header | OPCODE=SQUERY, RESPONSE | +---------------------------------------------------+ Question | QNAME=SRI-NIC.ARPA., QCLASS=IN, QTYPE=* | +---------------------------------------------------+ Answer | SRI-NIC.ARPA. 12345 IN A 26.0.0.73 | | A 10.0.0.51 | +---------------------------------------------------+ Authority | <empty> | +---------------------------------------------------+ Additional | <empty> | +---------------------------------------------------+and +---------------------------------------------------+ Header | OPCODE=SQUERY, RESPONSE | +---------------------------------------------------+ Question | QNAME=SRI-NIC.ARPA., QCLASS=IN, QTYPE=* | +---------------------------------------------------+ Answer | SRI-NIC.ARPA. 1290 IN HINFO DEC-2060 TOPS20 | +---------------------------------------------------+ Authority | <empty> | +---------------------------------------------------+ Additional | <empty> | +---------------------------------------------------+Neither of these answers have AA set, so neither response comes fromauthoritative data. The different contents and different TTLs suggestthat the two servers cached data at different times, and that the firstserver cached the response to a QTYPE=A query and the second cached theresponse to a HINFO query.Mockapetris [Page 42]
RFC 1034 Domain Concepts and Facilities November 19876.2.3. QNAME=SRI-NIC.ARPA, QTYPE=MXThis type of query might be result from a mailer trying to look uprouting information for the mail destination HOSTMASTER@SRI-NIC.ARPA.The response from C.ISI.EDU would be: +---------------------------------------------------+ Header | OPCODE=SQUERY, RESPONSE, AA | +---------------------------------------------------+ Question | QNAME=SRI-NIC.ARPA., QCLASS=IN, QTYPE=MX | +---------------------------------------------------+ Answer | SRI-NIC.ARPA. 86400 IN MX 0 SRI-NIC.ARPA.| +---------------------------------------------------+ Authority | <empty> | +---------------------------------------------------+ Additional | SRI-NIC.ARPA. 86400 IN A 26.0.0.73 | | A 10.0.0.51 | +---------------------------------------------------+This response contains the MX RR in the answer section of the response.The additional section contains the address RRs because the name serverat C.ISI.EDU guesses that the requester will need the addresses in orderto properly use the information carried by the MX.6.2.4. QNAME=SRI-NIC.ARPA, QTYPE=NSC.ISI.EDU would reply to this query with: +---------------------------------------------------+ Header | OPCODE=SQUERY, RESPONSE, AA | +---------------------------------------------------+ Question | QNAME=SRI-NIC.ARPA., QCLASS=IN, QTYPE=NS | +---------------------------------------------------+ Answer | <empty> | +---------------------------------------------------+ Authority | <empty> | +---------------------------------------------------+ Additional | <empty> | +---------------------------------------------------+The only difference between the response and the query is the AA andRESPONSE bits in the header. The interpretation of this response isthat the server is authoritative for the name, and the name exists, butno RRs of type NS are present there.6.2.5. QNAME=SIR-NIC.ARPA, QTYPE=AIf a user mistyped a host name, we might see this type of query.Mockapetris [Page 43]
RFC 1034 Domain Concepts and Facilities November 1987C.ISI.EDU would answer it with: +---------------------------------------------------+ Header | OPCODE=SQUERY, RESPONSE, AA, RCODE=NE | +---------------------------------------------------+ Question | QNAME=SIR-NIC.ARPA., QCLASS=IN, QTYPE=A | +---------------------------------------------------+ Answer | <empty> | +---------------------------------------------------+ Authority | . SOA SRI-NIC.ARPA. HOSTMASTER.SRI-NIC.ARPA. | | 870611 1800 300 604800 86400 | +---------------------------------------------------+ Additional | <empty> | +---------------------------------------------------+This response states that the name does not exist. This condition issignalled in the response code (RCODE) section of the header.The SOA RR in the authority section is the optional negative cachinginformation which allows the resolver using this response to assume thatthe name will not exist for the SOA MINIMUM (86400) seconds.6.2.6. QNAME=BRL.MIL, QTYPE=AIf this query is sent to C.ISI.EDU, the reply would be: +---------------------------------------------------+ Header | OPCODE=SQUERY, RESPONSE | +---------------------------------------------------+ Question | QNAME=BRL.MIL, QCLASS=IN, QTYPE=A | +---------------------------------------------------+ Answer | <empty> | +---------------------------------------------------+ Authority | MIL. 86400 IN NS SRI-NIC.ARPA. | | 86400 NS A.ISI.EDU. | +---------------------------------------------------+ Additional | A.ISI.EDU. A 26.3.0.103 | | SRI-NIC.ARPA. A 26.0.0.73 | | A 10.0.0.51 | +---------------------------------------------------+This response has an empty answer section, but is not authoritative, soit is a referral. The name server on C.ISI.EDU, realizing that it isnot authoritative for the MIL domain, has referred the requester toservers on A.ISI.EDU and SRI-NIC.ARPA, which it knows are authoritativefor the MIL domain.Mockapetris [Page 44]
RFC 1034 Domain Concepts and Facilities November 19876.2.7. QNAME=USC-ISIC.ARPA, QTYPE=AThe response to this query from A.ISI.EDU would be: +---------------------------------------------------+ Header | OPCODE=SQUERY, RESPONSE, AA | +---------------------------------------------------+ Question | QNAME=USC-ISIC.ARPA., QCLASS=IN, QTYPE=A | +---------------------------------------------------+ Answer | USC-ISIC.ARPA. 86400 IN CNAME C.ISI.EDU. | | C.ISI.EDU. 86400 IN A 10.0.0.52 | +---------------------------------------------------+ Authority | <empty> | +---------------------------------------------------+ Additional | <empty> | +---------------------------------------------------+Note that the AA bit in the header guarantees that the data matchingQNAME is authoritative, but does not say anything about whether the datafor C.ISI.EDU is authoritative. This complete reply is possible becauseA.ISI.EDU happens to be authoritative for both the ARPA domain whereUSC-ISIC.ARPA is found and the ISI.EDU domain where C.ISI.EDU data isfound.If the same query was sent to C.ISI.EDU, its response might be the sameas shown above if it had its own address in its cache, but might alsobe:Mockapetris [Page 45]
RFC 1034 Domain Concepts and Facilities November 1987 +---------------------------------------------------+ Header | OPCODE=SQUERY, RESPONSE, AA | +---------------------------------------------------+ Question | QNAME=USC-ISIC.ARPA., QCLASS=IN, QTYPE=A | +---------------------------------------------------+ Answer | USC-ISIC.ARPA. 86400 IN CNAME C.ISI.EDU. | +---------------------------------------------------+ Authority | ISI.EDU. 172800 IN NS VAXA.ISI.EDU. | | NS A.ISI.EDU. | | NS VENERA.ISI.EDU. | +---------------------------------------------------+ Additional | VAXA.ISI.EDU. 172800 A 10.2.0.27 | | 172800 A 128.9.0.33 | | VENERA.ISI.EDU. 172800 A 10.1.0.52 | | 172800 A 128.9.0.32 | | A.ISI.EDU. 172800 A 26.3.0.103 | +---------------------------------------------------+This reply contains an authoritative reply for the alias USC-ISIC.ARPA,plus a referral to the name servers for ISI.EDU. This sort of replyisn't very likely given that the query is for the host name of the nameserver being asked, but would be common for other aliases.6.2.8. QNAME=USC-ISIC.ARPA, QTYPE=CNAMEIf this query is sent to either A.ISI.EDU or C.ISI.EDU, the reply wouldbe: +---------------------------------------------------+ Header | OPCODE=SQUERY, RESPONSE, AA | +---------------------------------------------------+ Question | QNAME=USC-ISIC.ARPA., QCLASS=IN, QTYPE=A | +---------------------------------------------------+ Answer | USC-ISIC.ARPA. 86400 IN CNAME C.ISI.EDU. | +---------------------------------------------------+ Authority | <empty> | +---------------------------------------------------+ Additional | <empty> | +---------------------------------------------------+Because QTYPE=CNAME, the CNAME RR itself answers the query, and the nameserver doesn't attempt to look up anything for C.ISI.EDU. (Exceptpossibly for the additional section.)6.3. Example resolutionThe following examples illustrate the operations a resolver must performfor its client. We assume that the resolver is starting without aMockapetris [Page 46]
RFC 1034 Domain Concepts and Facilities November 1987cache, as might be the case after system boot. We further assume thatthe system is not one of the hosts in the data and that the host islocated somewhere on net 26, and that its safety belt (SBELT) datastructure has the following information: Match count = -1 SRI-NIC.ARPA. 26.0.0.73 10.0.0.51 A.ISI.EDU. 26.3.0.103This information specifies servers to try, their addresses, and a matchcount of -1, which says that the servers aren't very close to thetarget. Note that the -1 isn't supposed to be an accurate closenessmeasure, just a value so that later stages of the algorithm will work.The following examples illustrate the use of a cache, so each exampleassumes that previous requests have completed.6.3.1. Resolve MX for ISI.EDU.Suppose the first request to the resolver comes from the local mailer,which has mail for PVM@ISI.EDU. The mailer might then ask for type MXRRs for the domain name ISI.EDU.The resolver would look in its cache for MX RRs at ISI.EDU, but theempty cache wouldn't be helpful. The resolver would recognize that itneeded to query foreign servers and try to determine the best servers toquery. This search would look for NS RRs for the domains ISI.EDU, EDU,and the root. These searches of the cache would also fail. As a lastresort, the resolver would use the information from the SBELT, copyingit into its SLIST structure.At this point the resolver would need to pick one of the three availableaddresses to try. Given that the resolver is on net 26, it shouldchoose either 26.0.0.73 or 26.3.0.103 as its first choice. It wouldthen send off a query of the form:Mockapetris [Page 47]
RFC 1034 Domain Concepts and Facilities November 1987 +---------------------------------------------------+ Header | OPCODE=SQUERY | +---------------------------------------------------+ Question | QNAME=ISI.EDU., QCLASS=IN, QTYPE=MX | +---------------------------------------------------+ Answer | <empty> | +---------------------------------------------------+ Authority | <empty> | +---------------------------------------------------+ Additional | <empty> | +---------------------------------------------------+The resolver would then wait for a response to its query or a timeout.If the timeout occurs, it would try different servers, then differentaddresses of the same servers, lastly retrying addresses already tried.It might eventually receive a reply from SRI-NIC.ARPA: +---------------------------------------------------+ Header | OPCODE=SQUERY, RESPONSE | +---------------------------------------------------+ Question | QNAME=ISI.EDU., QCLASS=IN, QTYPE=MX | +---------------------------------------------------+ Answer | <empty> | +---------------------------------------------------+ Authority | ISI.EDU. 172800 IN NS VAXA.ISI.EDU. | | NS A.ISI.EDU. | | NS VENERA.ISI.EDU.| +---------------------------------------------------+ Additional | VAXA.ISI.EDU. 172800 A 10.2.0.27 | | 172800 A 128.9.0.33 | | VENERA.ISI.EDU. 172800 A 10.1.0.52 | | 172800 A 128.9.0.32 | | A.ISI.EDU. 172800 A 26.3.0.103 | +---------------------------------------------------+The resolver would notice that the information in the response gave acloser delegation to ISI.EDU than its existing SLIST (since it matchesthree labels). The resolver would then cache the information in thisresponse and use it to set up a new SLIST: Match count = 3 A.ISI.EDU. 26.3.0.103 VAXA.ISI.EDU. 10.2.0.27 128.9.0.33 VENERA.ISI.EDU. 10.1.0.52 128.9.0.32A.ISI.EDU appears on this list as well as the previous one, but that ispurely coincidental. The resolver would again start transmitting andwaiting for responses. Eventually it would get an answer:Mockapetris [Page 48]
RFC 1034 Domain Concepts and Facilities November 1987 +---------------------------------------------------+ Header | OPCODE=SQUERY, RESPONSE, AA | +---------------------------------------------------+ Question | QNAME=ISI.EDU., QCLASS=IN, QTYPE=MX | +---------------------------------------------------+ Answer | ISI.EDU. MX 10 VENERA.ISI.EDU. | | MX 20 VAXA.ISI.EDU. | +---------------------------------------------------+ Authority | <empty> | +---------------------------------------------------+ Additional | VAXA.ISI.EDU. 172800 A 10.2.0.27 | | 172800 A 128.9.0.33 | | VENERA.ISI.EDU. 172800 A 10.1.0.52 | | 172800 A 128.9.0.32 | +---------------------------------------------------+The resolver would add this information to its cache, and return the MXRRs to its client.6.3.2. Get the host name for address 26.6.0.65The resolver would translate this into a request for PTR RRs for65.0.6.26.IN-ADDR.ARPA. This information is not in the cache, so theresolver would look for foreign servers to ask. No servers would match,so it would use SBELT again. (Note that the servers for the ISI.EDUdomain are in the cache, but ISI.EDU is not an ancestor of65.0.6.26.IN-ADDR.ARPA, so the SBELT is used.)Since this request is within the authoritative data of both servers inSBELT, eventually one would return:Mockapetris [Page 49]
RFC 1034 Domain Concepts and Facilities November 1987 +---------------------------------------------------+ Header | OPCODE=SQUERY, RESPONSE, AA | +---------------------------------------------------+ Question | QNAME=65.0.6.26.IN-ADDR.ARPA.,QCLASS=IN,QTYPE=PTR | +---------------------------------------------------+ Answer | 65.0.6.26.IN-ADDR.ARPA. PTR ACC.ARPA. | +---------------------------------------------------+ Authority | <empty> | +---------------------------------------------------+ Additional | <empty> | +---------------------------------------------------+6.3.3. Get the host address of poneria.ISI.EDUThis request would translate into a type A request for poneria.ISI.EDU.The resolver would not find any cached data for this name, but wouldfind the NS RRs in the cache for ISI.EDU when it looks for foreignservers to ask. Using this data, it would construct a SLIST of theform: Match count = 3 A.ISI.EDU. 26.3.0.103 VAXA.ISI.EDU. 10.2.0.27 128.9.0.33 VENERA.ISI.EDU. 10.1.0.52A.ISI.EDU is listed first on the assumption that the resolver orders itschoices by preference, and A.ISI.EDU is on the same network.One of these servers would answer the query.7. REFERENCES and BIBLIOGRAPHY[Dyer 87] Dyer, S., and F. Hsu, "Hesiod", Project Athena Technical Plan - Name Service, April 1987, version 1.9. Describes the fundamentals of the Hesiod name service.[IEN-116] J. Postel, "Internet Name Server", IEN-116, USC/Information Sciences Institute, August 1979. A name service obsoleted by the Domain Name System, but still in use.Mockapetris [Page 50]
RFC 1034 Domain Concepts and Facilities November 1987[Quarterman 86] Quarterman, J., and J. Hoskins, "Notable Computer Networks",Communications of the ACM, October 1986, volume 29, number 10.[RFC-742] K. Harrenstien, "NAME/FINGER",RFC-742, Network Information Center, SRI International, December 1977.[RFC-768] J. Postel, "User Datagram Protocol",RFC-768, USC/Information Sciences Institute, August 1980.[RFC-793] J. Postel, "Transmission Control Protocol",RFC-793, USC/Information Sciences Institute, September 1981.[RFC-799] D. Mills, "Internet Name Domains",RFC-799, COMSAT, September 1981. Suggests introduction of a hierarchy in place of a flat name space for the Internet.[RFC-805] J. Postel, "Computer Mail Meeting Notes",RFC-805, USC/Information Sciences Institute, February 1982.[RFC-810] E. Feinler, K. Harrenstien, Z. Su, and V. White, "DOD Internet Host Table Specification",RFC-810, Network Information Center, SRI International, March 1982. Obsolete. SeeRFC-952.[RFC-811] K. Harrenstien, V. White, and E. Feinler, "Hostnames Server",RFC-811, Network Information Center, SRI International, March 1982. Obsolete. SeeRFC-953.[RFC-812] K. Harrenstien, and V. White, "NICNAME/WHOIS",RFC-812, Network Information Center, SRI International, March 1982.[RFC-819] Z. Su, and J. Postel, "The Domain Naming Convention for Internet User Applications",RFC-819, Network Information Center, SRI International, August 1982. Early thoughts on the design of the domain system. Current implementation is completely different.[RFC-821] J. Postel, "Simple Mail Transfer Protocol",RFC-821, USC/Information Sciences Institute, August 1980.Mockapetris [Page 51]
RFC 1034 Domain Concepts and Facilities November 1987[RFC-830] Z. Su, "A Distributed System for Internet Name Service",RFC-830, Network Information Center, SRI International, October 1982. Early thoughts on the design of the domain system. Current implementation is completely different.[RFC-882] P. Mockapetris, "Domain names - Concepts and Facilities,"RFC-882, USC/Information Sciences Institute, November 1983. Superceeded by this memo.[RFC-883] P. Mockapetris, "Domain names - Implementation and Specification,"RFC-883, USC/Information Sciences Institute, November 1983. Superceeded by this memo.[RFC-920] J. Postel and J. Reynolds, "Domain Requirements",RFC-920, USC/Information Sciences Institute October 1984. Explains the naming scheme for top level domains.[RFC-952] K. Harrenstien, M. Stahl, E. Feinler, "DoD Internet Host Table Specification",RFC-952, SRI, October 1985. Specifies the format of HOSTS.TXT, the host/address table replaced by the DNS.[RFC-953] K. Harrenstien, M. Stahl, E. Feinler, "HOSTNAME Server",RFC-953, SRI, October 1985. This RFC contains the official specification of the hostname server protocol, which is obsoleted by the DNS. This TCP based protocol accesses information stored in theRFC-952 format, and is used to obtain copies of the host table.[RFC-973] P. Mockapetris, "Domain System Changes and Observations",RFC-973, USC/Information Sciences Institute, January 1986. Describes changes toRFC-882 andRFC-883 and reasons for them. Now obsolete.Mockapetris [Page 52]
RFC 1034 Domain Concepts and Facilities November 1987[RFC-974] C. Partridge, "Mail routing and the domain system",RFC-974, CSNET CIC BBN Labs, January 1986. Describes the transition from HOSTS.TXT based mail addressing to the more powerful MX system used with the domain system.[RFC-1001] NetBIOS Working Group, "Protocol standard for a NetBIOS service on a TCP/UDP transport: Concepts and Methods",RFC-1001, March 1987. This RFC andRFC-1002 are a preliminary design for NETBIOS on top of TCP/IP which proposes to base NetBIOS name service on top of the DNS.[RFC-1002] NetBIOS Working Group, "Protocol standard for a NetBIOS service on a TCP/UDP transport: Detailed Specifications",RFC-1002, March 1987.[RFC-1010] J. Reynolds and J. Postel, "Assigned Numbers",RFC-1010, USC/Information Sciences Institute, May 1987 Contains socket numbers and mnemonics for host names, operating systems, etc.[RFC-1031] W. Lazear, "MILNET Name Domain Transition",RFC-1031, November 1987. Describes a plan for converting the MILNET to the DNS.[RFC-1032] M. K. Stahl, "Establishing a Domain - Guidelines for Administrators",RFC-1032, November 1987. Describes the registration policies used by the NIC to administer the top level domains and delegate subzones.[RFC-1033] M. K. Lottor, "Domain Administrators Operations Guide",RFC-1033, November 1987. A cookbook for domain administrators.[Solomon 82] M. Solomon, L. Landweber, and D. Neuhengen, "The CSNET Name Server", Computer Networks, vol 6, nr 3, July 1982. Describes a name service for CSNET which is independent from the DNS and DNS use in the CSNET.Mockapetris [Page 53]
RFC 1034 Domain Concepts and Facilities November 1987Index A 12 Absolute names 8 Aliases 14, 31 Authority 6 AXFR 17 Case of characters 7 CH 12 CNAME 12, 13, 31 Completion queries 18 Domain name 6, 7 Glue RRs 20 HINFO 12 IN 12 Inverse queries 16 Iterative 4 Label 7 Mailbox names 9 MX 12 Name error 27, 36 Name servers 5, 17 NE 30 Negative caching 44 NS 12 Opcode 16 PTR 12 QCLASS 16 QTYPE 16 RDATA 13 Recursive 4 Recursive service 22 Relative names 7 Resolvers 6 RR 12Mockapetris [Page 54]
RFC 1034 Domain Concepts and Facilities November 1987 Safety belt 33 Sections 16 SOA 12 Standard queries 22 Status queries 18 Stub resolvers 32 TTL 12, 13 Wildcards 25 Zone transfers 28 Zones 19Mockapetris [Page 55]