RFC 6891

Extension Mechanisms for DNS (EDNS(0))

📅 published April 2013, from ietf

Extension Mechanisms for DNS (EDNS(0)) 🎀

Okay bestie, this is RFC 6891 💖 and it's STD 75 on the Standards Track ✨. It came out in April 2013 from the IETF, which is the Internet Engineering Task Force 🌸. The authors are J. Damas from Bond Internet Systems, M. Graff, and P. Vixie from the Internet Systems Consortium 🧚. The ISSN is 2070-1721. This doc obsoletes RFC 2671 and RFC 2673 💅, and the abstract says it also updates the EDNS(0) spec 🦋.

Abstract

okay so the DNS wire protocol has a bunch of fixed fields whose room has been used up or is about to be 😭, and there's no way for requestors to tell responders what they're capable of 💀. This document describes backward-compatible ways to let the protocol grow 🌈.

It updates the EDNS(0) spec (and obsoletes RFC 2671) based on what implementers learned from deploying it in several implementations 🔥. It also obsoletes RFC 2673 ("Binary Labels in the Domain Name System") and adds some thoughts on using extended labels in DNS 🍓.

Status of This Memo

this is an Internet Standards Track document ✨.

It's a product of the Internet Engineering Task Force (IETF) 🌸. It represents the consensus of the IETF community and got public review, then the Internet Engineering Steering Group (IESG) approved it for publication 👑. For more on Internet Standards, check Section 2 of RFC 5741 💜.

Info about the current status, any errata, and how to give feedback lives at http://www.rfc-editor.org/info/rfc6891 🦋.

Copyright (c) 2013 IETF Trust and the persons identified as the document authors. All rights reserved. 🎀

