IANA Registration of Enumservices: Guide, Template and IANA Considerations
draft-ietf-enum-enumservices-guide-22

Abstract

This document specifies a revision of the IANA Registration Guidelines for Enumservices, describes corresponding registration procedures, and provides a guideline for creating Enumservice Specifications.

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 April 15, 2011.

Copyright Notice

Copyright (c) 2010 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.

This document may contain material from IETF Documents or IETF Contributions published or made publicly available before November 10, 2008. The person(s) controlling the copyright in some of this material may not have granted the IETF Trust the right to allow modifications of such material outside the IETF Standards Process. Without obtaining an adequate license from the person(s) controlling the copyright in such materials, 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, except to format it for publication as an RFC or to translate it into languages other than English.

Table of Contents

1.  Introduction

2.  Terminology

3.  Registration Requirements
    3.1.  Functionality Requirements
    3.2.  Naming Requirements
    3.3.  Security Requirements
    3.4.  Publication Requirements

4.  Enumservice Creation Cookbook
    4.1.  General Enumservice Considerations
    4.2.  Classification, Type and Subtype
        4.2.1.  General Type / Subtype Considerations
        4.2.2.  Protocol-Based Enumservices Class
        4.2.3.  Application-Based Enumservice Classes
        4.2.4.  Data Type-Based Enumservice Class
        4.2.5.  Other Enumservice

5.  Required Sections and Information
    5.1.  Introduction (REQUIRED)
    5.2.  IANA Registration (REQUIRED)
        5.2.1.  Enumservice Class (<class>)
        5.2.2.  Enumservice Type (<type>)
        5.2.3.  Enumservice Subtype (<subtype>)
        5.2.4.  URI Scheme(s) (<urischeme>)
        5.2.5.  Functional Specification (<functionalspec>)
        5.2.6.  Security Considerations (<security>)
        5.2.7.  Intended Usage (<usage>)
        5.2.8.  Enumservice Specification (<registrationdocs>)
        5.2.9.  Requesters (<requesters>)
        5.2.10.  Further Information (<additionalinfo>)
    5.3.  Examples (REQUIRED)
    5.4.  Implementation Recommendations / Notes (OPTIONAL)
    5.5.  Security Considerations (REQUIRED)
    5.6.  IANA Considerations (REQUIRED)
    5.7.  DNS Considerations (REQUIRED)
    5.8.  Other Sections (OPTIONAL)

6.  The Process of Registering New Enumservices
    6.1.  Step 1: Read This Document in Detail
    6.2.  Step 2: Write and Submit Registration Document
    6.3.  Step 3: Request Comments From the IETF Community
        6.3.1.  Outcome 1: No Changes Needed
        6.3.2.  Outcome 2: Changes, But No Further Comments Requested
        6.3.3.  Outcome 3: Changes and Further Comments Requested
    6.4.  Step 4: Submit Registration Document to IANA
    6.5.  Step 5: Expert Review
        6.5.1.  Outcome 1: Experts Approve the Registration Document
        6.5.2.  Outcome 2: Changes Required
        6.5.3.  Outcome 3: Experts Reject the Registration Document
    6.6.  Step 6: Publication of the Registration Document
    6.7.  Step 7: Adding Enumservice to IANA Registry

7.  Expert Review
    7.1.  Expert Selection Process
    7.2.  Review Guidelines
    7.3.  Appeals

8.  Revision of Existing Enumservice Specifications

9.  Extension of Existing Enumservice Specifications

10.  Security Considerations
    10.1.  Considerations Regarding This Document
    10.2.  Enumservice Security Considerations Guideline

11.  IANA Considerations
    11.1.  Registry Update
    11.2.  Registration Template (XML chunk)
    11.3.  Location
    11.4.  Structure
    11.5.  Expert Review Procedure
    11.6.  Registration Procedure
        11.6.1.  Published as RFC
        11.6.2.  Published as a Non-RFC
    11.7.  Change Control
    11.8.  Restrictions

12.  Acknowledgments

13.  References
    13.1.  Normative References
    13.2.  Informative References

Appendix A.  IANA Registration Template Examples

Appendix B.  Changes from RFC 3761

Appendix C.  Document Changelog

Appendix D.  Open Issues

Appendix E.  Notes for the RFC Editor Concerning RFC 3761

§  Authors' Addresses

1.  Introduction

E.164 Number Mapping (ENUM) [I‑D.ietf‑enum‑3761bis] (Bradner, S., Conroy, L., and K. Fujiwara, “The E.164 to Uniform Resource Identifiers (URI) Dynamic Delegation Discovery System (DDDS) Application (ENUM),” June 2010.) provides an identifier mapping mechanism to map E.164 numbers (International Telecommunications Union, “The International Public Telecommunication Numbering Plan,” Feb 2005.) [ITU.E164.2005] to Uniform Resource Identifiers (URIs) (Berners-Lee, T., Fielding, R., and L. Masinter, “Uniform Resource Identifier (URI): Generic Syntax,” January 2005.) [RFC3986] using the Domain Name System (DNS) (Mockapetris, P., “Domain names - implementation and specification,” November 1987.) [RFC1035]. One of the primary concepts of ENUM is the definition of "Enumservices", which allows for providing different URIs for different applications of said mapping mechanism.

This document specifies a revision of the IANA Registry for Enumservices, which was originally described in [RFC3761] (Faltstrom, P. and M. Mealling, “The E.164 to Uniform Resource Identifiers (URI) Dynamic Delegation Discovery System (DDDS) Application (ENUM),” April 2004.). This document obsoletes Section 3 of RFC 3761.

The new registration processes, which is detailed in Section 6 (The Process of Registering New Enumservices), have been specifically designed to be decoupled from the existence of the ENUM working group. Compared to RFC 3761, the main changes are:

• For an Enumservice to be inserted to the IANA Registry, "Specification Required", which implies the use of a Designated Expert, according to "Guidelines for Writing an IANA Considerations Section in RFCs" (Narten, T. and H. Alvestrand, “Guidelines for Writing an IANA Considerations Section in RFCs,” May 2008.) [RFC5226] are now sufficient.



• The IANA Registration Template has been supplemented with elements for "Enumservice Class" and "Enumservice Specification".

The IETF's ENUM Working Group has encountered an unnecessary amount of variation in the format of Enumservice Specifications. The ENUM Working Group's view of what particular information is required and/or recommended has also evolved, and capturing these best current practices is helpful in both the creation of new Enumservice Specifications, as well as the revision or refinement of existing Enumservice Specifications.

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 (Bradner, S., “Key words for use in RFCs to Indicate Requirement Levels,” March 1997.) [RFC2119].

For the purpose of this document:

• "Registration Document" refers to a draft specification that defines an Enumservice and proposes its registration following the procedures outlined herein.



• "Enumservice Specification" refers to a Registration Document that has been approved by the experts and published according to "Specification Required" as defined in [RFC5226] (Narten, T. and H. Alvestrand, “Guidelines for Writing an IANA Considerations Section in RFCs,” May 2008.).

3.  Registration Requirements

As specified in the Augmented Backus-Naur Form (ABNF, [RFC5234] (Crocker, D. and P. Overell, “Augmented BNF for Syntax Specifications: ABNF,” January 2008.)) found in Section 2.4.3 of [I‑D.ietf‑enum‑3761bis] (Bradner, S., Conroy, L., and K. Fujiwara, “The E.164 to Uniform Resource Identifiers (URI) Dynamic Delegation Discovery System (DDDS) Application (ENUM),” June 2010.), an Enumservice is made up of Types and Subtypes. For any given Type, the allowable Subtypes (if any) must be defined in the Enumservice Specification. There is currently no concept of a registered Subtype outside the scope of a given Type.

While the combination of each Type and all of its Subtypes constitutes the allowed values for the "Enumservice" field, it is not sufficient to just list their allowed values. To allow for interoperability, a complete Enumservice Specification MUST document the semantics of the Type and Subtype values to be registered, and MUST contain all sections listed in Section 5 (Required Sections and Information) of this document.

Furthermore, in order for an Enumservice to be registered, the entire Registration Document requires approval by the experts according to "Specification Required", which implies the use of a Designated Expert, as set out in "Guidelines for Writing an IANA Considerations Section in RFCs" (Narten, T. and H. Alvestrand, “Guidelines for Writing an IANA Considerations Section in RFCs,” May 2008.) [RFC5226] and Section 7.2 (Review Guidelines) of this document.

All Enumservice Specifications are expected to conform also to various requirements laid out in the following sections.

3.1.  Functionality Requirements

A registered Enumservice must be able to function as a selection mechanism for choosing one Naming Authority Pointer (NAPTR) (Mealling, M., “Dynamic Delegation Discovery System (DDDS) Part Three: The Domain Name System (DNS) Database,” October 2002.) [RFC3403] DNS Resource Record (RR) from a set of such RRs. That means the Enumservice Specification MUST define how to use the NAPTR RR and the URI(s) the NAPTR RR resolves to.

Specifically, a registered Enumservice MUST specify the URI Scheme(s) that may be used for the Enumservice, and, when needed, other information that will have to be transferred into the URI resolution process itself.

3.2.  Naming Requirements

The name of an Enumservice MUST be unique in order to be useful as a selection criteria:

• The Type MUST be unique.



• The Subtype (being dependent on the Type) MUST be unique within a given Type.

Types and Subtypes MUST conform to the ABNF specified in Section 3.4.3 of [I‑D.ietf‑enum‑3761bis] (Bradner, S., Conroy, L., and K. Fujiwara, “The E.164 to Uniform Resource Identifiers (URI) Dynamic Delegation Discovery System (DDDS) Application (ENUM),” June 2010.).

