HTTP usage in the Registration Data Access Protocol (RDAP)
draft-ietf-weirds-using-http-07

Abstract

This document is one of a collection that together describe the Registration Data Access Protocol (RDAP). It describes how RDAP is transported using the Hypertext Transfer Protocol (HTTP).

Status of This Memo

This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79.

Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet-Drafts is at http://datatracker.ietf.org/drafts/current/.

Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress."

This Internet-Draft will expire on January 04, 2014.

Copyright Notice

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) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect to this document. Code Components extracted from this document must include Simplified BSD License text as described in Section 4.e of the Trust Legal Provisions and are provided without warranty as described in the Simplified BSD License.

Table of Contents

• 1. Introduction
• 2. Terminology
• 3. Design Intents
• 4. Queries
• 4.1. Accept Header
• 4.2. Query Parameters
• 5. Types of HTTP Response
• 5.1. Positive Answers
• 5.2. Redirects
• 5.3. Negative Answers
• 5.4. Malformed Queries
• 5.5. Rate Limits
• 5.6. Cross-Origin Resource Sharing
• 6. Extensibility
• 7. Security Considerations
• 8. IANA Considerations
• 8.1. RDAP Extensions Registry
• 9. Internationalization Considerations
• 9.1. URIs and IRIs
• 9.2. Language Identifiers in Queries and Responses
• 9.3. Language Identifiers in HTTP Headers
• 10. Contributing Authors and Acknowledgements
• 11. References
• 11.1. Normative References
• 11.2. Informative References
• Appendix A. Protocol Example
• Appendix B. Cache Busting
• Appendix C. Changelog
• Authors' Addresses

1. Introduction

This document describes the usage of HTTP for Registration Data Directory Services. The goal of this document is to tie together usage patterns of HTTP into a common profile applicable to the various types of Directory Services serving Registration Data using RESTful practices. By giving the various Directory Services common behavior, a single client is better able to retrieve data from Directory Services adhering to this behavior.

The registration data expected to be presented by this service is Internet resource registration data - registration of domain names and Internet number resources. This data is typically provided by WHOIS [RFC3912] services, but the WHOIS protocol is insufficient to modern registration data service requirements. A replacement protocol is expected to retain the simple transactional nature of WHOIS, while providing a specification for queries and responses, redirection to authoritative sources, support for Internationalized Domain Names (IDNs, [RFC5890]), and support for localized registration data such as addresses and organisation or person names.

In designing these common usage patterns, this document introduces considerations for a simple use of HTTP. Where complexity may reside, it is the goal of this document to place it upon the server and to keep the client as simple as possible. A client implementation should be possible using common operating system scripting tools.

This is the basic usage pattern for this protocol:

1. A client issues an HTTP query using GET. As an example, a query for the network registration 192.0.2.0 might be http://example.com/ip/192.0.2.0.
2. If the receiving server has the information for the query, it examines the Accept header field of the query and returns a 200 response with a response entity appropriate for the requested format.
3. If the receiving server does not have the information for the query but does have knowledge of where the information can be found, it will return a redirection response (3xx) with the Location: header field containing an HTTP(S) URL (Uniform Resource Locator) pointing to the information or another server known to have knowledge of the location of the information. The client is expected to re-query using that HTTP URL.
4. If the receiving server does not have the information being requested and does not have knowledge of where the information can be found, it returns a 404 response.
5. If the receiving server will not answer a request for policy reasons, it will return an error response (4xx) indicating the reason for giving no answer.

It is important to note that it is not the intent of this document to redefine the meaning and semantics of HTTP. The purpose of this document is to clarify the use of standard HTTP mechanisms 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 RFC 2119 [RFC2119].

As is noted in SSAC Report on WHOIS Terminology and Structure [SAC-051], the term "WHOIS" is overloaded, often referring to a protocol, a service and data. In accordance with [SAC-051], this document describes the base behavior for a Registration Data Access Protocol (RDAP). [SAC-051] describes a protocol profile of RDAP for Domain Name Registries (DNRs), the Domain Name Registration Data Access Protocol (DNRD-AP).

In this document, an RDAP client is an HTTP User Agent performing an RDAP query, and an RDAP server is an HTTP server providing an RDAP response. RDAP query and response formats are described in other documents in the collection of RDAP specifications, while this document describes how RDAP clients and servers use HTTP to exchange queries and responses.

3. Design Intents

There are a few design criteria this document attempts to meet.

First, each query is meant to return either zero or one result. With the maximum upper bound being set to one, the issuance of redirects is simplified to the known query/response model used by HTTP [RFC2616]. Should an entity contain more than one result, some of which are better served by other servers, the redirection model becomes much more complicated.

Second, the semantics of the request/response allow for future and/or non-standard response formats. In this document, only a JSON [RFC4627] response media type is noted, with the response contents to be described separately. This document only describes how RDAP is transported using HTTP with this format.

