Network Working Group A. Newton
Request for Comments: 3981 VeriSign, Inc.
Category: Standards Track M. Sanz
DENIC eG
January 2005
Network Working Group A. Newton
Request for Comments: 3981 VeriSign, Inc.
Category: Standards Track M. Sanz
DENIC eG
January 2005
IRIS: The Internet Registry Information Service (IRIS) Core Protocol
IRIS：互联网注册信息服务（IRIS）核心协议
Status of This Memo
关于下段备忘
This document specifies an Internet standards track protocol for the Internet community, and requests discussion and suggestions for improvements. Please refer to the current edition of the "Internet Official Protocol Standards" (STD 1) for the standardization state and status of this protocol. Distribution of this memo is unlimited.
本文件规定了互联网社区的互联网标准跟踪协议，并要求进行讨论和提出改进建议。有关本协议的标准化状态和状态，请参考当前版本的“互联网官方协议标准”（STD 1）。本备忘录的分发不受限制。
Copyright Notice
版权公告
Copyright (C) The Internet Society (2005).
版权所有（C）互联网协会（2005年）。
Abstract
摘要
This document describes an application layer client-server protocol for a framework to represent the query and result operations of the information services of Internet registries. Specified in the Extensible Markup Language (XML), the protocol defines generic query and result operations and a mechanism for extending these operations for specific registry service needs.
本文档描述了一个框架的应用层客户机-服务器协议，用于表示Internet注册中心信息服务的查询和结果操作。该协议由可扩展标记语言（XML）指定，定义了通用查询和结果操作，以及用于扩展这些操作以满足特定注册表服务需求的机制。
Table of Contents
目录
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1. Use of XML . . . . . . . . . . . . . . . . . . . . . . . 2
1.2. General Concepts . . . . . . . . . . . . . . . . . . . . 3
1.3. Framework Layers . . . . . . . . . . . . . . . . . . . . 4
1.4. Definitions . . . . . . . . . . . . . . . . . . . . . . 4
1.5. Further Reading . . . . . . . . . . . . . . . . . . . . 5
2. Document Terminology . . . . . . . . . . . . . . . . . . . . . 5
3. Protocol Identification . . . . . . . . . . . . . . . . . . . 5
4. Exchange Description . . . . . . . . . . . . . . . . . . . . . 6
4.1. Request Format . . . . . . . . . . . . . . . . . . . . . 6
4.2. Response Format . . . . . . . . . . . . . . . . . . . . 6
4.3. Extension Framework . . . . . . . . . . . . . . . . . . 9
4.3.1. Derived Elements . . . . . . . . . . . . . . . . 9
4.3.2. Registry Type Identifier Requirements . . . . . 10
4.3.3. Entity Classes . . . . . . . . . . . . . . . . . 10
4.3.4. Names of Entities . . . . . . . . . . . . . . . 11
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1. Use of XML . . . . . . . . . . . . . . . . . . . . . . . 2
1.2. General Concepts . . . . . . . . . . . . . . . . . . . . 3
1.3. Framework Layers . . . . . . . . . . . . . . . . . . . . 4
1.4. Definitions . . . . . . . . . . . . . . . . . . . . . . 4
1.5. Further Reading . . . . . . . . . . . . . . . . . . . . 5
2. Document Terminology . . . . . . . . . . . . . . . . . . . . . 5
3. Protocol Identification . . . . . . . . . . . . . . . . . . . 5
4. Exchange Description . . . . . . . . . . . . . . . . . . . . . 6
4.1. Request Format . . . . . . . . . . . . . . . . . . . . . 6
4.2. Response Format . . . . . . . . . . . . . . . . . . . . 6
4.3. Extension Framework . . . . . . . . . . . . . . . . . . 9
4.3.1. Derived Elements . . . . . . . . . . . . . . . . 9
4.3.2. Registry Type Identifier Requirements . . . . . 10
4.3.3. Entity Classes . . . . . . . . . . . . . . . . . 10
4.3.4. Names of Entities . . . . . . . . . . . . . . . 11
4.3.5. References to Entities . . . . . . . . . . . . . 11
4.3.6. Temporary Entities . . . . . . . . . . . . . . . 12
4.3.7. <result> Derived Elements . . . . . . . . . . . 13
4.3.8. <control> and <reaction> Elements . . . . . . . 16
4.4. Relay Bags . . . . . . . . . . . . . . . . . . . . . . . 18
5. Database Serialization . . . . . . . . . . . . . . . . . . . . 19
6. Formal XML Syntax . . . . . . . . . . . . . . . . . . . . . . 22
7. The IRIS URI . . . . . . . . . . . . . . . . . . . . . . . . . 37
7.1. URI Definition . . . . . . . . . . . . . . . . . . . . . 37
7.2. Transport Specific Schemes . . . . . . . . . . . . . . . 38
7.3. URI Resolution . . . . . . . . . . . . . . . . . . . . . 38
7.3.1. Registry Dependent Resolution . . . . . . . . . 38
7.3.2. Direct Resolution . . . . . . . . . . . . . . . 39
7.3.3. Transport and Service Location . . . . . . . . . 39
7.4. IRIS URI Examples . . . . . . . . . . . . . . . . . . . 40
8. Checklists . . . . . . . . . . . . . . . . . . . . . . . . . . 41
8.1. Registry Definition Checklist . . . . . . . . . . . . . 41
8.2. Transport Mapping Checklist . . . . . . . . . . . . . . 42
9. Internationalization Considerations . . . . . . . . . . . . . 42
10. IANA Considerations . . . . . . . . . . . . . . . . . . . . . 43
11. Security Considerations . . . . . . . . . . . . . . . . . . . 43
12. References . . . . . . . . . . . . . . . . . . . . . . . . . . 43
12.1. Normative References . . . . . . . . . . . . . . . . . . 43
12.2. Informative References . . . . . . . . . . . . . . . . . 45
A. S-NAPTR and IRIS Uses . . . . . . . . . . . . . . . . . . . . 46
A.1. Examples of S-NAPTR with IRIS. . . . . . . . . . . . . . 46
A.2. Using S-NAPTR for Cohabitation . . . . . . . . . . . . . 47
B. IRIS Design Philosophy . . . . . . . . . . . . . . . . . . . . 48
B.1. The Basic Premise . . . . . . . . . . . . . . . . . . . 48
B.2. The Lure of a Universal Client . . . . . . . . . . . . . 49
B.3. Server Considerations . . . . . . . . . . . . . . . . . 49
B.4. Lookups, Searches, and Entity Classes . . . . . . . . . 50
B.5. Entities References, Search Continuations, and Scope . . 50
C. Acknowledgments . . . . . . . . . . . . . . . . . . . . . . . 51
Authors' Addresses . . . . . . . . . . . . . . . . . . . . . . . . 51
Full Copyright Statement . . . . . . . . . . . . . . . . . . . . . 52
4.3.5. References to Entities . . . . . . . . . . . . . 11
4.3.6. Temporary Entities . . . . . . . . . . . . . . . 12
4.3.7. <result> Derived Elements . . . . . . . . . . . 13
4.3.8. <control> and <reaction> Elements . . . . . . . 16
4.4. Relay Bags . . . . . . . . . . . . . . . . . . . . . . . 18
5. Database Serialization . . . . . . . . . . . . . . . . . . . . 19
6. Formal XML Syntax . . . . . . . . . . . . . . . . . . . . . . 22
7. The IRIS URI . . . . . . . . . . . . . . . . . . . . . . . . . 37
7.1. URI Definition . . . . . . . . . . . . . . . . . . . . . 37
7.2. Transport Specific Schemes . . . . . . . . . . . . . . . 38
7.3. URI Resolution . . . . . . . . . . . . . . . . . . . . . 38
7.3.1. Registry Dependent Resolution . . . . . . . . . 38
7.3.2. Direct Resolution . . . . . . . . . . . . . . . 39
7.3.3. Transport and Service Location . . . . . . . . . 39
7.4. IRIS URI Examples . . . . . . . . . . . . . . . . . . . 40
8. Checklists . . . . . . . . . . . . . . . . . . . . . . . . . . 41
8.1. Registry Definition Checklist . . . . . . . . . . . . . 41
8.2. Transport Mapping Checklist . . . . . . . . . . . . . . 42
9. Internationalization Considerations . . . . . . . . . . . . . 42
10. IANA Considerations . . . . . . . . . . . . . . . . . . . . . 43
11. Security Considerations . . . . . . . . . . . . . . . . . . . 43
12. References . . . . . . . . . . . . . . . . . . . . . . . . . . 43
12.1. Normative References . . . . . . . . . . . . . . . . . . 43
12.2. Informative References . . . . . . . . . . . . . . . . . 45
A. S-NAPTR and IRIS Uses . . . . . . . . . . . . . . . . . . . . 46
A.1. Examples of S-NAPTR with IRIS. . . . . . . . . . . . . . 46
A.2. Using S-NAPTR for Cohabitation . . . . . . . . . . . . . 47
B. IRIS Design Philosophy . . . . . . . . . . . . . . . . . . . . 48
B.1. The Basic Premise . . . . . . . . . . . . . . . . . . . 48
B.2. The Lure of a Universal Client . . . . . . . . . . . . . 49
B.3. Server Considerations . . . . . . . . . . . . . . . . . 49
B.4. Lookups, Searches, and Entity Classes . . . . . . . . . 50
B.5. Entities References, Search Continuations, and Scope . . 50
C. Acknowledgments . . . . . . . . . . . . . . . . . . . . . . . 51
Authors' Addresses . . . . . . . . . . . . . . . . . . . . . . . . 51
Full Copyright Statement . . . . . . . . . . . . . . . . . . . . . 52
The specification outlined in this document is based on the functional requirements described in CRISP [17].
本文件中概述的规范基于CRISP[17]中描述的功能要求。
This document describes the specification for the Internet Registry Information Service (IRIS), an XML text protocol intended to describe the query types and result types of various registry information services. IRIS is specified by using the Extensible Markup Language
本文档描述了Internet注册表信息服务（IRIS）规范，这是一种XML文本协议，旨在描述各种注册表信息服务的查询类型和结果类型。IRIS是使用可扩展标记语言指定的
(XML) 1.0 as described in [2], XML Schema notation as described in [4] and [5], and XML Namespaces as described in [3].
（XML）1.0，如[2]中所述，[4]和[5]中所述的XML模式表示法，[3]中所述的XML名称空间。
Each kind of Internet registry is identified by a registry type. The identifier for a registry type is a Uniform Resource Name (URN) used within the XML instances to identify the XML schema that formally describes the set of queries, results, and entity classes allowed within that type of registry.
每种Internet注册表都由一个注册表类型标识。注册表类型的标识符是XML实例中使用的统一资源名（URN），用于标识XML模式，该模式正式描述该类型注册表中允许的查询、结果和实体类集。
The structure of these URNs makes no assumptions or restrictions on the types of registries they identify. Therefore, IRIS may support multiple registry types of a disparate or similar nature; it is only a matter of definition. For instance, a single registry type may be defined for domain name registries, and multiple registry types for the various IP address registries.
这些URN的结构对其确定的登记类型没有任何假设或限制。因此，IRIS可能支持不同或类似性质的多种注册表类型；这只是一个定义问题。例如，可以为域名注册中心定义一个注册中心类型，为各种IP地址注册中心定义多个注册中心类型。
A registry information server may handle queries and serve results for multiple registry types. Each registry type that a particular registry operator serves is a registry service instance.
注册表信息服务器可以处理多个注册表类型的查询并提供结果。特定注册表操作符提供的每个注册表类型都是一个注册表服务实例。
IRIS and the XML schema formally describing IRIS do not specify any registry, registry identifier, or knowledge of a particular service instance or set of instances. IRIS is a specification for a framework with which these registries can be defined, used and, in some cases, interoperate. The framework merely specifies the elements for registry identification and the elements that must be used to derive queries and results.
IRIS和正式描述IRIS的XML模式没有指定任何注册表、注册表标识符或特定服务实例或实例集的知识。IRIS是一个框架规范，通过它可以定义、使用这些注册中心，在某些情况下还可以进行互操作。该框架仅指定用于注册表标识的元素以及必须用于派生查询和结果的元素。
This framework allows a registry type to define its own structure for naming, entities, queries, etc., through the use of XML namespaces and XML schemas (hence, a registry type MUST be identified by the same URI that identifies its XML namespace). To be compliant, a registry type's specification must extend from this framework.
该框架允许注册表类型通过使用XML名称空间和XML模式定义自己的命名、实体、查询等结构（因此，注册表类型必须由标识其XML名称空间的相同URI标识）。为了兼容，注册表类型的规范必须从此框架扩展。
The framework defines certain structures that can be common to all registry types, such as references to entities, search continuations, and entity classes. A registry type may declare its own definitions for all of these, or it may mix its derived definitions with the base definitions.
该框架定义了所有注册表类型通用的某些结构，例如对实体的引用、搜索延续和实体类。注册表类型可以为所有这些声明自己的定义，也可以将其派生定义与基定义混合使用。
IRIS defines two types of referrals: an entity reference and a search continuation. An entity reference indicates specific knowledge about an individual entity, and a search continuation allows distributed searches. Both referrals may span differing registry types and instances. No assumptions or specifications are made about the roots, bases, or meshes of entities.
IRIS定义了两种类型的引用：实体引用和搜索延续。实体引用表示有关单个实体的特定知识，搜索延续允许分布式搜索。这两个引用可能跨越不同的注册表类型和实例。未对实体的根、基或网格进行任何假设或说明。
The IRIS framework can be thought of as having three layers.
IRIS框架可以被认为有三层。
-----------------------------
Registry-Specific |domain | address | etc... |
-----------------------------
Common-Registry | IRIS |
-----------------------------
Application-Transport | beep | iris-lwz | etc... |
-----------------------------
-----------------------------
Registry-Specific |domain | address | etc... |
-----------------------------
Common-Registry | IRIS |
-----------------------------
Application-Transport | beep | iris-lwz | etc... |
-----------------------------
In this figure, "beep" refers to the Blocks Extensible Exchange Protocol (BEEP) (see [20]), and "iris-lwz" refers to a theoretical UDP binding that uses compression.
在此图中，“beep”指的是块可扩展交换协议（beep）（参见[20]），而“iris lwz”指的是使用压缩的理论UDP绑定。
The differing layers have the following responsibilities:
不同的层具有以下职责：
Registry-Specific :: defines queries, results, and entity classes of a specific type of registry. Each specific type of registry is identified by a URN. Common-Registry :: defines base operations and semantics common to all registry types such as search sets, result sets, and referrals. It also defines the syntaxes for talking about specific registry types. Application-Transport :: defines the mechanisms for authentication, message passing, connection and session management, etc. It also defines the URI syntax specific to the application-transport mechanism.
Registry Specific:：定义特定类型注册表的查询、结果和实体类。每个特定类型的注册表都由URN标识。CommonRegistry:：定义所有注册表类型（如搜索集、结果集和引用）共有的基本操作和语义。它还定义了用于讨论特定注册表类型的语法。Application Transport:：定义身份验证、消息传递、连接和会话管理等机制。它还定义了特定于应用程序传输机制的URI语法。
For clarity, the following definitions are supplied:
为清楚起见，提供了以下定义：
o registry type -- A registry serving a specific function, such as a domain registry or an address registry. Each type of registry is assigned a URN.
o 注册表类型——为特定功能提供服务的注册表，如域注册表或地址注册表。每种类型的注册表都分配了一个URN。
o registry schema -- The definition for a registry type specifying the queries, results, and entity classes.
o 注册表模式——指定查询、结果和实体类的注册表类型的定义。
o authority -- A reference to the server or set of servers containing information.
o authority——对包含信息的服务器或服务器集的引用。
o resolution method -- The technique used to locate an authority.
o 解析方法——用于定位权限的技术。
o entity class -- A group of entities with a common type or common set of characteristics.
o 实体类——具有共同类型或共同特征集的一组实体。
o entity name -- The identifier used to refer to a single entity within an entity class.
o 实体名称——用于引用实体类中单个实体的标识符。
o entity reference -- A pointer to an entity composed of an authority, an optional resolution method, a registry type, an entity class, and an entity name. One type of entity reference is the IRIS URI (defined in Section 7).
o 实体引用——指向由权限、可选解析方法、注册表类型、实体类和实体名称组成的实体的指针。一种类型的实体引用是IRIS URI（定义见第7节）。
The terms "derivative", "derive", and "derivation" are used with the same meaning for deriving one type of element from another as specified in XML_SS [5].
术语“派生”、“派生”和“派生”用于从XML_SS[5]中指定的另一种类型的元素派生一种类型的元素时具有相同的含义。
Appendix B contains text answering the question, "Why IRIS?".
附录B包含了回答“为什么使用IRIS？”问题的文本。
This document describes the structure at the core of IRIS. The following documents describe the other aspects of IRIS relevant to CRISP [17]: iris-beep [1] and iris-dreg [18].
本文档描述了IRIS的核心结构。以下文件描述了与CRISP[17]相关的IRIS的其他方面：IRIS beep[1]和IRIS dreg[18]。
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 BCP 14, RFC 2119 [8].
本文件中的关键词“必须”、“不得”、“要求”、“应”、“不应”、“应”、“不应”、“建议”、“可”和“可选”应按照BCP 14、RFC 2119[8]中的描述进行解释。
The root element of all request XML instances MUST be <request>. The root element of all response XML instances MUST be <response>. These elements identify the start of the IRIS elements, the XML namespace used as the identifier for IRIS, and, optionally, the location of the schema. These elements and the associated closing tag MUST be applied to all requests and responses sent by both clients and servers.
所有请求XML实例的根元素必须是<request>。所有响应XML实例的根元素必须是<response>。这些元素标识IRIS元素的开始、用作IRIS标识符的XML名称空间，以及（可选）模式的位置。这些元素和相关的结束标记必须应用于客户端和服务器发送的所有请求和响应。
The use of the schema location attribute 'xsi:schemaLocation' is OPTIONAL with respect to this specification, and IRIS implementations MAY resolve it to retrieve the schema or MAY use a locally cached version of the schema.
对于本规范，模式位置属性“xsi:schemaLocation”的使用是可选的，IRIS实现可以解析它以检索模式，或者可以使用本地缓存的模式版本。
Versioning of the IRIS protocol is the responsibility of the application-transport layer but MUST be associated with the XML namespace [3] URI representing IRIS. A change in this URI indicates a change of the underlying schema and, therefore, a new version of the protocol (and vice versa).
IRIS协议的版本控制由应用程序传输层负责，但必须与表示IRIS的XML命名空间[3]URI相关联。此URI中的更改表示基础架构的更改，因此表示协议的新版本（反之亦然）。
This section describes the request and response exchanges of the protocol. The descriptions contained within this section refer to XML elements and attributes and their relation to the exchange of data within the protocol. These descriptions also contain specifications outside the scope of the formal XML syntax. Therefore, this section will use terms defined by RFC 2119 [8] to describe the specification outside the scope of the formal XML syntax. While reading this section, please reference Section 6 for details on the formal XML syntax.
本节描述协议的请求和响应交换。本节中包含的描述涉及XML元素和属性及其与协议内数据交换的关系。这些描述还包含正式XML语法范围之外的规范。因此，本节将使用RFC 2119[8]定义的术语来描述正式XML语法范围之外的规范。在阅读本节时，请参考第6节以了解正式XML语法的详细信息。
A <request> element contains an optional <control> element and a set of <searchSet> elements.
<request>元素包含一个可选的<control>元素和一组<searchSet>元素。
The <searchSet> elements enable a client to query a particular registry type by using the URN identifying the registry type. This can be found in one of its two children: <lookupEntity> and <query>.
<searchSet>元素使客户端能够使用标识注册表类型的URN来查询特定的注册表类型。这可以在它的两个子项中找到：<lookupEntity>和<query>。
The <lookupEntity> element describes the lookup of an entity in a specific registry. This element has three attributes: 'registryType', 'entityClass', and 'entityName'. The 'registryType' attribute contains the registry identifier for the registry type in which the lookup operation will take place. The 'entityClass' attribute contains the token identifying the index for which the lookup operation will take place, and the 'entityName' attribute contains the name of the entity to look up.
元素描述在特定注册表中查找实体。此元素有三个属性：“registryType”、“entityClass”和“entityName”。“registryType”属性包含将在其中执行查找操作的注册表类型的注册表标识符。“entityClass”属性包含标识将对其执行查找操作的索引的标记，“entityName”属性包含要查找的实体的名称。
The <query> element is abstract and may not legally appear in an XML instance. It provides the base type that registry schemas will use to define derived query types. This derivation mechanism is described in Section 4.3.
<query>元素是抽象的，不能合法地出现在XML实例中。它提供了注册表模式将用于定义派生查询类型的基类型。第4.3节描述了这种衍生机制。
Each <searchSet> may also contain a <bag> element. When this element appears as a child of <searchSet>, it MUST NOT contain the 'id' attribute. For a description of the <bag> element, see Section 4.4.
每个<searchSet>还可以包含一个<bag>元素。当此元素显示为<searchSet>的子元素时，它不能包含“id”属性。有关<bag>元件的说明，请参见第4.4节。
The <control> element may contain one child element of any XML namespace. This child element allows a client to signal a server for special states or processing. An example of one such <control> child element may be found in Section 4.3.8.
<control>元素可以包含任何XML命名空间的一个子元素。这个子元素允许客户机向服务器发送信号以获取特殊状态或处理。可在第4.3.8节中找到此类<control>子元素的示例。
The <response> element contains an optional <reaction> element, a set of <resultSet> elements, and an optional <bags> element.
<response>元素包含一个可选的<reaction>元素、一组<resultSet>元素和一个可选的<bags>元素。
The <resultSet> elements are responses to a <searchSet> request. The contents of this element contain an <answer> element, an optional <additional> element, and error elements, if applicable.
<resultSet>元素是对<searchSet>请求的响应。此元素的内容包含<answer>元素、可选<additional>元素和错误元素（如果适用）。
The children of the <answer> element are of the following types:
<answer>元素的子元素具有以下类型：
o <result> is an abstract element and may not be legally placed in an XML instance. It provides the base type to be used by registry schemas to define derived result types. This derivation mechanism is described in Section 4.3.
o <result>是一个抽象元素，不能合法地放在XML实例中。它提供注册表架构用于定义派生结果类型的基类型。第4.3节描述了这种衍生机制。
o <entity> is an element specifying an entity reference. See Section 4.3.5.
o <entity>是指定实体引用的元素。见第4.3.5节。
o The <searchContinuation> element specifies a query referral. Its one child is any element derived from <query> (see Section 4.3.1). To direct the query to a referent server, <searchContinuation> has a mandatory 'authority' attribute and an optional 'resolution' attribute. The <searchContinuation> element may also contain a 'bagRef' attribute. For a description of the 'bagRef' attribute, see Section 4.4.
o 元素指定查询引用。它的一个子元素是从<query>派生的任何元素（参见第4.3.1节）。要将查询定向到引用服务器，<searchContinuation>具有一个必需的“authority”属性和一个可选的“resolution”属性。<searchContinuation>元素还可能包含“bagRef”属性。有关“bagRef”属性的说明，请参见第4.4节。
When following entity references and search continuations, clients SHOULD only follow an <entity> or <searchContinuation> response once. Failure to do so may result in the client process getting stuck in a never-ending query loop, commonly known as a referral loop.
当遵循实体引用和搜索继续时，客户端只应遵循一次<entity>或<searchContinuation>响应。如果不这样做，可能会导致客户端进程陷入一个永无止境的查询循环，通常称为引用循环。
The <additional> element only contains <result> elements, as described above. This element allows a server to indicate to a client results that were not specifically queried but that are related to the queried results, thus enabling the client to display this distinction to a user properly. The <additional> element use is optional.
如上所述，<additional>元素只包含<result>元素。此元素允许服务器向客户端指示未专门查询但与查询结果相关的结果，从而使客户端能够正确地向用户显示此区别。<additional>元素的使用是可选的。
The following elements, which represent error conditions, may be returned:
可以返回以下表示错误条件的元素：
o <insufficientResources> -- The corresponding query requires resources unobtainable by the server.
o <insufficientResources>——相应的查询需要服务器无法获取的资源。
o <invalidName> -- A name given in a query is not syntactically correct.
o <invalidName>——查询中给定的名称在语法上不正确。
o <invalidSearch> -- Parameters of the corresponding query are not semantically meaningful.
o <invalidSearch>——相应查询的参数在语义上没有意义。
o <queryNotSupported> -- The corresponding query is not supported by this server.
o <queryNotSupported>--此服务器不支持相应的查询。
o <limitExceeded> -- The corresponding query requires more resources than allowed.
o <limitextended>--相应的查询需要的资源超出了允许的范围。
o <nameNotFound> -- The name given in a query does not match a known entity.
o <nameNotFound>--查询中给定的名称与已知实体不匹配。
o <permissionDenied> -- The authentication given does not allow access to a specific result entry.
o <permissionDenied>--给定的身份验证不允许访问特定的结果条目。
o <bagUnrecognized> -- The contents of a bag were unrecognized. See Section 4.4.
o <bagUnrecognized>——袋子里的东西无法识别。见第4.4节。
o <bagUnacceptable> -- The contents of a bag were not and never will be acceptable. See Section 4.4.
o <BagAcceptable>——袋子里的东西过去不被接受，将来也永远不会被接受。见第4.4节。
o <bagRefused> -- The contents of a bag were not acceptable at this time. See Section 4.4.
o <BagRejected>——此时袋子里的东西是不可接受的。见第4.4节。
o A derivative of <genericCode>, as described in Section 4.3.
o 如第4.3节所述，<genericCode>的衍生物。
The <resultSet> section is divided into the <answer> and <additional> sections to allow easier processing and navigation of the results by a client. Servers MUST return the direct answers to queries in the <answer> element and MAY return results in the <additional> element for which a reference has been made in the <answer> element. Results in the <additional> element MUST have been referenced in the <answer>, either as direct children of the <answer> element or as deeper descendants of the <answer> element.
<resultSet>部分分为<answer>和<additional>部分，以便于客户对结果进行处理和导航。服务器必须在<answer>元素中返回查询的直接答案，并且可以在<additional>元素中返回结果，在<answer>元素中已对其进行了引用。<additional>元素中的结果必须作为<answer>元素的直接子元素或<answer>元素的深层子元素在<answer>中引用。
This serves two purposes. First, it may eliminate a requery by the client for references contained in the <answer> element. Second, it distinguishes between results that are a direct result of a query and those that would have been returned had the client followed the appropriate referrals, thus hinting how clients could process or display the returned results. For instance, clients constructing complex displays with tree navigation widgets will know that results in the <answer> element should all be directly beneath the root node of the tree, while results in the <additional> element are leaf nodes of those produced from the <answer> element.
这有两个目的。首先，它可以消除客户对<answer>元素中包含的引用的重新查询。其次，它区分了查询的直接结果和如果客户遵循适当的转介就会返回的结果，从而暗示客户如何处理或显示返回的结果。例如，使用树导航小部件构建复杂显示的客户端将知道<answer>元素中的结果都应该直接位于树的根节点之下，而<additional>元素中的结果是<answer>元素中生成的结果的叶节点。
A <reaction> element (child of <response>) is a response to a <control> element, and provides a means for a server to advise a client of the effect of a <control> element.
<reaction>元素（<response>的子元素）是对<control>元素的响应，它为服务器提供了一种方法，用于向客户端建议<control>元素的效果。
The <bags> element (child of <response>) is optional. It contains
<bag> elements, and the contents of each <bag> element constitute one
element in any XML namespace. Each <bag> element has an 'id'
attribute, which is referenced by the 'bagRef' attribute of entity
The <bags> element (child of <response>) is optional. It contains
<bag> elements, and the contents of each <bag> element constitute one
element in any XML namespace. Each <bag> element has an 'id'
attribute, which is referenced by the 'bagRef' attribute of entity
references (<entity>) and search continuations (<searchContinuation>). See Section 4.4.
引用（<entity>）和搜索继续（<searchContinuation>）。见第4.4节。
Because the IRIS schema defines only one query type, and two stand-alone result types, and does not define a registry structure, it is of limited use by itself. Extension of IRIS is accomplished through the use of a base IRIS schema, as defined in XML_SD [4] and XML_SS [5], and through extension of it by schemas constructed on top of IRIS.
因为IRIS模式只定义了一种查询类型和两种独立的结果类型，并且没有定义注册表结构，所以它本身的使用受到限制。IRIS的扩展是通过使用XML_SD[4]和XML_SS[5]中定义的基础IRIS模式，并通过在IRIS之上构建的模式对其进行扩展来实现的。
The XML Schema definition of IRIS requires schemas of registry types to derive element types from base types in the IRIS definition. The registry schemas MUST derive elements to define typed queries and results.
IRIS的XML模式定义要求注册表类型的模式从IRIS定义中的基类型派生元素类型。注册表模式必须派生元素来定义类型化查询和结果。
While the IRIS schema definition does not prohibit the derivation of any elements, registry schemas SHOULD restrict the derivations to the following types:
虽然IRIS模式定义不禁止派生任何元素，但注册表模式应将派生限制为以下类型：
o <query> -- As defined, this element contains no content and has no valid attributes. It is abstract and therefore only its derivatives appear in XML instances. Registry schemas derive from this element to define the queries allowed.
o <query>--根据定义，此元素不包含任何内容，也没有有效属性。它是抽象的，因此只有它的派生出现在XML实例中。注册表架构从该元素派生来定义允许的查询。
o <result> -- As defined, this element contains no content and has five valid attributes: 'authority', 'resolution' (optional), 'registryType', 'entityClass', 'entityName', and 'temporaryReference' (optional, see Section 4.3.6). It is abstract and therefore only its derivatives appear in XML instances. Registry schemas derive from this element to define results that may be returned from a query.
o <result>--根据定义，此元素不包含任何内容，并且有五个有效属性：“authority”、“resolution”（可选）、“registryType”、“entityClass”、“entityName”和“temporaryReference”（可选，见第4.3.6节）。它是抽象的，因此只有它的派生出现在XML实例中。注册表模式从该元素派生，以定义查询返回的结果。
o <genericCode> -- As defined, this element is an instance of <codeType>. It contains the optional elements <explanation> and <language>, which further describe the nature of the error.
o <genericCode>--根据定义，此元素是<codeType>的实例。它包含可选元素<解释>和<语言>，它们进一步描述了错误的性质。
o <entity> -- Identifies a reference to an entity. Registry schemas SHOULD use elements derived from <entity> but MAY use <entity> directly. The advantage of deriving from <entity> vs. direct use is the chance to define the name of the element and to use that name descriptively -- for instance, as the role the entity plays with respect to another entity. See Section 4.3.5.
o <实体>--标识对实体的引用。注册表架构应该使用从<entity>派生的元素，但可以直接使用<entity>。与直接使用相比，从<entity>派生的优势在于有机会定义元素的名称，并以描述性的方式使用该名称——例如，作为实体相对于另一个实体所扮演的角色。见第4.3.5节。
o <seeAlso> -- Indicates a reference to an entity that has indirect association with a parent element representing an entity. This element is derived from the <entity> element (Section 4.3.5). Registry schemas MAY derive from this element or MAY use it directly.
o <参见>--表示对与表示实体的父元素间接关联的实体的引用。该元素源自<entity>元素（第4.3.5节）。注册表模式可以从该元素派生，也可以直接使用它。
The identifier for a registry type and the XML namespace identifier used by the XML Schema describing the registry MUST be the same. These identifiers MUST be restricted to a URN [7] registered in the 'ns' class of the IANA registry governed by XML_URN [9]. These identifiers are case insensitive.
注册表类型的标识符和描述注册表的XML架构使用的XML命名空间标识符必须相同。这些标识符必须限制为在IANA注册中心的“ns”类中注册的URN[7]，该注册中心由XML_URN[9]管理。这些标识符不区分大小写。
This is a restriction on XML_NS [3], which specifies that an XML namespace identifier is any valid URI [6].
这是对XML的限制[3]，它指定XML名称空间标识符是任何有效的URI[6]。
These identifiers MAY be abbreviated to the part following the class component and its separator of the URN. For example, the full URN "urn:ietf:params:xml:ns:dreg1" may be abbreviated to "dreg1".
这些标识符可以缩写为URN的类组件及其分隔符后面的部分。例如，完整的URN“URN:ietf:params:xml:ns:dreg1”可以缩写为“dreg1”。
In use with IRIS, this abbreviation MUST NOT be used inside of XML instances in which the XML Schema [4] specifies the use of a URI for schema identification or where XML_NS [3] specifies the use of a URI for XML namespace identification.
与IRIS一起使用时，在XML模式[4]指定使用URI进行模式标识的XML实例中，或在XML\n[3]指定使用URI进行XML命名空间标识的XML实例中，不得使用此缩写。
IRIS provides entity classes to help avoid collisions with entity names within any given registry type. Their specification in queries also allows server implementations to narrow search or lookup scopes quickly to a single index.
IRIS提供实体类以帮助避免与任何给定注册表类型内的实体名称发生冲突。它们在查询中的规范还允许服务器实现将搜索或查找范围快速缩小到单个索引。
For instance, the entity name "192.0.2.0" might refer to separate entities in the "name-server" and "network" classes. The entity "192.0.2.0" in the "name-server" class may refer to the name server host that is also multi-homed by address 192.0.2.255 and known in DNS as "ns.example.com", whereas the entity "192.0.2.0" in the "network" class may refer to the network 192.0.2/30.
例如，实体名称“192.0.2.0”可能指的是“名称服务器”和“网络”类中的独立实体。“名称服务器”类中的实体“192.0.2.0”可指地址为192.0.2.255且在DNS中称为“ns.example.com”的名称服务器主机，而“网络”类中的实体“192.0.2.0”可指网络192.0.2/30。
IRIS defines two default entity classes of "local" and "iris", which MUST NOT be redefined. These entity classes MUST be valid in all registry types.
IRIS定义了两个默认的实体类“local”和“IRIS”，不能重新定义它们。这些实体类必须在所有注册表类型中有效。
The "local" class is reserved for entities defined locally by a server operator and does not denote any particular type of entity. A lookup in this entity class MAY result in an entity reference or search continuation. For example, "iris:dreg1//example.com/local/
“local”类是为服务器操作员在本地定义的实体保留的，不表示任何特定类型的实体。此实体类中的查找可能导致实体引用或搜索继续。例如，“iris:dreg1//example.com/local/
myhosts" may result in a search continuation yielding the nameservers for example.com.
myhosts”可能会导致搜索继续，生成名称服务器，例如.com。
The "iris" class is reserved for entities specific to a particular service instance. It MUST contain the following entity names (see Section 4.3.4):
“iris”类是为特定于特定服务实例的实体保留的。必须包含以下实体名称（见第4.3.4节）：
o "id", which yields a result of <serviceIdentification> (see Section 4.3.7.1).
o “id”，产生<serviceIdentification>的结果（见第4.3.7.1节）。
o "limits", which yields a result of <limits> (see Section 4.3.7.2). This entity class MAY contain other locally defined entities as well.
o “限制”，产生<限制>（见第4.3.7.2节）。该实体类还可以包含其他本地定义的实体。
The names of entity classes in a registry schema are of type token, as defined by XML_SD [4]. Their case sensitivity MUST be defined by the definition of the registry type. In general, they SHOULD be case insensitive.
注册表模式中实体类的名称是XML_SD[4]定义的token类型。它们的大小写敏感度必须由注册表类型的定义定义。一般来说，它们应该不区分大小写。
The names of entities in a registry schema are of type token, as defined by XML_SD [4].
注册表模式中实体的名称为XML_SD[4]定义的token类型。
Names of entities SHOULD be unique within an instance of any particular entity class within a registry. Two entities SHOULD NOT have the same name, but a single entity MAY be known by multiple names. In situations where a single name may result in two entities, the registry schema SHOULD make allowances by defining result types that contain entity references to both entities (e.g., "example.com" can refer to both the domain example.com and the host example.com). However, this type of conflict SHOULD generally be avoided by the proper use of entity classes.
实体名称在注册表中任何特定实体类的实例中都应该是唯一的。两个实体不应具有相同的名称，但一个实体可能有多个名称。在单个名称可能导致两个实体的情况下，注册表模式应通过定义包含对这两个实体的实体引用的结果类型（例如，“example.com”可以同时引用域example.com和主机example.com）来允许。但是，通常应通过正确使用实体类来避免此类冲突。
The case sensitivity of entity names is dependent on the entity class in which they reside. The definition of a registry type MUST specify the case sensitivity for entity names. A registry type MAY define the entity names of differing entity classes as having different case sensitivity.
实体名称的大小写敏感度取决于它们所在的实体类。注册表类型的定义必须指定实体名称的大小写敏感度。注册表类型可以将不同实体类的实体名称定义为具有不同的大小写敏感度。
The element <entity> allows references to entities in result sets,
either as a direct child of <resultSet> or within a more complex
structure deriving from <result>. The <entity> element is defined by
'entityType'. Registry schemas SHOULD define elements derived from
<entity> when referencing entities but may use the <entity> element
directly. Deriving a new element allows a registry schema to use the
The element <entity> allows references to entities in result sets,
either as a direct child of <resultSet> or within a more complex
structure deriving from <result>. The <entity> element is defined by
'entityType'. Registry schemas SHOULD define elements derived from
<entity> when referencing entities but may use the <entity> element
directly. Deriving a new element allows a registry schema to use the
name of the new element to signify the relationship the referenced entity has with the referrer. A derivative of <entity> MUST NOT be used as a substitute when the <entity> element is declared (such as in the <answer> section of the <resultSet>).
新元素的名称，表示被引用实体与引用者之间的关系。声明<entity>元素时（如<resultSet>的<answer>部分），不得将<entity>的派生词用作替换词。
The <entity> element (and elements of type 'entityType') can have child elements of <displayName> with an optional 'language' attribute. These are provided so that servers may provide clients with a more human-friendly description of the entity reference. This is often useful to users navigating referral structures.
<entity>元素（以及类型为“entityType”的元素）可以具有具有可选“language”属性的<displayName>子元素。提供这些工具是为了使服务器可以为客户端提供对实体引用更人性化的描述。这对于浏览推荐结构的用户通常很有用。
The <entity> element (and its derivations) have the following attributes:
<entity>元素（及其派生）具有以下属性：
o 'authority', 'resolution' (optional), 'registryType', 'entityClass', and 'entityName' -- These attributes specify where the entity may be found.
o “authority”、“resolution”（可选）、“registryType”、“entityClass”和“entityName”——这些属性指定可以在何处找到实体。
o 'temporaryReference' -- This attribute is optional. See Section 4.3.6.
o “临时引用”-此属性是可选的。见第4.3.6节。
o 'referentType' -- This attribute contains the expected type of the entity being referenced and may contain the word "ANY" or a qualified XML name. Unlike the other attributes of <entity>, this attribute is qualified and declared in the IRIS XML namespace. Therefore it will also be qualified with the prefix associated with the IRIS XML namespace (e.g., 'iris:referentType'). This allows clients to recognize entity references using an element derived from <entity>.
o “referentType”-此属性包含被引用实体的预期类型，并且可能包含单词“ANY”或限定的XML名称。与<entity>的其他属性不同，此属性是在IRIS XML命名空间中限定和声明的。因此，它还将使用与IRIS XML名称空间相关联的前缀进行限定（例如，“IRIS:ReferenceType”）。这允许客户端使用从<entity>派生的元素识别实体引用。
o 'bagRef' -- This attribute is optional. If present, it must contain an XML identifier to a <bag> element in the <bags> section of the result set. For a description of the 'bagRef' attribute, see Section 4.4.
o “bagRef”-此属性是可选的。如果存在，它必须包含结果集<bags>部分中<bag>元素的XML标识符。有关“bagRef”属性的说明，请参见第4.4节。
Instances may exist in which an entity reference needs to be temporary. For example, a particular type of result may only have one unique key. If that key contains semantic meaning that may not be exposed to all users, a synthetic key will have to be substituted.
可能存在实体引用需要为临时引用的实例。例如，特定类型的结果可能只有一个唯一键。如果该键包含可能不会向所有用户公开的语义含义，则必须替换合成键。
Furthermore, there may be times when data in the data store is not normalized in the same manner as that expressed by the registry schema. In the registry schema, objects of type A may reference objects of type B. But in the data store, objects of type A may contain objects of type B. Again, a synthetic key will have to be temporarily produced.
此外，有时数据存储中的数据可能没有以与注册表模式所表示的相同的方式进行规范化。在注册表模式中，类型A的对象可能引用类型B的对象。但在数据存储中，类型A的对象可能包含类型B的对象。同样，必须临时生成合成键。
To support such use cases, results and entity references can be declared temporary by using the 'temporaryReference' attribute. This attribute is of type boolean [4] and has a default value of "false". It is optional for <result> derivatives and elements of type 'entityType'.
为了支持这种用例，可以使用“temporaryReference”属性将结果和实体引用声明为临时的。此属性的类型为布尔[4]，默认值为“false”。对于类型为“entityType”的<result>导数和元素，它是可选的。
When this attribute is used, the entity reference data (e.g., 'entityClass', 'entityName') is only valid within the response in which it appears and may not be consistent with subsequent responses. A server MUST include the referent of any temporary entity reference in the <additional> section of the same <resultSet>
使用此属性时，实体引用数据（例如，“entityClass”、“entityName”）仅在其出现的响应中有效，并且可能与后续响应不一致。服务器必须在同一<resultSet>的<additional>部分中包含任何临时实体引用的referent
The base IRIS framework contains three elements directly derived from the <result> element for use by any registry type.
基本IRIS框架包含三个直接从<result>元素派生的元素，供任何注册表类型使用。
An example of a <serviceIdentification> result:
<serviceIdentification>结果示例：
<serviceIdentification
authority="example.com" registryType="dreg1"
entityClass="iris"
entityName="id" >
<authorities>
<authority> example.com </authority>
<authority> example.net </authority>
<authority> example.org </authority>
</authorities>
<operatorName>
Internet Assigned Numbers Authority
</operatorName>
<eMail>
iana@iana.org
</eMail>
</serviceIdentification>
<serviceIdentification
authority="example.com" registryType="dreg1"
entityClass="iris"
entityName="id" >
<authorities>
<authority> example.com </authority>
<authority> example.net </authority>
<authority> example.org </authority>
</authorities>
<operatorName>
Internet Assigned Numbers Authority
</operatorName>
<eMail>
iana@iana.org
</eMail>
</serviceIdentification>
The <serviceIdentification> element is provided to allow IRIS clients to reference IRIS service instances. It contains the following elements:
提供<serviceIdentification>元素以允许IRIS客户端引用IRIS服务实例。它包含以下元素：
o <authorities> -- This element contains one or more <authority> elements. Each <authority> element contains a URI authority component for which the server has results. Although a server MAY only return a partial list of its authority areas, depending on operator policy, it MUST return the authority for which the client has requested.
o <authorities>--此元素包含一个或多个<authority>元素。每个<authority>元素都包含一个URI授权组件，服务器对该组件有结果。尽管服务器可能只返回其权限区域的部分列表，但根据运营商策略，它必须返回客户端请求的权限。
o <operatorName> -- This element contains the name of the operator of the server.
o <operatorName>——此元素包含服务器操作员的名称。
o <eMail> -- These optional elements contain email addresses of the operator of the service instance.
o <eMail>——这些可选元素包含服务实例的操作员的电子邮件地址。
o <phone> -- These optional elements contain phone numbers of the operator of the service instance.
o <phone>——这些可选元素包含服务实例的运营商的电话号码。
o <seeAlso> -- See Section 4.3.1 for its definition.
o <另见>--其定义见第4.3.1节。
An example of a <limits> result:
<limits>结果示例：
<limits
authority="example.com" registryType="dreg1"
entityClass="iris" entityName="limits">
<totalQueries>
<perHour>2</perHour>
<perDay>15</perDay>
</totalQueries>
<totalResults>
<perHour>25</perHour>
<perDay>200</perDay>
</totalResults>
<totalSessions>
<perHour>2</perHour>
<perDay>15</perDay>
</totalSessions>
</limits>
<limits
authority="example.com" registryType="dreg1"
entityClass="iris" entityName="limits">
<totalQueries>
<perHour>2</perHour>
<perDay>15</perDay>
</totalQueries>
<totalResults>
<perHour>25</perHour>
<perDay>200</perDay>
</totalResults>
<totalSessions>
<perHour>2</perHour>
<perDay>15</perDay>
</totalSessions>
</limits>
The <limits> element provides a mechanism allowing a server to inform a client of the limits it may encounter from overuse of the service. The contents describe the service limitations to a client at the current level of access. The contents of this element are as follows:
<limits>元素提供了一种机制，允许服务器通知客户端由于过度使用服务而可能遇到的限制。内容描述了在当前访问级别上对客户端的服务限制。该要素的内容如下：
o <totalQueries> -- This element describes the total number of queries that the server will accept. The children of this element indicate this number per unit of time. The children are <perSecond>, <perMinute>, <perHour>, and <perDay>. Each child MUST only appear once as a child of <totalQueries>, but more than one child MAY be present. For example, a server could indicate that it will accept 15 queries a minute but only 60 queries a day.
o <totalQueries>--此元素描述服务器将接受的查询总数。此元素的子元素表示每单位时间的数字。孩子们是<perSecond>，<perMinute>，<perHour>和<perDay>。每个子项只能作为<totalQueries>的子项出现一次，但可能存在多个子项。例如，一台服务器可以表示它每分钟接受15个查询，但每天只接受60个查询。
o <totalResults> -- This element describes the total number of results that the server will send to a client. The children of this element indicate this number per unit of time in the same manner as <totalQueries>.
o <totalResults>--此元素描述服务器将发送给客户端的结果总数。此元素的子元素以与<totalQueries>相同的方式指示每单位时间的此数字。
o <totalSessions> -- This element describes the total number of sessions that the server will accept from a client. The children of this element indicate this number per unit of time in the same manner as <totalQueries>. The definition of a session is defined the by application transport layer.
o <totalSessions>--此元素描述服务器将从客户端接受的会话总数。此元素的子元素以与<totalQueries>相同的方式指示每单位时间的此数字。会话的定义由应用程序传输层定义。
o <otherRestrictions> -- This element describes other restrictions that may only be expressible outside of the structured syntax of the other child elements of <limits>. This element may have optional <description> child elements, each with a mandatory 'language' attribute.
o <otherRestrictions>--此元素描述了只能在<limits>的其他子元素的结构化语法之外表达的其他限制。此元素可能有可选的<description>子元素，每个子元素都有一个必需的“language”属性。
o <seeAlso> -- These elements are provided to reference other entities, such as a <simpleEntity> (Section 4.3.7.3) describing a published policy. See <seeAlso> (Section 4.3.1).
o <另请参见>--提供这些元素是为了参考其他实体，例如描述已发布策略的<simpleEntity>（第4.3.7.3节）。另请参见（第4.3.1节）。
All of these child elements are optional, and a server may express that it has no limits by using a <limits> element with no content (e.g., <limits authority=... />).
所有这些子元素都是可选的，服务器可以通过使用不包含内容的<limits>元素（例如，<limits authority=…/>）来表示它没有限制。
An example of a <simpleEntity> result:
<simpleEntity>结果示例：
<simpleEntity
authority="example.com" registryType="dreg1"
entityClass="local"
entityName="notice" >
<property name="legal" language="en">
Example.com is reserved according to RFC 2606.
</property>
</simpleEntity>
<simpleEntity
authority="example.com" registryType="dreg1"
entityClass="local"
entityName="notice" >
<property name="legal" language="en">
Example.com is reserved according to RFC 2606.
</property>
</simpleEntity>
The <simpleEntity> element is provided so that service operators may make simple additions to other entities without deriving entirely new registry types. Its definition allows service operators to reference it from other entities (using, for instance, a <seeAlso> element). The <simpleEntity> is meant to represent name and value pairs of strings, allowing each pair to be associated with a specific language qualifier and an optional URI pointing to more information.
提供了<simpleEntity>元素，以便服务运营商可以对其他实体进行简单的添加，而无需派生全新的注册表类型。它的定义允许服务运营商从其他实体引用它（例如，使用<seealsh>元素）。<simpleEntity>表示字符串的名称和值对，允许每对字符串与特定的语言限定符和指向更多信息的可选URI相关联。
Clients may easily display such information in a two-column table. Applications using binary data or richer data structures are out of scope for this element. When such usage scenarios arise, a client will likely need specific knowledge to handle such data, thus calling the need for a new registry type into question.
客户机可以很容易地在两列表中显示此类信息。使用二进制数据或更丰富数据结构的应用程序超出此元素的范围。当出现这样的使用场景时，客户机可能需要特定的知识来处理这样的数据，因此对新注册表类型的需求提出了疑问。
The <control> (Section 4.1) and <reaction> (Section 4.2) elements allow the client to request from the server special states for the processing of queries. The intent of these elements is to allow extensibility so that some jurisdictions may adopt policies for query processing without requiring re-versioning of IRIS or any registry type.
<control>（第4.1节）和<reaction>（第4.2节）元素允许客户端从服务器请求处理查询的特殊状态。这些元素的目的是允许扩展性，以便某些司法管辖区可以采用查询处理策略，而无需对IRIS或任何注册表类型进行重新版本控制。
This document defines one control, <onlyCheckPermissions>, and its requisite reaction, <standardReaction>, for compliance with CRISP [17].
本文件定义了一种控制方法，<onlyCheckPermissions>，以及它的必要反应，<standardReaction>，以符合CRISP[17]。
When a client sends an <onlyCheckPermissions> control, it is only asking the server to check to see whether adequate permissions are available to execute the queries in the associated request. A server MUST respond to this control with a <standardReaction> element.
当客户端发送<onlyCheckPermissions>控件时，它只要求服务器检查是否有足够的权限来执行关联请求中的查询。服务器必须使用<standardReaction>元素响应此控件。
The <standardReaction> element provides a server with a standard means to respond to controls (it may be used by other controls, but this is left to their definition). It contains four children:
<standardReaction>元素为服务器提供了响应控件的标准方法（其他控件可以使用它，但这取决于它们的定义）。它包含四个子项：
o <controlAccepted> -- the processing or state needed by the control has been accepted.
o <controlAccepted>——控件所需的处理或状态已被接受。
o <controlDenied> -- the processing or state needed by the control has been denied (a transient failure).
o <controlDenied>——控件所需的处理或状态已被拒绝（瞬时故障）。
o <controlDisabled> -- the processing or state needed by the control cannot be activated (a permanent failure).
o <controlDisabled>——无法激活控件所需的处理或状态（永久性故障）。
o <controlUnrecognized> -- the control is not recognized (a permanent failure).
o <ControlUnrecogned>——无法识别该控件（永久性故障）。
If <onlyCheckPermissions> is rejected, then the server MUST return all appropriate result sets (i.e., for every search set in the request), but all result sets MUST be empty of results and MUST contain no errors (a reaction is not part of a result set and is therefore not a result set error). This control applies to all search sets or none of them; therefore a server MUST issue a rejection if <onlyCheckPermissions> cannot be accepted for all search sets in a request.
如果<onlyCheckPermissions>被拒绝，则服务器必须返回所有适当的结果集（即，对于请求中的每个搜索集），但所有结果集必须为空，且不得包含任何错误（反应不是结果集的一部分，因此不是结果集错误）。此控件适用于所有搜索集或不适用于任何搜索集；因此，如果请求中的所有搜索集都不能接受<onlyCheckPermissions>，则服务器必须发出拒绝。
An example of an IRIS XML exchange using these elements follows:
使用以下元素的IRIS XML交换示例如下：
C: <?xml version="1.0"?>
C: <request xmlns="urn:ietf:params:xml:ns:iris1"
C: xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" >
C:
C: <control>
C: <onlyCheckPermissions />
C: </control>
C:
C: <searchSet>
C:
C: <lookupEntity
C: registryType="dreg1"
C: entityClass="local"
C: entityName="AUP" />
C:
C: </searchSet>
C:
C: </request>
C: <?xml version="1.0"?>
C: <request xmlns="urn:ietf:params:xml:ns:iris1"
C: xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" >
C:
C: <control>
C: <onlyCheckPermissions />
C: </control>
C:
C: <searchSet>
C:
C: <lookupEntity
C: registryType="dreg1"
C: entityClass="local"
C: entityName="AUP" />
C:
C: </searchSet>
C:
C: </request>
S: <?xml version="1.0"?>
S: <response xmlns="urn:ietf:params:xml:ns:iris1"
S: xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" >
S:
S: <reaction>
S: <standardReaction>
S: <controlAccepted />
S: </standardReaction>
S: </reaction>
S:
S: <resultSet>
S: <answer>
S:
S: <simpleEntity
S: authority="example.com" registryType="dreg1"
S: entityClass="local" entityName="AUP" >
S: <property name="legal" language="en">
S: It is illegal to use information from this service
S: for the purposes of sending unsolicited bulk email.
S: </property>
S: </simpleEntity>
S:
S: </answer>
S: </resultSet>
S:
S: </response>
S: <?xml version="1.0"?>
S: <response xmlns="urn:ietf:params:xml:ns:iris1"
S: xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" >
S:
S: <reaction>
S: <standardReaction>
S: <controlAccepted />
S: </standardReaction>
S: </reaction>
S:
S: <resultSet>
S: <answer>
S:
S: <simpleEntity
S: authority="example.com" registryType="dreg1"
S: entityClass="local" entityName="AUP" >
S: <property name="legal" language="en">
S: It is illegal to use information from this service
S: for the purposes of sending unsolicited bulk email.
S: </property>
S: </simpleEntity>
S:
S: </answer>
S: </resultSet>
S:
S: </response>
IRIS employs bags to allow a server to relay information to a referent server via the client. These bags are generated by the queried server, passed to the client as opaque data, and then passed to the referent server for processing. The contents of the bags are not defined by IRIS, and the client MUST NOT make any assumptions about the contents of a bag when relaying it from one server to another.
IRIS使用包允许服务器通过客户端将信息中继到引用服务器。这些包由查询的服务器生成，作为不透明数据传递给客户端，然后传递给referent服务器进行处理。包的内容不是由IRIS定义的，当包从一台服务器中继到另一台服务器时，客户端不得对包的内容进行任何假设。
When a server returns a result set to a client, the <response> element may contain a <bags> child element. This child element contains one or more <bag> elements. Each of these MUST contain an 'id' attribute containing the XML data type ID. Entity references and search continuations that have to specify a bag to be used when they are followed MUST have a 'bagRef' attribute containing the XML data type IDREF. See Section 4.2. This allows the response to specify a bag only once but allows each entity reference or search continuation (in all result sets) to have a distinct bag, as needed.
当服务器向客户端返回结果集时，<response>元素可能包含一个子元素。此子元素包含一个或多个<bag>元素。其中每一个都必须包含一个包含XML数据类型id的“id”属性。实体引用和搜索延续必须指定在遵循它们时要使用的包，必须具有一个包含XML数据类型IDREF的“bagRef”属性。见第4.2节。这允许响应只指定一次包，但允许每个实体引用或搜索继续（在所有结果集中）根据需要具有不同的包。
When following an entity reference or search continuation that specifies the use of a bag, the client MUST include the referenced bag in the search set as a child of the <searchSet> element. See Section 4.1.
当遵循指定行李使用的实体引用或搜索延续时，客户机必须将被引用的行李作为<searchSet>元素的子元素包含在搜索集中。见第4.1节。
See Section 4.2 for the list of errors a server may return to a client when a bag is received. A server MUST NOT ignore a bag when it is received. In case a bag cannot be recognized or accepted, one of the errors from Section 4.2 MUST be returned.
有关收到行李时服务器可能返回给客户端的错误列表，请参见第4.2节。当收到行李时，服务器不得忽略该行李。如果无法识别或接受行李，则必须返回第4.2节中的一个错误。
An example of an IRIS XML exchange using these elements follows:
使用以下元素的IRIS XML交换示例如下：
C: <?xml version="1.0"?>
C: <request xmlns="urn:ietf:params:xml:ns:iris1"
C: xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" >
C:
C: <searchSet>
C:
C: <bag>
C: <simpleBag xmlns="http://example.com/">
C: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
C: </simpleBag>
C: </bag>
C:
C: <lookupEntity
C: registryType="dreg1"
C: entityClass="local"
C: entityName="AUP" />
C: <?xml version="1.0"?>
C: <request xmlns="urn:ietf:params:xml:ns:iris1"
C: xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" >
C:
C: <searchSet>
C:
C: <bag>
C: <simpleBag xmlns="http://example.com/">
C: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
C: </simpleBag>
C: </bag>
C:
C: <lookupEntity
C: registryType="dreg1"
C: entityClass="local"
C: entityName="AUP" />
C:
C: </searchSet>
C:
C: </request>
C:
C: </searchSet>
C:
C: </request>
S: <?xml version="1.0"?>
S: <response xmlns="urn:ietf:params:xml:ns:iris1"
S: xmlns:iris="urn:ietf:params:xml:ns:iris1"
S: xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" >
S:
S: <resultSet>
S: <answer>
S:
S: <entity authority="example.com" bagRef="x1"
S: registryType="dreg1"
S: entityClass="local" entityName="AUP"
S: iris:referentType="ANY" >
S: <displayName language="en">
S: Acceptable Usage Policy
S: </displayName>
S: </entity>
S:
S: </answer>
S: </resultSet>
S:
S: <bags>
S:
S: <bag id="x1">
S: <simpleBag xmlns="http://example.com/">
S: AAAAB3NzaC1yc2EAAAABIwAAAIEA0ddD+W3Agl0Lel98G1r77fZ
S: </simpleBag>
S: </bag>
S:
S: </bags>
S: </response>
S: <?xml version="1.0"?>
S: <response xmlns="urn:ietf:params:xml:ns:iris1"
S: xmlns:iris="urn:ietf:params:xml:ns:iris1"
S: xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" >
S:
S: <resultSet>
S: <answer>
S:
S: <entity authority="example.com" bagRef="x1"
S: registryType="dreg1"
S: entityClass="local" entityName="AUP"
S: iris:referentType="ANY" >
S: <displayName language="en">
S: Acceptable Usage Policy
S: </displayName>
S: </entity>
S:
S: </answer>
S: </resultSet>
S:
S: <bags>
S:
S: <bag id="x1">
S: <simpleBag xmlns="http://example.com/">
S: AAAAB3NzaC1yc2EAAAABIwAAAIEA0ddD+W3Agl0Lel98G1r77fZ
S: </simpleBag>
S: </bag>
S:
S: </bags>
S: </response>
This section describes a method for serializing IRIS registry entities. The descriptions contained within this section refer to XML elements and attributes and their relation to this serialization process. These descriptions also contain specifications outside the scope of the formal XML syntax. This section will use terms defined by RFC 2119 [8] to describe these. While reading this section, please reference Section 6 for needed details on the formal XML syntax.
本节介绍序列化IRIS注册表实体的方法。本节中包含的描述涉及XML元素和属性及其与此序列化过程的关系。这些描述还包含正式XML语法范围之外的规范。本节将使用RFC 2119[8]定义的术语来描述这些。在阅读本节时，请参考第6节，以了解有关正式XML语法的必要详细信息。
A database of IRIS entities can be serialized to file storage with XML [2] by using the IRIS defined <serialization> element. This element contains <result> element derivatives and <serializedReferral> elements.
通过使用IRIS定义的<serialization>元素，IRIS实体数据库可以用XML[2]序列化为文件存储。此元素包含<result>元素派生和<serializedFerral>元素。
Derivatives of the <result> element are entities. Servers loading these entities MUST place the entity in the entity classes specified by the elements 'registryType', 'entityClass', and 'entityName' attributes and in any entity classes the entities may apply according to explicitly defined children of that element. For instance, if a registry type has two entity classes "foo" and "bar" and a <result> derivative has the attributes entityClass="foo" and entityName="one" and a child element <bar>two</bar>, the server is to enter that entity into the entity class "foo" as the name "one" and into the entity class "bar" as the name "two".
<result>元素的导数是实体。加载这些实体的服务器必须将该实体放置在元素“registryType”、“entityClass”和“entityName”属性指定的实体类中，以及实体可以根据该元素的显式定义的子级应用的任何实体类中。例如，如果注册表类型有两个实体类“foo”和“bar”，并且<result>派生具有属性entityClass=“foo”和entityName=“one”以及子元素<bar>two</bar>，则服务器将该实体作为名称“one”输入实体类“foo”，作为名称“two”输入实体类“bar”。
Servers loading entities as serialized derivatives of the <result> element MAY translate the authority attribute. Servers will likely have to do this if the authority for the entity has changed.
将实体作为<result>元素的序列化派生加载的服务器可以转换authority属性。如果实体的权限已更改，服务器可能必须执行此操作。
<serializedReferral> elements allow the serialization of explicit entity references and search continuations. This element has a child <source> element containing the 'authority', 'resolution' (optional), 'registryType', 'entityClass', and 'entityName' attributes. The attributes of this element are used to signify the entity that can be referenced to yield this referral.
<SerializedFerral>元素允许显式实体引用和搜索延续的序列化。此元素有一个子<source>元素，其中包含“authority”、“resolution”（可选）、“registryType”、“entityClass”和“entityName”属性。此元素的属性用于表示可被引用以产生此引用的实体。
As mentioned above, there may be times when a server needs to translate the authority attribute of a loaded entity. Implementations must also beware of this need for referrals. During deserialization, servers MUST change the authority attribute of a referral (either <entity> or elements derived from <entity> or <source> child of <serializedReferral>) to contain a valid authority of the server if the serialized attribute is empty. During serialization, servers and their related processes MUST leave the authority attribute empty for referrals in which the referent is an entity for which the server answers queries.
如上所述，有时服务器可能需要转换加载实体的authority属性。实现还必须注意这种转介需求。在反序列化过程中，如果序列化属性为空，服务器必须更改引用的authority属性（“实体”）或派生自<entity>或<serializedFerral>子级的元素，以包含服务器的有效权限。在序列化过程中，对于引用对象是服务器回答查询的实体的引用，服务器及其相关进程必须将authority属性保留为空。
The following is an example of serialized IRIS:
以下是序列化IRI的示例：
<iris:serialization
xmlns:iris="urn:ietf:params:xml:ns:iris1"
xmlns="urn:ietf:params:xml:ns:iris1"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<iris:serialization
xmlns:iris="urn:ietf:params:xml:ns:iris1"
xmlns="urn:ietf:params:xml:ns:iris1"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<serviceIdentification
authority="iana.org" registryType="dreg1"
entityClass="iris"
entityName="id" >
<authorities>
<authority> iana.org </authority>
</authorities>
<operatorName>
Internet Assigned Numbers Authority
</operatorName>
<eMail>
dbarton@iana.org
</eMail>
<seeAlso
iris:referentType="iris:simpleEntity"
authority="iana.org" registryType="dreg1"
entityClass="local"
entityName="notice">
<displayName language="en">
Legal Notice
</displayName>
</seeAlso>
</serviceIdentification>
<serviceIdentification
authority="iana.org" registryType="dreg1"
entityClass="iris"
entityName="id" >
<authorities>
<authority> iana.org </authority>
</authorities>
<operatorName>
Internet Assigned Numbers Authority
</operatorName>
<eMail>
dbarton@iana.org
</eMail>
<seeAlso
iris:referentType="iris:simpleEntity"
authority="iana.org" registryType="dreg1"
entityClass="local"
entityName="notice">
<displayName language="en">
Legal Notice
</displayName>
</seeAlso>
</serviceIdentification>
<serializedReferral>
<source
authority="example.com" registryType="dreg1"
entityClass="iris"
entityName="id"/>
<entity
iris:referentType="iris:serviceIdentification"
authority="iana.org" registryType="dreg1"
entityClass="iris" entityName="id"/>
</serializedReferral>
<serializedReferral>
<source
authority="example.com" registryType="dreg1"
entityClass="iris"
entityName="id"/>
<entity
iris:referentType="iris:serviceIdentification"
authority="iana.org" registryType="dreg1"
entityClass="iris" entityName="id"/>
</serializedReferral>
<simpleEntity
authority="iana.org" registryType="dreg1"
entityClass="local"
entityName="notice" >
<property name="legal" language="en">
Please use the net wisely!
</property>
</simpleEntity>
<simpleEntity
authority="iana.org" registryType="dreg1"
entityClass="local"
entityName="notice" >
<property name="legal" language="en">
Please use the net wisely!
</property>
</simpleEntity>
</iris:serialization>
</iris:serialization>
IRIS is specified in XML Schema notation. The formal syntax presented here is a complete schema representation of IRIS suitable for automated validation of IRIS XML instances.
IRIS是用XML模式表示法指定的。这里给出的形式语法是一个完整的IRIS模式表示，适合于IRIS XML实例的自动验证。
<?xml version="1.0"?>
<schema xmlns="http://www.w3.org/2001/XMLSchema"
xmlns:iris="urn:ietf:params:xml:ns:iris1"
targetNamespace="urn:ietf:params:xml:ns:iris1"
elementFormDefault="qualified" >
<?xml version="1.0"?>
<schema xmlns="http://www.w3.org/2001/XMLSchema"
xmlns:iris="urn:ietf:params:xml:ns:iris1"
targetNamespace="urn:ietf:params:xml:ns:iris1"
elementFormDefault="qualified" >
<annotation>
<documentation>
Internet Registry Information Service (IRIS) Schema v1
</documentation>
</annotation>
<annotation>
<documentation>
Internet Registry Information Service (IRIS) Schema v1
</documentation>
</annotation>
<!-- ========================================= -->
<!-- -->
<!-- The Transactions -->
<!-- -->
<!-- ========================================= -->
<!-- ========================================= -->
<!-- -->
<!-- The Transactions -->
<!-- -->
<!-- ========================================= -->
<element name="request">
<complexType>
<sequence>
<element
name="control"
type="iris:controlType"
minOccurs="0"
maxOccurs="1" />
<element
name="searchSet"
type="iris:searchSetType"
minOccurs="1"
maxOccurs="unbounded" />
</sequence>
</complexType>
</element>
<element name="request">
<complexType>
<sequence>
<element
name="control"
type="iris:controlType"
minOccurs="0"
maxOccurs="1" />
<element
name="searchSet"
type="iris:searchSetType"
minOccurs="1"
maxOccurs="unbounded" />
</sequence>
</complexType>
</element>
<element name="response">
<complexType>
<sequence>
<element
name="reaction"
type="iris:reactionType"
minOccurs="0"
<element name="response">
<complexType>
<sequence>
<element
name="reaction"
type="iris:reactionType"
minOccurs="0"
maxOccurs="1" />
<element
name="resultSet"
type="iris:resultSetType"
minOccurs="1"
maxOccurs="unbounded" />
<element
name="bags"
type="iris:bagsType"
minOccurs="0"
maxOccurs="1" />
</sequence>
</complexType>
</element>
maxOccurs="1" />
<element
name="resultSet"
type="iris:resultSetType"
minOccurs="1"
maxOccurs="unbounded" />
<element
name="bags"
type="iris:bagsType"
minOccurs="0"
maxOccurs="1" />
</sequence>
</complexType>
</element>
<!-- ========================================= -->
<!-- -->
<!-- Search Sets and Result Sets -->
<!-- -->
<!-- ========================================= -->
<!-- ========================================= -->
<!-- -->
<!-- Search Sets and Result Sets -->
<!-- -->
<!-- ========================================= -->
<complexType
name="searchSetType" >
<sequence>
<element
name="bag"
type="iris:bagType"
minOccurs="0"
maxOccurs="1" />
<choice>
<element
name="lookupEntity"
type="iris:lookupEntityType" />
<element
ref="iris:query" />
</choice>
</sequence>
</complexType>
<complexType
name="searchSetType" >
<sequence>
<element
name="bag"
type="iris:bagType"
minOccurs="0"
maxOccurs="1" />
<choice>
<element
name="lookupEntity"
type="iris:lookupEntityType" />
<element
ref="iris:query" />
</choice>
</sequence>
</complexType>
<complexType
name="resultSetType" >
<sequence>
<element
name="answer"
minOccurs="1"
maxOccurs="1">
<complexType>
<sequence>
<complexType
name="resultSetType" >
<sequence>
<element
name="answer"
minOccurs="1"
maxOccurs="1">
<complexType>
<sequence>
<element
ref="iris:result"
minOccurs="0"
maxOccurs="unbounded" />
<element
ref="iris:entity"
minOccurs="0"
maxOccurs="unbounded" />
<element
ref="iris:searchContinuation"
minOccurs="0"
maxOccurs="unbounded" />
</sequence>
</complexType>
</element>
<element
name="additional"
minOccurs="0"
maxOccurs="1">
<complexType>
<sequence>
<element
ref="iris:result"
minOccurs="1"
maxOccurs="unbounded" />
</sequence>
</complexType>
</element>
<choice
minOccurs="0"
maxOccurs="1" >
<element
name="insufficientResources"
type="iris:codeType" />
<element
name="invalidName"
type="iris:codeType" />
<element
name="invalidSearch"
type="iris:codeType" />
<element
name="queryNotSupported"
type="iris:codeType" />
<element
name="limitExceeded"
type="iris:codeType" />
<element
name="nameNotFound"
<element
ref="iris:result"
minOccurs="0"
maxOccurs="unbounded" />
<element
ref="iris:entity"
minOccurs="0"
maxOccurs="unbounded" />
<element
ref="iris:searchContinuation"
minOccurs="0"
maxOccurs="unbounded" />
</sequence>
</complexType>
</element>
<element
name="additional"
minOccurs="0"
maxOccurs="1">
<complexType>
<sequence>
<element
ref="iris:result"
minOccurs="1"
maxOccurs="unbounded" />
</sequence>
</complexType>
</element>
<choice
minOccurs="0"
maxOccurs="1" >
<element
name="insufficientResources"
type="iris:codeType" />
<element
name="invalidName"
type="iris:codeType" />
<element
name="invalidSearch"
type="iris:codeType" />
<element
name="queryNotSupported"
type="iris:codeType" />
<element
name="limitExceeded"
type="iris:codeType" />
<element
name="nameNotFound"
type="iris:codeType" />
<element
name="permissionDenied"
type="iris:codeType" />
<element
name="bagUnrecognized"
type="iris:codeType" />
<element
name="bagUnacceptable"
type="iris:codeType" />
<element
name="bagRefused"
type="iris:codeType" />
<element
ref="iris:genericCode"/>
</choice>
</sequence>
</complexType>
type="iris:codeType" />
<element
name="permissionDenied"
type="iris:codeType" />
<element
name="bagUnrecognized"
type="iris:codeType" />
<element
name="bagUnacceptable"
type="iris:codeType" />
<element
name="bagRefused"
type="iris:codeType" />
<element
ref="iris:genericCode"/>
</choice>
</sequence>
</complexType>
<!-- ========================================= -->
<!-- -->
<!-- Controls and Reactions -->
<!-- -->
<!-- ========================================= -->
<!-- ========================================= -->
<!-- -->
<!-- Controls and Reactions -->
<!-- -->
<!-- ========================================= -->
<complexType
name="controlType">
<sequence>
<any
namespace="##any"
processContents="skip"
minOccurs="1"
maxOccurs="1" />
</sequence>
</complexType>
<complexType
name="controlType">
<sequence>
<any
namespace="##any"
processContents="skip"
minOccurs="1"
maxOccurs="1" />
</sequence>
</complexType>
<complexType
name="reactionType">
<sequence>
<any
namespace="##any"
processContents="skip"
minOccurs="1"
maxOccurs="1" />
</sequence>
</complexType>
<complexType
name="reactionType">
<sequence>
<any
namespace="##any"
processContents="skip"
minOccurs="1"
maxOccurs="1" />
</sequence>
</complexType>
<!-- ========================================= -->
<!-- ========================================= -->
<!-- -->
<!-- Queries and Lookups -->
<!-- -->
<!-- ========================================= -->
<!-- -->
<!-- Queries and Lookups -->
<!-- -->
<!-- ========================================= -->
<complexType
name="queryType" />
<complexType
name="queryType" />
<element
name="query"
type="iris:queryType"
abstract="true" />
<element
name="query"
type="iris:queryType"
abstract="true" />
<complexType
name="lookupEntityType" >
<attribute
name="registryType"
type="anyURI"
use="required" />
<attribute
name="entityClass"
type="token"
use="required" />
<attribute
name="entityName"
type="token"
use="required" />
</complexType>
<complexType
name="lookupEntityType" >
<attribute
name="registryType"
type="anyURI"
use="required" />
<attribute
name="entityClass"
type="token"
use="required" />
<attribute
name="entityName"
type="token"
use="required" />
</complexType>
<!-- ========================================= -->
<!-- -->
<!-- Results -->
<!-- -->
<!-- ========================================= -->
<!-- ========================================= -->
<!-- -->
<!-- Results -->
<!-- -->
<!-- ========================================= -->
<complexType
name="resultType">
<attribute
name="authority"
use="required"
type="token" />
<attribute
name="resolution"
type="token" />
<attribute
name="registryType"
use="required"
type="anyURI" />
<complexType
name="resultType">
<attribute
name="authority"
use="required"
type="token" />
<attribute
name="resolution"
type="token" />
<attribute
name="registryType"
use="required"
type="anyURI" />
<attribute
name="entityClass"
use="required"
type="token" />
<attribute
name="entityName"
use="required"
type="token" />
<attribute
name="temporaryReference"
default="false"
type="boolean" />
</complexType>
<attribute
name="entityClass"
use="required"
type="token" />
<attribute
name="entityName"
use="required"
type="token" />
<attribute
name="temporaryReference"
default="false"
type="boolean" />
</complexType>
<element
name="result"
type="iris:resultType"
abstract="true" />
<element
name="result"
type="iris:resultType"
abstract="true" />
<!-- ========================================= -->
<!-- -->
<!-- Errors -->
<!-- -->
<!-- ========================================= -->
<!-- ========================================= -->
<!-- -->
<!-- Errors -->
<!-- -->
<!-- ========================================= -->
<complexType
name="codeType">
<sequence
minOccurs="0"
maxOccurs="unbounded">
<element
name="explanation">
<complexType>
<simpleContent>
<extension
base="string">
<attribute
use="required"
name="language"
type="language" />
</extension>
</simpleContent>
</complexType>
</element>
</sequence>
</complexType>
<element
name="genericCode"
<complexType
name="codeType">
<sequence
minOccurs="0"
maxOccurs="unbounded">
<element
name="explanation">
<complexType>
<simpleContent>
<extension
base="string">
<attribute
use="required"
name="language"
type="language" />
</extension>
</simpleContent>
</complexType>
</element>
</sequence>
</complexType>
<element
name="genericCode"
type="iris:codeType"
abstract="true" />
type="iris:codeType"
abstract="true" />
<!-- ========================================= -->
<!-- -->
<!-- Entity References and -->
<!-- Search Continuations -->
<!-- -->
<!-- ========================================= -->
<!-- ========================================= -->
<!-- -->
<!-- Entity References and -->
<!-- Search Continuations -->
<!-- -->
<!-- ========================================= -->
<complexType
name="entityType">
<sequence>
<element
name="displayName"
minOccurs="0"
maxOccurs="unbounded">
<complexType>
<simpleContent>
<extension
base="string">
<attribute
name="language"
use="required"
type="language" />
</extension>
</simpleContent>
</complexType>
</element>
</sequence>
<attribute
name="authority"
use="required"
type="token" />
<attribute
name="resolution"
type="token" />
<attribute
name="registryType"
use="required"
type="anyURI" />
<attribute
name="entityClass"
use="required"
type="token" />
<attribute
name="entityName"
use="required"
<complexType
name="entityType">
<sequence>
<element
name="displayName"
minOccurs="0"
maxOccurs="unbounded">
<complexType>
<simpleContent>
<extension
base="string">
<attribute
name="language"
use="required"
type="language" />
</extension>
</simpleContent>
</complexType>
</element>
</sequence>
<attribute
name="authority"
use="required"
type="token" />
<attribute
name="resolution"
type="token" />
<attribute
name="registryType"
use="required"
type="anyURI" />
<attribute
name="entityClass"
use="required"
type="token" />
<attribute
name="entityName"
use="required"
type="token" />
<attribute
name="referentType"
use="required"
form="qualified"
type="iris:referentTypeType" />
<attribute
name="temporaryReference"
default="false"
type="boolean" />
<attribute
name="bagRef"
type="IDREF" />
</complexType>
type="token" />
<attribute
name="referentType"
use="required"
form="qualified"
type="iris:referentTypeType" />
<attribute
name="temporaryReference"
default="false"
type="boolean" />
<attribute
name="bagRef"
type="IDREF" />
</complexType>
<element
name="entity"
type="iris:entityType" />
<element
name="entity"
type="iris:entityType" />
<simpleType
name="referentTypeType">
<union
memberTypes="QName iris:anyLiteralType" />
</simpleType>
<simpleType
name="referentTypeType">
<union
memberTypes="QName iris:anyLiteralType" />
</simpleType>
<simpleType
name="anyLiteralType">
<restriction
base="string">
<enumeration
value="ANY" />
</restriction>
</simpleType>
<simpleType
name="anyLiteralType">
<restriction
base="string">
<enumeration
value="ANY" />
</restriction>
</simpleType>
<complexType
name="searchContinuationType">
<sequence>
<element ref="iris:query" />
</sequence>
<attribute
name="bagRef"
type="IDREF" />
<attribute
name="authority"
type="token"
use="required" />
<attribute
name="resolution"
<complexType
name="searchContinuationType">
<sequence>
<element ref="iris:query" />
</sequence>
<attribute
name="bagRef"
type="IDREF" />
<attribute
name="authority"
type="token"
use="required" />
<attribute
name="resolution"
type="token" />
</complexType>
type="token" />
</complexType>
<element
name="searchContinuation"
type="iris:searchContinuationType" />
<element
name="searchContinuation"
type="iris:searchContinuationType" />
<!-- ========================================= -->
<!-- -->
<!-- Bags -->
<!-- -->
<!-- ========================================= -->
<!-- ========================================= -->
<!-- -->
<!-- Bags -->
<!-- -->
<!-- ========================================= -->
<complexType
name="bagsType">
<sequence>
<element
name="bag"
minOccurs="1"
maxOccurs="unbounded">
<complexType>
<complexContent>
<extension
base="iris:bagType">
<attribute
use="required"
name="id"
type="ID" />
</extension>
</complexContent>
</complexType>
</element>
</sequence>
</complexType>
<complexType
name="bagsType">
<sequence>
<element
name="bag"
minOccurs="1"
maxOccurs="unbounded">
<complexType>
<complexContent>
<extension
base="iris:bagType">
<attribute
use="required"
name="id"
type="ID" />
</extension>
</complexContent>
</complexType>
</element>
</sequence>
</complexType>
<complexType
name="bagType">
<sequence>
<any
namespace="##any"
processContents="skip"
minOccurs="1"
maxOccurs="1" />
</sequence>
</complexType>
<!-- ========================================= -->
<!-- -->
<!-- Derived Results for use with all -->
<complexType
name="bagType">
<sequence>
<any
namespace="##any"
processContents="skip"
minOccurs="1"
maxOccurs="1" />
</sequence>
</complexType>
<!-- ========================================= -->
<!-- -->
<!-- Derived Results for use with all -->
<!-- registry types. -->
<!-- -->
<!-- ========================================= -->
<!-- registry types. -->
<!-- -->
<!-- ========================================= -->
<!-- -->
<!-- See Also -->
<!-- -->
<!-- -->
<!-- See Also -->
<!-- -->
<element
name="seeAlso"
type="iris:entityType" />
<element
name="seeAlso"
type="iris:entityType" />
<!-- -->
<!-- Service Identification -->
<!-- -->
<!-- -->
<!-- Service Identification -->
<!-- -->
<complexType
name="serviceIdentificationType">
<complexContent>
<extension
base="iris:resultType">
<sequence>
<element
name="authorities"
minOccurs="1"
maxOccurs="1">
<complexType>
<sequence>
<element
name="authority"
type="token"
minOccurs="1"
maxOccurs="unbounded" />
</sequence>
</complexType>
</element>
<element
name="operatorName"
type="string"
minOccurs="0"
maxOccurs="1" />
<element
name="eMail"
type="string"
minOccurs="0"
maxOccurs="unbounded" />
<element
name="phone"
<complexType
name="serviceIdentificationType">
<complexContent>
<extension
base="iris:resultType">
<sequence>
<element
name="authorities"
minOccurs="1"
maxOccurs="1">
<complexType>
<sequence>
<element
name="authority"
type="token"
minOccurs="1"
maxOccurs="unbounded" />
</sequence>
</complexType>
</element>
<element
name="operatorName"
type="string"
minOccurs="0"
maxOccurs="1" />
<element
name="eMail"
type="string"
minOccurs="0"
maxOccurs="unbounded" />
<element
name="phone"
type="string"
minOccurs="0"
maxOccurs="unbounded" />
<element
ref="iris:seeAlso"
minOccurs="0"
maxOccurs="unbounded" />
</sequence>
</extension>
</complexContent>
</complexType>
type="string"
minOccurs="0"
maxOccurs="unbounded" />
<element
ref="iris:seeAlso"
minOccurs="0"
maxOccurs="unbounded" />
</sequence>
</extension>
</complexContent>
</complexType>
<element
name="serviceIdentification"
type="iris:serviceIdentificationType"
substitutionGroup="iris:result" />
<element
name="serviceIdentification"
type="iris:serviceIdentificationType"
substitutionGroup="iris:result" />
<!-- -->
<!-- Limits -->
<!-- -->
<!-- -->
<!-- Limits -->
<!-- -->
<complexType
name="limitsType">
<complexContent>
<extension
base="iris:resultType">
<sequence>
<element
name="totalQueries"
minOccurs="0"
maxOccurs="1" >
<complexType>
<group
ref="iris:timeLimitsGroup"
minOccurs="1"
maxOccurs="4" />
</complexType>
</element>
<element
name="totalResults"
minOccurs="0"
maxOccurs="1" >
<complexType>
<group
ref="iris:timeLimitsGroup"
minOccurs="1"
maxOccurs="4" />
</complexType>
<complexType
name="limitsType">
<complexContent>
<extension
base="iris:resultType">
<sequence>
<element
name="totalQueries"
minOccurs="0"
maxOccurs="1" >
<complexType>
<group
ref="iris:timeLimitsGroup"
minOccurs="1"
maxOccurs="4" />
</complexType>
</element>
<element
name="totalResults"
minOccurs="0"
maxOccurs="1" >
<complexType>
<group
ref="iris:timeLimitsGroup"
minOccurs="1"
maxOccurs="4" />
</complexType>
</element>
<element
name="totalSessions"
minOccurs="0"
maxOccurs="1" >
<complexType>
<group
ref="iris:timeLimitsGroup"
minOccurs="1"
maxOccurs="4" />
</complexType>
</element>
<element
name="otherRestrictions"
minOccurs="0"
maxOccurs="1">
<complexType>
<sequence>
<element
name="description"
minOccurs="0"
maxOccurs="unbounded">
<complexType>
<simpleContent>
<extension
base="string">
<attribute
name="language"
type="language"
use="required" />
</extension>
</simpleContent>
</complexType>
</element>
</sequence>
</complexType>
</element>
<element
ref="iris:seeAlso"
minOccurs="0"
maxOccurs="unbounded" />
</sequence>
</extension>
</complexContent>
</complexType>
<element
name="limits"
type="iris:limitsType"
</element>
<element
name="totalSessions"
minOccurs="0"
maxOccurs="1" >
<complexType>
<group
ref="iris:timeLimitsGroup"
minOccurs="1"
maxOccurs="4" />
</complexType>
</element>
<element
name="otherRestrictions"
minOccurs="0"
maxOccurs="1">
<complexType>
<sequence>
<element
name="description"
minOccurs="0"
maxOccurs="unbounded">
<complexType>
<simpleContent>
<extension
base="string">
<attribute
name="language"
type="language"
use="required" />
</extension>
</simpleContent>
</complexType>
</element>
</sequence>
</complexType>
</element>
<element
ref="iris:seeAlso"
minOccurs="0"
maxOccurs="unbounded" />
</sequence>
</extension>
</complexContent>
</complexType>
<element
name="limits"
type="iris:limitsType"
substitutionGroup="iris:result" />
substitutionGroup="iris:result" />
<group
name="timeLimitsGroup">
<choice>
<element
name="perSecond"
type="nonNegativeInteger" />
<element
name="perMinute"
type="nonNegativeInteger" />
<element
name="perHour"
type="nonNegativeInteger" />
<element
name="perDay"
type="nonNegativeInteger" />
</choice>
</group>
<group
name="timeLimitsGroup">
<choice>
<element
name="perSecond"
type="nonNegativeInteger" />
<element
name="perMinute"
type="nonNegativeInteger" />
<element
name="perHour"
type="nonNegativeInteger" />
<element
name="perDay"
type="nonNegativeInteger" />
</choice>
</group>
<!-- -->
<!-- Simple Entity -->
<!-- -->
<!-- -->
<!-- Simple Entity -->
<!-- -->
<complexType
name="simpleEntityType">
<complexContent>
<extension
base="iris:resultType">
<sequence>
<element
name="property"
minOccurs="1"
maxOccurs="unbounded">
<complexType>
<simpleContent>
<extension
base="string">
<attribute
name="name"
type="string"
use="required" />
<attribute
name="language"
type="language"
use="required" />
<attribute
name="uri"
<complexType
name="simpleEntityType">
<complexContent>
<extension
base="iris:resultType">
<sequence>
<element
name="property"
minOccurs="1"
maxOccurs="unbounded">
<complexType>
<simpleContent>
<extension
base="string">
<attribute
name="name"
type="string"
use="required" />
<attribute
name="language"
type="language"
use="required" />
<attribute
name="uri"
type="anyURI" />
</extension>
</simpleContent>
</complexType>
</element>
</sequence>
</extension>
</complexContent>
</complexType>
type="anyURI" />
</extension>
</simpleContent>
</complexType>
</element>
</sequence>
</extension>
</complexContent>
</complexType>
<element
name="simpleEntity"
type="iris:simpleEntityType"
substitutionGroup="iris:result" />
<element
name="simpleEntity"
type="iris:simpleEntityType"
substitutionGroup="iris:result" />
<!-- ========================================= -->
<!-- -->
<!-- Derived Controls and Reactions -->
<!-- -->
<!-- ========================================= -->
<!-- ========================================= -->
<!-- -->
<!-- Derived Controls and Reactions -->
<!-- -->
<!-- ========================================= -->
<!-- -->
<!-- Only Check Permissions -->
<!-- -->
<!-- -->
<!-- Only Check Permissions -->
<!-- -->
<element
name="onlyCheckPermissions" >
<complexType />
</element>
<element
name="onlyCheckPermissions" >
<complexType />
</element>
<!-- -->
<!-- Standard Reaction -->
<!-- -->
<!-- -->
<!-- Standard Reaction -->
<!-- -->
<element
name="standardReaction" >
<complexType>
<choice>
<element
name="controlAccepted">
<complexType/>
</element>
<element
name="controlDenied">
<complexType/>
</element>
<element
name="controlDisabled">
<element
name="standardReaction" >
<complexType>
<choice>
<element
name="controlAccepted">
<complexType/>
</element>
<element
name="controlDenied">
<complexType/>
</element>
<element
name="controlDisabled">
<complexType/>
</element>
<element
name="controlUnrecognized">
<complexType/>
</element>
</choice>
</complexType>
</element>
<complexType/>
</element>
<element
name="controlUnrecognized">
<complexType/>
</element>
</choice>
</complexType>
</element>
<!-- ========================================= -->
<!-- -->
<!-- Serialization -->
<!-- -->
<!-- ========================================= -->
<!-- ========================================= -->
<!-- -->
<!-- Serialization -->
<!-- -->
<!-- ========================================= -->
<complexType
name="serializedReferralType">
<sequence>
<element name="source">
<complexType>
<attribute
name="authority"
use="required"
type="token" />
<attribute
name="resolution"
type="token" />
<attribute
name="registryType"
type="anyURI"
use="required" />
<attribute
name="entityClass"
type="token"
use="required" />
<attribute
name="entityName"
type="token"
use="required" />
</complexType>
</element>
<choice>
<element
ref="iris:searchContinuation" />
<element
ref="iris:entity" />
</choice>
<complexType
name="serializedReferralType">
<sequence>
<element name="source">
<complexType>
<attribute
name="authority"
use="required"
type="token" />
<attribute
name="resolution"
type="token" />
<attribute
name="registryType"
type="anyURI"
use="required" />
<attribute
name="entityClass"
type="token"
use="required" />
<attribute
name="entityName"
type="token"
use="required" />
</complexType>
</element>
<choice>
<element
ref="iris:searchContinuation" />
<element
ref="iris:entity" />
</choice>
</sequence>
</complexType>
</sequence>
</complexType>
<element
name="serialization">
<complexType>
<choice
minOccurs="1"
maxOccurs="unbounded">
<element
ref="iris:result" />
<element
name="serializedReferral"
type="iris:serializedReferralType" />
</choice>
</complexType>
</element>
<element
name="serialization">
<complexType>
<choice
minOccurs="1"
maxOccurs="unbounded">
<element
ref="iris:result" />
<element
name="serializedReferral"
type="iris:serializedReferralType" />
</choice>
</complexType>
</element>
</schema>
</schema>
Figure 8
图8
The IRIS URI has a very rigid structure. All IRIS URIs have the same fields and look similar to users.
IRIS URI具有非常严格的结构。所有IRIS URI都有相同的字段，看起来与用户相似。
But the IRIS URIs are flexible because they allow different methods to be employed to find servers and allow the use of multiple transports (with BEEP being the default).
但是irisuri是灵活的，因为它们允许使用不同的方法来查找服务器，并允许使用多个传输（默认为BEEP）。
An IRIS URI [6] has the following general syntax.
IRIS URI[6]具有以下通用语法。
iris:<registry>/<resolution>/<authority>/<class>/<name>
iris:<registry>/<resolution>/<authority>/<class>/<name>
The full ABNF [11] follows, with certain values included from RFC 2396 [6] and RFC 2732 [15].
完整的ABNF[11]如下，RFC 2396[6]和RFC 2732[15]中包含了某些值。
iris-uri = scheme ":" registry-urn "/"
[ resolution-method ] "/" authority
[ "/" entity-class "/" entity-name ]
scheme = "iris"
authority = // as specified by RFC2396
registry-urn = // as specified by IRIS
resolution-method = *(unreserved | escaped)
entity-class = *(unreserved | escaped)
iris-uri = scheme ":" registry-urn "/"
[ resolution-method ] "/" authority
[ "/" entity-class "/" entity-name ]
scheme = "iris"
authority = // as specified by RFC2396
registry-urn = // as specified by IRIS
resolution-method = *(unreserved | escaped)
entity-class = *(unreserved | escaped)
entity-name = *(unreserved | escaped)
unreserved = // as specified by RFC2396
escaped = // as specified by RFC2396
entity-name = *(unreserved | escaped)
unreserved = // as specified by RFC2396
escaped = // as specified by RFC2396
An IRIS URI MUST NOT be a relative URI. The resolution method, entity class, and entity name MUST be of the UTF-8 [12] character set encoded with "application/x-www-form-urlencoded", as specified by URL_ENC [14].
IRIS URI不能是相对URI。解析方法、实体类和实体名称必须为UTF-8[12]字符集，按照URL_ENC[14]的规定，用“application/x-www-form-urlencoded”编码。
When the entity-class and entity-name components are not specified, the defaults "iris" and "id" MUST be implied. For example, "iris:dreg1//com" is interpreted as "iris:dreg1//com/iris/id".
如果未指定实体类和实体名称组件，则必须暗示默认的“iris”和“id”。例如，“iris:dreg1//com”被解释为“iris:dreg1//com/iris/id”。
When the resolution-method is not specified, the default is the direct resolution method described in Section 7.3.2.
未指定解析方法时，默认为第7.3.2节所述的直接解析方法。
The "iris" scheme name is not application transport specific. The URI resolution process MAY determine the application transport. An example of such a process is direct resolution (Section 7.3.2), which uses the steps outlined in Section 7.3.3 to determine the application transport.
“iris”方案名称不是特定于应用程序传输的。URI解析过程可以确定应用程序传输。这种过程的一个例子是直接解析（第7.3.2节），它使用第7.3.3节中概述的步骤来确定应用程序传输。
A mapping between an application transport and IRIS MAY define a scheme name signifying its use with the semantics of the IRIS URI.
应用程序传输和IRIS之间的映射可以定义一个方案名称，表示其使用IRIS URI的语义。
The rules for determining which application transport to use are as follows:
确定使用哪个应用程序传输的规则如下：
o If an application transport specific scheme name is present, the application transport it signifies SHOULD be used if possible.
o 如果存在特定于应用程序传输的方案名称，则应尽可能使用它所表示的应用程序传输。
o If a client has a preferred transport and the resolution process allows for its use, the client MAY use that application transport.
o 如果客户端具有首选传输，并且解析过程允许使用该传输，则客户端可以使用该应用程序传输。
o Otherwise, the default application transport specified by IRIS-BEEP [1] MUST be used.
o 否则，必须使用IRIS-BEEP[1]指定的默认应用程序传输。
Interpretation and resolution of the authority component of an IRIS URI may be altered with the specification of a resolution-method in the URI. If no resolution-method component is specified in the URI, the default is the direct resolution method (see Section 7.3.2).
IRIS URI的授权组件的解释和解析可以通过URI中解析方法的规范来改变。如果URI中未指定解析方法组件，则默认为直接解析方法（参见第7.3.2节）。
Alternate resolution methods MAY be specified by registry types. The identifiers for these methods MUST conform to the ABNF in Section 7.1.
可通过注册表类型指定替代解决方法。这些方法的标识符必须符合第7.1节中的ABNF。
In the direct resolution process, the authority component of an IRIS URI may only contain a domain name, a domain name accompanied by a port number, an IP address, or an IP address accompanied by a port number. The authority component of the scheme indicates the server or set of servers authoritatively responsible for a domain according to records in DNS (Section 7.3.3) if a domain is specified. If an IP address is specified, it indicates the specific server to be queried.
在直接解析过程中，IRIS URI的授权组件可能仅包含域名、带有端口号的域名、IP地址或带有端口号的IP地址。如果指定了域，则方案的授权组件表示根据DNS中的记录（第7.3.3节）授权负责域的服务器或服务器集。如果指定了IP地址，则表示要查询的特定服务器。
The rules for resolution are as follows:
处置规则如下：
o If the authority component is a domain name accompanied by a port number as specified by RFC 2396, the domain name is converted to an IP address via an A or AAAA record to the DNS.
o 如果授权组件是带有RFC 2396指定的端口号的域名，则该域名将通过DNS的a或AAAA记录转换为IP地址。
o If the authority component is a domain name by itself, the service/transport location (Section 7.3.3) process is used. If this process produces no results, then the DNS is queried for the A or AAAA RRs corresponding to the domain name, and the port number used is the well-known port of the transport used according to Section 7.2.
o 如果授权组件本身是域名，则使用服务/传输位置（第7.3.3节）流程。如果此过程未产生任何结果，则会在DNS中查询对应于域名的A或AAAA RRs，并且使用的端口号是根据第7.2节使用的传输的已知端口。
o If the authority component is an IP address, then the DNS is not queried, and the IP address is used directly. If the port number is present, it is used directly; otherwise, the port number used is the well-known port of the transport used according to Section 7.2.
o 如果授权组件是IP地址，则不查询DNS，直接使用IP地址。如果存在端口号，则直接使用；否则，所使用的端口号为根据第7.2节使用的已知运输端口。
The use of an IPv6 address in the authority component MUST conform to RFC 2732 [15].
在授权组件中使用IPv6地址必须符合RFC 2732[15]。
The direct resolution method (Section 7.3.2) uses the profiled use of the NAPTR and SRV resource records defined in S-NAPTR [10] to determine both the location of a set of servers for a given service and the set of possible transports that may be used. It is RECOMMENDED that any resolution method not making explicit use of the direct resolution process should use S-NAPTR [10] in whatever process it does define.
直接解析法（第7.3.2节）使用S-NAPTR[10]中定义的NAPTR和SRV资源记录的概要使用来确定给定服务的一组服务器的位置和可能使用的一组传输。建议任何未明确使用直接解析过程的解析方法在其定义的任何过程中都应使用S-NAPTR[10]。
S-NAPTR [10] requires an application service label. The direct resolution method (Section 7.3.2) uses the abbreviated form of the registry URN as the application service label. Other resolution methods MAY specify other application service labels.
S-NAPTR[10]需要应用程序服务标签。直接解析方法（第7.3.2节）使用注册表URN的缩写形式作为应用程序服务标签。其他解析方法可以指定其他应用程序服务标签。
See Appendix A for sample uses of S-NAPTR.
S-NAPTR的使用示例见附录A。
Here are some examples of IRIS URIs and their meaning:
以下是IRIS URI的一些示例及其含义：
o iris:dreg1//example.com/domain/example.com * Finds a server authoritative for "example.com" according to the rules of direct resolution (Section 7.3.2). * The server is asked for "example.com" in the "domain" index, or entity class, of the "dreg1" registry.
o iris:dreg1//example.com/domain/example.com*根据直接解析规则（第7.3.2节）查找“example.com”的权威服务器。*服务器被要求在“dreg1”注册表的“域”索引或实体类中输入“example.com”。
o iris:dreg1//example.com * Finds a server authoritative for "example.com" according to the rules of direct resolution (Section 7.3.2). * The server is asked for "id" in the "iris" index, or entity class, of the "dreg1" registry.
o iris:dreg1//example.com*根据直接解析规则（第7.3.2节）查找“example.com”的权威服务器。*服务器被要求在“dreg1”注册表的“iris”索引或实体类中输入“id”。
o iris:dreg1//com/domain/example.com * Finds a server authoritative for "com" according to the rules of direct-resolution (Section 7.3.2). * The server is asked for "example.com" in the "domain" index, or entity class, of the "dreg1" registry.
o iris:dreg1//com/domain/example.com*根据直接解析规则（第7.3.2节）查找“com”的权威服务器。*服务器被要求在“dreg1”注册表的“域”索引或实体类中输入“example.com”。
o iris:dreg1//192.0.2.1:44/domain/example.com * Following the rules of direct-resolution (Section 7.3.2), the server at IP address 192.0.2.1 on port 44 is queried by using BEEP. * The server is asked for "example.com" in the "domain" index, or entity class, of the "dreg1" registry.
o iris:dreg1//192.0.2.1:44/domain/example.com*遵循直接解析规则（第7.3.2节），使用BEEP查询端口44上IP地址为192.0.2.1的服务器。*服务器被要求在“dreg1”注册表的“域”索引或实体类中输入“example.com”。
o iris.lwz:dreg1//192.0.2.1:44/domain/example.com * Following the rules of direct-resolution (Section 7.3.2), the server at IP address 192.0.2.1 on port 44 is queried by using a lightweight application transport. * The server is asked for "example.com" in the "domain" index, or entity class, of the "dreg1" registry.
o iris.lwz:dreg1//192.0.2.1:44/domain/example.com*遵循直接解析规则（第7.3.2节），使用轻量级应用程序传输查询端口44上IP地址为192.0.2.1的服务器。*服务器被要求在“dreg1”注册表的“域”索引或实体类中输入“example.com”。
o iris.beep:dreg1//com/domain/example.com * Finds a server authoritative for "com" according to the rules of direct-resolution (Section 7.3.2). * Uses the BEEP application transport. * The server is asked for "example.com" in the "domain" index, or entity class, of the "dreg1" registry.
o iris.beep:dreg1//com/domain/example.com*根据直接解析规则（第7.3.2节）查找“com”的权威服务器。*使用BEEP应用程序传输。*服务器被要求在“dreg1”注册表的“域”索引或实体类中输入“example.com”。
o iris:dreg1/bottom/example.com/domain/example.com * Finds a server authoritative for "example.com" according to the rules of the resolution method 'bottom' as defined by the registry type urn:ietf:params:xml:ns:dreg1. * The application transport used is determined by the 'bottom' resolution method. * The server is asked for "example.com" in the "domain" index, or entity class, of the "dreg1" registry.
o iris:dreg1/bottom/example.com/domain/example.com*根据注册表类型urn:ietf:params:xml:ns:dreg1.*定义的解析方法“bottom”的规则，查找“example.com”的权威服务器使用的应用程序传输由“底部”解析方法确定。*服务器被要求在“dreg1”注册表的“域”索引或实体类中输入“example.com”。
o iris.beep:dreg1/bottom/example.com/domain/example.com * Finds a server authoritative for "example.com" according to the rules of the resolution method 'bottom' as defined by the registry type urn:ietf:params:xml:ns:dreg1. * Uses the BEEP application transport. * The server is asked for "example.com" in the "domain" index, or entity class, of the "dreg1" registry.
o iris.beep:dreg1/bottom/example.com/domain/example.com*根据注册表类型urn:ietf:params:xml:ns:dreg1.*定义的解析方法“bottom”的规则，查找“example.com”的权威服务器使用BEEP应用程序传输。*服务器被要求在“dreg1”注册表的“域”索引或实体类中输入“example.com”。
Specifications of registry types MUST include the following explicit definitions:
注册表类型的规范必须包括以下明确定义：
o Formal XML syntax deriving from the IRIS XML.
o 从IRIS XML派生的正式XML语法。
o An identifying registry URN.
o 一个可识别的注册表URN。
o Any registry specific resolution methods.
o 任何特定于注册表的解析方法。
o A registration of the abbreviated registry URN as an application service label for compliance with S-NAPTR [10]. Note that this is a different IANA registry than the registry type URN IANA registry.
o 将缩写注册表URN注册为应用程序服务标签，以符合S-NAPTR[10]。请注意，这是一个与注册表类型URN IANA registry不同的IANA注册表。
o A list of well-known entity classes.
o 已知实体类的列表。
o A statement regarding the case sensitivity of the names in each entity class.
o 关于每个实体类中名称区分大小写的语句。
Specifications of transport mappings MUST include the following explicit definitions:
传输映射的规范必须包括以下明确定义：
o A URI scheme name specific to the transport.
o 特定于传输的URI方案名称。
o An application protocol label for compliance with S-NAPTR [10]. See Section 7.3.3. Note that although this is a different IANA registry than the URI scheme name IANA registry, it is RECOMMENDED that they be the same string of characters.
o 符合S-NAPTR[10]的应用协议标签。见第7.3.3节。请注意，尽管这是一个与URI方案名称IANA registry不同的IANA注册表，但建议它们是相同的字符串。
o The set of allowable character set encodings for the exchange of XML (see Section 9).
o XML交换允许的字符集编码集（见第9节）。
o The set of security mechanisms.
o 一套安全机制。
IRIS is represented in XML. XML processors are obliged to recognize both UTF-8 and UTF-16 [12] encodings. XML provides for mechanisms to identify and use other character encodings by means of the "encoding" attribute in the <xml> declaration. Absence of this attribute or a byte order mark (BOM) indicates a default of UTF-8 [13] encoding. Thus, for compatibility reasons and per RFC 2277 [16], use of UTF-8 [13] is RECOMMENDED with IRIS.
IRIS是用XML表示的。XML处理器必须同时识别UTF-8和UTF-16[12]编码。XML通过<XML>声明中的“encoding”属性提供了识别和使用其他字符编码的机制。缺少此属性或字节顺序标记（BOM）表示默认的UTF-8[13]编码。因此，出于兼容性原因，并根据RFC 2277[16]，建议在IRIS中使用UTF-8[13]。
The complete list of character set encoding identifiers is maintained by IANA at [21].
IANA在[21]中维护字符集编码标识符的完整列表。
The application-transport layer MUST define a common set of character set encodings to be understood by both client and server.
应用程序传输层必须定义一组通用的字符集编码，以便客户端和服务器都能理解。
Localization of internationalized strings may require additional information from the client. Entity definitions SHOULD use the "language" type defined by XML_SD [4] to aid clients in the localization process. See Section 4.3.7.3 for an example.
国际化字符串的本地化可能需要客户端提供更多信息。实体定义应使用XML_SD[4]定义的“语言”类型，以帮助客户端进行本地化。示例见第4.3.7.3节。
This document uses a proposed XML namespace and schema registry specified in XML_URN [9]. Accordingly, the following registration information is provided for the IANA:
本文档使用XML_URN[9]中指定的建议XML命名空间和模式注册表。因此，为IANA提供了以下注册信息：
o URN/URI: * urn:ietf:params:xml:ns:iris1 o Contact: * Andrew Newton <andy@hxr.us> * Marcos Sanz <sanz@denic.de> o XML: * The XML Schema specified in Section 6
o URN/URI:*URN:ietf:params:xml:ns:iris1 o联系人：*安德鲁·牛顿<andy@hxr.us>*马科斯·桑兹<sanz@denic.de>o XML:*第6节中指定的XML模式
The IRIS XML layer provides no authentication or privacy facilities of its own. It relies on the application-transport layer for all of these abilities. Application-transports should explicitly define their security mechanisms (see Section 8.2).
IRIS XML层本身不提供身份验证或隐私设施。所有这些功能都依赖于应用程序传输层。应用程序传输应明确定义其安全机制（参见第8.2节）。
Referral IRIS registry results may contain entity lookups and search continuations that result in a client query operation against another registry service. Clients SHOULD NOT use authentication credentials and mechanisms subject to replay attacks to conduct subsequent entity lookups and search continuations.
参考IRIS注册表结果可能包含实体查找和搜索继续，从而导致针对另一个注册表服务的客户端查询操作。客户端不应使用受重播攻击的身份验证凭据和机制来执行后续实体查找和搜索继续。
[1] Newton, A. and M. Sanz, "Using the Internet Registry Information Service (IRIS) over the Blocks Extensible Exchange Protocol (BEEP)", RFC 3983, January 2005.
[1] Newton，A.和M.Sanz，“通过块可扩展交换协议（BEEP）使用互联网注册信息服务（IRIS）”，RFC 3983，2005年1月。
[2] World Wide Web Consortium, "Extensible Markup Language (XML) 1.0", W3C XML, February 1998, <http://www.w3.org/TR/1998/REC-xml-19980210>.
[2] 万维网联盟，“可扩展标记语言（XML）1.0”，W3C XML，1998年2月<http://www.w3.org/TR/1998/REC-xml-19980210>.
[3] World Wide Web Consortium, "Namespaces in XML", W3C XML Namespaces, January 1999, <http://www.w3.org/TR/1999/REC-xml-names-19990114>.
[3] 万维网联盟，“XML中的名称空间”，W3C XML名称空间，1999年1月<http://www.w3.org/TR/1999/REC-xml-names-19990114>.
[4] World Wide Web Consortium, "XML Schema Part 2: Datatypes", W3C XML Schema, October 2000, <http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/>.
[4] 万维网联盟，“XML模式第2部分：数据类型”，W3C XML模式，2000年10月<http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/>.
[5] World Wide Web Consortium, "XML Schema Part 1: Structures", W3C XML Schema, October 2000, <http://www.w3.org/TR/2001/REC-xmlschema-1-20010502/>.
[5] 万维网联盟，“XML模式第1部分：结构”，W3C XML模式，2000年10月<http://www.w3.org/TR/2001/REC-xmlschema-1-20010502/>.
[6] Berners-Lee, T., Fielding, R., and L. Masinter, "Uniform Resource Identifiers (URI): Generic Syntax", RFC 2396, August 1998.
[6] Berners Lee，T.，Fielding，R.，和L.Masinter，“统一资源标识符（URI）：通用语法”，RFC 2396，1998年8月。
[7] Moats, R., "URN Syntax", RFC 2141, May 1997.
[7] 护城河，R.，“瓮语法”，RFC 21411997年5月。
[8] Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, March 1997.
[8] Bradner，S.，“RFC中用于表示需求水平的关键词”，BCP 14，RFC 2119，1997年3月。
[9] Mealling, M., "The IETF XML Registry", BCP 81, RFC 3688, January 2004.
[9] Mealling，M.，“IETF XML注册表”，BCP 81，RFC 3688，2004年1月。
[10] Daigle, L. and A. Newton, "Domain-based Application Service Location Using SRV RRs and the Dynamic Delegation Discovery Service (DDDS)", RFC 3958, January 2005.
[10] Daigle，L.和A.Newton，“使用SRV RRs和动态委托发现服务（DDDS）的基于域的应用程序服务定位”，RFC 3958，2005年1月。
[11] Crocker, D. and P. Overell, "Augmented BNF for Syntax Specifications: ABNF", RFC 2234, November 1997.
[11] Crocker，D.和P.Overell，“语法规范的扩充BNF:ABNF”，RFC 2234，1997年11月。
[12] The Unicode Consortium, "The Unicode Standard, Version 3", ISBN 0-201-61633-5, 2000, <The Unicode Standard, Version 3>.
[12] Unicode联盟，“Unicode标准，第3版”，ISBN 0-201-61633-52000，<Unicode标准，第3版>。
[13] Yergeau, F., "UTF-8, a transformation format of ISO 10646", STD 63, RFC 3629, November 2003.
[13] Yergeau，F.，“UTF-8，ISO 10646的转换格式”，STD 63，RFC 3629，2003年11月。
[14] Connolly, D. and L. Masinter, "The 'text/html' Media Type", RFC 2854, June 2000.
[14] Connolly，D.和L.Masinter，“文本/html”媒体类型”，RFC 28542000年6月。
[15] Hinden, R., Carpenter, B., and L. Masinter, "Format for Literal IPv6 Addresses in URL's", RFC 2732, December 1999.
[15] Hinden，R.，Carpenter，B.，和L.Masinter，“URL中文字IPv6地址的格式”，RFC 2732，1999年12月。
[16] Alvestrand, H., "IETF Policy on Character Sets and Languages", BCP 18, RFC 2277, January 1998.
[16] Alvestrand，H.，“IETF字符集和语言政策”，BCP 18，RFC 2277，1998年1月。
[17] Newton, A., "Cross Registry Internet Service Protocol (CRISP) Requirements", RFC 3707, February 2004.
[17] Newton，A.，“跨注册互联网服务协议（CRISP）要求”，RFC 3707，2004年2月。
[18] Newton, A. and M. Sanz, "IRIS: A Domain Registry (dreg) Type for the Internet Registry Information Service (IRIS)", RFC 3982, January 2005.
[18] Newton，A.和M.Sanz，“IRIS：互联网注册信息服务（IRIS）的域注册（dreg）类型”，RFC 3982，2005年1月。
[19] Daigle, L., "WHOIS Protocol Specification", RFC 3912, September 2004.
[19] Daigle，L.，“WHOIS协议规范”，RFC 3912，2004年9月。
[20] Rose, M., "The Blocks Extensible Exchange Protocol Core", RFC 3080, March 2001.
[20] Rose，M.，“块可扩展交换协议核心”，RFC 30802001年3月。
URIs
URI
[21] <http://www.iana.org/assignments/character-sets>
[21] <http://www.iana.org/assignments/character-sets>
This section shows an example of S-NAPTR [10] use by IRIS. In this example, there are two registry types: REGA and REGB. There are also two IRIS application transports: iris-a and iris-b. Given this, the use of S-NAPTR offers the following:
本节显示了IRIS使用S-NAPTR[10]的示例。在本例中，有两种注册表类型：REGA和REGB。还有两种IRIS应用程序传输：IRIS-a和IRIS-b。鉴于此，使用S-NAPTR可提供以下功能：
1. A means by which an operator can split the set of servers running REGA from the set of servers running REGB. This is to say, the operator is able to split out the set of servers serving up data for REGA from the set of servers serving up data for REGB.
1. 运营商可以将运行REGA的服务器集与运行REGB的服务器集分开的一种方式。这就是说，运营商能够将为REGA提供数据的服务器集从为REGB提供数据的服务器集中分离出来。
2. A means by which an operator can distinguish the set of servers running iris-a from the set of servers running iris-b. This is to say, the operator is able to split out the set of servers running protocol iris-a serving REGA and REGB data from the set of servers running protocol iris-b serving REGA and REGB data.
2. 一种操作员可以区分运行iris-A的服务器集和运行iris-b的服务器集的方法。这就是说，运营商能够将运行协议iris-a服务于REGA和REGB数据的服务器组从运行协议iris-b服务于REGA和REGB数据的服务器组中分离出来。
3. A means by which an operator can specify which set of the servers to operate and which set of the above servers to delegate to another operator.
3. 一种方法，操作员可以通过该方法指定要操作的服务器集以及要委托给另一操作员的上述服务器集。
To implement the first feature, the operator deploys the following in his or her DNS zone:
为了实现第一项功能，运营商在其DNS区域中部署以下各项：
example.com.
;; order pref flags service re replacement
IN NAPTR 100 10 "" "REGA:iris-a:iris-b" "" rega.example.com
IN NAPTR 100 10 "" "REGB:iris-a:iris-b" "" regb.example.com
example.com.
;; order pref flags service re replacement
IN NAPTR 100 10 "" "REGA:iris-a:iris-b" "" rega.example.com
IN NAPTR 100 10 "" "REGB:iris-a:iris-b" "" regb.example.com
To implement the second feature, the operator then adds the following in their DNS zone:
为了实现第二项功能，运营商随后在其DNS区域中添加以下内容：
rega.example.com. ;; order pref flags service re replacement IN NAPTR 100 10 "s" "REGA:iris-a" "" _iris-a._udp.example.com regb.example.com. IN NAPTR 100 10 "s" "REGA:iris-b" "" _iris-b._tcp.example.com
rega.example.com；；在NAPTR 100 10“s”“REGA:iris-a”“”\u iris-a.\u udp.example.com regb.example.com中订购pref标志服务重新更换。在NAPTR 100 10“s”“REGA:iris-b”“\u iris-b.\u tcp.example.com中
_iris-a._udp.example.com. ;; pref weight port target IN SRV 10 0 34 big-a.example.com. IN SRV 20 0 34 small-a.example.com.
_iris-a._udp.example.com；；SRV 10 0 34 big-a.example.com中的pref weight端口目标。在SRV 20 0 34 small-a.example.com中。
_iris-b._tcp.example.com. ;; pref weight port target IN SRV 10 0 34 big-b.example.com. IN SRV 20 0 34 small-b.example.com.
_iris-b._tcp.example.com；；SRV 10 0 34 big-b.example.com中的pref weight端口目标。在SRV 20 0 34 small-b.example.com中。
Finally, an operator may decide to operate the REGA services while delegating the REGB services to somebody else. Here is how that is done:
最后，运营商可以决定在将REGB服务委托给其他人的同时运营REGA服务。这是如何做到的：
example.com.
;; order pref flags service re replacement
IN NAPTR 100 10 "" "REGA:iris-a:iris-b" "" rega.example.com
IN NAPTR 100 10 "" "REGB:iris-a:iris-b" "" somebodyelse.com
example.com.
;; order pref flags service re replacement
IN NAPTR 100 10 "" "REGA:iris-a:iris-b" "" rega.example.com
IN NAPTR 100 10 "" "REGB:iris-a:iris-b" "" somebodyelse.com
Or the operator may decide to operate REGB services under the iris-a protocol/transport while delegating the REGB services under the iris-b protocol/transport to somebody else.
或者，运营商可以决定根据iris-a协议/传输操作REGB服务，同时将iris-b协议/传输下的REGB服务委托给其他人。
example.com. ;; order pref flags service re replacement IN NAPTR 100 10 "" "REGB:iris-a:iris-b" "" regb.example.com IN NAPTR 100 10 "s" "REGB:iris-a" "" _iris-a._udp.example.com IN NAPTR 100 10 "s" "REGB:iris-b" "" _iris-b._tcp.somebodyelse.com
example.com；；order pref flags service re replacement IN NAPTR 100 10““REGB:iris-a:iris-b”“REGB.example.com IN NAPTR 100 10 10”s”“REGB:iris-a”“”REGB:iris-a”“”udp.example.com IN NAPTR 100 10”s”“REGB:iris-b”“”iris-b.\tcp.somebodyelse.com
_iris-a._udp.example.com. ;; pref weight port target IN SRV 10 0 34 big-a.example.com. IN SRV 20 0 34 small-a.example.com.
_iris-a._udp.example.com；；SRV 10 0 34 big-a.example.com中的pref weight端口目标。在SRV 20 0 34 small-a.example.com中。
Note that while this last example is possible, it is probably not advisable because of the operational issues involved in synchronizing the data between example.com and somebodyelse.com. It is provided here as an example of what is possible.
请注意，虽然最后一个示例是可能的，但由于example.com和somebodyelse.com之间的数据同步涉及操作问题，因此可能不建议使用最后一个示例。这里提供了一个可能的示例。
Given the examples in Appendix A.1, the use of S-NAPTR could be part of a transition strategy for cohabitation of protocols solving the problems of CRISP [17].
鉴于附录A.1中的示例，S-NAPTR的使用可能是解决CRISP问题的协议同居过渡策略的一部分[17]。
For example, the type of data for domain information could be given the application service label of "DREG1". Given this, the service field of an S-NAPTR compliant NAPTR record could read
例如，域信息的数据类型可以被赋予应用程序服务标签“DREG1”。因此，符合S-NAPTR的NAPTR记录的服务字段可以读取
"DREG1:whois:iris-beep"
“DREG1:whois:iris-beep”
This service field conveys that domain data, as defined by CRISP, is available via both the iris-beep protocol and the whois protocol. The whois application protocol label refers to RFC 954 [19].
此服务字段表示CRISP定义的域数据可通过iris beep协议和whois协议获得。whois应用协议标签参考RFC 954[19]。
Beyond the concrete arguments that could be placed behind a thoughtful analysis of the bits flying across the ether, there are other abstract reasons for the development of IRIS. This section attempts an explanation.
除了对飞过以太的比特进行深思熟虑的分析所能提出的具体论点之外，IRIS的发展还有其他抽象的原因。本节试图进行解释。
IRIS has been designed as a directory service for public-facing registries of Internet resources. The basic premise is this:
IRIS被设计为面向公众的互联网资源注册中心的目录服务。基本前提是：
o A client should be able to look up any single piece of data from any type of registry. This lookup should involve a straight-forward and consistent definition for finding the registry and should entail a hit to a single data index in the registry.
o 客户机应该能够从任何类型的注册表中查找任何单个数据段。这种查找应该包含一个用于查找注册表的直接且一致的定义，并且应该包含对注册表中单个数据索引的点击。
o Anything more, such as searches up and down the DNS tree to find the registry or searches across multiple indexes in a registry, requires a client with special knowledge of the data relationships contained within a registry.
o 除此之外，如在DNS树上下搜索以查找注册表或在注册表中跨多个索引进行搜索，都需要对注册表中包含的数据关系有专门知识的客户机。
Therefore, IRIS does the following:
因此，IRIS执行以下操作：
o It specifies the basic schema language used by all registries to specify their schemas.
o 它指定所有注册表用于指定其模式的基本模式语言。
o It provides the basic framework for a registry to make a reference to an entity in another type of registry.
o 它为注册中心提供了一个基本框架，以引用另一种类型的注册中心中的实体。
And, therefore, IRIS does not do the following:
因此，IRIS不具备以下功能：
o It does not specify a common query language across all types of registries. A common query language imposed across multiple types of registries usually results in the disabling of certain functions by a server operator in order to meet acceptable levels of performance, leaving a common query language that does not commonly work.
o 它没有在所有类型的注册表中指定公共查询语言。跨多种类型的注册表强制使用公共查询语言通常会导致服务器操作员禁用某些功能，以达到可接受的性能水平，从而导致公共查询语言无法正常工作。
o It does not impose any relationship between sets of data in any type of registry, such as specifying a tree. There are many types of Internet resources, and they do not all share the same style of
o 它不会在任何类型的注册表中的数据集之间施加任何关系，例如指定树。有许多类型的互联网资源，它们并不都共享相同的风格
relationship with their contained sets of data. When it is not a natural fit, an imposition of a common relationship is often a concern and not a benefit.
与其包含的数据集的关系。当这不是一种自然的契合时，强加一种共同的关系往往是一种担忧，而不是一种好处。
The design premise of IRIS signifies that, for directory services, there is no such thing as a universal client (or that if there is one, it is commonly called the "web browser").
IRIS的设计前提意味着，对于目录服务，没有通用客户机（或者，如果有，通常称为“web浏览器”）。
For IRIS, the closest thing to a universal client is one that may "look up" data and may be able to display the data in a rudimentary fashion. For a client to be able to "search" data or display it in a truly user-friendly manner, it must have specific knowledge about the type of data it is retrieving.
对于IRIS来说，最接近通用客户机的是可以“查找”数据并能够以基本方式显示数据的客户机。对于能够“搜索”数据或以真正用户友好的方式显示数据的客户机来说，它必须对所检索的数据类型有特定的了解。
Attempts to outfit a universal client with a common query language are also not very useful. A common query language may be applied to a specific problem domain, which would require a user to have expertise in both the common query language and the problem domain. In the end, the outcome is usually the development of a client specific to the problem domain but saddled with translation of the user's desires and the lowest-common-denominator aspect of the query language.
尝试为通用客户机配备通用查询语言也不是很有用。公共查询语言可以应用于特定的问题域，这需要用户在公共查询语言和问题域方面都具有专业知识。最终，结果通常是开发特定于问题域的客户机，但需要翻译用户的需求和查询语言的最低公分母方面。
As mentioned above, IRIS was designed for the directory service needs of public-facing registries. In this light, certain aspects of more generalized directory services are a hindrance in an environment that does not have the same control and safety considerations as a managed network.
如上所述，IRIS是为面向公众的注册中心的目录服务需求而设计的。有鉴于此，在一个没有与托管网络相同的控制和安全考虑的环境中，更通用的目录服务的某些方面是一个障碍。
For instance, a common query language can provide great flexibility to both the power user and the abusive user. An abusive user could easily submit a query across multiple indexes with partial values. Such a query would have no utility other than to cause denial of service to other users. To combat this, a service operator must restrict the types of queries that cause harm to overall performance, and this act obsoletes the benefit of a common query language.
例如，公共查询语言可以为超级用户和滥用用户提供极大的灵活性。滥用权限的用户可以很容易地跨多个具有部分值的索引提交查询。这样的查询除了对其他用户造成拒绝服务之外没有其他用途。为了解决这一问题，服务运营商必须限制对整体性能造成损害的查询类型，而这一行为使通用查询语言的优势消失殆尽。
Another consideration for server performance is the lack of a required data relationship. Because sets of data often have differing relationships, a one-size-fits-all approach does not fit well with all types of registries. In addition, public-facing services tend to have service level requirements that cannot reasonably be met by transforming complete data stores from a native format into a format enforcing an artificial set of relationships.
服务器性能的另一个考虑因素是缺少所需的数据关系。因为数据集通常具有不同的关系，所以“一刀切”的方法并不适合所有类型的注册中心。此外，面向公众的服务往往具有无法通过将完整数据存储从本机格式转换为强制执行一组人工关系的格式来合理满足的服务级别要求。
To combat these issues, operators of public-facing services tend to create their own custom query parsers and back-end data stores. But doing so brings into question the use of a generalized directory service.
为了解决这些问题，面向公众服务的运营商倾向于创建自己的定制查询解析器和后端数据存储。但是这样做会对通用目录服务的使用产生疑问。
Finally, IRIS is built upon a set of standard technological layers. This allows service operators to switch components to meet the needs of their particular environment.
最后，IRIS建立在一组标准技术层之上。这允许服务运营商切换组件以满足其特定环境的需要。
IRIS supports both lookups and searches. Conceptually, the difference between the two is as follows:
IRIS支持查找和搜索。从概念上讲，两者的区别如下：
A "lookup" is a single query with a discrete value on a single index.
“查找”是在单个索引上具有离散值的单个查询。
Anything more, such as partial value queries, queries across multiple indexes, or multiple queries to a single index is a "search".
任何其他查询，如部分值查询、跨多个索引的查询或对单个索引的多个查询，都是“搜索”。
Lookups are accomplished through the defined query <lookupEntity>. This query specifies a discrete name, called the entity name, to be queried in a single index, called the entity class. Therefore, implementations may consider a type of registry to be composed of multiple indexes, one for each defined entity class.
通过定义的查询<lookupEntity>完成查找。此查询指定一个离散名称（称为实体名称），该名称将在单个索引（称为实体类）中查询。因此，实现可以考虑注册表的类型由多个索引组成，每个类型定义一个实体类。
There are no standard searches in IRIS. Each type of registry defines its own set of searches.
IRIS中没有标准搜索。每种类型的注册表都定义自己的一组搜索。
Due to its effect on client behavior and the side effects such behavior may have on servers, IRIS makes a clear distinction between entity references (<entity>) and search continuations (<searchContinuation>). It is not an add-on, but a fundamental core of the protocol.
由于它对客户端行为的影响以及这种行为可能对服务器产生的副作用，IRIS在实体引用（<entity>）和搜索延续（<searchContinuation>）之间做出了明确的区分。它不是附加组件，而是协议的基本核心。
The distinction is very important to a client:
这种区别对于客户来说非常重要：
"Go look over there and you will find what you seek." "Go look over there and you may find what you seek, or you may find some other stuff, or you may find nothing."
“去那边看看，你会找到你想要的。”“去那边看看，你可能会找到你想要的，或者你可能会找到其他东西，或者你可能什么也找不到。”
Finally, because IRIS makes no assumptions about and places no requirements on the relationship of data in a registry, this also extends to data of the same registry type spread across multiple authority areas. This means that IRIS makes no requirements as to
最后，由于IRIS对注册表中的数据关系不作任何假设，也不作任何要求，因此这也适用于分布在多个权限区域的同一注册表类型的数据。这意味着IRIS不要求
the scope of entity references or search continuations. The scope is determined by what the registry type needs and by what the registry type allows a service operator.
实体引用或搜索延续的范围。范围由注册表类型需要什么以及注册表类型允许服务操作员使用什么来确定。
The terminology used in this document to describe namespaces and namespaces of namespaces is now much clearer thanks to the skillful debate tactics of Leslie Daigle. Previously, it was much more confusing. In addition, Leslie has provided great insight into the details of URIs, URNs, and NAPTR/SRV resource records.
由于Leslie Daigle巧妙的辩论策略，本文档中用于描述名称空间和名称空间中的名称空间的术语现在更加清晰。以前，它更令人困惑。此外，Leslie还深入了解了URI、URN和NAPTR/SRV资源记录的详细信息。
Many other technical complexities were proved unnecessary by David Blacka and have been removed. And his IRIS implementation has helped smooth out the rougher edges.
David Blacka证明许多其他技术复杂性是不必要的，并且已经消除。他的虹膜技术帮助平滑了粗糙的边缘。
Authors' Addresses
作者地址
Andrew L. Newton VeriSign, Inc. 21345 Ridgetop Circle Sterling, VA 20166 USA
Andrew L.Newton VeriSign，Inc.美国弗吉尼亚州斯特林Ridgetop Circle 21345，邮编20166
Phone: +1 703 948 3382
EMail: anewton@verisignlabs.com; andy@hxr.us
URI: http://www.verisignlabs.com/
Phone: +1 703 948 3382
EMail: anewton@verisignlabs.com; andy@hxr.us
URI: http://www.verisignlabs.com/
Marcos Sanz DENIC eG Wiesenhuettenplatz 26 D-60329 Frankfurt Germany
Marcos Sanz DENIC eG Wiesenhuettenplatz 26 D-60329德国法兰克福
EMail: sanz@denic.de
URI: http://www.denic.de/
EMail: sanz@denic.de
URI: http://www.denic.de/
Full Copyright Statement
完整版权声明
Copyright (C) The Internet Society (2005).
版权所有（C）互联网协会（2005年）。
This document is subject to the rights, licenses and restrictions contained in BCP 78, and except as set forth therein, the authors retain all their rights.
本文件受BCP 78中包含的权利、许可和限制的约束，除其中规定外，作者保留其所有权利。
This document and the information contained herein are provided on an "AS IS" basis and THE CONTRIBUTOR, THE ORGANIZATION HE/SHE REPRESENTS OR IS SPONSORED BY (IF ANY), THE INTERNET SOCIETY AND THE INTERNET ENGINEERING TASK FORCE DISCLAIM ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
本文件及其包含的信息是按“原样”提供的，贡献者、他/她所代表或赞助的组织（如有）、互联网协会和互联网工程任务组不承担任何明示或暗示的担保，包括但不限于任何保证，即使用本文中的信息不会侵犯任何权利，或对适销性或特定用途适用性的任何默示保证。
Intellectual Property
知识产权
The IETF takes no position regarding the validity or scope of any Intellectual Property Rights or other rights that might be claimed to pertain to the implementation or use of the technology described in this document or the extent to which any license under such rights might or might not be available; nor does it represent that it has made any independent effort to identify any such rights. Information on the IETF's procedures with respect to rights in IETF Documents can be found in BCP 78 and BCP 79.
IETF对可能声称与本文件所述技术的实施或使用有关的任何知识产权或其他权利的有效性或范围，或此类权利下的任何许可可能或可能不可用的程度，不采取任何立场；它也不表示它已作出任何独立努力来确定任何此类权利。有关IETF文件中权利的IETF程序信息，请参见BCP 78和BCP 79。
Copies of IPR disclosures made to the IETF Secretariat and any assurances of licenses to be made available, or the result of an attempt made to obtain a general license or permission for the use of such proprietary rights by implementers or users of this specification can be obtained from the IETF on-line IPR repository at http://www.ietf.org/ipr.
向IETF秘书处披露的知识产权副本和任何许可证保证，或本规范实施者或用户试图获得使用此类专有权利的一般许可证或许可的结果，可从IETF在线知识产权存储库获取，网址为http://www.ietf.org/ipr.
The IETF invites any interested party to bring to its attention any copyrights, patents or patent applications, or other proprietary rights that may cover technology that may be required to implement this standard. Please address the information to the IETF at ietf-ipr@ietf.org.
IETF邀请任何相关方提请其注意任何版权、专利或专利申请，或其他可能涵盖实施本标准所需技术的专有权利。请将信息发送至IETF的IETF-ipr@ietf.org.
Acknowledgement
确认
Funding for the RFC Editor function is currently provided by the Internet Society.
RFC编辑功能的资金目前由互联网协会提供。