The ABNF specified in Section 3.4.3 of [I‑D.ietf‑enum‑3761bis] (Bradner, S., Conroy, L., and K. Fujiwara, “The E.164 to Uniform Resource Identifiers (URI) Dynamic Delegation Discovery System (DDDS) Application (ENUM),” June 2010.) allows the "-" (dash) character for Types and Subtypes . To avoid confusion with possible future prefixes, a "-" MUST NOT be used as the first nor as the second character of a Type nor a Subtype. Furthermore, a "-" MUST NOT be used as the last character of a Type nor a Subtype. In addition, Types and Subtypes are case insensitive and SHOULD be specified in lowercase letters.

Note: The legacy IANA Registry of Enumservices contains Type and Subtype strings with uppercase letters. Implementors could be tempted to refuse handling uppercase Type or Subtype strings, which could negatively affect interoperability.

To avoid confusion with Enumservice fields using a deprecated (obsolete) syntax, Type and Subtype MUST NOT start with the string "e2u".

The Subtype for one Type MAY have the same identifier as a Subtype for another Type but it is not sufficient to simply reference another Type's Subtype. The functionality of each Subtype MUST be fully specified in the context of the Type being registered.

Section 4 (Enumservice Creation Cookbook) contains further naming requirements.

3.3.  Security Requirements

An analysis of security issues is REQUIRED for all registered Enumservices. (This is in accordance with the basic requirements for all IETF protocols.)

All descriptions of security issues MUST be as accurate and extensive as feasible. In particular, a statement that there are "no security issues associated with this Enumservice" must not be confused with "the security issues associated with this Enumservice have not been assessed".

There is no requirement that an Enumservice must be completely free of security risks. Nevertheless, all known security risks MUST be identified in an Enumservice Specification.

Some of the issues to be looked at in a security analysis of an Enumservice are:

1. Complex Enumservices may include provisions for directives that institute actions on a user's resources. In many cases provision can be made to specify arbitrary actions in an unrestricted fashion which may then have devastating results (especially if there is a risk for a new ENUM look-up, and because of that an infinite loop in the overall resolution process of the E.164 number).



2. Complex Enumservices may include provisions for directives that institute actions which, while not directly harmful, may result in disclosure of information that either facilitates a subsequent attack or else violates the users' privacy in some way.



3. An Enumservice might be targeted for applications that require some sort of security assurance but do not provide the necessary security mechanisms themselves. For example, an Enumservice could be defined for storage of confidential security services information such as alarm systems or message service passcodes, which in turn require an external confidentiality service.

3.4.  Publication Requirements

Enumservices Specifications MUST be published according to the requirements for "Specification Required" set out in "Guidelines for Writing an IANA Considerations Section in RFCs" (Narten, T. and H. Alvestrand, “Guidelines for Writing an IANA Considerations Section in RFCs,” May 2008.) [RFC5226]. RFCs fulfill these requirements. Therefore, it is strongly RECOMMENDED to publish Enumservice Specifications as RFCs.

In case the Enumservice Specification is not published as an RFC, sufficient information that allows to uniquely identify the Enumservice Specification MUST be provided.

4.  Enumservice Creation Cookbook

4.1.  General Enumservice Considerations

ENUM is an extremely flexible identifier mapping mechanism, using E.164 (phone) numbers as input identifiers, and returning URIs as output identifiers. Because of this flexibility, almost every use case for ENUM could be implemented in several ways.

Section 2 of "Guidelines for Writing an IANA Considerations Section in RFCs" (Narten, T. and H. Alvestrand, “Guidelines for Writing an IANA Considerations Section in RFCs,” May 2008.) [RFC5226] provides motivation why management of a name space might be necessary. Even though the namespace for Enumservices is rather large (up to 32 alphanumeric characters), there are reasons to manage this in accordance with Section 2 of [RFC5226] (Narten, T. and H. Alvestrand, “Guidelines for Writing an IANA Considerations Section in RFCs,” May 2008.). The following is a list of motivations applying to Enumservices:

• Prevent hoarding or wasting of values: Enumservice Types are not an opaque identifier to prevent collisions in the namespace, but rather identify the use of a certain technology in the context of ENUM. Service Types might also be displayed to end users in implementations, so meaningful Type strings having a clear relation to the protocols and applications used are strongly RECOMMENDED. Therefore, preventing hoarding, wasting, or "hijacking" of Enumservice Type strings is important.



• Sanity check to ensure sensible or necessary requests: This applies to Enumservices, since especially various Enumservices for the same purpose would reduce the chance of successful interoperability, and unnecessarily increase the confusion among implementers.



• Delegation of namespace portions: Theoretically, the Type and/or Subtype structure of Enumservices would allow for delegations of Type values, and self-supporting management of Subtype values by a delegate within the Type value. Such delegates could for example be other standardization bodies. However, this would require clear policies regarding publication and use of such Subtypes. Delegation of Enumservice namespace portions is therefore currently not supported.



• Interoperability: Since the benefit of an Enumservice rises with the number of supporting clients, the registration and use of several services for a similar or identical purpose clearly reduces interoperability. Operational circumstances suggest to keep the space occupied by all services published in the NAPTR RRSet at any owner in the e164.arpa domain bounded. Registration of nearly identical services and subsequent competing or parallel use could easily increase the DNS operational complexity.

Generally, before commencing work on a new Enumservice registration, the following should be considered:

• Is there an existing Enumservice that could fulfill the desired functionality without overloading it? Check the IANA Enumservice Registry at <http://www.iana.org/assignments/enum-services>.



• Is there work in progress, or previous work, on a similar Enumservice? Check the <enum@ietf.org> mailing list archives at <http://www.ietf.org/mail-archive/web/enum/index.html>, and search the Internet-Drafts Archive at <http://tools.ietf.org/>. As some Internet-Drafts may have expired and no longer be available in the Internet-Drafts Archive, or some work on Enumservices may have been considered outside the IETF, we recommend also a web search.



• Section 4.2 (Classification, Type and Subtype) provides three general categories for Enumservice classification. In some cases, there might be several options for designing an Enumservice. For example, a mapping service using HTTP could be considered a "protocol Type" Enumservice (using HTTP as the protocol), while it could also be viewed as an "application Type" Enumservice, with the application being access to mapping services. In such a case where several options are available, defining use cases before commencing work on the Enumservice itself might be useful before making a decision on which aspect of the Enumservice is more important.

4.2.  Classification, Type and Subtype

Because of their flexibility, Enumservices can be and are used in a lot of different ways. This section contains a classification of Enumservices, and provides guidance for choosing suitable Type and Subtype strings for each individual Enumservice Class.

The Classification of each Enumservice MUST be listed in the Registration Document (see Section 5.2 (IANA Registration (REQUIRED))). If the Enumservice cannot be assigned to one of the classes outlined below, the Registration Document MUST contain a section on the difficulties encountered while trying to classify the service to help the experts in their decision.

4.2.1.  General Type / Subtype Considerations

To avoid confusion, the name of a URI Scheme MUST NOT be used as a Type string for an Enumservice which is not specifically about the respective protocol or URI Scheme. For example, the Type string "imap" would be inadequate for use in an Enumservice about "Internet mapping" services, because it corresponds to an existing URI Scheme / protocol for something different.

If Subtypes are defined, the minimum number SHOULD be two (including the empty Subtype, if defined). The choice of just one possible Subtype for a given Type does not add any information when selecting an ENUM record, and hence can be left out completely. However, potential future expansion of a Type towards several Subtypes may justify the use of Subtypes, even in the case just one is currently defined, as noted in Section 9 (Extension of Existing Enumservice Specifications).

It is perfectly legal under a certain Type to mix the Enumservice without a Subtype (empty Subtype) with Enumservices containing a Subtype. In that case, however, the Enumservice with an empty Subtype SHOULD be specified to reflect the base service, while the other Enumservices SHOULD be specified to reflect variants.

4.2.2.  Protocol-Based Enumservices Class

Such an Enumservice indicates that an interaction using the named protocol will result for use of this NAPTR. The expected behavior of a system using this Enumservice MUST be clear from the protocol.

A good indication that an Enumservice belongs to this Class is the fact that a client does not need to understand the actual application to make use of an instance of this Enumservice.

Examples of such Enumservices include "xmpp" (Mayrhofer, A., “IANA Registration for Enumservice 'XMPP',” August 2007.) [RFC4979] and "sip" (Peterson, J., “enumservice registration for Session Initiation Protocol (SIP) Addresses-of-Record,” April 2004.) [RFC3764].

4.2.2.1.  Protocol-Based Enumservice "Type" Strings