Third, this protocol is intended to be able to make use of the range of mechanisms available for use with HTTP. HTTP offers a number of mechanisms not described further in this document. Operators are able to make use of these mechanisms according to their local policy, including cache control, authorization, compression, and redirection. HTTP also benefits from widespread investment in scalability, reliability, and performance, and widespread programmer understanding of client behaviours for RESTful web services, reducing the cost to deploy Registration Data Directory Services and clients.

4. Queries

4.1. Accept Header

To indicate to servers that an RDAP response is desired, clients include an Accept: header field with an RDAP specific JSON media type, the generic JSON media type, or both. Servers receiving an RDAP request return an entity with a Content-Type: header containing the RDAP specific JSON media type.

This specification does not define the responses a server returns to a request with any other media types in the Accept: header field, or with no Accept: header field. One possibility would be to return a response in a media type suitable for rendering in a web browser.

4.2. Query Parameters

Servers MUST ignore unknown query parameters. Use of unknown query parameters for cache-busting is described in Appendix B.

5. Types of HTTP Response

This section describes the various types of responses a server may send to a client. While no standard HTTP response code is forbidden in usage, at a minimum clients SHOULD understand the response codes described in this section as they will be in common use by servers. It is expected that usage of response codes and types for this application not defined here will be described in subsequent documents.

5.1. Positive Answers

If a server has the information requested by the client and wishes to respond to the client with the information according to its policies, it returns that answer in the body of a 200 response.

5.2. Redirects

If a server wishes to inform a client that the answer to a given query can be found elsewhere, it returns either a 301 response code to indicate a permanent move, or a 302, 303 or 307 response code to indicate a non-permanent redirection, and it includes an HTTP(s) URL in the Location: header field. The client is expected to issue a subsequent request to satisfy the original query using the given URL without any processing of the URL. In other words, the server is to hand back a complete URL and the client should not have to transform the URL to follow it.

For this application, such an example of a permanent move might be a Top Level Domain (TLD) operator informing a client the information being sought can be found with another TLD operator (i.e. a query for the domain bar in foo.example is found at http://foo.example/domain/bar).

For example, if the client sends http://serv1.example.com/weirds/domain/example.com, the server redirecting to https://serv2.example.net/weirds2/ would set the Location: field to the value: https://serv2.example.net/weirds2/domain/example.com.

5.3. Negative Answers

If a server wishes to respond that it has no information regarding the query, it returns a 404 response code. Optionally, it MAY include additional information regarding the negative answer in the HTTP entity body.

If a server wishes to inform the client that information about the query is available, but cannot include the information in the response to the client for policy reasons, the server MUST respond with an appropriate response code out of HTTP's 4xx range. Clients MAY retry the query based on the respective response code.

5.4. Malformed Queries

If a server receives a query which it cannot interpret as an RDAP query, it returns a 400 response code. Optionally, it MAY include additional information regarding this negative answer in the HTTP entity body.

5.5. Rate Limits

Some servers apply rate limits to deter address scraping and other abuses. When a server declines to answer a query due to rate limits, it returns a 429 response code as described in [RFC6585]. A client that receives a 429 response SHOULD decrease its query rate, and honor the Retry-After header field if one is present.

Note that this is not a defense against denial-of-service attacks, since a malicious client could ignore the code and continue to send queries at a high rate. A server might use another response code if it did not wish to reveal to a client that rate limiting is the reason for the denial of a reply.

5.6. Cross-Origin Resource Sharing

When responding to queries, it is RECOMMENDED that servers use the Access-Control-Allow-Origin header field, as specified by [W3C.CR-cors-20130129].

6. Extensibility

For extensibility purposes, this document defines an IANA registry for prefixes used in JSON [RFC4627] data serialization and URI path segments (see Section 8).

Prefixes and identifiers SHOULD only consist of the alphabetic ASCII characters A through Z in both uppercase and lowercase, the numerical digits 0 through 9, underscore characters, and SHOULD NOT begin with an underscore character, numerical digit or the characters "xml". The following describes the production of JSON names in ABNF [RFC5234].

  name = ALPHA *( ALPHA / DIGIT / "_" )

                

  Client:
      <TCP connect to rdap.example.com port 80>
      GET /ip/203.0.113.0/24 HTTP/1.1
      Host: rdap.example.com
      Accept: application/rdap+json

  rdap.example.com:
      HTTP 301 Moved Permanently
      Location: http://rdap-ip.example.com/ip/203.0.113.0/24
      Content-Length: 0
      Content-Type: application/rdap+json; charset=UTF-8
      <TCP disconnect>

  Client:
      <TCP connect to rdap-ip.example.com port 80>
      GET /ip/203.0.113.0/24 HTTP/1.1
      Host:  rdap-ip.example.com
      Accept: application/rdap+json

  rdap-ip.example.com:
      HTTP 200 OK
      Content-Type: application/rdap+json; charset=UTF-8
      Content-Length: 9001

      { ... }
      <TCP disconnect>

                

                    
  http://example.com/ip/192.0.2.0?__fuhgetaboutit=xyz123