RFC 7480
HTTP Usage in the Registration Data Access Protocol (RDAP)
Internet Engineering Task Force (IETF) 🎀 RFC 7480: HTTP Usage in the Registration Data Access Protocol (RDAP) ✨
Okay bestie, this one is the big-deal RFC that explains how RDAP rides on top of HTTP 🌸. It's a Standards Track document from March 2015, written by A. Newton (ARIN), B. Ellacott (APNIC), and N. Kong (CNNIC) 💅. It's part of a whole RDAP collection, and it doesn't obsolete or update any earlier RFCs, so it's giving fresh start 🦋. The ISSN is 2070-1721 🧚.
This is part 1 of 3, so stay tuned 🫶.
Abstract
okay so this doc is one piece of a little family of docs that together describe the Registration Data Access Protocol (RDAP) 💖. It explains how RDAP gets transported over the Hypertext Transfer Protocol (HTTP) 🌈. RDAP is the glow-up successor to the super old WHOIS protocol 👑. The whole point is to clarify how we use normal HTTP mechanisms for this app, no cap 💜.
Status of This Memo
This is an Internet Standards Track document ✨.
It's a product of the Internet Engineering Task Force (IETF) and represents the consensus of the IETF community 🫶. It got public review and was approved for publication by the Internet Engineering Steering Group (IESG) 💅. If you want more info on Internet Standards, check Section 2 of RFC 5741 🎀.
For the current status, any errata, and how to give feedback, go to http://www.rfc-editor.org/info/rfc7480 🌸.
Copyright Notice
Copyright (c) 2015 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) in effect on the date of publication 🧚. Please read these carefully, bestie, because they spell out your rights and restrictions 🍓. Code Components extracted from 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 💜.
Table of Contents
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . 2
2. Terminology . . . . . . . . . . . . . . . . . . . . . . . . . 4
3. Design Intents . . . . . . . . . . . . . . . . . . . . . . . 5
4. Queries . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
4.1. HTTP Methods . . . . . . . . . . . . . . . . . . . . . . 5
4.2. Accept Header . . . . . . . . . . . . . . . . . . . . . . 5
4.3. Query Parameters . . . . . . . . . . . . . . . . . . . . 6
5. Types of HTTP Response . . . . . . . . . . . . . . . . . . . 6
5.1. Positive Answers . . . . . . . . . . . . . . . . . . . . 6
5.2. Redirects . . . . . . . . . . . . . . . . . . . . . . . . 6
5.3. Negative Answers . . . . . . . . . . . . . . . . . . . . 7
5.4. Malformed Queries . . . . . . . . . . . . . . . . . . . . 7
5.5. Rate Limits . . . . . . . . . . . . . . . . . . . . . . . 7
5.6. Cross-Origin Resource Sharing (CORS) . . . . . . . . . . 8
6. Extensibility . . . . . . . . . . . . . . . . . . . . . . . . 8
7. Security Considerations . . . . . . . . . . . . . . . . . . . 9
8. IANA Considerations . . . . . . . . . . . . . . . . . . . . . 9
8.1. RDAP Extensions Registry . . . . . . . . . . . . . . . . 9
9. Internationalization Considerations . . . . . . . . . . . . . 10
9.1. URIs and IRIs . . . . . . . . . . . . . . . . . . . . . . 10
9.2. Language Identifiers in Queries and Responses . . . . . . 10
9.3. Language Identifiers in HTTP Headers . . . . . . . . . . 10
10. References . . . . . . . . . . . . . . . . . . . . . . . . . 11
10.1. Normative References . . . . . . . . . . . . . . . . . . 11
10.2. Informative References . . . . . . . . . . . . . . . . . 12
Appendix A. Protocol Example . . . . . . . . . . . . . . . . . . 13
Appendix B. Cache Busting . . . . . . . . . . . . . . . . . . . 13
Appendix C. Bootstrapping and Redirection . . . . . . . . . . . 14
Acknowledgements . . . . . . . . . . . . . . . . . . . . . . . . . 15
Authors' Addresses . . . . . . . . . . . . . . . . . . . . . . . 161. Introduction 🌸
This doc describes how the Hypertext Transfer Protocol (HTTP) [RFC7230] gets used for the Registration Data Access Protocol (RDAP) 💅. The goal is to tie HTTP usage patterns together into one common profile that works for all the different kinds of directory services serving registration data 🦋. Those patterns are informed by the Representational State Transfer (REST) [REST] architectural style ✨. Because all these services behave the same way, one client can grab data from any of them much more easily 🫶.
Registration data here means Internet resource registration data: domain names and Internet number resources 🌈. This data is usually provided by WHOIS [RFC3912] services, but WHOIS just isn't enough for modern registration data needs 💀. A replacement protocol should keep the simple back-and-forth nature of WHOIS, and also give us a real spec for queries and responses, redirection to authoritative sources, support for Internationalized Domain Names (IDNs) [RFC5890], and support for localized registration data like addresses and organization or person names 💖.
When designing these patterns, this doc brings in considerations for a simple use of HTTP 🧚. Wherever complexity can live, the goal is to put it on the server and keep the client as simple as possible 👑. A client should be totally doable with common OS scripting tools, like bash and wget 🍓.
Here's the basic usage pattern for this protocol 🎀:
- A client figures out which server to query, plus the base Uniform Resource Locator (URL) to use for those queries. [RFC7484] describes one way to find the server and base URL. See Appendix C for more info 💜.
- A client sends an HTTP (or HTTPS) query using GET [RFC7231]. For example, a query URL for the network registration 192.0.2.0 might be:
http://example.com/rdap/ip/192.0.2.0[RFC7482] details the various queries used in RDAP 🦋.
- If the receiving server has the info for the query, it checks the Accept header field of the query and returns a 200 response with a response entity in the requested format 🔥. [RFC7483] details a response in JavaScript Object Notation (JSON) ✨.
- If the receiving server doesn't have the info but knows where it can be found, it sends back a redirection response (3xx) with the Location header field containing an HTTP(S) URL pointing to the info, or to another server that knows where the info lives 🌸. The client is expected to requery using that HTTP URL 🫶.
- If the receiving server doesn't have the info and doesn't know where it can be found, it returns a 404 response 🙈.
- If the receiving server won't answer a request for policy reasons, it returns an error response (4xx) that says why it's not answering 💅.
It's not the intent of this doc to redefine the meaning and semantics of HTTP 💖. The purpose is to clarify how standard HTTP mechanisms get used for this application 🦋.
2. Terminology 🧚
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 [RFC2119] 🎀.
As the "Security and Stability Advisory Committee (SSAC) Report on WHOIS Terminology and Structure" [SAC-051] points out, the term "WHOIS" is overloaded, often meaning a protocol, a service, and data all at once 🌈. Following [SAC-051], this doc describes the base behavior for an RDAP 🍓. [SAC-051] also describes a protocol profile of RDAP for Domain Name Registries (DNRs), called the Domain Name Registration Data Access Protocol (DNRD-AP) 👑.
In this doc, an RDAP client is an HTTP user agent making an RDAP query, and an RDAP server is an HTTP server giving back an RDAP response ✨. RDAP query and response formats are described in [RFC7482] and [RFC7483], while this doc is all about how RDAP clients and servers use HTTP to swap queries and responses 💜. [RFC7481] covers security considerations for RDAP 🔥.
3. Design Intents 💖
There are a few design criteria this doc tries to hit 🌸.
First, each query should only need one path of execution to get an answer 🦋. A response might contain an answer, no answer, or a redirect, and clients aren't expected to fork multiple paths of execution for a query 🫶.
Second, the request/response semantics allow for future and/or non-standard response formats 🧚. This doc only notes one media type, a JSON [RFC7159] response, and the response contents get described separately (see [RFC7483]) 💅. This doc only describes how RDAP gets transported over HTTP with this format 🎀.
Third, this protocol is meant to make use of the whole range of HTTP mechanisms 🌈. HTTP has a bunch of mechanisms this doc doesn't go into further 🍓. Operators can use these mechanisms according to their local policy, including cache control, authorization, compression, and redirection 👑. HTTP also has widespread investment in scalability, reliability, and performance, plus lots of programmers already understand client behavior for web services styled after REST [REST] ✨. That keeps the cost down for deploying Registration Data Directory Services and clients 💜. This protocol is forward compatible with HTTP 2.0 🔥.
4. Queries 🌸
4.1. HTTP Methods 🦋
Clients use the GET method to retrieve a response body, and the HEAD method to check whether data exists on the server 🫶. Clients SHOULD use either the HTTP GET or HEAD methods (see [RFC7231]) 🧚. Servers are under no obligation to support other HTTP methods, so clients using other methods will likely not interoperate properly 💅.
Clients and servers MUST support HTTPS to support security services 🎀.
4.2. Accept Header 💖
To tell servers that an RDAP response is wanted, clients include an Accept header field with an RDAP-specific JSON media type, the generic JSON media type, or both 🌈. Servers that get an RDAP request return an entity with a Content-Type header containing the RDAP-specific JSON media type 🍓.
This spec doesn't define what a server returns for a request with any other media types in the Accept header field, or with no Accept header field at all 👑. One possibility would be returning a response in a media type that's suitable for rendering in a web browser ✨.
4.3. Query Parameters 💜
Servers MUST ignore unknown query parameters 🔥. Using unknown query parameters for cache busting is described in Appendix B 🌸.
5. Types of HTTP Response ✨
okay bestie, this section is all about the kinds of responses a server can send back to a client 💌 no standard HTTP response code is banned here, BUT this section lays out the minimal set of codes that servers commonly use and that a client needs to understand 🫶 some clients are built with super simple tooling that doesn't handle every single one, but a more robust client that handles them will likely give users a way better experience 💅 and any codes and types for this app that aren't defined here are expected to show up in later documents 🦋
5.1. Positive Answers 🌸
If a server has the info the client asked for and wants to hand it over according to its policies, it sends that answer in the body of a 200 (OK) response (see [RFC7231]). ding ding, happy path 🎉
5.2. Redirects 🔀
okay so if a server wants to tell a client that the answer to a query lives somewhere else 🗺️, it sends either a 301 (Moved Permanently) response code for a permanent move, or a 302 (Found), 303 (See Other), or 307 (Temporary Redirect) response code for a non-permanent redirection 💜. either way it includes an HTTP(S) URL in the Location: header field (see [RFC7231]). the client is expected to make a follow-up request for the original query using that URL, with no processing of the URL at all 🧚. in other words, the server hands back a complete URL, and the client shouldn't have to transform it to follow it. servers aren't obligated to return a URL that conforms to [RFC7482] 🙈
for this application, a permanent move might look like a Top-Level Domain (TLD) operator telling a client that the info they want is with another TLD operator 🌈 (like, a query for the domain bar in foo.example is found at http://foo.example/domain/bar).
for example, if the client uses
http://serv1.example.com/weirds/domain/example.comand the server redirects to
https://serv2.example.net/weirds2/then it would set the Location: field to the value
https://serv2.example.net/weirds2/domain/example.com5.3. Negative Answers 🙅♀️
if a server wants to say it has an empty result set (basically, no data that satisfies the query), it returns a 404 (Not Found) response code 💀. optionally, it MAY include extra info about that negative answer in the HTTP entity body 🎀
if a server wants to tell the client that info about the query exists but it can't include that info in the response for policy reasons, the server MUST respond with an appropriate response code out of HTTP's 4xx range 🔒. a client MAY retry the query if that makes sense for that specific response code 🔁
5.4. Malformed Queries 🧩
if a server gets a query it can't interpret as an RDAP query, it returns a 400 (Bad Request) response code 🙃. optionally, it MAY include extra info about this negative answer in the HTTP entity body 💌
5.5. Rate Limits 🚦
some servers put rate limits in place to deter address scraping and other abuses 🕵️♀️. when a server declines to answer a query because of rate limits, it returns a 429 (Too Many Requests) response code, as described in [RFC6585] 🛑. a client that gets a 429 response SHOULD decrease its query rate and honor the Retry-After header field if one is present ⏰. servers may place stricter limits on clients that don't honor the Retry-After header. optionally, the server MAY include extra info about the rate limiting in the HTTP entity body 📝
ngl this is NOT a defense against denial-of-service (DoS) attacks 😭, because a malicious client could just ignore the code and keep firing queries at a high rate 💀. a server might use another response code if it didn't want to reveal to a client that rate limiting is the reason for the denial 🤫
5.6. Cross-Origin Resource Sharing (CORS) 🌐
when responding to queries, it is RECOMMENDED that servers use the Access-Control-Allow-Origin header field, as specified by [W3C.REC-cors-20140116] 🫶. a value of "*" is suitable when RDAP is used for public resources 🌸
this header (often called the CORS header) helps in-browser web apps by lifting the "same-origin" restriction 🦋. so a browser can load RDAP client code from one web server but query others for RDAP data, which is giving main character energy 👑
by default, browsers don't send cookies when cross origin requests are allowed 🍪. setting the Access-Control-Allow-Credentials header field to "true" will send cookies. using the Access-Control-Allow-Credentials header field is NOT RECOMMENDED 🚫
6. Extensibility 🧚
for extensibility purposes, this document defines an IANA registry for prefixes used in JSON [RFC7159] data serialization and URI path segments (see Section 8) 💖
prefixes and identifiers SHOULD only consist of the alphabetic US-ASCII characters A through Z in both uppercase and lowercase, the numerical digits 0 through 9, and the underscore character 🔤. they SHOULD NOT begin with an underscore character, a numerical digit, or the characters "xml" 🙅♀️. the following describes how JSON names are produced in ABNF [RFC5234] 📐
name = ALPHA *( ALPHA / DIGIT / "_" )
Figure 1: ABNF for JSON Namesthis restriction is a union of the Ruby programming language identifier syntax and the XML element name syntax, and it has two purposes 💅. first, client implementers using modern programming languages like Ruby or Java can use libraries that automatically promote JSON names to first-order object attributes or members ✨. second, a clean mapping between JSON and XML is easy to pull off using these rules 🎀
7. Security Considerations 🔐
okay this part is SERIOUS bestie 😤 this document doesn't pose strong security requirements to the RDAP protocol. however, it doesn't restrict the use of security mechanisms offered by the HTTP protocol 🛡️. it does require that RDAP clients and servers MUST support HTTPS 🔒🔒. no HTTPS, no entry, periodt 💀
this document makes recommendations for server implementations against DoS (Section 5.5) and for interoperability with existing security mechanisms in HTTP clients (Section 5.6) 🧯
additional security considerations for the RDAP protocol are covered in [RFC7481] 📚 go read that one too, no cap 🫶
8. IANA Considerations 🏛️
8.1. RDAP Extensions Registry 📒
IANA has created a new category in the protocol registries labeled "Registration Data Access Protocol (RDAP)" 🗂️. within that category, IANA has established a URL-referenceable, stand-alone registry labeled "RDAP Extensions" ✨. the purpose of this registry is to make sure extension identifiers are unique 🔑. the extension identifier is used as a prefix in JSON names and as a prefix of path segments in RDAP URLs 💜
the production rule for these identifiers is specified in Section 6 📐
in accordance with [RFC5226], the IANA policy for assigning new values shall be Specification Required 📜: values and their meanings must be documented in an RFC or in some other permanent and readily available reference, in enough detail that interoperability between independent implementations is possible 🤝
here's the template for an RDAP extension registration 🎀:
Extension identifier: the identifier of the extension
Registry operator: the name of the registry operator
Published specification: RFC number, bibliographical reference, or
URL to a permanent and readily available specification
Person & email address to contact for further information: The
names and email addresses of individuals to contact regarding this
registry entry
Intended usage: brief reasons for this registry entry (as defined
by [RFC5226]).and here's an example of a registration in the RDAP extension registry 🌈:
Extension identifier: lunarNic
Registry operator: The Registry of the Moon, LLC
Published specification: http://www.example/moon_apis/rdap
Person & email address to contact for further information:
Professor Bernardo de la Paz <berny@moon.example>
Intended usage: COMMON9. Internationalization Considerations 🌍
9.1. URIs and IRIs 🔗
clients can use Internationalized Resource Identifiers (IRIs) [RFC3987] for internal use however they like, but they MUST transform them to URIs [RFC3986] for interaction with RDAP servers 🔄. RDAP servers MUST use URIs in all responses, and then clients can transform these URIs to IRIs for internal use however they see fit 💅
9.2. Language Identifiers in Queries and Responses 🗣️
under most scenarios, clients requesting data won't signal that the data should come back in a particular language or script 🤷♀️. on the other hand, when servers return data and know that it's in a particular language or script, the data SHOULD be annotated with language identifiers whenever they're available, so clients can process and display it correctly 💖
[RFC7483] provides such a mechanism ✨
9.3. Language Identifiers in HTTP Headers 🏷️
given how language identifiers are used in Section 9.2, unless otherwise specified, servers SHOULD ignore the HTTP [RFC7231] Accept-Language header field when formulating HTTP entity responses 🙈. this way, clients don't mix up the Accept-Language header with the 'lang' values in the entity body 🫠
however, servers MAY return language identifiers in the Content-Language header field to tell clients the intended language of HTTP layer messages 🌸
10. References 📚
10.1. Normative References ✨
okay so these are the docs the spec literally can't work without, bestie 📚💅
[RFC2119]Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, March 1997,<http://www.rfc-editor.org/info/rfc2119>.[RFC3986]Berners-Lee, T., Fielding, R., and L. Masinter, "Uniform Resource Identifier (URI): Generic Syntax", STD 66, RFC 3986, January 2005,<http://www.rfc-editor.org/info/rfc3986>.[RFC3987]Duerst, M. and M. Suignard, "Internationalized Resource Identifiers (IRIs)", RFC 3987, January 2005,<http://www.rfc-editor.org/info/rfc3987>.[RFC5226]Narten, T. and H. Alvestrand, "Guidelines for Writing an IANA Considerations Section in RFCs", BCP 26, RFC 5226, May 2008,<http://www.rfc-editor.org/info/rfc5226>.[RFC6585]Nottingham, M. and R. Fielding, "Additional HTTP Status Codes", RFC 6585, April 2012,<http://www.rfc-editor.org/info/rfc6585>.[RFC7230]Fielding, R., Ed. and J. Reschke, Ed., "Hypertext Transfer Protocol (HTTP/1.1): Message Syntax and Routing", RFC 7230, June 2014,<http://www.rfc-editor.org/info/rfc7230>.[RFC7231]Fielding, R., Ed. and J. Reschke, Ed., "Hypertext Transfer Protocol (HTTP/1.1): Semantics and Content", RFC 7231, June 2014,<http://www.rfc-editor.org/info/rfc7231>.[RFC7481]Hollenbeck, S. and N. Kong, "Security Services for the Registration Data Access Protocol (RDAP)", RFC 7481, February 2015,<http://www.rfc-editor.org/info/rfc7481>.[RFC7482]Newton, A. and S. Hollenbeck, "Registration Data Access Protocol (RDAP) Query Format", RFC 7482, February 2015,<http://www.rfc-editor.org/info/rfc7482>.[RFC7483]Newton, A. and S. Hollenbeck, "JSON Responses for the Registration Data Access Protocol (RDAP)", RFC 7483, February 2015,<http://www.rfc-editor.org/info/rfc7483>.[RFC7484]Blanchet, M., "Finding the Authoritative Registration Data (RDAP) Service", RFC 7484, February 2015,<http://www.rfc-editor.org/info/rfc7484>.[W3C.REC-cors-20140116]Kesteren, A., "Cross-Origin Resource Sharing", W3C Recommendation, REC-cors-20140116, January 2014,<http://www.w3.org/TR/2014/REC-cors-20140116/>.
10.2. Informative References 🦋
these ones are more like "good to know" reading, not required to build the thing 🤓
[REST]Fielding, R. and R. Taylor, "Principled Design of the Modern Web Architecture", ACM Transactions on Internet Technology, Vol. 2, No. 2, May 2002.[RFC3912]Daigle, L., "WHOIS Protocol Specification", RFC 3912, September 2004,<http://www.rfc-editor.org/info/rfc3912>.[RFC5234]Crocker, D., Ed. and P. Overell, "Augmented BNF for Syntax Specifications: ABNF", STD 68, RFC 5234, January 2008,<http://www.rfc-editor.org/info/rfc5234>.[RFC5890]Klensin, J., "Internationalized Domain Names for Applications (IDNA): Definitions and Document Framework", RFC 5890, August 2010,<http://www.rfc-editor.org/info/rfc5890>.[RFC7159]Bray, T., Ed., "The JavaScript Object Notation (JSON) Data Interchange Format", RFC 7159, March 2014,<http://www.rfc-editor.org/info/rfc7159>.[SAC-051]Piscitello, D., Ed., "SSAC Report on Domain Name WHOIS Terminology and Structure", A report from the ICANN Security and Stability Advisory Committee (SSAC), September 2011.[lacnic-joint-whois]LACNIC, "Joint Whois", December 2005,<ftp://anonymous@ftp.registro.br/pub/gter/gter20/02-jwhois-lacnic.pdf>.
Appendix A. Protocol Example 🎀
okay so this one shows a typical back-and-forth between an RDAP client and server, and yes there's a redirect in it, iykyk 💅 the data in the response is elided (aka cut out) because the data format isn't described in this doc. the media type used here is described in [RFC7483] ✨
here's the exchange:
Client:
<TCP connect to rdap.example.com port 80>
GET /rdap/ip/203.0.113.0/24 HTTP/1.1
Host: rdap.example.com
Accept: application/rdap+json
rdap.example.com:
HTTP/1.1 301 Moved Permanently
Location: http://rdap-ip.example.com/rdap/ip/203.0.113.0/24
Content-Length: 0
Content-Type: application/rdap+json
<TCP disconnect>
Client:
<TCP connect to rdap-ip.example.com port 80>
GET /rdap/ip/203.0.113.0/24 HTTP/1.1
Host: rdap-ip.example.com
Accept: application/rdap+json
rdap-ip.example.com:
HTTP/1.1 200 OK
Content-Type: application/rdap+json
Content-Length: 9001
{ ... }
<TCP disconnect>Appendix B. Cache Busting 🙈
bestie, some HTTP [RFC7230] cache setups don't follow caching standards super well, and they can hold onto responses longer than the server meant them to 😭 so to get around that, clients can tack on an ad hoc, improbably used query parameter with a random value they pick themselves. and since Section 4.3 tells servers to ignore unknown parameters, this stays compatible with the RDAP definition 🧚
here's what it looks like:
http://example.com/ip/192.0.2.0?__fuhgetaboutit=xyz123Using an unknown parameter to dodge misbehaving caches is not part of any specification. it's only offered here for informational purposes, so don't treat it as an official rule 💀
Appendix C. Bootstrapping and Redirection 🌈
so the traditional WHOIS [RFC3912] deployment model has no way to figure out which source is the authoritative one for a piece of info 🥺
there were some past attempts, most notably the Joint WHOIS [lacnic-joint-whois] initiative. but among other problems, Joint WHOIS is built on proxies and server-side referrals, which is giving messy 🙃
RDAP fixes this with HTTP redirects and bootstrapping. bootstrapping gets discussed in [RFC7484]. in constrained environments the processes outlined in [RFC7484] might not be viable, and there may be a need for servers acting as a "redirector" 👑
redirector servers send HTTP redirects to clients using a redirection table informed by [RFC7484]. Figure 2 shows a client using a redirector for bootstrapping ✨
REDIRECTOR ARIN
RDAP RDAP
. .
| |
Q: 23.1.1.1? -----------------> | |
| |
<---------- HTTP 301 --------| |
('Try ARIN RDAP') | |
| |
|
Q: 23.1.1.1? -------------------------------> |
|
<---------- HTTP 200 --------------------- |
(JSON response is returned) |
|
|
.
Figure 2: Querying RDAP Data for 23.1.1.1sometimes, especially with sub-delegations between Regional Internet Registries (RIRs), known as "ERX space", and with network transfers, you get multiple HTTP redirects in a row. Figure 3 shows that drama 🍓
REDIRECTOR LACNIC ARIN
RDAP RDAP RDAP
. . .
Q: 23.1.1.1? ----> | | |
| | |
<-- HTTP 301 --- | | |
('Try LACNIC') | | |
| | |
| | |
Q: 23.1.1.1? -----------------> | |
| |
<---------- HTTP 301 --------| |
('Try ARIN RDAP') | |
| |
|
Q: 23.1.1.1? -------------------------------> |
|
<---------- HTTP 200 --------------------- |
(JSON response is returned) |
|
|
.
Figure 3: Querying RDAP Data for Data That Has Been TransferredAcknowledgements 🫶
John Levine gave text to tighten up the Accept header field usage and the text for the section on 429 responses. he's the real MVP 👑
Marc Blanchet provided some clarifying text about using URLs with redirects, plus super useful feedback during Working Group Last Call (WGLC) 💜
Normative language reviews came from Murray S. Kucherawy, Andrew Sullivan, Tom Harrison, Ed Lewis, and Alexander Mayrhofer. the people checking the key words, iconic 💅
Jean-Phillipe Dionne wrote the text for the Security Considerations section. security stays serious, periodt 🔒
The concept of the redirector server, which Appendix C covers informatively, was documented by Carlos M. Martinez and Gerardo Rada of LACNIC and Linlin Zhou of CNNIC, and then got incorporated into this document 🌸
This document is the work product of the IETF's WEIRDS working group, whose chairs were Olaf Kolkman and Murray Kucherawy ✨
Authors' Addresses 💖
Andrew Lee Newton, from the American Registry for Internet Numbers:
Andrew Lee Newton
American Registry for Internet Numbers
3635 Concorde Parkway
Chantilly, VA 20151
United States
EMail: andy@arin.net
URI: http://www.arin.netByron J. Ellacott, from the Asia Pacific Network Information Centre:
Byron J. Ellacott
Asia Pacific Network Information Centre
6 Cordelia Street
South Brisbane QLD 4101
Australia
EMail: bje@apnic.net
URI: http://www.apnic.netNing Kong, from the China Internet Network Information Center:
Ning Kong
China Internet Network Information Center
4 South 4th Street, Zhongguancun, Haidian District
Beijing 100190
China
Phone: +86 10 5881 3147
EMail: nkong@cnnic.cn📦 where this page comes from
- ietf: rfc7480 2015-03
- 💖 girlified by claude-haiku-5-5 on : a language model's rewrite of the original, under its terms