A protocol-based Enumservice SHOULD use the lowercase name of the protocol as its Type string. Names as registered in the IANA Port Number Registry (<http://www.iana.org/assignments/port-numbers>, defined in Section 8 and 9 of [RFC2780] (Bradner, S. and V. Paxson, “IANA Allocation Guidelines For Values In the Internet Protocol and Related Headers,” March 2000.)) are preferred.

4.2.2.2.  Protocol-Based Enumservice "Subtype" Strings

Where there is a single URI Scheme associated with this protocol, a Subtype SHOULD NOT be specified for the Enumservice.

Where there are a number of different URI Schemes associated with this protocol, the Enumservice Specification MAY use the empty Subtype for all URI Schemes that it specifies as mandatory to implement. For each URI Scheme that is not mandatory to implement a distinct Subtype string MUST be used.

If Subtypes are defined, it is RECOMMENDED to use the URI Scheme name as the Subtype string.

4.2.3.  Application-Based Enumservice Classes

Application-based Enumservices are used when the kind of service intended is not fully defined by a protocol specification. There are three cases here:

• Common Application Enumservice:
  
  The application reflects a kind of interaction that can be realized by different protocols, but where the intent of the publisher is the same. From a user's perspective, there is a common kind of interaction - how that interaction is implemented is not important. The Enumservice Specification MUST describe the interaction and expected behavior in enough detail that an implementation can decide if this activity is one in which it can engage. However, it is RECOMMENDED that the Enumservice is defined in a way that will allow others to use it at a later date. An Enumservice that defines a generalized application is preferred to one that has narrow use.
  
  An example of this flavor of Enumservice is email. Whilst this might appear to be a "pure" protocol scheme, it is not. The URI Scheme is 'mailto', and does not identify the protocol used by the sender or the recipient to offer or retrieve emails.
  
  Another example is SMS, where the existence of such an Enumservice indicates that the publishing entity is capable of engaging in sending or receiving a message according to the Short Messaging Service specifications. The underlying protocol used and the URI Scheme for the addressable end point can differ, but the "user visible" interaction of sending and receiving an SMS is similar.



• Subset Enumservice:
  
  The application interaction reflects a subset of the interactions possible by use of a protocol. Use of this Enumservice indicates that some options available by use of the protocol will not be accepted or are not possible in this case. Any such Enumservice Specification MUST define the options available by use of this NAPTR in enough detail that an implementation can decide whether or not it can use this Enumservice. Examples of this kind of Enumservice are "voice:tel" and "fax:tel". In both cases the URI holds a telephone number. However, the essential feature of these Enumservices is that the telephone number is capable of receiving a voice call or of receiving a Facsimile transmission, respectively. These form subsets of the interactions capable of using the telephone number, and so have their own Enumservices. These allow an end point to decide if it has the appropriate capability of engaging in the advertised user service (a voice call or sending a fax) rather than just being capable of making a connection to such a destination address. This is especially important where there is no underlying mechanism within the protocol to negotiate a different kind of user interaction.



• Ancillary Application Enumservice
  
  Another variant on this is the Ancillary Application. This is one in which further processing (potentially using a number of different protocols or methods) is the intended result of using this Enumservice. An example of this kind of application is the "pstn:tel" Enumservice. This indicates that the NAPTR holds Number Portability data. It implies that the client should engage in number portability processing using the associated URI. Note that this Enumservice usually does not itself define the kind of interaction available using the associated URI. That application is negotiated with some other "out of band" means (either through prior negotiation, or explicitly through the number portability process, or through negotiation following the selection of the final destination address).

4.2.3.1.  Application-Based Enumservice "Type" Strings

It is recommended that Application-class Enumservices use the lowercase well known name of the abstract application as Type string.

4.2.3.2.  Application-Based Enumservice "Subtype" Strings

It is RECOMMENDED to use the URI Scheme(s) which the application uses, as Subtype string(s). Subtype strings MAY be shared between URI Schemes, if all the URI Schemes within the same Subtype are mandatory to implement.

If it is foreseen that there is only one URI Scheme ever to be used with the application, the empty Subtype string MAY be used.

4.2.4.  Data Type-Based Enumservice Class

"Data Type" Enumservices typically refer to a specific data type or format, which may be addressed using one or more URI Schemes and protocols. Examples of such Enumservices include "vpim" (Vaudreuil, G., “Voice Message Routing Service,” October 2005.) [RFC4238] and "vcard" (Mayrhofer, A., “IANA Registration for vCard Enumservice,” August 2007.) [RFC4969].

4.2.4.1.  Data Type-Based Enumservice "Type" Strings

It is recommended to use the lowercase well known name of the data type or format name as the Type string.

4.2.4.2.  Data Type-Based Enumservice "Subtype" Strings

It is RECOMMENDED to use the URI Schemes used to access the service as Subtype strings. Subtype strings MAY be shared between URI Schemes, if all the URI Schemes within the same Subtype are mandatory to implement.

If there is only one URI Scheme foreseen to access the data type or format, the empty Subtype string MAY be used.

4.2.5.  Other Enumservice

In case an Enumservice proposal cannot be assigned to any of the classes mentioned above, the <class> element (Enumservice Class) in the IANA Registration Template (see Section 5.2 (IANA Registration (REQUIRED))) MUST be populated with "Other". In that case, the Enumservice Specification MUST contain a section elaborating on why the Enumservice does not fit into the classification structure.

5.  Required Sections and Information

There are several sections that MUST appear in an Enumservice Specification. These sections are as follows, and SHOULD be in the given order.

The following terms SHOULD begin with a capital letter, whenever they refer to the IANA Registration:

• Class
• Type
• Subtype
• URI Scheme

5.1.  Introduction (REQUIRED)

An introductory section MUST be included. This section will explain, in plain English, the purpose and intended use of the proposed Enumservice registration.

The Introduction SHOULD start with a short sentence about ENUM, introduce the protocol used in the Enumservice, and discuss the Enumservice as it refers from the E.164 number to the protocol or service.

5.2.  IANA Registration (REQUIRED)

This section MUST be included in an Enumservice Specification. Where a given Enumservice Type has multiple Subtypes, there MUST be a separate "IANA Registration" section for each Subtype. The following lists the elements that are to be used in the XML chunk based Registration Template of an "IANA Registration" section.

5.2.1.  Enumservice Class (<class>)

This element contains the Class of the Enumservice as defined in Section 4.2 (Classification, Type and Subtype). Its value MUST be one of (without quotes):

• "Protocol-Based": The Enumservice belongs to the Protocol-based class as described in Section 4.2.2 (Protocol-Based Enumservices Class).



• "Application-Based, Common": The Enumservice is a "common" case of the Application-based class as described in Section 4.2.3 (Application-Based Enumservice Classes).



• "Application-Based, Subset": The Enumservice belongs to the "subset" case of the Application-based class as described in Section 4.2.3 (Application-Based Enumservice Classes).



• "Application-Based, Ancillary": The Enumservice is an "ancillary" case of the Application-based class, as described in Section 4.2.3 (Application-Based Enumservice Classes).



• "Data Type-Based": The Enumservice belongs to the Data Type-Based class as described in Section 4.2.4 (Data Type-Based Enumservice Class).



• "Other": The majority of the functionality of the Enumservice does not fall into one of the classes defined.

e.g.   <class>Protocol-Based</class>

5.2.2.  Enumservice Type (<type>)

The Type of the Enumservice. All Types SHOULD be listed in lower-case. The choice of Type depends on the Enumservice Class. Please find further instructions in Section 4 (Enumservice Creation Cookbook).

e.g.   <type>foo</type>

5.2.3.  Enumservice Subtype (<subtype>)

The Subtype of the Enumservice. All Subtypes SHOULD be listed in lower-case. The choice of Subtype depends on the Enumservice Class. Should the Enumservice not utilize a Subtype, then the <subtype> element MUST be omitted in the IANA Registration Template. If a given Enumservice Type has multiple Subtypes, then there MUST be a separate IANA Registration Template for each Subtype. Please find further instructions in Section 4 (Enumservice Creation Cookbook).

e.g.   <subtype>bar</subtype>

5.2.4.  URI Scheme(s) (<urischeme>)

The URI Schemes [RFC3986] (Berners-Lee, T., Fielding, R., and L. Masinter, “Uniform Resource Identifier (URI): Generic Syntax,” January 2005.) that are used with the Enumservice. The selection of URI Schemes often depends on the Enumservice Class, Type, and/or Subtype. A colon MUST NOT be placed after the URI Scheme name. If there is more than one URI Scheme, then one <urischeme> element per URI scheme MUST be used in the IANA Registration Template. Please find further instructions in Section 4 (Enumservice Creation Cookbook).

e.g.   <urischeme>bar</urischeme>
       <urischeme>sbar</urischeme>

Note: A client cannot choose a specific ENUM record in a record set based on the URI Scheme - the selection is only based on Type and Subtype, in accordance with [RFC3402] (Mealling, M., “Dynamic Delegation Discovery System (DDDS) Part Two: The Algorithm,” October 2002.).

5.2.5.  Functional Specification (<functionalspec>)

The Functional Specification describes how the Enumservice is used in connection with the URI to which it resolves.

e.g.   <functionalspec>
         <paragraph>
           This Enumservice indicates that the resource
           identified can be addressed by the associated
           URI in order to foo the bar.
         </paragraph>
         <paragraph>
           [...]
         </paragraph>
       </functionalspec>

Where the terms used are non-obvious, they should be defined in the Enumservice Specification, or a reference to an external document containing their definition should be provided.

5.2.6.  Security Considerations (<security>)

A reference to the "Security Considerations" section of a given Enumservice Specification.

e.g.   <security>
         See <xref type="rfc" data="rfc4979"/>, Section 6.
       </security>

5.2.7.  Intended Usage (<usage>)

One of the following values (without quotes):

• "COMMON": Indicates that the Enumservice is intended for widespread use on the public Internet, and that its scope is not limited to a certain environment.



• "LIMITED USE": Indicates that the Enumservice is intended for use on a limited scope, for example in private ENUM-like application scenarios. The use case provided in the Enumservice Specification should describe such a scenario.



• "DEPRECATED": Indicates that the Enumservice has been declared deprecated (Section 11.7 (Change Control)) and is not to be used in new deployments. Applications SHOULD however expect to encounter legacy instances of this Enumservice.

e.g.   <usage>COMMON</usage>

5.2.8.  Enumservice Specification (<registrationdocs>)

Reference(s) to the Document(s) containing the Enumservice Specification.

e.g.   <registrationdocs>
         <xref type="rfc" data="rfc4979"/>
       </registrationdocs>


e.g.   <registrationdocs>
         <xref type="rfc" data="rfc2026"/> (obsoleted by RFC 2551)
         <xref type="rfc" data="rfc2551"/>
       </registrationdocs>


e.g.   <registrationdocs>
         [International Telecommunications Union,
         "Enumservice Specification for Foobar",
         ITU-F Recommendation B.193, Release 73, Mar 2009.]
       </registrationdocs>

5.2.9.  Requesters (<requesters>)

The persons requesting the registration of the Enumservice. Usually these are the authors of the Enumservice specification.

e.g.   <requesters>
         <xref type="person" data="John_Doe"/>
       </requesters>

       [...]

       <people>
         <person id="John_Doe">
           <name>John Doe</name>
           <org>ACME Research and Development Inc.</org>
           <uri>mailto:jd@acme.example.com</uri>
           <updated>2008-11-20</updated>
         </person>
       </people>

If there is more than one requester, there MUST be one <xref> element per requester in the <requesters> element, and one <person> chunk per requester in the <people> element.

5.2.10.  Further Information (<additionalinfo>)

Any other information the authors deem interesting, including artwork.

e.g.   <additionalinfo>
         <paragraph>more info goes here</paragraph>
       </additionalinfo>

Note: If there is no such additional information, then the <additionalinfo> element is omitted.

5.3.  Examples (REQUIRED)

This section MUST show at least one example of the Enumservice being registered, for illustrative purposes. The example(s) shall in no way limit the various forms that a given Enumservice may take, and this should be noted at the beginning of this section of the document. The example(s) MUST show the specific formatting of the intended NAPTRs (according to [RFC3403] (Mealling, M., “Dynamic Delegation Discovery System (DDDS) Part Three: The Domain Name System (DNS) Database,” October 2002.) and [I‑D.ietf‑enum‑3761bis] (Bradner, S., Conroy, L., and K. Fujiwara, “The E.164 to Uniform Resource Identifiers (URI) Dynamic Delegation Discovery System (DDDS) Application (ENUM),” June 2010.)), including one or more NAPTR example(s), AND a brief textual description, consisting of one or more sentences written in plain English, explaining the various parts or attributes of the record(s).

The example(s) SHOULD contain a brief description how a client supporting this Enumservice could behave, if that description was not already given in e.g. the Introduction or the Functional Specification.

The example(s) SHOULD follow any relevant IETF guidelines on the use of domain names, phone numbers, and other resource identifier examples, such as [RFC2606] (Eastlake, D. and A. Panitz, “Reserved Top Level DNS Names,” June 1999.).

e.g.
$ORIGIN 9.7.8.0.6.9.2.3.6.1.4.4.e164.arpa.
@ IN NAPTR 100 10 "u" "E2U+foo:bar" "!^.*$!bar://example.com/!" .

5.4.  Implementation Recommendations / Notes (OPTIONAL)

Recommendations that pertain to implementation and/or operations SHOULD be included. Such a section is helpful to someone reading an Enumservice Specification and trying to understand how best to use it to support their network or service.

5.5.  Security Considerations (REQUIRED)

A section explaining any potential security threats which are especially applicable to the given registration MUST be included. This MUST also include any information about access to Personally Identifiable Information (PII).

An Enumservice Specification SHOULD NOT include general and obvious security recommendations, such as securing servers with strong password authentication.

For additional background, please note that [RFC3552] (Rescorla, E. and B. Korver, “Guidelines for Writing RFC Text on Security Considerations,” July 2003.) provides guidance to write a good Security Considerations section. In addition, [I‑D.ietf‑enum‑3761bis] (Bradner, S., Conroy, L., and K. Fujiwara, “The E.164 to Uniform Resource Identifiers (URI) Dynamic Delegation Discovery System (DDDS) Application (ENUM),” June 2010.) already outlines security considerations affecting ENUM as a whole. Enumservice Specifications do not need to and SHOULD NOT repeat considerations already listed in that document. However, Enumservice Specifications SHOULD include a reference to that section.

Also, ENUM refers to resources using existing URI Schemes and protocols. Enumservice Specifications do not need to and SHOULD NOT repeat security considerations affecting those protocols and URI Schemes themselves.

However, in some cases, the inclusion of those protocols and URI Schemes into ENUM specifically could introduce new security issues. In these cases, those issues or risks MUST be covered in the "Security Considerations" section of the Enumservice Specification. Authors should pay particular attention to any indirect risks that are associated with a proposed Enumservice, including cases where the proposed Enumservice could lead to the discovery or disclosure of Personally Identifiable Information (PII).

5.6.  IANA Considerations (REQUIRED)

Describe the task IANA needs to fulfill processing the Enumservice Registration Document.

e.g.
This document requests the IANA registration of the Enumservice with Type "foo" and Subtype "bar" according to the definitions in this document, RFC XXXX [Note for RFC Editor: Please replace XXXX with the RFC number of this document before publication] and [I‑D.ietf‑enum‑3761bis] (Bradner, S., Conroy, L., and K. Fujiwara, “The E.164 to Uniform Resource Identifiers (URI) Dynamic Delegation Discovery System (DDDS) Application (ENUM),” June 2010.).

e.g.
This document requests an update of the IANA registration of the Enumservice Type "foo" with Subtype "bar", according to the definitions in this document, RFC XXXX [Note for RFC Editor: Please replace XXXX with the RFC number of this document before publication] and [I‑D.ietf‑enum‑3761bis] (Bradner, S., Conroy, L., and K. Fujiwara, “The E.164 to Uniform Resource Identifiers (URI) Dynamic Delegation Discovery System (DDDS) Application (ENUM),” June 2010.). Therefore, in the existing IANA registration for this Enumservice, the <registrationdocs> element (Enumservice Specification) is enhanced by adding a supplementary reference that points to this document.

e.g.
This document requests an update of the IANA registration of the Enumservice Type "foo" with all its Subtypes, in order to declare it deprecated. Therefore, in the existing IANA registration for this Enumservice, the <usage> element (Intended Usage) is changed to "DEPRECATED", and the <registrationdocs> element (Enumservice Specification) is enhanced by adding a supplementary reference that points to this document.

5.7.  DNS Considerations (REQUIRED)

In case the inclusion of protocols and URI Schemes into ENUM specifically introduces new DNS issues, those MUST be described within this section.

Such DNS issues include, but are not limited to:

• Assumptions about ownership or administrative control of the namespace.
  
  
• Requirement or need to use DNS wildcards.
  
  
• Incompatibility with DNS wildcards.
  
  
• Presence or absence of respective NAPTR Resource Records at particular levels in the DNS hierarchy (e.g. only for "full" E.164 numbers, or wildcards only).
  
  
• Use of any Resource Records (especially non-NAPTR) within or beyond the e164.arpa namespace other than those needed to resolve the domain names that appear in the "replacement" URI.



• Potential for significant additional load on the nameserver chain due to use of the service, and the mitigation of such additional load.



• Mitigation of potential for DNS loops, specifically in cases where the result URI of an Enumservice might be used to trigger additional (subsequent) ENUM queries. This applies in particular to Enumservices using the 'tel' URI scheme (Schulzrinne, H., “The tel URI for Telephone Numbers,” December 2004.) [RFC3966] or any other (future) URI scheme using (E.164) numbers. The "ENUM Dip Indicator Parameter for the 'tel' URI scheme" (Stastny, R., Shockey, R., and L. Conroy, “The ENUM Dip Indicator Parameter for the "tel" URI,” December 2006.) [RFC4759] provides an example of a loop mitigation mechanism.

Rationale: some Enumservices try to exploit side effects of the DNS that need to be explicitly discussed.

5.8.  Other Sections (OPTIONAL)

Other sections beyond those required above MAY be included in an Enumservice Specification. These sections may relate to the specifics of the intended use of the Enumservice registration, as well as to any associated technical, operational, administrative, or other concerns.

A use case SHOULD be included by the authors of the proposal, so that experts can better understand the problem the proposal seeks to solve (intended use of the Enumservice). The inclusion of such a use case will both accelerate the Expert Review process, as well as make any eventual registration easier to understand and implement by other parties.

6.  The Process of Registering New Enumservices

This section is an illustration of the process by which a new Enumservice Registration Document is submitted for review and comment, how such proposed Enumservices are reviewed, and how they are published. This section is a non-normative description of the process. The normative process is described in [RFC5226] (Narten, T. and H. Alvestrand, “Guidelines for Writing an IANA Considerations Section in RFCs,” May 2008.).

Figure 1 shows what authors of a Registration Document describing an Enumservice must carry out before said Registration Document can be formally submitted to IANA for Expert Review. Figure 2 shows the process from Expert Review onwards.

                  +----------------------------+
                  | Step 1: Read this document |
                  +----------------------------+
                               |
                               V
                +-------------------------------+
                | Step 2:  Write R-D and submit |
                +-------------------------------+
                               |
                               V
          +--------------------------------------------+
          | Step 3:  Announce R-D and solicit feedback |<--+
          +--------------------------------------------+   |
                               |                           |
                               V                           |
                              .^.                          |
                            .     .                        |
+------------+            .  Feed-  .               +------------+
| Update R-D |<---------<    back     >------------>| Update R-D |
| and submit |  non-sub-  . results .   substantial | and submit |
+------------+  stantial    . in: .     changes     +------------+
      |         changes       . .       needed
      |         needed         Y
      |                        | no changes needed
      |                        V
      |         +-----------------------------+
      +-------->| Step 4:  Submit R-D to IANA |
                +-----------------------------+
                               :
                               :
                               V

R-D: Registration Document

6.1.  Step 1: Read This Document in Detail

This document, particularly in Sections 3 (Registration Requirements), 4 (Enumservice Creation Cookbook), and 5 (Required Sections and Information), describes all of the recommended and required sections, as well as requirements and suggestions for content of an Enumservice Specification.

6.2.  Step 2: Write and Submit Registration Document

An Internet-Draft (or another specification as appropriate) must be written and made publicly available (submitted). The Registration Document shall follow the guidelines according to Sections 4 (Enumservice Creation Cookbook) and 5 (Required Sections and Information) of this document. The Review Guidelines for experts are defined in Section 7.2 (Review Guidelines).

6.3.  Step 3: Request Comments From the IETF Community

The authors shall send an email to <enum@ietf.org>, in which comments on the Registration Document are requested. A proper public reference (a URL is recommended) to the Registration Document must be included in this email.

Note: The ENUM WG mailing list <enum@ietf.org> will be kept open after conclusion of the ENUM WG.

The authors should allow a reasonable period of time to elapse, such as two to four weeks, in order to collect any feedback. The authors then consider whether or not to take any of those comments into account, by making changes to the Registration Document and submitting a revision, or otherwise proceeding. The following outcomes are open to the authors. The choice of path is left to the authors' judgement.

Note: Whatever the outcome is, the experts performing the Expert Review later in the processs are not bound to any decision during this phase.

6.3.1.  Outcome 1: No Changes Needed

No changes to the Registration Document are made, and the authors proceed to Step 4 below.

This outcome is recommended when the feedback received does not lead to a new revision of the Registration Document.

6.3.2.  Outcome 2: Changes, But No Further Comments Requested

The authors update the Registration Document and is/are confident that all issues are resolved and do not require further discussion. The authors proceed to Step 4 below.

This outcome is recommended when minor objections have been raised, or minor changes have been suggested.

6.3.3.  Outcome 3: Changes and Further Comments Requested

The authors update and submit the Registration Document, and proceed to Step 3 above, which involves sending another email to <enum@ietf.org> to request additional comments for the updated version.

This outcome is recommended when substantial objections have been raised, or substantial changes have been suggested.

6.4.  Step 4: Submit Registration Document to IANA

The authors submit the Registration Document to IANA (using the <http://www.iana.org/> website) for Expert Review.

                               :
                               :
                               V
                    +-----------------------+
                    | Step 5: Expert Review |<-------------+
                    +-----------------------+              |
                               |                           |
                               V                           |
                              .^.                          |
                            .     .                        |
  .---------.             .  Expert .               +------------+
 ( Bad luck! )<-------- <    Review   >------------>| Update R-D |
  `---------'   experts   . results .   changes     | and submit |
                reject      . in: .     required    +------------+
                              . .
                               Y
                               | experts approve
                               V
             +-----------------------------------+
             | Step 6: Publication of R-D        |
             +-----------------------------------+
                               |
                               V
        +---------------------------------------------+
        | Step 7: Adding Enumservice to IANA Registry |
        +---------------------------------------------+

R-D: Registration Document

6.5.  Step 5: Expert Review

IANA will take care of the "Expert Review" according to [RFC5226] (Narten, T. and H. Alvestrand, “Guidelines for Writing an IANA Considerations Section in RFCs,” May 2008.). The Expert Review guidelines are outlined in Section 7.2 (Review Guidelines) of this document. The authors must be prepared for further interaction with IANA and the experts.

6.5.1.  Outcome 1: Experts Approve the Registration Document

No (more) changes to the Registration Document are made. IANA will inform the authors, who then will proceed to Step 6 below.

6.5.2.  Outcome 2: Changes Required

The experts might require changes before they can approve the Registration Document. The authors update and submit the Registration Document. The authors inform the experts about the available update, who then continue the Expert Review Process.

6.5.3.  Outcome 3: Experts Reject the Registration Document

The expert might reject the Registration, which means the Expert Review process is discontinued.

6.6.  Step 6: Publication of the Registration Document

The authors are responsible that the Registration Document is published according to "Specification Required" as defined in [RFC5226] (Narten, T. and H. Alvestrand, “Guidelines for Writing an IANA Considerations Section in RFCs,” May 2008.).

As set out in Section 3.4 (Publication Requirements) it is strongly recommended to publish Enumservice Specifications as RFCs. As to every RFC the normal IETF publication process applies (see [Instructions2authors] (Reynolds, J. and R. Braden, “Instructions to Request for Comments (RFC) Authors,” August 2004.)); i.e. the Registration Document is submitted in the form of an Internet Draft (e.g. via an IETF Working Group or a sponsoring Area Director). [Instructions2authors] (Reynolds, J. and R. Braden, “Instructions to Request for Comments (RFC) Authors,” August 2004.) also contains an option to publish an RFC as 'Independent Submission', which is further described in "Independent Submissions to the RFC Editor" (Klensin, J. and D. Thaler, “Independent Submissions to the RFC Editor,” July 2007.) [RFC4846].

6.7.  Step 7: Adding Enumservice to IANA Registry

In case the Registration Document is to be published as an RFC, the RFC publication process ensures that IANA will add the Enumservice to the Registry.

In case the Registration Document is to be published in a specification other than RFC, the authors must inform IANA, as soon as the Enumservice Specification has been published according to "Specification Required" as defined in [RFC5226] (Narten, T. and H. Alvestrand, “Guidelines for Writing an IANA Considerations Section in RFCs,” May 2008.). The <registrationdocs> element in the IANA Registration Template must contain an unambiguous reference to the Enumservice Specification (see also Section 5.2 (IANA Registration (REQUIRED))). In addition, the authors must provide IANA with a stable URL to the Enumservice Specification, in order that IANA may obtain the information included in the Enumservice Specification. IANA will then add the Enumservice to the Registry.

7.  Expert Review

7.1.  Expert Selection Process

According to Section 3.2 of [RFC5226] (Narten, T. and H. Alvestrand, “Guidelines for Writing an IANA Considerations Section in RFCs,” May 2008.), experts are appointed by the IESG. The IESG is responsible for ensuring that there is always a sufficient pool of experts available.

7.2.  Review Guidelines

Generally, the "Expert Review" process of an Enumservice follows the guidelines documented in Section 3.3 of "Guidelines for Writing an IANA Considerations Section in RFCs" (Narten, T. and H. Alvestrand, “Guidelines for Writing an IANA Considerations Section in RFCs,” May 2008.) [RFC5226]. Note that RFC 5226 says 'The review may be wide or narrow, depending on the situation and the judgment of the designated expert'. Therefore, the following list should be considered a guideline, rather than a binding list.

In case of conflicts between [RFC5226] (Narten, T. and H. Alvestrand, “Guidelines for Writing an IANA Considerations Section in RFCs,” May 2008.) and the guidelines in this section, [RFC5226] (Narten, T. and H. Alvestrand, “Guidelines for Writing an IANA Considerations Section in RFCs,” May 2008.) remains authoritative.

The expert evaluates the criterion as set out in [RFC5226] (Narten, T. and H. Alvestrand, “Guidelines for Writing an IANA Considerations Section in RFCs,” May 2008.), and should additionally consider the following:

• Verify conformance with the ENUM specification (Bradner, S., Conroy, L., and K. Fujiwara, “The E.164 to Uniform Resource Identifiers (URI) Dynamic Delegation Discovery System (DDDS) Application (ENUM),” June 2010.) [I‑D.ietf‑enum‑3761bis].



• Verify that the requirements set out in this document (Sections 3 (Registration Requirements) and 5 (Required Sections and Information)) are met. This includes check for completeness and whether all the aspects described in Sections 3 (Registration Requirements) and 5 (Required Sections and Information) are sufficiently addressed.



• If a use case is provided, the experts should verify whether the proposed Enumservice does actually match the use case. The experts should also determine whether the use case could be covered by an existing Enumservice.



• Verify that the Enumservice proposed cannot be confused with identical (or similar) other Enumservices already registered.



• If the Enumservice is classified according to Section 4.2 (Classification, Type and Subtype), the experts must verify that the principles of the Class in question are followed.



• In case the Enumservice is not classified, the experts must verify whether a convincing reason for the deviation is provided in the Registration Document.



• Investigate whether the proposed Enumservice has any negative side effects on existing clients and infrastructure, particularly the DNS.



• If the output of processing an Enumservice might be used for input to more ENUM processing (especially services returning 'tel' URIs), the experts should verify that the authors have adequately addressed the issue of potential query loops.

7.3.  Appeals

Appeals of Expert Review decisions follow the process described in section 7 of [RFC5226] (Narten, T. and H. Alvestrand, “Guidelines for Writing an IANA Considerations Section in RFCs,” May 2008.) and section 6.5 of [RFC2026] (Bradner, S., “The Internet Standards Process -- Revision 3,” October 1996.).

8.  Revision of Existing Enumservice Specifications

Many Enumservice Registrations, published via IETF RFCs, already exist at the time of the development of this document. These existing Enumservice Specifications MAY be revised to comply with the specifications contained herein. All revisions of Enumservice Specifications MUST be compliant with the specifications contained herein.

Note: Enumservice Specifications updated only by [I‑D.ietf‑enum‑enumservices‑transition] (Hoeneisen, B. and A. Mayrhofer, “Update of legacy IANA Registrations of Enumservices,” July 2010.) are not compliant with the specifications contained herein!

9.  Extension of Existing Enumservice Specifications

There are cases where it is more sensible to extend an existing Enumservice registration rather than proposing a new one. Such cases include adding a new Subtype to an existing Type. Depending on the nature of the extension, the original Enumservice Specification needs to be extended (Updates) or replaced (Obsoletes) [RFC2223] (Postel, J. and J. Reynolds, “Instructions to RFC Authors,” October 1997.). Specifically, an update is appropriate when a new Subtype is being added without changes to the existing repertoire. A replacement is needed if there is a change to the default, or changes to the assumptions of URI support in clients.

Any Enumservice Specifications for existing Enumservices that are extended MUST comply with the specifications contained herein. As a consequence, revisions of existing Enumservice Specifications according to Section 8 (Revision of Existing Enumservice Specifications) may be required.

10.  Security Considerations

10.1.  Considerations Regarding This Document

Since this document does not introduce any new technology, protocol, or Enumservice Specification, there are no specific security issues to be considered for this document. However, as this is a guide to authors of new Enumservice Specifications, the next section should be considered closely by authors and experts.

10.2.  Enumservice Security Considerations Guideline

Guidelines concerning the Security Considerations section of an Enumservice Specification can be found in Section 5.5 (Security Considerations (REQUIRED)).

11.  IANA Considerations

11.1.  Registry Update

IANA will update the Registry "Enumservice Registrations" as defined in (this) Section 11 (IANA Considerations), which will replace the old mechanism as defined in RFC 3761 (Faltstrom, P. and M. Mealling, “The E.164 to Uniform Resource Identifiers (URI) Dynamic Delegation Discovery System (DDDS) Application (ENUM),” April 2004.) [RFC3761].

It is noted that the process described herein applies only to ordinary Enumservice registrations (i.e. the registration process of "X-" Enumservices is beyond the scope of this document, and as per [I‑D.ietf‑enum‑3761bis] (Bradner, S., Conroy, L., and K. Fujiwara, “The E.164 to Uniform Resource Identifiers (URI) Dynamic Delegation Discovery System (DDDS) Application (ENUM),” June 2010.) "P-" Enumservices will not be registered at all).

11.2.  Registration Template (XML chunk)

        <record>
          <class> <!-- Enumservice Class --> </class>
          <type> <!-- Type --> </type>
          <subtype> <!-- Subtype --> </subtype>
          <urischeme> <!-- URI Schema Name --> </urischeme>
          <urischeme> <!-- another URI Schema Name --> </urischeme>
          <functionalspec>
            <paragraph>
              <!-- Text that explains the functionality of
                   the Enumservice to be registered -->
            </paragraph>
          </functionalspec>
          <security>
              <!-- Security Considerations of the
                   Enumservice to be registered -->
          </security>
          <usage> <!-- COMMON, LIMITED USE or OBSOLETE --> </usage>
          <registrationdocs>
            <!-- Change accordingly -->
            <xref type="rfc" data="rfc2551"/>
          </registrationdocs>
          <requesters>
            <!-- Change accordingly -->
            <xref type="person" data="John_Doe"/>
            <xref type="person" data="Jane_Dale"/>
          </requesters>
          <additionalinfo>
            <paragraph>
              <!-- Text with additional information about
                   the Enumservice to be registered -->
            </paragraph>
            <artwork>
              <!-- There can be artwork sections, too -->
              :-)
            </artwork>
          </additionalinfo>
        </record>

       <people>
         <person id="John_Doe">
           <name> <!-- Firstname Lastname --> </name>
           <org> <!-- Organisation Name --> </org>
           <uri> <!-- mailto: or http: URI --> </uri>
           <updated> <!-- date format YYYY-MM-DD --> </updated>
         </person>
         <!-- repeat person section for each person -->
       </people>

Authors of Enumservice Specification are encouraged to use these XML chunks as a template to create the IANA Registration Template. Examples for the use of this template are contained in Appendix A (IANA Registration Template Examples).

11.3.  Location

Approved Enumservice registrations are published in the IANA Registry named "Enumservice Registrations", which is available at the following URI:
< http://www.iana.org/assignments/enum-services >.

This Registry publishes representations derived from the IANA Registration Template as described in Section 11.2 (Registration Template (XML chunk)) and specified in Section 5.2 (IANA Registration (REQUIRED)).

Where the Enumservice Specification is not an RFC, IANA must hold an escrow copy of that Enumservice Specification. Said escrow copy will act as the master reference for that Enumservice Registration.

11.4.  Structure

IANA maintains the Enumservice Registry sorted in alphabetical order. The first sort field is Type, the second is Subtype.

Each Enumservice starts with a caption, which is composed of Type and Subtype, separated by a colon; e.g. if the Type is "foo" and the Subtype "bar", the resulting caption is "foo:bar".

[I‑D.ietf‑enum‑enumservices‑transition] (Hoeneisen, B. and A. Mayrhofer, “Update of legacy IANA Registrations of Enumservices,” July 2010.) updates the existing Enumservices by transforming them into the new XML chunk based IANA Registration Template (see also Section 8 (Revision of Existing Enumservice Specifications)).

11.5.  Expert Review Procedure

Whenever a Registration Document is submitted via the IANA website, IANA will take care of the "Expert Review" process according to "Guidelines for Writing an IANA Considerations Section in RFCs" (Narten, T. and H. Alvestrand, “Guidelines for Writing an IANA Considerations Section in RFCs,” May 2008.) [RFC5226].

To prevent clashes IANA will check whether a request with identical "type:subtype" (or "type" without Subtype) was submitted for Expert Review earlier and will inform the experts accordingly. The experts are authorized to resolve clashes as they see fit. The requesters may need to update their registration request before getting expert approval.

Once the experts have conditionally approved the Enumservice, IANA will inform the authors. This information should also include a reminder that (i) the authors are now responsible for publication of the Registration Document (see also Section 6.6 (Step 6: Publication of the Registration Document)) and (ii) the Enumservice will be added to the IANA Registry only after its Enumservice Specification is published according to the "Specification Required" policy as defined in [RFC5226] (Narten, T. and H. Alvestrand, “Guidelines for Writing an IANA Considerations Section in RFCs,” May 2008.) (see also Section 6.7 (Step 7: Adding Enumservice to IANA Registry)).

Note: After sending the approval note to the authors, IANA has no further responsibilities besides keeping internal records of approved Registration Documents. IANA will be involved again at registration of the Enumservice (see Section 11.6 (Registration Procedure)).

11.6.  Registration Procedure

There is a slight difference in process depending on whether or not the Enumservice Specification will be published as an RFC. The reason for this difference lies in the current RFC publication process that includes IANA interaction shortly before publication of an RFC.

11.6.1.  Published as RFC

As per the RFC publication process IANA will receive the Enumservice Specification to carry out IANA actions shortly before publication of the RFC. The IANA action will be to register the Enumservice, i.e. add the Enumservice to the IANA "Enumservice Registrations" Registry (see also Section 11.3 (Location)).

IANA must only add Enumservices to the Registry, if the experts have approved the corresponding Enumservice Specification as to be published. IANA should attempt to resolve possible conflicts arising from this together with the experts. In case changes between the (conditionally) approved and the to be published version are substantial, IANA may reject the request after consulting the experts.

IANA must ensure that any further substantial changes the Enumservice Specification might undergo before final RFC publication are approved by the experts.

Note: Clearly editorial changes (such as typos) or minor changes in purely editorial sections (such as Authors' Addresses, Acknowledgments, References, and alike) are not considered substantial.

11.6.2.  Published as a Non-RFC

Once the authors have informed IANA about the publication, IANA must ensure that the requirements to "Specification Required" as defined in [RFC5226] (Narten, T. and H. Alvestrand, “Guidelines for Writing an IANA Considerations Section in RFCs,” May 2008.) are met, the reference to the specification is unambiguous, and the content of the Enumservice Specification is identical to the Registration Document as approved by the experts. IANA will then register the Enumservice, i.e. add the Enumservice to the IANA "Enumservice Registrations" Registry, and make an escrow copy (see also Section 11.3 (Location)).

IANA must only add Enumservices to the Registry, if the experts have approved the corresponding Enumservice Specification as published. IANA should attempt to resolve possible conflicts arising from this together with the experts. In case changes between the approved and the published version are substantial, IANA may reject the request after consulting the experts.

Note: Clearly editorial changes (such as typos) or minor changes in purely editorial sections (such as Authors' Addresses, Acknowledgments, References, and alike) are not considered substantial.

11.7.  Change Control

Change control of any Enumservice Registrations is done by "Specification Required", which implies the use of a Designated Expert, according to [RFC5226] (Narten, T. and H. Alvestrand, “Guidelines for Writing an IANA Considerations Section in RFCs,” May 2008.). Updates of Enumservice Specifications MUST comply with the requirements described in this document. Updates are handled the same way as initial Enumservice Registrations.

Authorized Change Controllers are the experts and the IESG.

Enumservice registrations must not be deleted. An Enumservice that is believed no longer appropriate for use can be declared deprecated by publication of a new Enumservice Specification changing its <usage> element (Intended Usage) to "DEPRECATED"; such Enumservices will be clearly marked in the lists published by IANA. As obsoletions are updates, they are also handled the same way as initial Enumservice Registrations. Alternatively, Enumservices may be declared deprecated by an IESG action.

11.8.  Restrictions

As stated in Section 3.2 (Naming Requirements), a "-" (dash) MUST NOT be used as the first nor as the second nor as the last character of a Type nor a Subtype. Furthermore, Type nor Subtype of any Enumservice MUST NOT be set to nor start with "E2U". Any Enumservice registration requests not following these restrictions must be rejected by IANA, and the Expert Review process should not be initiated.

Section 5.2 (IANA Registration (REQUIRED)) contains examples for Enumservice registrations. Therefore, IANA must not register an Enumservice with Type or Subtype set to "foo", "bar", or "sbar", unless the experts explicitly confirm an exception.

12.  Acknowledgments

The authors would like to thank the following people who have provided feedback or significant contributions to the development of this document: Jari Arkko, Stewart Bryant, Gonzalo Camarillo, Lawrence Conroy, Michelle Cotton, Miguel Garcia, David Harrington, Alfred Hoenes, Ari Keranen, Peter Koch, Edward Lewis, Alexey Melnikov, Jon Peterson, Pekka Savola, and Peter Saint-Andre

Lawrence Conroy has provided extensive text for the Enumservice Classification section.

Section 3 of RFC 3761 (Faltstrom, P. and M. Mealling, “The E.164 to Uniform Resource Identifiers (URI) Dynamic Delegation Discovery System (DDDS) Application (ENUM),” April 2004.) [RFC3761], which was edited by Patrik Faltstrom and Michael Mealling, has been incorporated into this document. Please see the Acknowledgments section in RFC 3761 for additional acknowledgments.

13.  References

13.1. Normative References

13.2. Informative References

Appendix A.  IANA Registration Template Examples

This section contains non-normative examples of the XML chunk based IANA Registration Template:

This is the first example:

        <record>
          <class>Protocol-Based</class>
          <type>email</type>
          <subtype>mailto</subtype>
          <urischeme>mailto</urischeme>
          <functionalspec>
            <paragraph>
              This Enumservice indicates that the resource
              can be addressed by the associated URI in
              order to send an email.
            </paragraph>
          </functionalspec>
          <security>
            See <xref type="rfc" data="rfc4355"/>, Section 6.
          </security>
          <usage>COMMON</usage>
          <registrationdocs>
            <xref type="rfc" data="rfc4355"/>
          </registrationdocs>
          <requesters>
            <xref type="person" data="Lawrence_Conroy"/>
          </requesters>
        </record>

        <people>
          <person id="Lawrence_Conroy">
            <name>Lawrence Conroy</name>
            <org>Siemens Roke Manor Research</org>
            <uri>mailto:lwc@roke.co.uk</uri>
            <updated>2008-11-20</updated>
          </person>
        </people>

This is the second example.

        <record>
          <class>Protocol-Based</class>
          <type>xmpp</type>
          <urischeme>xmpp</urischeme>
          <functionalspec>
            <paragraph>
              This Enumservice indicates that the
              resource identified is an XMPP entity.
            </paragraph>
          </functionalspec>
          <security>
            See <xref type="rfc" data="rfc4979"/>, Section 6.
          </security>
          <usage>COMMON</usage>
          <registrationdocs>
            <xref type="rfc" data="rfc4979"/>
          </registrationdocs>
          <requesters>
            <xref type="person" data="Alexander_Mayrhofer"/>
          </requesters>
        </record>

        <people>
          <person id="Alexander_Mayrhofer">
            <name>Alexander Mayrhofer</name>
            <org>enum.at GmbH</org>
            <uri>mailto:alexander.mayrhofer@enum.at</uri>
            <updated>2008-10-10</updated>
          </person>
        </people>

This is the third example:

        <record>
          <class>Application-Based</class>
          <type>voicemsg</type>
          <subtype>sip</subtype>
          <urischeme>sip</urischeme>
          <functionalspec>
            <paragraph>
              This Enumservice indicates that the resource
              identified can be addressed by the associated
              URI scheme in order to initiate a voice
              communication session to a voice messaging system.
            </paragraph>
          </functionalspec>
          <security>
            See <xref type="rfc" data="rfc4279"/>, Section 3.
          </security>
          <usage>COMMON</usage>
          <registrationdocs>
            <xref type="rfc" data="rfc4279"/>
          </registrationdocs>
          <requesters>
            <xref type="person" data="Jason_Livingood"/>
            <xref type="person" data="Donald_Troshynski">
          </requesters>
          <additionalinfo>
            <paragraph>
              Implementers should review a non-exclusive list of
              examples in <xref type="rfc" data="rfc4279"/>,
              Section 7.
            </paragraph>
          </additionalinfo>
        </record>

        <people>
          <person id="Jason_Livingood">
            <name>Jason Livingood</name>
            <org>Comcast Cable Communications</org>
            <uri>mailto:jason_livingood@cable.comcast.com</uri>
            <updated>2008-11-20</updated>
          </person>
          <person id="Donald_Troshynski">
            <name>Donald Troshynski</name>
            <org>Acme Packet</org>
            <uri>mailto:dtroshynski@acmepacket.com</uri>
            <updated>2008-11-20</updated>
          </person>
        </people>

Note: The "voicemsg" Enumservice has several Subtypes. For each Subtype, an individual Registration Template must be submitted to IANA, with only the first one shown above. This is to avoid any ambiguity of the relation between <subtype> and <urischeme> elements.

Appendix B.  Changes from RFC 3761

This section lists the changes applied to the Enumservice registration process and the IANA Registry definition, compared to RFC 3761.

• While RFC 3761 required "Standards track or Experimental" RFCs for an Enumservice to be registered, this document mandates "Specification Required", which implies the use of a Designated Expert.



• This document defines the classification of Enumservices. The IANA Registration Template has been complemented to contain a <class> element (Enumservice Class).



• A new element <registrationdocs> (Enumservice Specification) has been added to the IANA Registration Template.



• The former field "Any other information that the author deems interesting" of the IANA Registration Template turned into the <additionalinfo> element (Further Information).



• The Enumservice "Name" field has been removed from the IANA Registration Template.



• The Registration Template is now a chunk of XML data, reflecting IANA's recent work to convert registries to XML.

Appendix C.  Document Changelog

[RFC Editor: This section is to be removed before publication]

draft-ietf-enum-enumservices-guide-22:

• jason: addressed numerous comments and discusses opened during IESG review from David Harrington
• bernie/alex: addressed more IESG review feedback from David Harrington
• bernie: removed obsolete text that was still in the XML version, but commented out
• bernie: minor editorials

draft-ietf-enum-enumservices-guide-21:

Implemented IESG Feedback:

• alex: added note about scope of expert review process ("wide or narrow") to section 7
• alex: changed cross-reference to section 2.4.4 of 3761bis to 3.4.3
• alex: Added "non-normative" text to section 6 and 7 (David)
• alex: Changed all RFC2119 text in section 6 and 7 to non-RFC2119 text (David)
• bernie: Adjusted comment in the registration template
• bernie: Intended Status to 'std' on IESG request
• bernie: Clarified 'substantial changes' in IANA section (Peter)
• alex: changed RFC 9999 to something more funny (Stewart)
• bernie: corrected typos in Sections 3.2, 11.6, 5.2.4
• bernie: sorted out XML chunk vs. IANA Registration Template
• bernie: added option for obsoletion by IESG action (Alexey)
• bernie: conduct an (Expert Review) -> take care of the (Alexey / Miguel)
• bernie: added "P-" Enumservices will not be registered at all (Alexey)
• bernie: changes to normative language in Section 5.2.4 and 5.2.9 (Jari)
• bernie: improvement of text in section 11.5 (Dave H. / Miguel)
• bernie: updated Acknowledgments section
• bernie: re-ordered references
• bernie: moved reference to rfc3986 to normative and added a reference in Section 5.2.4 (Alexey)

draft-ietf-enum-enumservices-guide-20:

• bernie: minor editorial (Feedback Alfred Hoenes)
• bernie: updated my author's address (swisscom -> ucom.ch)
• bernie: clarified IANA registration policy: "Specification Required", which implies "Expert Review", i.e. point to a single policy (Feedback Gonzalo Camarillo)
• bernie: Further clarifications concerning mailing list and experts (Feedback Gonzalo Camarillo)
• bernie: Rewording of recommendations for search for existing work

draft-ietf-enum-enumservices-guide-19:

• bernie: updated reference to specific RFC3761bis section
• bernie: corrected several typos / grammar / clarity issues reported by Alfred Hoenes
• bernie: added long versions of DNS and NAPTR / added DNS (incl. reference) to introduction
• bernie: cleared out NAPTR DNS RR in Functionality Requirements
• bernie: rewrote 2nd paragraph in Step 6
• bernie: cleared out 3rd paragraph of Section 11.5 (Expert Review Procedure)

draft-ietf-enum-enumservices-guide-18:

• bernie: corrected <requester> -> <requesters>
• bernie: changed "(sub)type name" -> "(sub)type string" to be consistent
• bernie: changed "element" -> "field" when referring to the old IANA template
• bernie: lots of small editorial/punctuation changes
• bernie: changed my author's address

draft-ietf-enum-enumservices-guide-17:

• bernie: As per IANA feedback changed the process in a way, that Expert Review takes place before the publication process is started (even in RFC case)
• bernie: Restructured IANA Considerations section
• bernie: IANA to ensure only expert reviewed versions are published as RFC
• bernie: Editorial changes to section 'IANA Registration (MANDATORY)' (made sub-sections)
• bernie: Added a note that IANA is to check for clashes in type:subtype naming
• bernie: redundant sentences about (not) skip Step 6 removed in Step 4
• bernie: Added clarification that extended Enumservices not complying with the new rules need to be updated
• bernie: Added explicit Section for ABNF in references to 3761bis
• bernie: Removed explicit hint / internal reference to appeal in Outcome 3 of step 5
• bernie: Reference from naming requirements to cookbook as requirement, not only recommendation.
• bernie: Explicit instructions to IANA to make the escrow copy
• bernie: Lowercased vCard example for Type
• bernie: Not that enum-svc-trans does not update compliant with this spec
• bernie: Added Pekka Savola and Michelle Cotton to Acknowledgments. The above changes are a result of Pekka's feedback.
• bernie: Typo in Step 6 corrected (Step 5 -> step 6)
• bernie: 'IANA Template' -> 'XML chunk based IANA template' (in Structure)
• bernie: Removed reference to RFC4355 (not used)
• bernie: Updated ipr attribute to 'pre5378Trust200902' according to http://www.ietf.org/mail-archive/web/syslog/current/msg02333.html

draft-ietf-enum-enumservices-guide-16:

• bernie: capitalize "-based" in <class>
• bernie: consistent usage of plural for <requesters>
• bernie: changed title/naming for element <registrationdocs> (not changing element name itself)
• bernie: updated Changes Overview section
• bernie: clarified Open Issues section to be removed before publication
• bernie: whitespace changes (indentations, line-breaks) in XML chunks
• bernie: changed drama number in the example to a non-premium rate one (feedback Lawrence Conroy)

draft-ietf-enum-enumservices-guide-15:

• bernie: cleared out authors/requesters
• alex: added ABNF reference + acronym expansion
• alex: changed order of paragraphs in introduction - registry update now in front of blah blah paragraph
• alex: various editorial and formatting updates to the new XML template specs.
• alex: moved XML template to IANA considerations
• alex: removed "identifying tag" language
• alex: clarified "element" vs. "field" usage - "element" now refers to XML chunk pieces of IANA registration, while "fields" refers to other things, like fields of a NAPTR record, etc.
• alex: removed more subtypes from third example - one subtype per template ensures that there is no confusion between the URI schemes for various subtypes

draft-ietf-enum-enumservices-guide-14:

• alex: changed template information in description of fields to XML chunk information
• alex: added references to person information in examples
• alex: replaced "registrant" with "requester"
• bernie: minor editorial corrections and nits
• jason: added the IANA XML chunk, as well as some examples

draft-ietf-enum-enumservices-guide-13:

• alex: Some minor changes - the only real open issue is whether or not we should go to an XML template instead of the plain text one. IANA provided a "chunk", but gave no feedback about schema, namespace, etc. so it is deemed not "normative" enough yet.
• bernie: Implemented IANA Feedback: made difference between RFC and no-RFC specs more clear; now the both variants slightly differ in process.
• bernie: Implemented more feedback of Peter Koch:
  • Terminology updated throughout the document: Enumservice Specification / Registration Document
  • Changed IANA Template field 'Registration Document(s) to 'Enumservice specification(s)'
  • Disallow dash '-' as last char of Type or Subtype
  • Removed XML2RFC template and referencing sections
• bernie: changed "Subtype names MAY be shared between URI Schemes that the Registration specifies as mandatory to implement for a given Subtype." to "Subtype names MAY be shared between URI Schemes, if all the URI Schemes within the same Subtype are mandatory to implement."
• bernie: Cleared out independent submission and added reference to RFC 4846
• jason: Per the co-chair and Peter Koch, doc changed to BCP. Doc doesn't specify a protocol but a process. Both RFC 2026, section 5, and section 4.3 of RFC 5226 suggest that process documents, and IANA Guidelines in particular, usually are published as BCP RFCs. Also, there's little to implement independently in this draft that could help advance it on the Standards Track.
• jason: various nits clean-up suggested by Peter Koch.

draft-ietf-enum-enumservices-guide-12:

• bernie: Refined process, i.e. separation of Expert Review and addition to IANA Registry (only after publication of spec):
  • Split up "Further Steps" into three new sections
  • Extended ASCII Art
  • Adjusted IANA considerations
• bernie: Updated Open Issues
• alex: Added reference to RFC3552 (security considerations guidance)
• alex: Added instructions2author as informative reference - i don't see another way (revision 439, closing ticket 25)
• alex: Moved text about use cases from Review Guidelines up to "other sections", slightly reworded it (revision 438, closing ticket 66)
• bernie: Updated own contact details
• bernie: Implemented editorial feedback from Alfred Hoenes
• bernie: Added some clarifications to IANA consideration as proposed by Michelle Cotton (IANA)
• bernie: Edited appendix "Changes Overview", moved stuff from "Introduction" to "Changes Overview"
• bernie: Updated IANA section "Change Control":
  • Authorized Change controllers are experts and IESG
  • Removed field "Authorized Change Controller" (was introduced in -11)
• bernie: Replaced "number blocks" by "wildcards" (DNS Considerations) to avoid conflict with RFC3761
• bernie: Extended recommendations about search for previous work
• bernie: Adjusted sections "Revision of Pre-Existing Enumservice RFCs" and "Submit Registration Document to IANA"

draft-ietf-enum-enumservices-guide-11:

• bernie: Replaced reference rfc2434bis with rfc5226
• bernie: Moved terminology related paragraph from Introduction to Terminology Section
• bernie: Added reference to transition document
• jason: Updated my author address
• jason: Closed out active tickets at http://ietf.enum.at/cgi-bin/trac.cgi/report/1
• jason: Section 8, review of pre-existing enumservices, updated with IETF 72 feedback that this must take place
• jason: Ticket 39: Added text to section 4.1, general enumservice considerations, section 2, bullet 2 to address comment by Lawrence Conroy about expired I-Ds
• jason: Ticket 45: Added text to section 7.1, expert review / review guidelines, bullet 3, to indicate that a use case SHOULD be included. Also added related text to section 5.8, other sections, to address this. This resolves comments by Lawrence Conroy
• jason: Ticket 55: Replaced 'repository' with 'registry' throughout the document to normalize this text and make it uniform.
• jason: Ticket 52: Checked references to ensure rfc5226 is cited instead of rfc2434bis, which Bernie seems to have mainly covered. I also added a reference in the header for rfc5226, since it is a normative reference.
• jason: Ticket 25: Removed reference to rfc2223bis-08 as this I-D is now listed as dead.
• jason: Ticket 49: Have updated section 5.2, IANA registration, bullet on authors addresses, to say that email addresses MUST NOT be included in the IANA Registry. I opened a related ticket. Seems there are some email addresses in the registry. Also simplified author(s) and expert(s) to authors and experts throughout.
• jason: Ticket 28: Minor changes to Section 10.1 and 10.2, Security Considerations
• jason: Ticket 30: Updated section 6.4, 6.5, on IANA registration to include that submission must be in XML format for IANA and that the Enumservice must have an RFC number, per discussion at IETF 72
• jason: Ticket 42: Cleaned up section 5.7, DNS considerations, per comments from Lawrence.
• jason: Updated definitions to reflect IANA Designated Experts per RFC 5226, and clean up of IANA-related terms (Registry, Template, etc.)
• jason: Ticket 51: added section to describe the need to have a contact listed for updating a registration, per RFC 5226, section 5.2.

draft-ietf-enum-enumservices-guide-10:

• bernie: No longer empty field for IANA Registration ('N/A' must be used in this case)
• bernie: Adjusted IANA Registration Template:
  • Registration Document -> Registration Document(s)
  • Author -> Author(s)
• bernie: IANA repository in alphabetical order by Type and Subtype
• bernie: Class, Type, Subtype and URI Schema to begin with capital
• bernie: Caption for each Enumservice
• bernie: Consistent use of "field" for fields within IANA registration template (no longer used are "item" or "section")
• bernie: URI Schemes without colons and between single quotes, no longer email address in author(s) field
• bernie: Adjusted IANA Registration Section of XML2RFC template
• alex: Added List of Classes to choose from

draft-ietf-enum-enumservices-guide-09:

• alex: Removed Enumservice "Name" as decided at IETF 71
• alex: Reworded registration requirements
• alex: Explained possible values for "Intended Usage"
• bernie: Rewrite of section 'Change Control'
• bernie: Cleared out scope of this document (only ordinary, but no 'X-' registrations)
• bernie: Cleared out naming restrictions in IANA section
• bernie: Changed section name from 'ENUM Service Registration' to 'IANA Registration'
• bernie: Combined Expert Review related sections
• bernie: Partly implemented feedback Alfred Hoenes and added him to Acknowledgments
• bernie: Enhanced examples for "Registration Document"
• bernie: Enhanced examples for "IANA Considerations" (feedback from Alfred Hoenes)
• bernie: Removed Note about RFC3761bis obsoleting RFC3761 (does not belong to this doc)
• bernie: Rewrote Naming Requirements section (impact to IANA Considerations - Restrictions)

draft-ietf-enum-enumservices-guide-08:

• alex: new text for Subtypes of protocol class enumservices ("mandatory to implement" stuff)
• alex: added "to be foreseen" to the application Type Subtype recommendation
• alex: added "lowercase" recommendation to the Type names
• bernie: Corrected various typos, clarifications, and other editorial stuff (feedback from Lawrence Conroy)
• bernie: IANA Registry ftp -> http (feedback from Lawrence Conroy)
• bernie: Made steps prior to IANA submission mandatory (feedback from Lawrence Conroy)
• bernie: Shortened abstract

draft-ietf-enum-enumservices-guide-07:

• bernie: Section DNS considerations made mandatory
• bernie: Complete rewrite of IANA considerations
• bernie: XML2RFC template will be downloadable at IANA
• bernie: Complete re-write of process
• alex: Adjusted Cook-book / classification
• bernie: Take over chapter "Registration mechanism for Enumservices" from RFC 3761bis
• bernie: Changed title to adjust to new purpose
• bernie: Intended status changed to Standards Track (was bcp)
• bernie: Obsoletes (partly) RFC 3761
• bernie: Adjusted section "Registration mechanism for Enumservices"
• bernie: Updated most RFC 3761 references to either RFC3761bis or new (internal) section
• bernie: Acknowledgment for RFC3761 contributors
• bernie: Shortened bullet point in IANA Registration Template:

  "Any other information that the author deems interesting"

  ==> "Further Information"

• alex: Rewritten Abstract, Introduction to be consistent with with new goal (IANA Registry description)
• alex: Add obsoletes section 3 of RFC 3761 to Introduction
• alex: Changed section 3 to "registration requirements", Simplified structure
• alex: Added examples for protocol Enumservice classification
• alex: Added text about "other" classification

draft-ietf-enum-enumservices-guide-06:

• alex: updated Class Schemes.
• alex: updated expert's tasks
• alex: added experts review considerations
• bernie: Moved Terminology section in XML2RFC template (now after Introduction)
• bernie: Class is now part of the Enumservice registration in the IANA template
• bernie: Individual Submission relaxed (comment Peter Koch)
• bernie: updated vcard Ref (now RFC)

draft-ietf-enum-enumservices-guide-05:

• bernie/alex: added text for sections 'The Enumservice Expert Selection Process' and 'The Process for Appealing Expert Review Decisions'
• bernie: added ASCII-art figure for registration process
• bernie: adjusted registration process
• jason: proposed registration process

draft-ietf-enum-enumservices-guide-04:

• bernie: added section about Extension of existing Enumservice RFCs
• bernie: added open issue about future registration process
• bernie: added category (bcp)
• bernie: clean up in Security Considerations
• bernie: editorial stuff (mainly XML issues)

draft-ietf-enum-enumservices-guide-03:

• alex: moved terminology section
• alex: removed note asking for feedback
• bernie: added DNS consideration section
• bernie: added Acknowledgments section
• bernie: editorial stuff (nicer formating, fixing too long lines)
• alex: added security considerations from vcard draft.

draft-ietf-enum-enumservices-guide-02:

• bernie: replaced numbers in examples by "Drama Numbers"
• bernie: moved Change and Open Issues to Appendix.
• bernie: major rewrite of section "6. Required Sections and Information" incl. separating explanations and examples.
• bernie: removed section 7 (was just a repetition of referencing to XML2RFC template)
• bernie: extended Appendix with Open Issues.

draft-ietf-enum-enumservices-guide-01:

• alex: added Security Considerations section for the doc itself
• alex: added IANA Considerations section for the doc itself
• alex: added cookbook idea

Appendix D.  Open Issues

[RFC Editor: This section should be removed before publication]

• None

Appendix E.  Notes for the RFC Editor Concerning RFC 3761

[RFC Editor: This section should be removed before publication]

This document obsoletes Section 3 of RFC3761, while draft-enum-ietf-3761bis obsoletes all the rest of RFC3761. We are a bit unclear about the id-nits rules about partially obsoleting a prior RFC. Furthermore, we ask whether you wish us to add something to this effect also to the Abstract or not (in addition to the mention in the Introduction section). We look forward to your guidance on what to do in this regard.

Authors' Addresses