This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (http://trustee.ietf.org/license-info) as they're in effect on the publication date 💅. Please read these carefully, because they spell out your rights and restrictions for this document. Code Components pulled out of this document must include Simplified BSD License text as described in Section 4.e of the Trust Legal Provisions, and they come without warranty as described in the Simplified BSD License 🫶.

This document may include material from IETF Documents or IETF Contributions published or made publicly available before November 10, 2008 📜. The people who control copyright in some of that material may not have given the IETF Trust permission to allow modifications outside the IETF Standards Process 😬. Unless you get an adequate license from those copyright holders, this document may not be modified outside the IETF Standards Process, and derivative works of it may not be created outside the IETF Standards Process 🙈. The one exceptions are formatting it for publication as an RFC or translating it into languages other than English 🌈.

Table of Contents

1.  Introduction . . . . . . . . . . . . . . . . . . . . . . . . .  4
2.  Terminology  . . . . . . . . . . . . . . . . . . . . . . . . .  4
3.  EDNS Support Requirement . . . . . . . . . . . . . . . . . . .  5
4.  DNS Message Changes  . . . . . . . . . . . . . . . . . . . . .  5
  4.1.  Message Header . . . . . . . . . . . . . . . . . . . . . .  5
  4.2.  Label Types  . . . . . . . . . . . . . . . . . . . . . . .  5
  4.3.  UDP Message Size . . . . . . . . . . . . . . . . . . . . .  6
5.  Extended Label Types . . . . . . . . . . . . . . . . . . . . .  6
6.  The OPT Pseudo-RR  . . . . . . . . . . . . . . . . . . . . . .  6
  6.1.  OPT Record Definition  . . . . . . . . . . . . . . . . . .  6
    6.1.1.  Basic Elements . . . . . . . . . . . . . . . . . . . .  6
    6.1.2.  Wire Format  . . . . . . . . . . . . . . . . . . . . .  7
    6.1.3.  OPT Record TTL Field Use . . . . . . . . . . . . . . .  9
    6.1.4.  Flags  . . . . . . . . . . . . . . . . . . . . . . . .  9
  6.2.  Behaviour  . . . . . . . . . . . . . . . . . . . . . . . . 10
    6.2.1.  Cache Behaviour  . . . . . . . . . . . . . . . . . . . 10
    6.2.2.  Fallback . . . . . . . . . . . . . . . . . . . . . . . 10
    6.2.3.  Requestor's Payload Size . . . . . . . . . . . . . . . 10
    6.2.4.  Responder's Payload Size . . . . . . . . . . . . . . . 11
    6.2.5.  Payload Size Selection . . . . . . . . . . . . . . . . 11
    6.2.6.  Support in Middleboxes . . . . . . . . . . . . . . . . 11
7.  Transport Considerations . . . . . . . . . . . . . . . . . . . 12
8.  Security Considerations  . . . . . . . . . . . . . . . . . . . 13
9.  IANA Considerations  . . . . . . . . . . . . . . . . . . . . . 13
  9.1.  OPT Option Code Allocation Procedure . . . . . . . . . . . 15
10. References . . . . . . . . . . . . . . . . . . . . . . . . . . 15
  10.1. Normative References . . . . . . . . . . . . . . . . . . . 15
  10.2. Informative References . . . . . . . . . . . . . . . . . . 15
Appendix A.  Changes since RFCs 2671 and 2673  . . . . . . . . . . 16

1. Introduction ✨

DNS [RFC1035] defines a message format, and inside those messages there are standard formats for options, errors, and name compression 🧚. The biggest message size over UDP without the extensions in this document is 512 bytes 😬. A lot of DNS's limits, like that max UDP message size, are too small to comfortably carry the extra stuff people want to send, like several IPv6 addresses or DNS Security (DNSSEC) signatures 💀. And honestly, RFC 1035 doesn't give implementations any way to tell the other actors they talk to what they can do 🙈.

[RFC2671] added extension mechanisms to DNS 🌸. They're widely supported, and a bunch of new DNS uses and protocol extensions depend on them 👑. This memo refines and obsoletes [RFC2671] 💅.

Unextended agents won't know how to read the protocol extensions defined in [RFC2671] and restated here 😭. Extended agents need to be ready to deal with unextended clients when new protocol elements show up, and they need to fall back gracefully to unextended DNS 🫶.

EDNS is a hop-by-hop extension to DNS 🦋. That means EDNS gets negotiated between each pair of hosts in a DNS resolution process 💜. For example, the stub resolver talking to the recursive resolver, or the recursive resolver talking to an authoritative server 🍓.

[RFC2671] specified extended label types 🌈. The only one actually proposed was in [RFC2673], a label type called "Bit-String Label" or "Binary Labels", and the second name is the one people actually use 🔥. For various reasons, bringing in a new label type turned out to be extremely difficult, so [RFC2673] was moved to Experimental 😬. This document obsoletes [RFC2673] and deprecates Binary Labels 🙅‍♀️. Extended labels are still defined, but their use is discouraged because deployment is so hard in practice 💀. Any future use of them SHOULD only be considered after carefully evaluating the deployment hindrances 🎀.

2. Terminology 🩷

"Requestor" means the side that sends a request 📮. "Responder" means an authoritative server, a recursive resolver, or some other DNS component that answers questions 🧚. Anything else follows the definitions in the RFCs this document cites 📚.

The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC 2119 [RFC2119] 💅.

3. EDNS Support Requirement 💖

EDNS gives DNS a way to scale better as its uses get more diverse on the Internet ✨. It does this by letting UDP carry DNS messages bigger than the limits in RFC 1035, and by giving extra space for more flags and return codes (RCODEs) 🌈. But implementation experience shows that adding new RCODEs should be avoided, because upgrading the installed base is so painful 😭. Flags SHOULD be used only when they're actually necessary for DNS resolution to work 🔥.

For lots of uses, an EDNS Option Code may be preferred 🍓.

Over time, some DNS applications have made EDNS a requirement for their deployment 👑. DNSSEC, for instance, uses the extra flag space that EDNS introduced to signal that it wants DNSSEC data included in a response 🦋.

Response sizes keep growing as they carry bigger stuff like AAAA records, DNSSEC info (e.g., RRSIG or DNSKEY), or big TXT records 📈. The extra UDP payload capacity EDNS brings can help DNS scale by avoiding widespread use of TCP for transport 🧚.

4. DNS Message Changes 🎀

4.1. Message Header

The second full 16-bit word of the DNS message header is split into a 4-bit OPCODE, a 4-bit RCODE, and a bunch of 1-bit flags (see Section 4.1.1 of [RFC1035]) 💅. Some of those flag values were marked for future use, and most of them have been allocated since 🌸. Most of the RCODE values are in use now too 😬. The OPT pseudo-RR we define below extends the RCODE bit field and adds more flag bits 💜.

4.2. Label Types

The first 2 bits of a wire format domain label say what type of label it is 🌈. [RFC1035] allocates 2 of the 4 possible types and reserves the other 2 🍓. More label types were defined in [RFC2671] 🧚. The 2-bit combination [RFC2671] defined for extended label types is still valid 🫶. But deploying new label types has turned out to be noticeably difficult, so they're only recommended after careful evaluation of alternatives and of whether the deployment is actually needed 💀.

4.3. UDP Message Size

Traditional DNS messages are limited to 512 octets when sent over UDP [RFC1035] 😭. Squeezing more and more data into that 512-byte limit is getting harder and harder 🙈. Including DNSSEC records, for example, often needs a response way bigger than 512 bytes can hold 🔥.

EDNS(0) gives a way to advertise extra features, like bigger response size capability 🦋. That's meant to help avoid truncated UDP responses, which then cause retries over TCP 💜. So it supports these larger packet sizes without having to fall back to TCP for transport 👑.

5. Extended Label Types 🌸

The first octet of a DNS label on the wire says what label type it is, and the basic DNS spec [RFC1035] dedicates the 2 most significant bits of that octet to this 🧚.

[RFC2671] defined DNS label type 0b01 as the signal for extended label types 🎀. A specific extended label type gets picked by the 6 least significant bits of the first octet 🍓. So extended label types show up as the values 64-127 (0b01xxxxxx) in that first octet 🌈.

Extended label types are extremely difficult to deploy because clients and intermediate gateways don't support them, as described in [RFC3363] (which moved [RFC2673] to Experimental status) and in [RFC3364] (which covers the pros and cons) 😬. So proposals that involve extended labels SHOULD weigh that deployment cost against the chance of building the functionality another way 💅.

Last but not least, implementations MUST NOT generate or pass Binary Labels in their communications, since they're deprecated now 🚫💖.

6. The OPT Pseudo-RR ✨

6.1. OPT Record Definition 🎀

6.1.1. Basic Elements 💅

okay so an OPT pseudo-RR (also called a meta-RR, iykyk) MAY be tucked into the additional data section of a request. no cap, it's just control info, not actual DNS data 🧚

The OPT RR has RR type 41. 🔢

If a request comes in carrying an OPT record, compliant responders MUST include an OPT record in their responses. bestie, match the energy 🫶

An OPT record doesn't carry any DNS data at all. It only exists to hold control information about that one question-and-answer exchange. OPT RRs MUST NOT be cached, forwarded, or stored in or loaded from master files. literally never let it leave the group chat 🙈

The OPT RR MAY be placed anywhere inside the additional data section. But when an OPT RR shows up in any DNS message, it MUST be the only OPT RR in that message. If a query arrives with more than one OPT RR, a FORMERR (RCODE=1) MUST be returned. The placement freedom doesn't override the rule that TSIG or SIG(0) RRs have to be last in the additional section whenever they're present 👑

6.1.2. Wire Format 🦋

okay so an OPT RR has a fixed part plus a variable set of options written as {attribute, value} pairs. The fixed part holds some DNS metadata, plus a small bundle of basic extension elements that are expected to be so popular that encoding them as pairs would waste wire space 💖

The fixed part of an OPT RR looks like this:

    +------------+--------------+------------------------------+
    | Field Name | Field Type   | Description                  |
    +------------+--------------+------------------------------+
    | NAME       | domain name  | MUST be 0 (root domain)      |
    | TYPE       | u_int16_t    | OPT (41)                     |
    | CLASS      | u_int16_t    | requestor's UDP payload size |
    | TTL        | u_int32_t    | extended RCODE and flags     |
    | RDLEN      | u_int16_t    | length of all RDATA          |
    | RDATA      | octet stream | {attribute,value} pairs      |
    +------------+--------------+------------------------------+

                            OPT RR Format

The variable part of an OPT RR may hold zero or more options in the RDATA. The vibe here is pure options stacking up 📦 Each option MUST be treated as a bit field, and each one is encoded like this:

               +0 (MSB)                            +1 (LSB)
    +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
 0: |                          OPTION-CODE                          |
    +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
 2: |                         OPTION-LENGTH                         |
    +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
 4: |                                                               |
    /                          OPTION-DATA                          /
    /                                                               /
    +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

Here's the breakdown of each piece 🍓

OPTION-CODE Assigned through the Expert Review process, as defined by the DNSEXT working group and the IESG. 🏷️

OPTION-LENGTH The size, in octets, of OPTION-DATA. 📏

OPTION-DATA Its contents vary per OPTION-CODE. It MUST be treated as a bit field. 🧩

The order that option tuples show up in is not defined. If one option modifies how another behaves, or multiple options are related somehow, they have the same effect no matter what order they appear in the RDATA wire encoding. Order doesn't matter, the vibes stay the same ✨

Any OPTION-CODE values that a responder or requestor doesn't understand MUST be ignored. Option specs might want to include some kind of signaled acknowledgement. For example, an option specification might say that if a responder sees and supports option XYZ, it MUST include option XYZ in its response. It's giving "I see you, I acknowledge you" 🫡

6.1.3. OPT Record TTL Field Use ⏰

The extended RCODE and flags, which OPT stores in the RR Time to Live (TTL) field, are laid out like this:

               +0 (MSB)                            +1 (LSB)
    +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
 0: |         EXTENDED-RCODE        |            VERSION            |
    +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
 2: | DO|                           Z                               |
    +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

EXTENDED-RCODE This forms the upper 8 bits of the extended 12-bit RCODE (together with the 4 bits defined in [RFC1035]. Note that an EXTENDED-RCODE value of 0 means an unextended RCODE is in use (values 0 through 15). 🔢

VERSION This tells you the implementation level of whoever set it. Full conformance with this spec is shown by version '0' 💯 Requestors are encouraged to set this to the lowest implemented level that can still express a transaction, so responders and the network don't have to work hard figuring out the greatest common implementation level between requestor and responder. A requestor's version numbering strategy MAY ideally be a run-time configuration option.

If a responder doesn't implement the VERSION level of the request, it MUST respond with RCODE=BADVERS. All responses MUST be limited in format to the VERSION level of the request, but the VERSION of each response SHOULD be the highest implementation level of the responder. That way, a requestor learns the responder's implementation level as a side effect of every response, including error responses and including RCODE=BADVERS. sneaky, but iconic 😭

6.1.4. Flags 🚩

DO The DNSSEC OK bit, as defined by [RFC3225]. 🔐

Z Set to zero by senders and ignored by receivers, unless a later specification changes that. 0️⃣

6.2. Behaviour 🌸

6.2.1. Cache Behaviour 🙅‍♀️

The OPT record MUST NOT be cached. Not even a little bit, periodt 💀

6.2.2. Fallback 🔙

If a requestor finds out the remote end doesn't support EDNS(0), it MAY send queries without an OPT record. It MAY also cache that knowledge for a short while so it can skip fallback delays next time. However, if DNSSEC or any future option that uses EDNS is required, no fallback should be performed, because those options are only signaled through EDNS. If an implementation finds that some servers for a zone support EDNS(0) while others would force TCP just to fetch all the data, preference MAY be given to the servers that support EDNS(0). Implementers SHOULD analyse this choice and its impact on both endpoints. Think it through, bestie 🧠

6.2.3. Requestor's Payload Size 📮

The requestor's UDP payload size, which lives in the RR CLASS field, is the number of octets in the largest UDP payload that can be reassembled and delivered by the requestor's network stack. Path MTU, with or without fragmentation, could be smaller than this, so keep that in mind 👀

Values lower than 512 MUST be treated as equal to 512.

The requestor SHOULD put a value in this field that it can actually receive. For example, if a requestor sits behind a firewall that blocks fragmented IP packets, a requestor SHOULD NOT choose a value that causes fragmentation. Doing that stops large responses from getting through and can trigger fallback. This knowledge may be auto-detected by the implementation or provided by a human administrator 🕵️‍♀️

Note that a 512-octet UDP payload needs a 576-octet IP reassembly buffer. Choosing between 1280 and 1410 bytes for IP (v4 or v6) over Ethernet would be reasonable 🎯

When fragmentation isn't a concern, implementers SHOULD consider using bigger values. Implementations SHOULD start from their largest configured or implemented values in an EDNS transaction when they have no previous knowledge about the destination server 🚀

Choosing a very large value will guarantee fragmentation at the IP layer, and that can stop answers from arriving because of a single lost fragment or misconfigured firewalls. Too big is not it 🙈

The requestor's maximum payload size can change over time. It MUST NOT be cached for use beyond the transaction in which it was advertised. one transaction, one moment ✨

6.2.4. Responder's Payload Size 📬

The responder's maximum payload size can change over time, but it can reasonably be expected to stay constant between two closely spaced sequential transactions. An example is an arbitrary QUERY used as a probe to find a responder's maximum UDP payload size, followed right after by an UPDATE that takes advantage of that size. This is considered preferable to going straight to TCP for oversized requests, if there's any reason to suspect the responder implements EDNS, and if a request won't fit in the default 512-byte payload size limit 🧃

6.2.5. Payload Size Selection 🎚️

Due to transaction overhead, it is not recommended to advertise an architectural limit as a maximum UDP payload size. Even on system stacks that can reassemble 64 KB datagrams, memory usage at the low levels of the system will be a concern. A good compromise may be to use an EDNS maximum payload size of 4096 octets as a starting point 🧁

A requestor MAY choose to implement a fallback to smaller advertised sizes to get around firewall or other network limitations. A requestor SHOULD use a fallback mechanism that begins with a large size, such as 4096. If that fails, a fallback around the range of 1280-1410 bytes SHOULD be tried, since it has a reasonable chance of fitting within a single Ethernet frame. If that fails too, a requestor MAY choose a 512-byte packet, which, with large answers, may cause a TCP retry 🔁

Values of less than 512 bytes MUST be treated as equal to 512 bytes.

6.2.6. Support in Middleboxes 📦🧚

In a network that carries DNS traffic, there could be active equipment that isn't directly part of the DNS resolution process (stub and caching resolvers, authoritative servers) but still affects how DNS messages get sent. Think firewalls, load balancers, proxies, and so on. Here they're called "middleboxes" 🚪

Conformant middleboxes MUST NOT limit DNS messages over UDP to 512 bytes.

Middleboxes that simply forward requests to a recursive resolver MUST NOT modify and MUST NOT delete the OPT record contents in either direction. hands off the OPT record, no touching 🙌

Middleboxes with extra functionality, like answering queries or acting as intelligent forwarders, SHOULD be able to process the OPT record and act based on its contents. These middleboxes MUST consider the incoming request and any outgoing requests as separate transactions if the characteristics of the messages are different 🫶

A deeper dive into this kind of equipment, and other things to consider when it interacts with DNS traffic, is in [RFC5625]. Lowkey the best read on the topic 💜

7. Transport Considerations 🚀

Okay bestie, so if a request has an OPT pseudo-RR in it, that's the requestor basically saying "hey, I fully implement this version of EDNS and I can understand any response that follows that feature's spec" 💅 It's a whole vibe check, and it's a good one.

If a request has no OPT record at all, that MUST be read as "this requestor doesn't implement any part of this spec," and the responder MUST NOT include an OPT record in its response 🙈 No OPT in, no OPT out. Super clean.

Extended agents MUST be ready to deal with unextended clients when new protocol stuff shows up, and they need to fall back gracefully to plain unextended DNS when it's needed 🫶 Be kind to the old school folks!

Responders that choose not to implement the extensions in this document MUST send back a return code (RCODE) of FORMERR for any message that has an OPT record in the additional section, and they MUST NOT include an OPT record in the response 💀 Not everyone's gonna glow up, and that's valid.

If something goes wrong while processing the OPT record itself, like an option value that's badly formatted or has out-of-range values, a FORMERR MUST be returned ✨ And when that happens, the response MUST include an OPT record. The whole point is so the requestor can tell "this server doesn't do EDNS at all" apart from "I did EDNS and messed up the formatting" 🧚

The minimal response MUST be the DNS header, the question section, and an OPT record. That MUST also happen when a truncated response (using the DNS header's TC bit) gets sent back 🎀

8. Security Considerations 🙈

Okay this section is serious, so buckle up 😭 Letting the requestor decide the maximum buffer size can open up a DNS denial-of-service attack if responders can be tricked into sending messages that are too big for intermediate gateways to forward. That could lead to potential ICMP storms between the gateways and the responders. Yikes.

Announcing really big UDP buffer sizes may get DNS messages dropped by middleboxes (see Section 6.2.6) 💀 That could cause retransmissions that have no hope of succeeding. Some devices have been found to reject fragmented UDP packets, so that's a real problem too.

On the flip side, announcing UDP buffer sizes that are too small may lead to fallback to TCP, and that comes with a corresponding load impact on DNS servers 😬 This matters a LOT with DNSSEC, because those answers are way bigger. Be careful, bestie!

9. IANA Considerations 📋

The IANA has assigned RR type code 41 for OPT ✨

[RFC2671] specified a number of IANA subregistries within "DOMAIN NAME SYSTEM PARAMETERS":

  • DNS EDNS(0) Options
  • EDNS Version Number
  • EDNS Header Flags

Additionally, two entries were generated in existing registries:

  • EDNS Extended Label Type in the DNS Label Types registry
  • Bad OPT Version in the DNS RCODES registry

IANA has updated references to [RFC2671] in these entries and subregistries to point to this document 🦋

[RFC2671] created the DNS Label Types registry. This registry is to remain open 🌈

The registration procedure for the DNS Label Types registry is Standards Action.

This document assigns option code 65535 in the DNS EDNS0 Options registry to "Reserved for future expansion" 🔥

The current status of the IANA registry for EDNS Option Codes at the time of publication of this document is:

  • 0-4 assigned, per references in the registry
  • 5-65000 Available for assignment, unassigned
  • 65001-65534 Local/Experimental use
  • 65535 Reserved for future expansion

[RFC2671] expands the RCODE space from 4 bits to 12 bits. That lets us have more than the 16 distinct RCODE values that [RFC1035] allowed. IETF Review is required to add a new RCODE 👑

This document assigns EDNS Extended RCODE 16 to "BADVERS" in the DNS RCODES registry 💖

[RFC2671] called for the recording of extended label types 0bxx111111 as "Reserved for future extended label types". The IANA registry currently says "Reserved for future expansion" instead. This request implied, back then, a request to open a new registry for extended label types. But because of the possibility of ambiguity, new text registrations were instead made within the general DNS Label Types registry, which also registers entries originally defined by [RFC1035]. So there is no Extended Label Types registry, and all label types are registered in the DNS Label Types registry ⭐

This document deprecates Binary Labels. Therefore, the status for the DNS Label Types registration "Binary Labels" is now "Historic" 🍓

IETF Standards Action is required for assignments of new EDNS(0) flags. Flags SHOULD be used only when necessary for DNS resolution to function. For many uses, an EDNS Option Code may be preferred 🫶

IETF Standards Action is required to create new entries in the EDNS Version Number registry. Within the EDNS Option Code space, Expert Review is required for allocation of an EDNS Option Code. Per this document, IANA maintains a registry for the EDNS Option Code space ✨

9.1. OPT Option Code Allocation Procedure

OPT Option Codes are assigned by Expert Review 💜

Assignment of Option Codes should be liberal, but duplicate functionality is to be avoided 🌸

10. References 📚

10.1. Normative References

  • [RFC1035] Mockapetris, P., "Domain names - implementation and specification", STD 13, RFC 1035, November 1987.
  • [RFC2119] Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, March 1997.
  • [RFC2671] Vixie, P., "Extension Mechanisms for DNS (EDNS0)", RFC 2671, August 1999.
  • [RFC3225] Conrad, D., "Indicating Resolver Support of DNSSEC", RFC 3225, December 2001.

10.2. Informative References

  • [RFC2673] Crawford, M., "Binary Labels in the Domain Name System", RFC 2673, August 1999.
  • [RFC3363] Bush, R., Durand, A., Fink, B., Gudmundsson, O., and T. Hain, "Representing Internet Protocol version 6 (IPv6) Addresses in the Domain Name System (DNS)", RFC 3363, August 2002.
  • [RFC3364] Austein, R., "Tradeoffs in Domain Name System (DNS) Support for Internet Protocol version 6 (IPv6)", RFC 3364, August 2002.
  • [RFC5625] Bellis, R., "DNS Proxy Implementation Guidelines", BCP 152, RFC 5625, August 2009.

Appendix A. Changes since RFCs 2671 and 2673 🎀

Following is a list of high-level changes to RFCs 2671 and 2673:

  • Support for the OPT record is now mandatory.
  • Extended label types remain available, but their use is discouraged as a general solution due to observed difficulties in their deployment on the Internet, as illustrated by the work with the "Binary Labels" type.
  • RFC 2673, which defined the "Binary Labels" type and is currently Experimental, is requested to be moved to Historic.
  • Changes were made in how EDNS buffer sizes are selected, and recommendations were provided on how to select them.

Authors' Addresses 💌

Joao Damas
Bond Internet Systems
Av Albufera 14
S.S. Reyes, Madrid  28701
ES

Phone: +1 650.423.1312
EMail: joao@bondis.org


Michael Graff

EMail: explorer@flame.org


Paul Vixie
Internet Systems Consortium
950 Charter Street
Redwood City, California  94063
US

Phone: +1 650.423.1301
EMail: vixie@isc.org
📦 where this page comes from