Independent Submission D. Worley
Request for Comments: 8433 Ariadne
Category: Informational August 2018
ISSN: 2070-1721
Independent Submission D. Worley
Request for Comments: 8433 Ariadne
Category: Informational August 2018
ISSN: 2070-1721
A Simpler Method for Resolving Alert-Info URNs
解析警报信息URN的更简单方法
Abstract
摘要
The "alert" namespace of Uniform Resource Names (URNs) can be used in the Alert-Info header field of Session Initiation Protocol (SIP) requests and responses to inform a voice over IP (VoIP) telephone (user agent) of the characteristics of the call that the user agent has originated or terminated. The user agent must resolve the URNs into a signal; that is, it must select the best available signal to present to its user to indicate the characteristics of the call.
统一资源名称（URN）的“警报”命名空间可用于会话发起协议（SIP）请求和响应的警报信息报头字段，以通知IP语音（VoIP）电话（用户代理）用户代理已发起或终止的呼叫的特征。用户代理必须将URN解析为信号；也就是说，它必须选择最好的可用信号来呈现给用户，以指示呼叫的特征。
RFC 7462 describes a non-normative algorithm for signal selection. This document describes a more efficient alternative algorithm: a user agent's designer can, based on the user agent's signals and their meanings, construct a finite state machine (FSM) to process the URNs to select a signal in a way that obeys the restrictions given in the definition of the "alert" URN namespace.
RFC 7462描述了信号选择的非标准算法。本文档描述了一种更有效的替代算法：用户代理的设计者可以根据用户代理的信号及其含义，构造一个有限状态机（FSM）来处理URN，以按照“警报”URN命名空间定义中给出的限制来选择信号。
Status of This Memo
关于下段备忘
This document is not an Internet Standards Track specification; it is published for informational purposes.
本文件不是互联网标准跟踪规范；它是为了提供信息而发布的。
This is a contribution to the RFC Series, independently of any other RFC stream. The RFC Editor has chosen to publish this document at its discretion and makes no statement about its value for implementation or deployment. Documents approved for publication by the RFC Editor are not candidates for any level of Internet Standard; see Section 2 of RFC 7841.
这是对RFC系列的贡献，独立于任何其他RFC流。RFC编辑器已选择自行发布此文档，并且未声明其对实现或部署的价值。RFC编辑批准发布的文件不适用于任何级别的互联网标准；见RFC 7841第2节。
Information about the current status of this document, any errata, and how to provide feedback on it may be obtained at https://www.rfc-editor.org/info/rfc8433.
有关本文件当前状态、任何勘误表以及如何提供反馈的信息，请访问https://www.rfc-editor.org/info/rfc8433.
Copyright Notice
版权公告
Copyright (c) 2018 IETF Trust and the persons identified as the document authors. All rights reserved.
版权所有（c）2018 IETF信托基金和确定为文件作者的人员。版权所有。
This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (https://trustee.ietf.org/license-info) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect to this document.
本文件受BCP 78和IETF信托有关IETF文件的法律规定的约束(https://trustee.ietf.org/license-info)自本文件出版之日起生效。请仔细阅读这些文件，因为它们描述了您对本文件的权利和限制。
Table of Contents
目录
1. Introduction ....................................................3
1.1. Requirements Governing Resolution Algorithms ...............4
1.2. Summary of the New Resolution Algorithm ....................5
1.3. Conventions Used in This Document ..........................7
2. Selecting the Signals and Their Corresponding "alert" URNs ......7
3. General Considerations for Processing Alert-Info ................9
4. Constructing the Finite State Machine for a Very Simple
Example ........................................................10
4.1. Listing the Expressed URNs ................................11
4.2. Constructing the Alphabet of Symbols ......................11
4.3. Constructing the States and Transitions ...................13
4.4. Summary ...................................................17
4.5. Examples of Processing Alert-Info URNs ....................19
5. Further Examples ...............................................20
5.1. Example with "source" and "priority" URNs .................20
5.2. Example 1 of RFC 7462 .....................................24
5.3. Examples 2, 3, and 4 of RFC 7462 ..........................30
5.4. An Example That Subsets Internal Sources ..................33
5.5. An Example of "alert:service" URNs ........................34
5.6. An Example Using Country Codes ............................34
6. Prioritizing Signals ...........................................40
7. Dynamic Sets of Signals ........................................41
8. Security Considerations ........................................43
9. IANA Considerations ............................................43
10. References ....................................................44
10.1. Normative References .....................................44
10.2. Informative References ...................................44
Acknowledgments ...................................................45
Author's Address ..................................................45
1. Introduction ....................................................3
1.1. Requirements Governing Resolution Algorithms ...............4
1.2. Summary of the New Resolution Algorithm ....................5
1.3. Conventions Used in This Document ..........................7
2. Selecting the Signals and Their Corresponding "alert" URNs ......7
3. General Considerations for Processing Alert-Info ................9
4. Constructing the Finite State Machine for a Very Simple
Example ........................................................10
4.1. Listing the Expressed URNs ................................11
4.2. Constructing the Alphabet of Symbols ......................11
4.3. Constructing the States and Transitions ...................13
4.4. Summary ...................................................17
4.5. Examples of Processing Alert-Info URNs ....................19
5. Further Examples ...............................................20
5.1. Example with "source" and "priority" URNs .................20
5.2. Example 1 of RFC 7462 .....................................24
5.3. Examples 2, 3, and 4 of RFC 7462 ..........................30
5.4. An Example That Subsets Internal Sources ..................33
5.5. An Example of "alert:service" URNs ........................34
5.6. An Example Using Country Codes ............................34
6. Prioritizing Signals ...........................................40
7. Dynamic Sets of Signals ........................................41
8. Security Considerations ........................................43
9. IANA Considerations ............................................43
10. References ....................................................44
10.1. Normative References .....................................44
10.2. Informative References ...................................44
Acknowledgments ...................................................45
Author's Address ..................................................45
When a SIP user agent (UA) server receives an incoming INVITE request, it chooses an alerting signal (the ring tone) to present to its user (the called user) by processing the Alert-Info header field(s) in the incoming INVITE request [RFC3261]. Similarly, a SIP UA client determines an alerting signal (the ringback tone) to present to its user (the calling user) by processing the Alert-Info header field(s) in the incoming provisional response(s) to its outgoing INVITE request.
当SIP用户代理（UA）服务器接收到传入的INVITE请求时，它通过处理传入INVITE请求[RFC3261]中的警报信息头字段来选择向其用户（被叫用户）显示的警报信号（铃声）。类似地，SIP UA客户端通过处理对其传出INVITE请求的传入临时响应中的警报信息报头字段来确定要呈现给其用户（呼叫用户）的警报信号（回铃音）。
[RFC3261] envisioned that the Alert-Info header field value would be a URL that the UA could use to retrieve the encoded media of the signal. This usage has security problems and is inconvenient to implement in practice.
[RFC3261]设想警报信息标题字段值将是UA可用于检索信号编码媒体的URL。这种用法存在安全问题，不便于在实践中实现。
[RFC7462] introduced an alternative practice: the Alert-Info values can be URNs in the "alert" URN namespace that specify features of the call or of the signal that should be signaled to the user. [RFC7462] defined a large set of "alert" URNs and procedures for extending the set.
[RFC7462]介绍了另一种做法：警报信息值可以是“警报”URN命名空间中的URN，用于指定呼叫或应发送给用户的信号的功能。[RFC7462]定义了一大组“警报”URN和扩展该组的过程。
A UA is unlikely to provide more than a small set of alerting signals, and there are an infinite number of possible combinations of "alert" URNs. Thus, a UA is often required to select an alerting signal that renders only a subset of the information in the Alert-Info header field(s) -- which is the resolution process for "alert" URNs. The requirements for resolving "alert" URNs are given in Section 11.1 of [RFC7462].
UA不太可能提供超过一小部分的警报信号，并且可能存在无限多的“警报”URN组合。因此，UA通常需要选择仅呈现警报信息标题字段中信息子集的警报信号，这是“警报”URN的解析过程。[RFC7462]第11.1节给出了解决“警报”URN的要求。
Section 12 of [RFC7462] gives a (non-normative) resolution algorithm for selecting a signal that satisfies the requirements of Section 11.1 of that document. That algorithm can be used regardless of the set of alerting signals that the UA provides and their specified meanings. The existence of the algorithm defined in [RFC7462] demonstrates that the resolution requirements can always be satisfied. However, the algorithm is complex and slow.
[RFC7462]第12节给出了一种（非规范性）分辨率算法，用于选择满足该文件第11.1节要求的信号。无论UA提供的警报信号集及其指定含义如何，都可以使用该算法。[RFC7462]中定义的算法的存在表明，始终可以满足分辨率要求。然而，该算法复杂且速度慢。
The purpose of this document is to describe an improved implementation -- a more efficient resolution algorithm for selecting signals that conforms to the requirements of Section 11.1 of [RFC7462]. (Of course, like any such algorithm, it is non-normative, and the implementation is free to use any algorithm that conforms to the requirements of Section 11.1 of [RFC7462].)
本文件的目的是描述一种改进的实现——一种更有效的分辨率算法，用于选择符合[RFC7462]第11.1节要求的信号。（当然，与任何此类算法一样，它是非规范性的，实现可以自由使用符合[RFC7462]第11.1节要求的任何算法。）
In the algorithm defined in this document, once the UA designer has chosen the set of signals that the UA produces and the "alert" URNs that they express, a finite state machine (FSM) is constructed that
在本文件中定义的算法中，一旦UA设计师选择了UA产生的一组信号和它们表示的“警报”URN，就会构建一个有限状态机（FSM），用于
selects alerting signals based on the URNs in the Alert-Info header field(s) in a SIP message. The incoming "alert" URNs are preprocessed in a straightforward manner into a sequence of "symbols" drawn from a fixed finite set; these symbols are then used as input to the FSM. After processing the input, the state of the FSM selects the correct alerting signal to present to the user.
根据SIP消息中警报信息标题字段中的URN选择警报信号。将传入的“警报”URN以简单的方式预处理为从固定有限集绘制的“符号”序列；然后将这些符号用作FSM的输入。在处理输入后，FSM的状态选择正确的报警信号以呈现给用户。
Both the preprocessor and the FSM are determined only by the selected set of signals and the set of "alert" URNs expressed by the signals, so the processing machinery can be fixed at the time of designing the UA.
预处理器和FSM仅由所选信号集和由信号表示的“警报”URN集确定，因此在设计UA时可以固定处理机械。
The requirements for the resolution of "alert" URNs are given in Section 11.1 of [RFC7462] and can be described as follows:
[RFC7462]第11.1节给出了解决“警报”URN的要求，可描述如下：
o The "alert" URNs are processed from left to right. Each "alert" URN has precedence over all URNs that follow it, and its interpretation is subordinate to all URNs that precede it.
o 从左到右处理“警报”URN。每个“警报”URN优先于其后面的所有URN，其解释从属于其前面的所有URN。
o As each URN is processed, one of the UA's signals is chosen that expresses that URN as far as can be done without reducing the degree to which any of the preceding URNs were expressed by the signal chosen for the preceding URN. Thus, as processing proceeds, the chosen signals become increasingly specific and contain more information, but all of the information about a particular URN that is expressed by the signal chosen for that URN is also expressed by the signals chosen for all following URNs.
o 在处理每个URN时，选择一个UA信号，该信号尽可能地表示该URN，而不降低为前一个URN选择的信号表示任何前一个URN的程度。因此，随着处理的进行，所选择的信号变得越来越具体并包含更多信息，但是由为该URN选择的信号表示的关于特定URN的所有信息也由为所有后续URN选择的信号表示。
o If the entirety of the current URN cannot be expressed by any allowed signal, then each of the trailing alert-ind-parts (the sections separated by colons) is in turn removed until the reduced URN can be expressed by some signal that also expresses at least the same reduced versions of the preceding URNs that were expressed by the signal chosen for the preceding URN. This can be described as "a signal that expresses as much of the current URN as possible while still expressing as much of the previous URNs as the preceding signal did."
o 如果当前URN的整体不能用任何允许的信号表示，则每个尾部警报ind部分（用冒号分隔的部分）依次移除，直到缩小的URN可以由某个信号表示，该信号也至少表示为先前URN选择的信号表示的先前URN的相同缩小版本。这可以被描述为“一个信号，它尽可能多地表示当前URN，同时仍然像前一个信号一样多地表示前一个URN。”
So, for instance, consider processing
因此，例如，考虑处理
Alert-Info: urn:alert:category-a:part-a1:part-a2,
urn:alert:category-b:part-b1:part-b2
Alert-Info: urn:alert:category-a:part-a1:part-a2,
urn:alert:category-b:part-b1:part-b2
If the UA has no signal for urn:alert:category-a:part-a1:part-a2, it
removes part-a2 from the URN and checks whether it has a signal for
the less-specific URN urn:alert:category-a:part-a1. If it has no
If the UA has no signal for urn:alert:category-a:part-a1:part-a2, it
removes part-a2 from the URN and checks whether it has a signal for
the less-specific URN urn:alert:category-a:part-a1. If it has no
signal for that URN, it gives up on the URN entirely (since urn:alert:category-a doesn't exist and can be considered to express nothing about the call), and the chosen signal is the default signal of the UA, i.e., the signal that is used when there is no Alert-Info.
该URN的信号，它完全放弃URN（因为URN:alert:CATEGORE-a不存在，可以认为对呼叫没有任何表示），所选信号是UA的默认信号，即在没有警报信息时使用的信号。
But let us suppose the UA has a signal for urn:alert:category-a:part-a1 and chooses that signal when processing the first URN. All processing after this point will be restricted to signals that express urn:alert:category-a:part-a1 or a more specific URN of the category "category-a".
但让我们假设UA有一个urn:alert:category-a:part-a1信号，并在处理第一个urn时选择该信号。此点之后的所有处理将限于表示urn:alert:category-a:part-a1或更具体的“category-a”类urn的信号。
The UA then goes on to examine the next URN, urn:alert:category-b:part-b1:part-b2. If there is a signal that expresses both urn:alert:category-a:part-a1 and urn:alert:category-b:part-b1:part-b2, then the UA chooses that signal. If there is no such signal, the second URN is reduced to urn:alert:category-b:part-b1, and the UA checks for a signal that expresses that URN along with urn:alert:category-a:part-a1. If there is no such signal that matches that relaxed requirement, the second URN is reduced to urn:alert:category-b, which is discarded, and the chosen signal for the first URN is chosen for the second URN. In any case, all processing after this point will be restricted to signals that express urn:alert:category-a:part-a1 or a more specific URN of the category "category-a" and that also express the chosen part of urn:alert:category-b:part-b1:part-b2.
UA接着检查下一个URN，URN:alert:category-b:part-b1:part-b2。如果有一个信号同时表示urn:alert:category-a:part-a1和urn:alert:category-b:part-b1:part-b2，则UA选择该信号。如果没有这样的信号，第二个URN将减少为URN:alert:CATEGORE-b:part-b1，UA将检查表示该URN以及URN:alert:CATEGORE-a:part-a1的信号。如果没有符合该放宽要求的信号，则第二个URN将减少为URN:alert:CATEGORE-b，这将被丢弃，并且为第一个URN选择的信号将为第二个URN选择。在任何情况下，这一点之后的所有处理都将限于表示urn:alert:category-a:part-a1或“category-a”类别中更具体的urn的信号，以及表示urn:alert:category-b:part-b1:part-b2所选部分的信号。
This process is continued until the last "alert" URN is processed; the signal chosen for the last URN is the signal that the UA uses.
此过程将继续，直到处理最后一个“警报”URN；为最后一个URN选择的信号是UA使用的信号。
The purpose of this document is to describe a resolution algorithm that conforms to Section 11.1 of [RFC7462] but is simpler than the algorithm described in Section 12 of [RFC7462]: once the UA designer has chosen a set of signals and the URNs that they express, an FSM is constructed that selects alerting signals based on the URNs in the Alert-Info header field(s) in a SIP message.
本文件旨在描述符合[RFC7462]第11.1节但比[RFC7462]第12节所述算法更简单的解析算法：一旦UA设计师选择了一组信号及其表示的URN，FSM的构造基于SIP消息中警报信息报头字段中的URN来选择警报信号。
o The designer selects the set of signals that the UA produces, matching each signal to a set of "alert" URNs that together specify the meaning that is carried by the signal. (If the signal is a "default" signal that has no specific meaning, the set is empty. If the signal carries the meaning of one "alert" URN, the set contains that URN. If the signal carries a meaning that is the logical AND of two or more "alert" URNs, the set contains those URNs.)
o 设计者选择UA产生的一组信号，将每个信号与一组“警报”URN相匹配，这些URN共同指定信号所承载的含义。（如果信号是没有特定含义的“默认”信号，则集合为空。如果信号具有一个“警报”URN的含义，则集合包含该URN。如果信号具有两个或多个“警报”URN的逻辑AND含义，则集合包含这些URN。）
o Based on the UA's signals and their meanings, the designer constructs an "alphabet" containing a finite number of symbols; each possible "alert" URN is mapped into one particular symbol.
o 基于UA的信号及其含义，设计师构建了一个包含有限数量符号的“字母表”；每个可能的“警报”URN都映射到一个特定符号中。
o The designer constructs an FSM whose input is the alphabet of symbols and whose states describe the information extracted from the Alert-Info URNs.
o 设计者构造一个FSM，其输入是符号的字母表，其状态描述从警报信息URN中提取的信息。
o Each state of the FSM has an associated signal. Processing the Alert-Info URNs will leave the FSM in some particular state; the UA renders the signal that is attached to that final state.
o FSM的每个状态都有一个相关的信号。处理警报信息URN将使FSM处于某种特定状态；UA呈现附加到该最终状态的信号。
To select a ring tone or ringback tone based on a SIP message, the UA processes the "alert" URNs in the Alert-Info header field from left to right. Initially, the FSM is in a designated initial state. The UA maps each successive URN into the corresponding symbol and then executes the state transition of the FSM specified by the symbol. The state of the FSM after processing the URNs determines which signal the UA will render to the user.
要根据SIP消息选择铃声或回铃音，UA从左到右处理警报信息标题字段中的“警报”URN。最初，FSM处于指定的初始状态。UA将每个连续URN映射到相应的符号中，然后执行该符号指定的FSM的状态转换。处理URN后FSM的状态确定UA将向用户呈现的信号。
Note that the UA generally has two FSMs, because a UA usually wants to signal different information in ring tones than it signals in ringback tones. One FSM is used to select the ring tone to render for an incoming INVITE request. The other FSM is used to select the ringback tone to render based on an incoming provisional response to an outgoing INVITE request. Both FSMs are constructed in the same way, but the constructions are based on different lists of signals and corresponding URNs.
请注意，UA通常有两个FSM，因为UA通常希望通过铃声发送不同的信息，而不是通过回铃音发送。一个FSM用于为传入的INVITE请求选择要呈现的铃声。另一个FSM用于根据对传出INVITE请求的传入临时响应选择要呈现的回铃音。两个FSM的构造方式相同，但构造基于不同的信号列表和相应的URN。
All of the steps of the method after the designer has selected the signals and their URNs are algorithmic, and the algorithm of those steps ensures that the operation of the FSM will satisfy the constraints of Section 11.1 of [RFC7462]. A Python implementation of the algorithmic steps is provided in [code].
设计师选择信号及其URN后，该方法的所有步骤都是算法步骤，这些步骤的算法确保FSM的操作将满足[RFC7462]第11.1节的约束。[代码]中提供了算法步骤的Python实现。
In simple situations, a suitable FSM or equivalent ad hoc code can be constructed by hand using ad hoc analysis. Generally, this is only practical in situations where a small number of alert-categories and alert-indications are signaled and the categories interact in a simple, uniform way. For example, the examples in Sections 5.1 and 5.2 could be constructed by ad hoc analysis. But automatic processing is valuable if the situation is too complicated to construct a correct FSM by ad hoc analysis, or if the set of signals will change too frequently for human production to be economical.
在简单的情况下，可以使用自组织分析手工构造合适的FSM或等效的自组织代码。一般来说，这仅适用于少量警报类别和警报指示发出信号且类别以简单、统一的方式相互作用的情况。例如，第5.1节和第5.2节中的示例可以通过特殊分析构建。但是，如果情况过于复杂，无法通过特殊分析构建正确的FSM，或者如果信号集的变化过于频繁，人类生产不经济，则自动处理是有价值的。
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all capitals, as shown here.
本文件中的关键词“必须”、“不得”、“必需”、“应”、“不应”、“建议”、“不建议”、“可”和“可选”在所有大写字母出现时（如图所示）应按照BCP 14[RFC2119][RFC8174]所述进行解释。
The designer must select signals that the UA will generate and define the meanings that the signals will have to the user. Based on this, the designer determines for each signal the "alert" URN or combination of "alert" URNs that (1) indicate that signal's meaning in SIP messages and (2) consequently should elicit that signal from the UA.
设计者必须选择UA将生成的信号，并定义这些信号对用户的意义。基于此，设计者确定每个信号的“警报”URN或“警报”URN的组合，其（1）指示SIP消息中的信号含义，并且（2）因此应从UA中引出该信号。
For example, suppose the UA has a particular ring tone for calls from an external source. A call from an external source is marked with the URN urn:alert:source:external (specified in Section 9 of [RFC7462]). Thus, the table of signals includes:
例如，假设UA有一个特定的铃声用于来自外部源的呼叫。来自外部源的调用标记为URN URN:alert:source:external（在[RFC7462]的第9节中指定）。因此，信号表包括：
Signal URN(s)
---------------------------- -------------------------------
external source urn:alert:source:external
Signal URN(s)
---------------------------- -------------------------------
external source urn:alert:source:external
Similarly, if the UA has a particular ring tone for calls from an internal source, the table includes:
类似地，如果UA对来自内部源的呼叫具有特定铃声，则该表包括：
Signal URN(s)
---------------------------- -------------------------------
internal source urn:alert:source:internal
Signal URN(s)
---------------------------- -------------------------------
internal source urn:alert:source:internal
If the UA has ring tones for calls that are marked as having higher or lower priority, then the table includes:
如果UA具有标记为具有较高或较低优先级的呼叫铃声，则该表包括：
Signal URN(s)
---------------------------- -------------------------------
high priority urn:alert:priority:high
low priority urn:alert:priority:low
Signal URN(s)
---------------------------- -------------------------------
high priority urn:alert:priority:high
low priority urn:alert:priority:low
Note that the UA must be able to signal for a message that has no "alert" URNs in the Alert-Info header field, which means that there must always be a default signal that has zero corresponding URNs:
请注意，UA必须能够为警报信息标题字段中没有“警报”URN的消息发送信号，这意味着必须始终有一个默认信号，该信号具有零个对应URN：
Signal URN(s)
---------------------------- -------------------------------
default (none)
Signal URN(s)
---------------------------- -------------------------------
default (none)
A signal can be defined to indicate a combination of conditions. For instance, a signal that is used only for high-priority, internal-source calls expresses two URNs and will only be used when both URNs are present in Alert-Info:
可以定义一个信号来指示各种条件的组合。例如，仅用于高优先级内部源调用的信号表示两个URN，并且仅在警报信息中同时存在两个URN时使用：
Signal URN(s)
------------------------------ -------------------------------
high priority, internal source urn:alert:priority:high,
urn:alert:source:internal
Signal URN(s)
------------------------------ -------------------------------
high priority, internal source urn:alert:priority:high,
urn:alert:source:internal
A signal can be defined to cover a number of related conditions by specifying a URN that is the common prefix of the URNs for the various conditions. For instance, the URNs for "recall due to callback", "recall due to call hold", and "recall due to transfer" all start with urn:alert:service:recall, and so one signal can be provided for all of them by:
通过指定一个URN（该URN是各种条件的URN的通用前缀），可以定义一个信号以覆盖许多相关条件。例如，“由于回调而召回”、“由于呼叫保持而召回”和“由于转接而召回”的urn都以urn:alert:service:recall开始，因此可以通过以下方式为所有urn提供一个信号：
Signal URN(s)
---------------------------- -------------------------------
recall urn:alert:service:recall
Signal URN(s)
---------------------------- -------------------------------
recall urn:alert:service:recall
But if a specific signal is also provided for "recall due to callback" by this entry:
但是，如果此条目还为“回调导致的回调”提供了特定信号：
Signal URN(s)
---------------------------- ---------------------------------
recall generally urn:alert:service:recall
recall due to callback urn:alert:service:recall:callback
Signal URN(s)
---------------------------- ---------------------------------
recall generally urn:alert:service:recall
recall due to callback urn:alert:service:recall:callback
then if the message contains urn:alert:service:recall:callback, the "recall due to callback" signal will be chosen instead of "recall generally" because the UA chooses the signal that most completely expresses the information in the Alert-Info header field.
然后，如果消息包含urn:alert:service:recall:callback，则将选择“由于回调而召回”信号，而不是“一般召回”，因为UA选择最完整地表达警报信息标头字段中信息的信号。
The designer may wish to define extension URNs that provide more specific information about a call than the standard "alert" URNs do. One method is to add additional components to standard URNs. For instance, an extra-high priority could be indicated by the URN urn:alert:priority:high:extra@example. The final "extra@example" is an "alert-ind-part" that is a private extension. (See Sections 7 and 10.2 of [RFC7462] for a discussion of private extensions.) In any case, adding an alert-ind-part to a URN makes its meaning more specific, in that any call to which the longer URN can be applied can also have the shorter URN applied. In this case, "extra-high-priority calls" are considered a subset of "high-priority calls".
设计者可能希望定义扩展URN，该扩展URN提供比标准“警报”URN更具体的呼叫信息。一种方法是向标准URN添加其他构件。例如，可以通过URN:URN:alert:priority:high:extra@example. “决赛”extra@example是一个“警报ind部件”，它是一个专用扩展。（有关专用扩展的讨论，请参见[RFC7462]第7节和第10.2节。）在任何情况下，将警报ind部分添加到URN会使其含义更加具体，因为可以应用较长URN的任何调用也可以应用较短的URN。在这种情况下，“超高优先级呼叫”被视为“高优先级呼叫”的子集。
Signal URN(s)
--------------------- -----------------------------------------
high priority urn:alert:priority:high
extra-high priority urn:alert:priority:high:extra@example.com
Signal URN(s)
--------------------- -----------------------------------------
high priority urn:alert:priority:high
extra-high priority urn:alert:priority:high:extra@example.com
Of course, for this extension to be useful, the senders of SIP messages (e.g., other UAs) must generate the extension URN in suitable circumstances.
当然，为了使此扩展有用，SIP消息的发送者（例如，其他UAs）必须在适当的情况下生成扩展URN。
In some circumstances, the designer may want to create an entirely new category of "alert" URNs to indicate a type of information that is not indicated by any standard category of URNs. In that case, the designer uses a private extension as the alert-category (the third component of the URN), combined with whatever alert-ind-part (fourth component) values are desired. For example, a simplified version of the U.S. military security designations could be:
在某些情况下，设计师可能希望创建一个全新的“警报”骨灰盒类别，以指示任何标准骨灰盒类别都未指示的信息类型。在这种情况下，设计器使用私有扩展作为警报类别（URN的第三个组件），并结合所需的警报ind part（第四个组件）值。例如，美国军事安全名称的简化版本可以是：
Signal URN(s)
----------------------- ---------------------------------------
unclassified urn:alert:security@example:unclassified
confidential urn:alert:security@example:confidential
secret urn:alert:security@example:secret
top secret urn:alert:security@example:top-secret
Signal URN(s)
----------------------- ---------------------------------------
unclassified urn:alert:security@example:unclassified
confidential urn:alert:security@example:confidential
secret urn:alert:security@example:secret
top secret urn:alert:security@example:top-secret
The designer should ensure that the new alert-category is orthogonal to all defined standard alert-categories, in that any combination of one of the new URNs with one of the standard URNs is meaningful in that there could be a message carrying both URNs.
设计者应确保新警报类别与所有定义的标准警报类别正交，因为其中一个新URN与其中一个标准URN的任何组合都是有意义的，因为可能有一条消息同时包含两个URN。
In addition, the set of alert-ind-parts for the new alert-category should be comprehensive and disjoint, in that every message can be described by exactly one of them.
此外，新警报类别的警报ind部分集应全面且不相交，因为每条消息都可以由其中一条描述。
In this section, we will discuss various considerations that arise when processing Alert-Info. These have to be taken care of properly in order to conform to the standards, as well as to ensure a good user experience. But since they are largely independent of the generated FSM and its processing, they are gathered here in a separate section.
在本节中，我们将讨论处理警报信息时出现的各种注意事项。为了符合标准，以及确保良好的用户体验，必须妥善处理这些问题。但由于它们在很大程度上独立于生成的FSM及其处理，因此在这里将它们集中在一个单独的部分中。
The UA may have a number of different FSMs for processing URNs. Generally, there will be different FSMs for processing Alert-Info in incoming INVITE requests and for incoming provisional responses to outgoing INVITE requests. But any situation that changes the set of signals that the UA is willing to generate specifies a different set of signals and corresponding URNs and thus generates a different FSM.
UA可能有许多不同的FSM用于处理URN。通常，将有不同的FSM用于处理传入INVITE请求中的警报信息和对传出INVITE请求的传入临时响应。但是，任何改变UA愿意生成的信号集的情况都会指定不同的信号集和相应的URN，从而生成不同的FSM。
For example, if a call is active on the UA, all audible signals may become unavailable, or audible signals may be available only if urn:alert:priority:high is specified.
例如，如果UA上的呼叫处于活动状态，则所有音频信号都可能不可用，或者只有在指定urn:alert:priority:high时音频信号才可用。
Similarly, if the set of signals is customized by user action or local policy, the generated FSM must be updated. This can be done by (1) regenerating it according to the method described here or (2) generating a "generic" FSM and instantiating it based on the available signals. (See Section 7 for a discussion of this.)
类似地，如果通过用户操作或本地策略定制信号集，则必须更新生成的FSM。这可以通过（1）根据此处描述的方法重新生成它或（2）生成“通用”FSM并基于可用信号实例化它来实现。（有关这方面的讨论，请参见第7节。）
Note that the values in an Alert-Info header field are allowed to be URIs of any scheme and, within the "urn" scheme, are allowed to have any namespace [RFC3261]. The processing of URIs that are not "alert" URNs is not considered by this document, nor is that processing specified by [RFC7462]. But the algorithm designer must consider what to do with such URIs if they are encountered. The simplest choice is to ignore them. Alternatively, the algorithm may examine the URI to determine if it names an alerting signal or describes how to retrieve an alerting signal, and, if so, choose to render that signal rather than process the "alert" URNs to select a signal. In any case, the remainder of this document assumes that (1) the signal is to be chosen based on the "alert" URNs in Alert-Info and (2) all Alert-Info URIs that are not "alert" URNs have been removed.
请注意，警报信息标头字段中的值允许为任何方案的URI，并且在“urn”方案中，允许具有任何命名空间[RFC3261]。本文档不考虑对非“警报”URN的URI的处理，也不考虑[RFC7462]指定的处理。但是如果遇到这些URI，算法设计者必须考虑如何处理这些URI。最简单的选择就是忽略它们。或者，该算法可以检查URI以确定其是否命名警报信号或描述如何检索警报信号，如果是，则选择呈现该信号而不是处理“警报”urn以选择信号。在任何情况下，本文档的其余部分都假定（1）将根据“警报信息”中的“警报”URN选择信号，（2）已删除所有非“警报”URN的警报信息URI。
The UA may also receive "alert" URNs that are semantically invalid in various ways. For example, the URN may have only three components, despite the fact that all valid "alert" URNs have at least one alert-ind-part and thus four components. The only useful strategy is to ignore such URNs (and possibly log them for analysis).
UA还可能接收以各种方式在语义上无效的“警报”URN。例如，URN可能只有三个组件，尽管所有有效的“警报”URN至少有一个警报ind部分，因此有四个组件。唯一有用的策略是忽略此类URN（并可能记录它们以供分析）。
The method described here is robust in its handling of categories and alert-ind-parts that are unknown to the UA; as a consequence, it is also robust if they are not valid standardized URNs. Thus, these error conditions need not be handled specially.
这里描述的方法在处理UA未知的类别和警报ind部件方面是稳健的；因此，如果它们不是有效的标准化URN，那么它也是健壮的。因此，不需要专门处理这些错误条件。
Constructing the FSM involves:
构建FSM包括：
1. Listing the URNs that are expressed by the various signals of the UA.
1. 列出由UA的各种信号表示的URN。
2. From the expressed URNs, constructing the finite alphabet of symbols into which input URNs are mapped and that drive the state transitions of the FSM.
2. 从表示的URN，构造符号的有限字母表，将输入URN映射到其中，并驱动FSM的状态转换。
3. Constructing the states of the FSM and the transitions between them.
3. 构造FSM的状态以及它们之间的转换。
4. Selecting a signal to be associated with each FSM state.
4. 选择要与每个FSM状态关联的信号。
We will explain the process using a very simple example in which there are two signals -- one expressing "internal source" and one expressing "external source" -- along with a default signal (for when there is no source information to signal). The "internal source" signal expresses urn:alert:source:internal, and the "external source" signal expresses urn:alert:source:external.
我们将使用一个非常简单的示例来解释这个过程，其中有两个信号——一个表示“内部源”，另一个表示“外部源”——以及一个默认信号（当没有要发送的源信息时）。“内部源”信号表示urn:alert:source:internal，“外部源”信号表示urn:alert:source:external。
The first step is to establish for each of the UA's signals what call characteristics it represents, which is to say, the set of "alert" URNs that are its information content.
第一步是为每个UA信号确定其代表的呼叫特征，也就是说，作为其信息内容的“警报”URN集。
Signal URN(s)
---------------------------- -------------------------------
default (none)
internal source urn:alert:source:internal
external source urn:alert:source:external
Signal URN(s)
---------------------------- -------------------------------
default (none)
internal source urn:alert:source:internal
external source urn:alert:source:external
From the totality of these expressed URNs, the designer can then determine which sets of URNs must be distinguished from each other. In our simple example, the expressed URNs are:
从这些表示的URN的总数中，设计师可以确定哪些URN集必须彼此区分。在我们的简单示例中，表示的URN是：
urn:alert:source:external
urn:alert:source:internal
urn:alert:source:external
urn:alert:source:internal
In order to reduce the infinite set of possible "alert" URNs to a finite alphabet of input symbols that cause the FSM's transitions, the designer must partition the "alert" URNs into a finite set of categories.
为了将无限组可能的“警报”URN减少为导致FSM转换的输入符号的有限字母表，设计者必须将“警报”URN划分为有限组类别。
Once we've listed all the expressed URNs, we can list all of the alert-categories that are relevant to the UA's signaling; "alert" URNs in any other alert-category cannot affect the signaling and can be ignored. (The easiest way to ignore the non-relevant URNs is to skip over them during Alert-Info processing. A more formal method is to map all of them into one "Other" symbol and then, for each state of the FSM, have the "Other" symbol transition to that same state.)
一旦我们列出了所有表示的URN，我们就可以列出与UA信令相关的所有警报类别；任何其他警报类别中的“警报”URN不能影响信号，可以忽略。（忽略不相关URN的最简单方法是在警报信息处理过程中跳过它们。更正式的方法是将所有URN映射到一个“其他”符号，然后，对于FSM的每个状态，将“其他”符号转换到相同的状态。）
Within each relevant alert-category, we now define a distinct symbol for every expressed URN and for all of their "ancestor" URNs (those that can be created by removing one or more trailing alert-ind-parts). In order to name the symbols in a way that distinguishes them from the corresponding URNs, we remove the initial "urn:alert:" and capitalize each alert-ind-part. Thus, in our example, we get these symbols:
在每个相关警报类别中，我们现在为每个表示的URN及其所有“祖先”URN（可通过删除一个或多个后续警报ind部分创建的URN）定义一个不同的符号。为了以区别于相应urn的方式命名符号，我们删除了首字母“urn:alert:”并将每个警报部分大写。因此，在我们的示例中，我们得到以下符号：
Source Source:External Source:Internal
来源：外部来源：内部
Note that there is a "Source" symbol even though there is no corresponding URN. (urn:alert:source is not a valid URN -- see Section 7 of [RFC7462] -- although the processing algorithm must be prepared to screen out such a purported URN if it appears in the Alert-Info header field.) However, its existence as a symbol will be useful later when we construct the FSM.
请注意，即使没有相应的URN，也有一个“源”符号。（urn:alert:source不是有效的urn——请参见[RFC7462]的第7节——尽管处理算法必须准备好在警报信息标题字段中显示这样一个声称的urn时将其筛选出来。）但是，它作为符号的存在将在以后构造FSM时非常有用。
For each of these symbols, we add a symbol that classifies URNs that extend the symbol's corresponding URN with alert-ind-parts that cannot be expressed by signals:
对于这些符号中的每一个，我们都添加了一个符号，用于对扩展符号对应URN的URN进行分类，该URN包含无法用信号表示的警报ind部分：
Source:Other
Source:External:Other
Source:Internal:Other
Source:Other
Source:External:Other
Source:Internal:Other
The latter two classify URNs, such as urn:alert:source:external:foo@example, that extend URNs that we already have symbols for. The first is for classifying URNs, such as urn:alert:source:bar@example, that have first alert-ind-parts that contradict all the "source" URNs that the UA can signal.
后两种方法对urn进行分类，例如urn:alert:source:external:foo@example，它扩展了我们已有符号的骨灰盒。第一个用于对urn进行分类，例如urn:alert:source:bar@example，具有与UA可以发出信号的所有“源”URN相矛盾的第一警报ind部件。
These steps give us this set of symbols:
这些步骤为我们提供了这组符号：
Source Source:External Source:External:Other Source:Internal Source:Internal:Other Source:Other
源源：外部源：外部：其他源：内部源：内部：其他源：其他
We can then simplify the set of symbols by removing the ones like Source:External:Other and Source:Internal:Other that consist of adding "Other" to a symbol that corresponds to an expressed URN that is not ancestral to any other expressed URNs. This works because adding further alert-ind-parts to a URN that is a leaf in regard to
然后，我们可以通过删除像Source:External:Other和Source:Internal:Other这样的符号来简化符号集，这些符号包括将“Other”添加到与表示的URN相对应的符号中，该表示的URN不是任何其他表示的URN的祖先。这是因为向URN添加了更多的警报ind部分，该URN是关于
the set of signals has no additional effect. In this example, urn:alert:source:external:foo@example has the same effect as urn:alert:source:external for both (1) causing a signal to be chosen and (2) suppressing the effect of later URNs.
这组信号没有额外的效果。在本例中，urn:alert:source:external:foo@example具有与urn:alert:source:external相同的效果，用于（1）导致选择信号和（2）抑制后续urn的效果。
This leaves the following symbols for the "source" category:
这将为“源”类别保留以下符号：
Source Source:External Source:Internal Source:Other
来源：外部来源：内部来源：其他
These can be visually summarized by showing the infinite tree of possible source "alert" URNs and how it is partitioned into subtrees that map to each of these symbols. We also mark with "*" the expressed URNs.
通过显示可能的源“警报”URN的无限树以及如何将其划分为映射到每个符号的子树，可以直观地总结这些符号。我们还用“*”标记表示的骨灰盒。
urn:alert
|
{ | }
{ source } --> 1
{ | }
|
+--------------------+------------------+
| | |
{ | } { | } { | }
{ external* } --> 2 { internal* } --> 3 { ... } --> 4
{ | } { | } { }
{ ... } { ... }
{ } { }
urn:alert
|
{ | }
{ source } --> 1
{ | }
|
+--------------------+------------------+
| | |
{ | } { | } { | }
{ external* } --> 2 { internal* } --> 3 { ... } --> 4
{ | } { | } { }
{ ... } { ... }
{ } { }
1 = Source
2 = Source:External
3 = Source:Internal
4 = Source:Other
1 = Source
2 = Source:External
3 = Source:Internal
4 = Source:Other
The UA processes the Alert-Info URNs from left to right using an FSM, with each successive URN causing the FSM to transition to a new state. Each state of the FSM records the information that has so far been extracted from the URNs. The state of the FSM after processing all the URNs determines which signal the UA will render to the user.
UA使用FSM从左到右处理警报信息URN，每个连续URN都会导致FSM转换到新状态。FSM的每个状态都记录迄今为止从URN中提取的信息。处理所有URN后FSM的状态确定UA将向用户呈现哪个信号。
We label each state with a set of symbols, one from each relevant category, that describe the information that's been extracted from all of the URNs that have so far been processed. The initial state is labeled with the "null" symbols that are just the category names,
我们用一组符号标记每个状态，每个相关类别中有一个符号，用于描述从所有已处理的URN中提取的信息。初始状态用“null”符号标记，这些符号只是类别名称，
because no information has yet been recorded. In our simple example, the initial state is labeled "Source", since that's the only relevant category.
因为还没有记录任何信息。在我们的简单示例中，初始状态标记为“Source”，因为这是唯一相关的类别。
State: Source (initial state)
状态：源（初始状态）
Each state has a corresponding alerting signal, which is the signal that the UA will produce when URN processing leaves the FSM in that state. The signal is the one that best expresses the information that has been extracted from the URNs. Usually, the choice of signal is obvious to the designer, but there are certain constraints that the choice must satisfy. The main constraint is that the signal's expressed URNs must be semantic supersets of (i.e., identical to or a prefix of) the URNs corresponding to the symbols in the state's label. In particular, if the expressed URN of the signal in a certain category is shorter than the state's label, we show that in the state's name by putting parentheses around the trailing part of the symbol that is not expressed by the signal. For instance, if the symbol in the label is "Source:External" but the signal only expresses "Source" (i.e., no "source" URN at all), then the symbol in the label is modified to be "Source:(External)".
每个状态都有相应的警报信号，这是当URN处理使FSM处于该状态时UA将产生的信号。该信号最能表达从URN中提取的信息。通常，信号的选择对设计者来说是显而易见的，但选择必须满足某些约束条件。主要约束条件是，信号的表示URN必须是与状态标签中的符号对应的URN的语义超集（即，相同或前缀）。特别是，如果某一类别中信号的表示URN比状态标签短，我们通过在信号未表示的符号尾随部分加括号来表示状态名称。例如，如果标签中的符号为“源：外部”，但信号仅表示“源”（即根本没有“源”URN），则标签中的符号修改为“源：（外部）”。
The reason for this nonintuitive construction is that in some states, the FSM has recorded information that the chosen signal cannot express.
这种非直观构造的原因是，在某些状态下，FSM记录了所选信号无法表达的信息。
Note that the parentheses are part of the state name, so in some circumstances there may be two or more distinct states labeled with the same symbols but with different placement of parentheses within the symbols. These similar state names are relevant when the FSM can record information from multiple "alert" URNs but cannot express all of them -- depending on the order in which the URNs appear, the UA may have to render different signals, so it needs states that record the same information but render different subsets of that information.
请注意，括号是状态名称的一部分，因此在某些情况下，可能有两个或多个不同的状态标记为相同的符号，但括号在符号中的位置不同。当FSM可以记录来自多个“警报”URN的信息，但不能表示所有这些信息时，这些类似的状态名称是相关的——根据URN出现的顺序，UA可能必须呈现不同的信号，因此它需要记录相同信息但呈现该信息不同子集的状态。
The initial state's label is the string of null symbols for the relevant categories, so the only allowed signal is the default signal, which expresses no URNs:
初始状态的标签是相关类别的空符号字符串，因此唯一允许的信号是默认信号，它不表示URN：
State: Source (initial state) Signal: default
状态：源（初始状态）信号：默认
From each state, we must construct the transition for each possible input symbol. For a particular current state and symbol, we construct the label of the next state by combining the input symbol with the symbol in the current state's label for the same category. If one of the symbols is a prefix of the other, we select the longer one; if not, we select the symbol in the current state's label.
从每个状态，我们必须为每个可能的输入符号构造转换。对于特定的当前状态和符号，我们通过将输入符号与当前状态标签中的相同类别的符号组合来构造下一个状态的标签。如果其中一个符号是另一个符号的前缀，则选择较长的符号；如果不是，则选择当前状态标签中的符号。
Thus, in our simple example, the initial state has the following transitions:
因此，在我们的简单示例中，初始状态具有以下转换：
State: Source (initial state)
Signal: default
Transitions:
Source:External -> Source:External
Source:Internal -> Source:Internal
Source:Other -> Source:Other
State: Source (initial state)
Signal: default
Transitions:
Source:External -> Source:External
Source:Internal -> Source:Internal
Source:Other -> Source:Other
In all of these transitions, the input symbol is compatible with the matching label of the current state, "Source", so the next state's label is the full input symbol.
在所有这些转换中，输入符号与当前状态的匹配标签“源”兼容，因此下一个状态的标签是完整的输入符号。
However, there is a further constraint on the next state: its signal must express URNs that at least contain the expressed URNs of the signal of the current state. Within that constraint, and being compatible with the next state's label, for the category of the input URN, the next state's signal must express the longest URN that can be expressed by any signal.
但是，下一个状态还有一个约束：其信号必须表示至少包含当前状态信号的表示URN的URN。在该约束范围内，并且与下一个状态的标签兼容，对于输入URN的类别，下一个状态的信号必须表示可以由任何信号表示的最长URN。
In our example, this means that the next Source:External state has the "external source" signal, which expresses urn:alert:source:external. Since that signal expresses all of the state's label, it is the chosen state. Similarly, the next Source:Internal state has the "internal source" signal. But for the transition on input Source:Other, the "Source:Other" state must have the default signal, as there is no signal that expresses urn:alert:source:[some-unknown-alert-ind-part]. So the next state is "Source:(Other)", where the parentheses record that the "Other" part of the label is not expressed by the state's signal.
在我们的示例中，这意味着下一个Source:External状态具有“External Source”信号，表示urn:alert:Source:External。由于该信号表示状态的所有标签，因此它是所选状态。类似地，下一个源：内部状态具有“内部源”信号。但对于输入Source:Other上的转换，“Source:Other”状态必须具有默认信号，因为没有表示urn:alert:Source:[某个未知警报ind part]的信号。所以下一个状态是“Source:（Other）”，括号中记录了标签的“Other”部分不是由状态的信号表示的。
Thus, the current state and the next states that it can transition to are:
因此，它可以转换到的当前状态和下一个状态是：
State: Source (initial state)
Signal: default
Transitions:
Source:External -> Source:External
Source:Internal -> Source:Internal
Source:Other -> Source:(Other)
State: Source (initial state)
Signal: default
Transitions:
Source:External -> Source:External
Source:Internal -> Source:Internal
Source:Other -> Source:(Other)
State: Source:External
Signal: external source (urn:alert:source:external)
State: Source:External
Signal: external source (urn:alert:source:external)
State: Source:Internal
Signal: internal source (urn:alert:source:internal)
State: Source:Internal
Signal: internal source (urn:alert:source:internal)
State: Source:(Other) Signal: default
状态：源：（其他）信号：默认值
Looking at the state Source:External, we see that it is incompatible with all input symbols other than Source:External, and thus all of its transitions are to itself:
查看状态Source:External，我们发现它与Source:External以外的所有输入符号都不兼容，因此它的所有转换都与自身不兼容：
State: Source:External
Signal: external source (urn:alert:source:external)
Transitions:
Source:External -> Source:External
Source:Internal -> Source:External
Source:Other -> Source:External
State: Source:External
Signal: external source (urn:alert:source:external)
Transitions:
Source:External -> Source:External
Source:Internal -> Source:External
Source:Other -> Source:External
and similarly:
同样地：
State: Source:Internal
Signal: internal source (urn:alert:source:internal)
Transitions:
Source:External -> Source:Internal
Source:Internal -> Source:Internal
Source:Other -> Source:Internal
State: Source:Internal
Signal: internal source (urn:alert:source:internal)
Transitions:
Source:External -> Source:Internal
Source:Internal -> Source:Internal
Source:Other -> Source:Internal
State: Source:(Other)
Signal: default
Transitions:
Source:External -> Source:(Other)
Source:Internal -> Source:(Other)
Source:Other -> Source:(Other)
State: Source:(Other)
Signal: default
Transitions:
Source:External -> Source:(Other)
Source:Internal -> Source:(Other)
Source:Other -> Source:(Other)
The FSM can be constructed by processing the file "very-simple.txt" with the program "alert-info-fsm.py" in [code]. The program's output shows the stages of the construction, which are as follows:
FSM可以通过使用[代码]中的程序“alert info FSM.py”处理文件“very simple.txt”来构造。该计划的输出显示了施工阶段，如下所示：
1. The signals have the meanings:
1. 这些信号具有以下含义：
Signal URN(s)
---------------------------- -------------------------------
default (none)
internal source urn:alert:source:internal
external source urn:alert:source:external
Signal URN(s)
---------------------------- -------------------------------
default (none)
internal source urn:alert:source:internal
external source urn:alert:source:external
2. The expressed URNs are:
2. 表达的URN是：
urn:alert:source:external
urn:alert:source:internal
urn:alert:source:external
urn:alert:source:internal
3. The relevant categories of "alert" URNs are only:
3. “警报”骨灰盒的相关类别仅包括：
source
来源
4. Thus, the infinite universe of possible "alert" URNs can be reduced to these symbols, which are the categories of URNs that are different in ways that are significant to the resolution process:
4. 因此，无限可能的“警报”骨灰盒可以简化为这些符号，这些符号是骨灰盒的类别，它们的不同方式对解析过程非常重要：
Source Source:External Source:Internal Source:Other
来源：外部来源：内部来源：其他
5. The FSM is:
5. 金融稳定机制是：
State: Source (initial state)
Signal: default
Transitions:
Source:External -> Source:External
Source:Internal -> Source:Internal
Source:Other -> Source:(Other)
State: Source (initial state)
Signal: default
Transitions:
Source:External -> Source:External
Source:Internal -> Source:Internal
Source:Other -> Source:(Other)
State: Source:External
Signal: external source (urn:alert:source:external)
Transitions:
Source:External -> Source:External
Source:Internal -> Source:External
Source:Other -> Source:External
State: Source:External
Signal: external source (urn:alert:source:external)
Transitions:
Source:External -> Source:External
Source:Internal -> Source:External
Source:Other -> Source:External
State: Source:Internal
Signal: internal source (urn:alert:source:internal)
Transitions:
Source:External -> Source:Internal
Source:Internal -> Source:Internal
Source:Other -> Source:Internal
State: Source:Internal
Signal: internal source (urn:alert:source:internal)
Transitions:
Source:External -> Source:Internal
Source:Internal -> Source:Internal
Source:Other -> Source:Internal
State: Source:(Other)
Signal: default
Transitions:
Source:External -> Source:(Other)
Source:Internal -> Source:(Other)
Source:Other -> Source:(Other)
State: Source:(Other)
Signal: default
Transitions:
Source:External -> Source:(Other)
Source:Internal -> Source:(Other)
Source:Other -> Source:(Other)
* Each state is labeled by a set of symbols that describe the information that has been extracted from the URNs so far.
* 每个状态都由一组符号标记，这些符号描述了迄今为止从URN中提取的信息。
* Each state has a signal that is a semantic superset of the state's label, i.e., the signal's expressed URNs match the initial portion of the label symbols. If Alert-Info processing finishes with the FSM in a state, the UA will render the state's signal to the user.
* 每个状态都有一个信号，该信号是状态标签的语义超集，即，信号的表示URN与标签符号的初始部分匹配。如果警报信息处理在FSM处于某一状态时完成，UA将向用户呈现该状态的信号。
* The state's label is marked to show what subset of the symbols are expressed by the state's signal. Two states can have the same label but different signals.
* 标记状态标签，以显示状态信号表示的符号子集。两个状态可以具有相同的标签，但信号不同。
* If a transition's input symbol is compatible with (is a semantic subset of) the current state's label for that category, the next state's label is updated with the input symbol. If not, the next state is the current state. This is how the state's label records what information has been accumulated while processing the Alert-Info URNs.
* 如果转换的输入符号与该类别的当前状态标签兼容（是其语义子集），则下一个状态的标签将使用输入符号更新。如果不是，则下一个状态为当前状态。这是州标签在处理警报信息URN时记录累积信息的方式。
* A transition's next state has a signal that semantically subsets the current state's signal as much as possible in the category of the input symbol. (In most cases, the choice of signal is unique. In rare cases, there may be more than one signal that meets this criterion, so the designer may have some flexibility.)
* 转换的下一个状态具有一个信号，该信号在语义上尽可能多地将当前状态的信号子集到输入符号的类别中。（在大多数情况下，信号的选择是唯一的。在极少数情况下，可能有多个信号符合此标准，因此设计师可能具有一定的灵活性。）
In the trivial case where the UA receives no Alert-Info URNs, processing begins and ends with the FSM in the initial state, and the default signal is selected.
在UA未收到警报信息URN的普通情况下，处理从FSM处于初始状态开始和结束，并选择默认信号。
If the UA receives
如果UA收到
Alert-Info: <urn:alert:source:internal>
Alert-Info: <urn:alert:source:internal>
then processing progresses:
然后进行处理：
State: Source
Process: Source:Internal (urn:alert:source:internal)
State: Source:Internal
Signal: internal source
State: Source
Process: Source:Internal (urn:alert:source:internal)
State: Source:Internal
Signal: internal source
If the UA receives
如果UA收到
Alert-Info: <urn:alert:source:external>,
<urn:alert:source:internal>
Alert-Info: <urn:alert:source:external>,
<urn:alert:source:internal>
then processing progresses:
然后进行处理：
State: Source
Process: Source:External (urn:alert:source:external)
State: Source:External
Process: Source:Internal (urn:alert:source:internal)
State: Source:External
Signal: external source
State: Source
Process: Source:External (urn:alert:source:external)
State: Source:External
Process: Source:Internal (urn:alert:source:internal)
State: Source:External
Signal: external source
If the UA receives
如果UA收到
Alert-Info: <urn:alert:source:unclassified>,
<urn:alert:source:internal>
Alert-Info: <urn:alert:source:unclassified>,
<urn:alert:source:internal>
then processing progresses:
然后进行处理：
State: Source
Process: Source:Other (urn:alert:source:unclassified)
State: Source:(Other)
Process: Source:Internal (urn:alert:source:internal)
State: Source:(Other)
Signal: default
State: Source
Process: Source:Other (urn:alert:source:unclassified)
State: Source:(Other)
Process: Source:Internal (urn:alert:source:internal)
State: Source:(Other)
Signal: default
If the UA receives
如果UA收到
Alert-Info: <urn:alert:priority:high>,
<urn:alert:source:internal>
Alert-Info: <urn:alert:priority:high>,
<urn:alert:source:internal>
then processing progresses:
然后进行处理：
State: Source
Ignore: urn:alert:priority:high
State: Source
Process: Source:Internal (urn:alert:source:internal)
State: Source:Internal
Signal: internal source
State: Source
Ignore: urn:alert:priority:high
State: Source
Process: Source:Internal (urn:alert:source:internal)
State: Source:Internal
Signal: internal source
Now consider an example where the UA can signal "external source", "internal source", "low priority", and "high priority" individually or in any combination of source and priority, along with a default signal. This example is essentially the Cartesian product of two copies of the example in Section 4: one dealing with the call's source and one dealing with the call's priority. So there are a total of 9 signals:
现在考虑一个示例，其中UA可以单独地或以源信号和优先级的任何组合以及默认信号来表示“外部源”、“内部源”、“低优先级”和“高优先级”。该示例实质上是第4节示例的两个副本的笛卡尔积：一个处理调用的源，另一个处理调用的优先级。因此总共有9个信号：
Signal URN(s)
---------------------------- -------------------------------
default (none)
external source urn:alert:source:external
internal source urn:alert:source:internal
low priority urn:alert:priority:low
low priority/external source urn:alert:priority:low,
urn:alert:source:external
low priority/internal source urn:alert:priority:low,
urn:alert:source:internal
high priority urn:alert:priority:high
high priority/external source urn:alert:priority:high,
urn:alert:source:external
high priority/internal source urn:alert:priority:high,
urn:alert:source:internal
Signal URN(s)
---------------------------- -------------------------------
default (none)
external source urn:alert:source:external
internal source urn:alert:source:internal
low priority urn:alert:priority:low
low priority/external source urn:alert:priority:low,
urn:alert:source:external
low priority/internal source urn:alert:priority:low,
urn:alert:source:internal
high priority urn:alert:priority:high
high priority/external source urn:alert:priority:high,
urn:alert:source:external
high priority/internal source urn:alert:priority:high,
urn:alert:source:internal
The expressed URNs are:
表达的URN是：
urn:alert:source:external
urn:alert:source:internal
urn:alert:priority:low
urn:alert:priority:high
urn:alert:source:external
urn:alert:source:internal
urn:alert:priority:low
urn:alert:priority:high
The relevant categories of "alert" URNs are only:
“警报”骨灰盒的相关类别仅包括：
source priority
源优先级
The alphabet of symbols is:
符号的字母表为：
Source Source:External Source:Internal Source:Other Priority Priority:Low Priority:High Priority:Other
源源：外部源：内部源：其他优先级优先级：低优先级：高优先级：其他
The 16 states are as follows, where 9 states are "sink" states from which no further information can be recorded, as all transitions from the state lead to itself.
16个状态如下所示，其中9个状态为“汇聚”状态，无法记录进一步的信息，因为从该状态到自身的所有转换。
State: Priority/Source
Signal: default
Transitions:
Priority:Other -> Priority:(Other)/Source
Priority:High -> Priority:High/Source
Priority:Low -> Priority:Low/Source
Source:Other -> Priority/Source:(Other)
Source:External -> Priority/Source:External
Source:Internal -> Priority/Source:Internal
State: Priority/Source
Signal: default
Transitions:
Priority:Other -> Priority:(Other)/Source
Priority:High -> Priority:High/Source
Priority:Low -> Priority:Low/Source
Source:Other -> Priority/Source:(Other)
Source:External -> Priority/Source:External
Source:Internal -> Priority/Source:Internal
State: Priority:(Other)/Source
Signal: default
Transitions:
Priority:Other -> Priority:(Other)/Source
Priority:High -> Priority:(Other)/Source
Priority:Low -> Priority:(Other)/Source
Source:Other -> Priority:(Other)/Source:(Other)
Source:External -> Priority:(Other)/Source:External
Source:Internal -> Priority:(Other)/Source:Internal
State: Priority:(Other)/Source
Signal: default
Transitions:
Priority:Other -> Priority:(Other)/Source
Priority:High -> Priority:(Other)/Source
Priority:Low -> Priority:(Other)/Source
Source:Other -> Priority:(Other)/Source:(Other)
Source:External -> Priority:(Other)/Source:External
Source:Internal -> Priority:(Other)/Source:Internal
State: Priority:(Other)/Source:(Other)
Signal: default
Transitions:
any -> Priority:(Other)/Source:(Other)
State: Priority:(Other)/Source:(Other)
Signal: default
Transitions:
any -> Priority:(Other)/Source:(Other)
State: Priority:(Other)/Source:External
Signal: external source
Transitions:
any -> Priority:(Other)/Source:External
State: Priority:(Other)/Source:External
Signal: external source
Transitions:
any -> Priority:(Other)/Source:External
State: Priority:(Other)/Source:Internal
Signal: internal source
Transitions:
any -> Priority:(Other)/Source:Internal
State: Priority:(Other)/Source:Internal
Signal: internal source
Transitions:
any -> Priority:(Other)/Source:Internal
State: Priority:High/Source
Signal: high priority
Transitions:
Priority:Other -> Priority:High/Source
Priority:High -> Priority:High/Source
Priority:Low -> Priority:High/Source
Source:Other -> Priority:High/Source:(Other)
Source:External -> Priority:High/Source:External
Source:Internal -> Priority:High/Source:Internal
State: Priority:High/Source
Signal: high priority
Transitions:
Priority:Other -> Priority:High/Source
Priority:High -> Priority:High/Source
Priority:Low -> Priority:High/Source
Source:Other -> Priority:High/Source:(Other)
Source:External -> Priority:High/Source:External
Source:Internal -> Priority:High/Source:Internal
State: Priority:High/Source:(Other)
Signal: high priority
Transitions:
any -> Priority:High/Source:(Other)
State: Priority:High/Source:(Other)
Signal: high priority
Transitions:
any -> Priority:High/Source:(Other)
State: Priority:High/Source:External
Signal: high priority/external source
Transitions:
any -> Priority:High/Source:External
State: Priority:High/Source:External
Signal: high priority/external source
Transitions:
any -> Priority:High/Source:External
State: Priority:High/Source:Internal
Signal: high priority/internal source
Transitions:
any -> Priority:High/Source:Internal
State: Priority:High/Source:Internal
Signal: high priority/internal source
Transitions:
any -> Priority:High/Source:Internal
State: Priority:Low/Source
Signal: low priority
Transitions:
Priority:Other -> Priority:Low/Source
Priority:High -> Priority:Low/Source
Priority:Low -> Priority:Low/Source
Source:Other -> Priority:Low/Source:(Other)
Source:External -> Priority:Low/Source:External
Source:Internal -> Priority:Low/Source:Internal
State: Priority:Low/Source
Signal: low priority
Transitions:
Priority:Other -> Priority:Low/Source
Priority:High -> Priority:Low/Source
Priority:Low -> Priority:Low/Source
Source:Other -> Priority:Low/Source:(Other)
Source:External -> Priority:Low/Source:External
Source:Internal -> Priority:Low/Source:Internal
State: Priority:Low/Source:(Other)
Signal: low priority
Transitions:
any -> Priority:Low/Source:(Other)
State: Priority:Low/Source:(Other)
Signal: low priority
Transitions:
any -> Priority:Low/Source:(Other)
State: Priority:Low/Source:External
Signal: low priority/external source
Transitions:
any -> Priority:Low/Source:External
State: Priority:Low/Source:External
Signal: low priority/external source
Transitions:
any -> Priority:Low/Source:External
State: Priority:Low/Source:Internal
Signal: low priority/internal source
Transitions:
any -> Priority:Low/Source:Internal
State: Priority:Low/Source:Internal
Signal: low priority/internal source
Transitions:
any -> Priority:Low/Source:Internal
State: Priority/Source:(Other)
Signal: default
Transitions:
Priority:Other -> Priority:(Other)/Source:(Other)
Priority:High -> Priority:High/Source:(Other)
Priority:Low -> Priority:Low/Source:(Other)
Source:Other -> Priority/Source:(Other)
Source:External -> Priority/Source:(Other)
Source:Internal -> Priority/Source:(Other)
State: Priority/Source:(Other)
Signal: default
Transitions:
Priority:Other -> Priority:(Other)/Source:(Other)
Priority:High -> Priority:High/Source:(Other)
Priority:Low -> Priority:Low/Source:(Other)
Source:Other -> Priority/Source:(Other)
Source:External -> Priority/Source:(Other)
Source:Internal -> Priority/Source:(Other)
State: Priority/Source:External
Signal: external source
Transitions:
Priority:Other -> Priority:(Other)/Source:External
Priority:High -> Priority:High/Source:External
Priority:Low -> Priority:Low/Source:External
Source:Other -> Priority/Source:External
Source:External -> Priority/Source:External
Source:Internal -> Priority/Source:External
State: Priority/Source:External
Signal: external source
Transitions:
Priority:Other -> Priority:(Other)/Source:External
Priority:High -> Priority:High/Source:External
Priority:Low -> Priority:Low/Source:External
Source:Other -> Priority/Source:External
Source:External -> Priority/Source:External
Source:Internal -> Priority/Source:External
State: Priority/Source:Internal
Signal: internal source
Transitions:
Priority:Other -> Priority:(Other)/Source:Internal
Priority:High -> Priority:High/Source:Internal
Priority:Low -> Priority:Low/Source:Internal
Source:Other -> Priority/Source:Internal
Source:External -> Priority/Source:Internal
Source:Internal -> Priority/Source:Internal
State: Priority/Source:Internal
Signal: internal source
Transitions:
Priority:Other -> Priority:(Other)/Source:Internal
Priority:High -> Priority:High/Source:Internal
Priority:Low -> Priority:Low/Source:Internal
Source:Other -> Priority/Source:Internal
Source:External -> Priority/Source:Internal
Source:Internal -> Priority/Source:Internal
An example of processing that involves multiple "source" URNs and one "priority" URN:
涉及多个“源”URN和一个“优先级”URN的处理示例：
Alert-Info: <urn:alert:source:internal>,
<urn:alert:source:unclassified>,
<urn:alert:priority:high>
Alert-Info: <urn:alert:source:internal>,
<urn:alert:source:unclassified>,
<urn:alert:priority:high>
in which case processing progresses:
在这种情况下，处理将继续：
State: Source/Priority
Process: Source:Internal (urn:alert:source:internal)
State: Source:Internal/Priority
Process: Source:(Other) (urn:alert:source:unclassified)
State: Source:Internal/Priority
Process: Priority:High (urn:alert:priority:high)
State: Source:Internal/Priority:High
Signal: internal source/high priority
State: Source/Priority
Process: Source:Internal (urn:alert:source:internal)
State: Source:Internal/Priority
Process: Source:(Other) (urn:alert:source:unclassified)
State: Source:Internal/Priority
Process: Priority:High (urn:alert:priority:high)
State: Source:Internal/Priority:High
Signal: internal source/high priority
A more complicated example is provided in Section 12.2.1 of [RFC7462]. It is like the example in Section 5.1 of this document, except that the UA can only signal "external source", "internal source", "low priority", and "high priority" individually but not in combination, as well as a default signal:
[RFC7462]第12.2.1节提供了一个更复杂的示例。与本文件第5.1节中的示例类似，但UA只能单独发出“外部源”、“内部源”、“低优先级”和“高优先级”信号，而不能组合发出，以及默认信号：
Signal URN(s)
---------------------------- -------------------------------
default (none)
internal source urn:alert:source:external
external source urn:alert:source:internal
low priority urn:alert:priority:low
high priority urn:alert:priority:high
Signal URN(s)
---------------------------- -------------------------------
default (none)
internal source urn:alert:source:external
external source urn:alert:source:internal
low priority urn:alert:priority:low
high priority urn:alert:priority:high
The signals can express the following URNs:
这些信号可以表示以下URN：
urn:alert:source:external
urn:alert:source:internal
urn:alert:priority:low
urn:alert:priority:high
urn:alert:source:external
urn:alert:source:internal
urn:alert:priority:low
urn:alert:priority:high
The relevant categories of "alert" URNs are:
“警报”骨灰盒的相关类别包括：
source priority
源优先级
The alphabet of symbols is:
符号的字母表为：
Source Source:External Source:Internal Source:Other Priority Priority:Low Priority:High Priority:Other
源源：外部源：内部源：其他优先级优先级：低优先级：高优先级：其他
In this example, the FSM has 20 states because both "source" and "priority" URNs are recorded, but the order in which the two appear affects the signal:
在此示例中，FSM有20个状态，因为“源”和“优先级”URN都被记录，但这两个状态出现的顺序会影响信号：
State: Priority/Source
Signal: default
Transitions:
Priority:Other -> Priority:(Other)/Source
Priority:High -> Priority:High/Source
Priority:Low -> Priority:Low/Source
Source:Other -> Priority/Source:(Other)
Source:External -> Priority/Source:External
Source:Internal -> Priority/Source:Internal
State: Priority/Source
Signal: default
Transitions:
Priority:Other -> Priority:(Other)/Source
Priority:High -> Priority:High/Source
Priority:Low -> Priority:Low/Source
Source:Other -> Priority/Source:(Other)
Source:External -> Priority/Source:External
Source:Internal -> Priority/Source:Internal
State Priority:(Other)/Source can transition to states that can signal the source, because the recorded priority can't be signaled and thus does not block the signaling of the source:
状态优先级：（其他）/源可以转换为可以向源发送信号的状态，因为记录的优先级无法发送信号，因此不会阻止源发送信号：
State: Priority:(Other)/Source
Signal: default
Transitions:
Priority:Other -> Priority:(Other)/Source
Priority:High -> Priority:(Other)/Source
Priority:Low -> Priority:(Other)/Source
Source:Other -> Priority:(Other)/Source:(Other)
Source:External -> Priority:(Other)/Source:External
Source:Internal -> Priority:(Other)/Source:Internal
State: Priority:(Other)/Source
Signal: default
Transitions:
Priority:Other -> Priority:(Other)/Source
Priority:High -> Priority:(Other)/Source
Priority:Low -> Priority:(Other)/Source
Source:Other -> Priority:(Other)/Source:(Other)
Source:External -> Priority:(Other)/Source:External
Source:Internal -> Priority:(Other)/Source:Internal
State: Priority:(Other)/Source:(Other)
Signal: default
Transitions:
any -> Priority:(Other)/Source:(Other)
State: Priority:(Other)/Source:(Other)
Signal: default
Transitions:
any -> Priority:(Other)/Source:(Other)
State: Priority:(Other)/Source:External
Signal: external source
Transitions:
any -> Priority:(Other)/Source:External
State: Priority:(Other)/Source:External
Signal: external source
Transitions:
any -> Priority:(Other)/Source:External
State: Priority:(Other)/Source:Internal
Signal: internal source
Transitions:
any -> Priority:(Other)/Source:Internal
State: Priority:(Other)/Source:Internal
Signal: internal source
Transitions:
any -> Priority:(Other)/Source:Internal
Because there are no signals for combinations of "source" and "priority" URNs, processing a "source" URN from the state Priority:High/Source leads to a state that records the priority information but does not signal it:
由于“源”和“优先级”URN的组合没有信号，因此从状态优先级：高/源处理“源”URN会导致记录优先级信息但不向其发送信号的状态：
State: Priority:High/Source
Signal: high priority
Transitions:
Priority:Other -> Priority:High/Source
Priority:High -> Priority:High/Source
Priority:Low -> Priority:High/Source
Source:Other -> Priority:High/Source:(Other)
Source:External -> Priority:High/Source:(External)
Source:Internal -> Priority:High/Source:(Internal)
State: Priority:High/Source
Signal: high priority
Transitions:
Priority:Other -> Priority:High/Source
Priority:High -> Priority:High/Source
Priority:Low -> Priority:High/Source
Source:Other -> Priority:High/Source:(Other)
Source:External -> Priority:High/Source:(External)
Source:Internal -> Priority:High/Source:(Internal)
State: Priority:High/Source:(Other)
Signal: high priority
Transitions:
any -> Priority:High/Source:(Other)
State: Priority:High/Source:(Other)
Signal: high priority
Transitions:
any -> Priority:High/Source:(Other)
From the state Priority:High/Source, "source" URNs transition to states that record both source and priority but signal only priority, one of which is Priority:High/Source:(External). But from Priority/Source:External, the symbol Priority:High transitions to the state Priority:(High)/Source:External, which records the same information but signals the source, not the priority. One state is reached by processing a "priority" URN and then a "source" URN, whereas the other is reached by processing a "source" URN and then a "priority" URN.
从状态优先级：高/源，“源”URN过渡到同时记录源和优先级但仅发送优先级信号的状态，其中之一是优先级：高/源：（外部）。但是从Priority/Source:External，符号Priority:High转换为state Priority:（High）/Source:External，它记录相同的信息，但向源发出信号，而不是向优先级发出信号。一种状态是通过处理“优先级”URN然后是“源”URN来达到的，而另一种状态是通过处理“源”URN然后是“优先级”URN来达到的。
State: Priority:High/Source:(External)
Signal: high priority
Transitions:
any -> Priority:High/Source:(External)
State: Priority:High/Source:(External)
Signal: high priority
Transitions:
any -> Priority:High/Source:(External)
State: Priority:High/Source:(Internal)
Signal: high priority
Transitions:
any -> Priority:High/Source:(Internal)
State: Priority:High/Source:(Internal)
Signal: high priority
Transitions:
any -> Priority:High/Source:(Internal)
and similarly for Priority:Low/Source:
优先级类似：低/源：
State: Priority:Low/Source
Signal: low priority
Transitions:
Priority:Other -> Priority:Low/Source
Priority:High -> Priority:Low/Source
Priority:Low -> Priority:Low/Source
Source:Other -> Priority:Low/Source:(Other)
Source:External -> Priority:Low/Source:(External)
Source:Internal -> Priority:Low/Source:(Internal)
State: Priority:Low/Source
Signal: low priority
Transitions:
Priority:Other -> Priority:Low/Source
Priority:High -> Priority:Low/Source
Priority:Low -> Priority:Low/Source
Source:Other -> Priority:Low/Source:(Other)
Source:External -> Priority:Low/Source:(External)
Source:Internal -> Priority:Low/Source:(Internal)
State: Priority:Low/Source:(Other)
Signal: low priority
Transitions:
any -> Priority:Low/Source:(Other)
State: Priority:Low/Source:(Other)
Signal: low priority
Transitions:
any -> Priority:Low/Source:(Other)
State: Priority:Low/Source:(External)
Signal: low priority
Transitions:
any -> Priority:Low/Source:(External)
State: Priority:Low/Source:(External)
Signal: low priority
Transitions:
any -> Priority:Low/Source:(External)
State: Priority:Low/Source:(Internal)
Signal: low priority
Transitions:
any -> Priority:Low/Source:(Internal)
State: Priority:Low/Source:(Internal)
Signal: low priority
Transitions:
any -> Priority:Low/Source:(Internal)
State: Priority/Source:(Other)
Signal: default
Transitions:
Priority:Other -> Priority:(Other)/Source:(Other)
Priority:High -> Priority:High/Source:(Other)
Priority:Low -> Priority:Low/Source:(Other)
Source:Other -> Priority/Source:(Other)
Source:External -> Priority/Source:(Other)
Source:Internal -> Priority/Source:(Other)
State: Priority/Source:(Other)
Signal: default
Transitions:
Priority:Other -> Priority:(Other)/Source:(Other)
Priority:High -> Priority:High/Source:(Other)
Priority:Low -> Priority:Low/Source:(Other)
Source:Other -> Priority/Source:(Other)
Source:External -> Priority/Source:(Other)
Source:Internal -> Priority/Source:(Other)
State: Priority/Source:External
Signal: external source
Transitions:
Priority:Other -> Priority:(Other)/Source:External
Priority:High -> Priority:(High)/Source:External
Priority:Low -> Priority:(Low)/Source:External
Source:Other -> Priority/Source:External
Source:External -> Priority/Source:External
Source:Internal -> Priority/Source:External
State: Priority/Source:External
Signal: external source
Transitions:
Priority:Other -> Priority:(Other)/Source:External
Priority:High -> Priority:(High)/Source:External
Priority:Low -> Priority:(Low)/Source:External
Source:Other -> Priority/Source:External
Source:External -> Priority/Source:External
Source:Internal -> Priority/Source:External
State: Priority:(High)/Source:External
Signal: external source
Transitions:
any -> Priority:(High)/Source:External
State: Priority:(High)/Source:External
Signal: external source
Transitions:
any -> Priority:(High)/Source:External
State: Priority:(Low)/Source:External
Signal: external source
Transitions:
any -> Priority:(Low)/Source:External
State: Priority:(Low)/Source:External
Signal: external source
Transitions:
any -> Priority:(Low)/Source:External
State: Priority/Source:Internal
Signal: internal source
Transitions:
Priority:Other -> Priority:(Other)/Source:Internal
Priority:High -> Priority:(High)/Source:Internal
Priority:Low -> Priority:(Low)/Source:Internal
Source:Other -> Priority/Source:Internal
Source:External -> Priority/Source:Internal
Source:Internal -> Priority/Source:Internal
State: Priority/Source:Internal
Signal: internal source
Transitions:
Priority:Other -> Priority:(Other)/Source:Internal
Priority:High -> Priority:(High)/Source:Internal
Priority:Low -> Priority:(Low)/Source:Internal
Source:Other -> Priority/Source:Internal
Source:External -> Priority/Source:Internal
Source:Internal -> Priority/Source:Internal
State: Priority:(High)/Source:Internal
Signal: internal source
Transitions:
any -> Priority:(High)/Source:Internal
State: Priority:(High)/Source:Internal
Signal: internal source
Transitions:
any -> Priority:(High)/Source:Internal
State: Priority:(Low)/Source:Internal
Signal: internal source
Transitions:
any -> Priority:(Low)/Source:Internal
State: Priority:(Low)/Source:Internal
Signal: internal source
Transitions:
any -> Priority:(Low)/Source:Internal
As an example of processing, if the UA receives
作为处理示例，如果UA接收到
Alert-Info: <urn:alert:source:internal>
Alert-Info: <urn:alert:source:internal>
then processing progresses:
然后进行处理：
State: Priority/Source
Process: Source:Internal (urn:alert:source:internal)
State: Priority/Source:Internal
Signal: internal source
State: Priority/Source
Process: Source:Internal (urn:alert:source:internal)
State: Priority/Source:Internal
Signal: internal source
A more complicated example involves multiple "source" URNs that do not select a non-default signal and one "priority" URN that can be signaled:
更复杂的示例涉及多个不选择非默认信号的“源”URN和一个可发信号的“优先级”URN：
Alert-Info: <urn:alert:source:unclassified>,
<urn:alert:source:internal>,
<urn:alert:priority:high>
Alert-Info: <urn:alert:source:unclassified>,
<urn:alert:source:internal>,
<urn:alert:priority:high>
in which case processing progresses:
在这种情况下，处理将继续：
State: Priority/Source
Process: Source:Other (urn:alert:source:unclassified)
State: Priority/Source:(Other)
Process: Source:Internal (urn:alert:source:internal)
State: Priority/Source:(Other)
Process: Priority:High (urn:alert:priority:high)
State: Priority:High/Source:(Other)
Signal: high priority
State: Priority/Source
Process: Source:Other (urn:alert:source:unclassified)
State: Priority/Source:(Other)
Process: Source:Internal (urn:alert:source:internal)
State: Priority/Source:(Other)
Process: Priority:High (urn:alert:priority:high)
State: Priority:High/Source:(Other)
Signal: high priority
The only output of the FSM is the state's signal. Based on this, several groups of states in this FSM can be merged using standard FSM optimization algorithms:
FSM的唯一输出是状态信号。基于此，可以使用标准FSM优化算法合并此FSM中的多组状态：
states with signal "high priority":
Priority:High/Source
Priority:High/Source:(Other)
Priority:High/Source:(External)
Priority:High/Source:(Internal)
states with signal "high priority":
Priority:High/Source
Priority:High/Source:(Other)
Priority:High/Source:(External)
Priority:High/Source:(Internal)
states with signal "low priority":
Priority:Low/Source
Priority:Low/Source:(Other)
Priority:Low/Source:(External)
Priority:Low/Source:(Internal)
states with signal "low priority":
Priority:Low/Source
Priority:Low/Source:(Other)
Priority:Low/Source:(External)
Priority:Low/Source:(Internal)
states with signal "external source":
Priority/Source:External
Priority:(High)/Source:External
Priority:(Low)/Source:External
Priority:(Other)/Source:External
states with signal "external source":
Priority/Source:External
Priority:(High)/Source:External
Priority:(Low)/Source:External
Priority:(Other)/Source:External
states with signal "internal source":
Priority/Source:Internal
Priority:(High)/Source:Internal
Priority:(Low)/Source:Internal
Priority:(Other)/Source:Internal
states with signal "internal source":
Priority/Source:Internal
Priority:(High)/Source:Internal
Priority:(Low)/Source:Internal
Priority:(Other)/Source:Internal
This reduces the FSM to eight states:
这将FSM减少到八个状态：
Priority/Source
Priority:(Other)/Source
Priority:(Other)/Source:(Other)
Priority:High/Source [aggregated]
Priority:Low/Source [aggregated]
Priority/Source:(Other)
Priority/Source:External [aggregated]
Priority/Source:Internal [aggregated]
Priority/Source
Priority:(Other)/Source
Priority:(Other)/Source:(Other)
Priority:High/Source [aggregated]
Priority:Low/Source [aggregated]
Priority/Source:(Other)
Priority/Source:External [aggregated]
Priority/Source:Internal [aggregated]
Examples 2, 3, and 4 of [RFC7462] are similar to the example in Section 5.1 of this document, but they do not include a signal for the combination "internal source, low priority" to make resolution examples work asymmetrically.
[RFC7462]的示例2、3和4与本文件第5.1节中的示例类似，但它们不包括用于组合“内部源，低优先级”的信号，以使分辨率示例不对称工作。
The FSM for this example has the same alphabet as the FSM of Section 5.1. Most of the states of this FSM are the same as the states of the FSM of Section 5.1, but the state Source:Internal/Priority:Low is missing because there is no signal for that combination. It is replaced by two states:
本示例中的FSM与第5.1节中的FSM具有相同的字母表。此FSM的大多数状态与第5.1节中FSM的状态相同，但缺少状态源：内部/优先级：低，因为没有该组合的信号。它被两种状态所取代：
1. One state is Source:Internal/Priority:(Low); it records that Source:Internal was specified first (and is to be signaled) and that Priority:Low was specified later (and cannot be signaled -- but it still prevents any further "priority" URNs from having an effect).
1. 一个状态是来源：内部/优先级：（低）；它记录了Source:Internal是首先指定的（并且要发出信号），Priority:Low是后来指定的（并且不能发出信号——但是它仍然阻止任何进一步的“Priority”URN产生影响）。
2. The other state is Source:(Internal)/Priority:Low; it records the reverse sequence of events.
2. 另一种状态是源：（内部）/优先级：低；它记录事件的相反顺序。
The changes in the FSM are:
FSM的变化如下：
State: Priority:Low/Source
Signal: low priority
Transitions:
Source:Internal -> Priority:Low/Source:(Internal)
(other transitions unchanged)
State: Priority:Low/Source
Signal: low priority
Transitions:
Source:Internal -> Priority:Low/Source:(Internal)
(other transitions unchanged)
State: Priority:Low/Source:(Internal)
Signal: low priority
Transitions:
any -> Priority:Low/Source:(Internal)
State: Priority:Low/Source:(Internal)
Signal: low priority
Transitions:
any -> Priority:Low/Source:(Internal)
State: Priority/Source:Internal
Signal: internal source
Transitions:
Priority:Low -> Priority:(Low)/Source:Internal
(other transitions unchanged)
State: Priority/Source:Internal
Signal: internal source
Transitions:
Priority:Low -> Priority:(Low)/Source:Internal
(other transitions unchanged)
State: Priority:(Low)/Source:Internal
Signal: internal source
Transitions:
any -> Priority:(Low)/Source:Internal
State: Priority:(Low)/Source:Internal
Signal: internal source
Transitions:
any -> Priority:(Low)/Source:Internal
An example of processing that involves multiple "source" URNs and one "priority" URN:
涉及多个“源”URN和一个“优先级”URN的处理示例：
Alert-Info: <urn:alert:source:internal>,
<urn:alert:source:unclassified>,
<urn:alert:priority:high>
Alert-Info: <urn:alert:source:internal>,
<urn:alert:source:unclassified>,
<urn:alert:priority:high>
then processing progresses:
然后进行处理：
State: Priority/Source
Process: Source:Internal (urn:alert:source:internal)
State: Priority/Source:Internal
Process: Source:Other (urn:alert:source:unclassified)
State: Priority/Source:Internal
Process: Priority:High (urn:alert:priority:high)
State: Priority:High/Source:Internal
Signal: internal source/high priority
State: Priority/Source
Process: Source:Internal (urn:alert:source:internal)
State: Priority/Source:Internal
Process: Source:Other (urn:alert:source:unclassified)
State: Priority/Source:Internal
Process: Priority:High (urn:alert:priority:high)
State: Priority:High/Source:Internal
Signal: internal source/high priority
If the UA receives
如果UA收到
Alert-Info: <urn:alert:source:internal>
Alert-Info: <urn:alert:source:internal>
then processing progresses:
然后进行处理：
State: Priority/Source
Process: Source:Internal (urn:alert:source:internal)
State: Priority/Source:Internal
Signal: internal source
State: Priority/Source
Process: Source:Internal (urn:alert:source:internal)
State: Priority/Source:Internal
Signal: internal source
If the UA receives
如果UA收到
Alert-Info: <urn:alert:source:external>,
<urn:alert:priority:low>
Alert-Info: <urn:alert:source:external>,
<urn:alert:priority:low>
then processing progresses:
然后进行处理：
State: Priority/Source
Process: Source:External (urn:alert:source:external)
State: Priority/Source:External
Process: Priority:Low (urn:alert:priority:low)
State: Priority:Low/Source:External
Signal: external source/low priority
State: Priority/Source
Process: Source:External (urn:alert:source:external)
State: Priority/Source:External
Process: Priority:Low (urn:alert:priority:low)
State: Priority:Low/Source:External
Signal: external source/low priority
Suppose the same UA receives
假设相同的UA收到
Alert-Info: <urn:alert:source:internal>,
<urn:alert:priority:low>
Alert-Info: <urn:alert:source:internal>,
<urn:alert:priority:low>
Note that there is no signal that corresponds to this combination. In that case, the processing is:
请注意，没有与此组合对应的信号。在这种情况下，处理是：
State: Priority/Source
Process: Source:Internal (urn:alert:source:internal)
State: Priority/Source:Internal
Process: Priority:Low (urn:alert:priority:low)
State: Priority:(Low)/Source:Internal
Signal: internal source
State: Priority/Source
Process: Source:Internal (urn:alert:source:internal)
State: Priority/Source:Internal
Process: Priority:Low (urn:alert:priority:low)
State: Priority:(Low)/Source:Internal
Signal: internal source
If the order of the URNs is reversed, what is signaled is the meaning of the now-different first URN:
如果URN的顺序颠倒，则发出的信号是现在不同的第一个URN的含义：
Alert-Info: <urn:alert:priority:low>,
<urn:alert:source:internal>
Alert-Info: <urn:alert:priority:low>,
<urn:alert:source:internal>
State: Priority/Source
Process: Priority:Low (urn:alert:priority:low)
State: Priority:Low/Source
Process: Source:Internal (urn:alert:source:internal)
State: Priority:Low/Source:(Internal)
Signal: low priority
State: Priority/Source
Process: Priority:Low (urn:alert:priority:low)
State: Priority:Low/Source
Process: Source:Internal (urn:alert:source:internal)
State: Priority:Low/Source:(Internal)
Signal: low priority
Notice that the existence of the new states prevents later URNs of a category from overriding earlier URNs of that category, even if the earlier one was not itself signalable and the later one would be signalable in the absence of the earlier one:
请注意，新状态的存在会阻止类别的后续URN覆盖该类别的早期URN，即使早期URN本身不可发出信号，而后期URN在缺少早期URN的情况下也可发出信号：
Alert-Info: <urn:alert:priority:low>,
<urn:alert:source:internal>,
<urn:alert:source:external>
Alert-Info: <urn:alert:priority:low>,
<urn:alert:source:internal>,
<urn:alert:source:external>
State: Priority/Source
Process: Priority:Low (urn:alert:priority:low)
State: Priority:Low/Source
Process: Source:Internal (urn:alert:source:internal)
State: Priority:Low/Source:(Internal)
Process: Source:External (urn:alert:source:external)
State: Priority:Low/Source:(Internal)
Signal: low priority
State: Priority/Source
Process: Priority:Low (urn:alert:priority:low)
State: Priority:Low/Source
Process: Source:Internal (urn:alert:source:internal)
State: Priority:Low/Source:(Internal)
Process: Source:External (urn:alert:source:external)
State: Priority:Low/Source:(Internal)
Signal: low priority
This situation shows the necessity of states whose labels contain parentheses. If the second transition had been to the state Priority:Low/Source (on the basis that there is no proper state Priority:Low/Source:Internal), then the third transition would have been to the state Priority:Low/Source:External, and the signal would have been "external source/low priority".
这种情况说明了标签中包含括号的状态的必要性。如果第二次转换为状态优先级：低/源（基于没有适当的状态优先级：低/源：内部），则第三次转换为状态优先级：低/源：外部，信号为“外部源/低优先级”。
In the example of Section 4, there are signals for "external source" and "internal source". Let us add to that example a signal for "source internal from a VIP (Very Important Person)". That last signal expresses the private extension URN urn:alert:source:internal:vip@example, which is a subset of urn:alert:source:internal, which is expressed by the "source internal" signal. There are a total of three expressed URNs, one of which is a subset of another:
在第4节的示例中，有“外部源”和“内部源”的信号。让我们在该示例中添加一个信号，表示“来自VIP（非常重要的人）的内部源”。最后一个信号表示专用扩展URN:URN:alert:source:internal:vip@example，它是urn:alert:source:internal的子集，由“source internal”信号表示。共有三个表示的URN，其中一个是另一个的子集：
urn:alert:source:internal
urn:alert:source:internal:vip@example
urn:alert:source:external
urn:alert:source:internal
urn:alert:source:internal:vip@example
urn:alert:source:external
This generates the following alphabet of symbols, which includes two "Other" symbols for the "source" category:
这将生成以下符号字母表，其中包括“源”类别的两个“其他”符号：
Source
Source:Internal
Source:Internal:Vip@example
Source:Internal:Other
Source:Other
Source
Source:Internal
Source:Internal:Vip@example
Source:Internal:Other
Source:Other
In this example, there are signals for "service forward" (the call has been forwarded) and "source recall callback" (a recall due to a callback). This gives two expressed URNs:
在本例中，有“服务转发”（调用已转发）和“源调用回调”（由于回调而调用）的信号。这将提供两个表示的URN：
urn:alert:service:forward
urn:alert:service:recall:callback
urn:alert:service:forward
urn:alert:service:recall:callback
This generates the following alphabet of symbols. Note that there are two "Other" symbols, because the "alert:service" URNs have an additional level of qualification.
这将生成以下符号的字母表。请注意，有两个“其他”符号，因为“警报：服务”URN具有附加的限定级别。
Service Service:Forward Service:Recall Service:Recall:Callback Service:Recall:Other Service:Other
服务服务：转发服务：调用服务：调用：回调服务：调用：其他服务：其他
In this example, we consider how a UA generates ringback signals when the UA wishes to reproduce the traditional behavior where the caller hears the ringback signals defined by the telephone service in the callee's country rather than the ringback signals defined by the service in the caller's country. In the Alert-Info header field of the 180 (Ringing) provisional response, we assume that the called UA provides an "alert:country" URN [RFC7462] containing the ISO 3166-1 [ISO-3166-1] alpha-2 country code of the callee's country.
在这个例子中，我们考虑UA如何产生回环信号，当UA希望再现传统的行为，其中呼叫者听到被呼叫方国家的电话服务所定义的回铃信号，而不是由呼叫者国家中的服务定义的回铃信号。在180（振铃）临时响应的警报信息标题字段中，我们假设被叫UA提供了一个“警报：国家”URN[RFC7462]，其中包含被叫国的ISO 3166-1[ISO-3166-1]alpha-2国家代码。
The UA has a default signal and a "non-country" signal for urn:alert:service:call-waiting. For the example country with code "XA", the UA has a default signal and signals for urn:alert:service:call-waiting and urn:alert:service:forward. For the example country with code "XB", the UA has a default signal and a signal for urn:alert:service:forward. These inconsistencies between the non-country signals and the country signals are chosen to demonstrate the flexibility of the construction method, showing that three systems of signals can be combined correctly even when the systems were established without coordination between them.
UA有urn:alert:service:call waiting的默认信号和“非国家”信号。对于代码为“XA”的示例国家，UA有一个默认信号和urn:alert:service:call waiting和urn:alert:service:forward的信号。对于代码为“XB”的示例国家，UA有一个默认信号和一个urn:alert:service:forward信号。选择非国家信号和国家信号之间的这些不一致性，以证明施工方法的灵活性，表明即使在不协调的情况下建立了三个信号系统，也可以正确组合三个信号系统。
The signals are:
这些信号是：
Signal URN(s)
-------------------------- ----------------------------------
default (none)
call-waiting urn:alert:service:call-waiting
Signal URN(s)
-------------------------- ----------------------------------
default (none)
call-waiting urn:alert:service:call-waiting
XA default urn:alert:country:xa
XA call-waiting urn:alert:country:xa,
urn:alert:service:call-waiting
XA forward urn:alert:country:xa,
urn:alert:service:forward
XA default urn:alert:country:xa
XA call-waiting urn:alert:country:xa,
urn:alert:service:call-waiting
XA forward urn:alert:country:xa,
urn:alert:service:forward
XB default urn:alert:country:xb
XB forward urn:alert:country:xb,
urn:alert:service:forward
XB default urn:alert:country:xb
XB forward urn:alert:country:xb,
urn:alert:service:forward
The expressed URNs are:
表达的URN是：
urn:alert:country:xa
urn:alert:country:xb
urn:alert:service:call-waiting
urn:alert:service:forward
urn:alert:country:xa
urn:alert:country:xb
urn:alert:service:call-waiting
urn:alert:service:forward
The relevant categories of "alert" URNs are only:
“警报”骨灰盒的相关类别仅包括：
country service
国家服务
The alphabet of symbols is:
符号的字母表为：
Country Country:[other] Country:Xa Country:Xb Service Service:[other] Service:Call-waiting Service:Forward
国家/地区：[其他]国家/地区：Xa国家/地区：Xb服务：[其他]服务：呼叫等待服务：转发
The 17 states are as follows:
这17个州的情况如下：
State: 0 Country/Service
Signal: default
Transitions:
Country:[other] -> 1 Country:([other])/Service
Country:Xa -> 5 Country:Xa/Service
Country:Xb -> 9 Country:Xb/Service
Service:[other] -> 13 Country/Service:([other])
Service:Call-waiting -> 14 Country/Service:Call-waiting
Service:Forward -> 16 Country/Service:(Forward)
State: 0 Country/Service
Signal: default
Transitions:
Country:[other] -> 1 Country:([other])/Service
Country:Xa -> 5 Country:Xa/Service
Country:Xb -> 9 Country:Xb/Service
Service:[other] -> 13 Country/Service:([other])
Service:Call-waiting -> 14 Country/Service:Call-waiting
Service:Forward -> 16 Country/Service:(Forward)
State: 1 Country:([other])/Service
Signal: default
Transitions:
Country:[other] -> 1 Country:([other])/Service
Country:Xa -> 1 Country:([other])/Service
Country:Xb -> 1 Country:([other])/Service
Service:[other] -> 2 Country:([other])/Service:([other])
Service:Call-waiting -> 3 Country:([other])/Service:Call-waiting
Service:Forward -> 4 Country:([other])/Service:(Forward)
State: 1 Country:([other])/Service
Signal: default
Transitions:
Country:[other] -> 1 Country:([other])/Service
Country:Xa -> 1 Country:([other])/Service
Country:Xb -> 1 Country:([other])/Service
Service:[other] -> 2 Country:([other])/Service:([other])
Service:Call-waiting -> 3 Country:([other])/Service:Call-waiting
Service:Forward -> 4 Country:([other])/Service:(Forward)
State: 2 Country:([other])/Service:([other])
Signal: default
Transitions:
any -> 2 Country:([other])/Service:([other])
State: 2 Country:([other])/Service:([other])
Signal: default
Transitions:
any -> 2 Country:([other])/Service:([other])
State: 3 Country:([other])/Service:Call-waiting
Signal: call-waiting
Transitions:
any -> 3 Country:([other])/Service:Call-waiting
State: 3 Country:([other])/Service:Call-waiting
Signal: call-waiting
Transitions:
any -> 3 Country:([other])/Service:Call-waiting
State: 4 Country:([other])/Service:(Forward)
Signal: default
Transitions:
any -> 4 Country:([other])/Service:(Forward)
State: 4 Country:([other])/Service:(Forward)
Signal: default
Transitions:
any -> 4 Country:([other])/Service:(Forward)
State: 5 Country:Xa/Service
Signal: XA default
Transitions:
Country:[other] -> 5 Country:Xa/Service
Country:Xa -> 5 Country:Xa/Service
Country:Xb -> 5 Country:Xa/Service
Service:[other] -> 6 Country:Xa/Service:([other])
Service:Call-waiting -> 7 Country:Xa/Service:Call-waiting
Service:Forward -> 8 Country:Xa/Service:Forward
State: 5 Country:Xa/Service
Signal: XA default
Transitions:
Country:[other] -> 5 Country:Xa/Service
Country:Xa -> 5 Country:Xa/Service
Country:Xb -> 5 Country:Xa/Service
Service:[other] -> 6 Country:Xa/Service:([other])
Service:Call-waiting -> 7 Country:Xa/Service:Call-waiting
Service:Forward -> 8 Country:Xa/Service:Forward
State: 6 Country:Xa/Service:([other])
Signal: XA default
Transitions:
any -> 6 Country:Xa/Service:([other])
State: 6 Country:Xa/Service:([other])
Signal: XA default
Transitions:
any -> 6 Country:Xa/Service:([other])
State: 7 Country:Xa/Service:Call-waiting
Signal: XA call-waiting
Transitions:
any -> 7 Country:Xa/Service:Call-waiting
State: 7 Country:Xa/Service:Call-waiting
Signal: XA call-waiting
Transitions:
any -> 7 Country:Xa/Service:Call-waiting
State: 8 Country:Xa/Service:Forward
Signal: XA forward
Transitions:
any -> 8 Country:Xa/Service:Forward
State: 8 Country:Xa/Service:Forward
Signal: XA forward
Transitions:
any -> 8 Country:Xa/Service:Forward
State: 9 Country:Xb/Service
Signal: XB default
Transitions:
Country:[other] -> 9 Country:Xb/Service
Country:Xa -> 9 Country:Xb/Service
Country:Xb -> 9 Country:Xb/Service
Service:[other] -> 10 Country:Xb/Service:([other])
Service:Call-waiting -> 11 Country:Xb/Service:(Call-waiting)
Service:Forward -> 12 Country:Xb/Service:Forward
State: 9 Country:Xb/Service
Signal: XB default
Transitions:
Country:[other] -> 9 Country:Xb/Service
Country:Xa -> 9 Country:Xb/Service
Country:Xb -> 9 Country:Xb/Service
Service:[other] -> 10 Country:Xb/Service:([other])
Service:Call-waiting -> 11 Country:Xb/Service:(Call-waiting)
Service:Forward -> 12 Country:Xb/Service:Forward
State: 10 Country:Xb/Service:([other])
Signal: XB default
Transitions:
any -> 10 Country:Xb/Service:([other])
State: 10 Country:Xb/Service:([other])
Signal: XB default
Transitions:
any -> 10 Country:Xb/Service:([other])
State: 11 Country:Xb/Service:(Call-waiting)
Signal: XB default
Transitions:
any -> 11 Country:Xb/Service:(Call-waiting)
State: 11 Country:Xb/Service:(Call-waiting)
Signal: XB default
Transitions:
any -> 11 Country:Xb/Service:(Call-waiting)
State: 12 Country:Xb/Service:Forward
Signal: XB forward
Transitions:
any -> 12 Country:Xb/Service:Forward
State: 12 Country:Xb/Service:Forward
Signal: XB forward
Transitions:
any -> 12 Country:Xb/Service:Forward
State: 13 Country/Service:([other])
Signal: default
Transitions:
Country:[other] -> 2 Country:([other])/Service:([other])
Country:Xa -> 6 Country:Xa/Service:([other])
Country:Xb -> 10 Country:Xb/Service:([other])
Service:[other] -> 13 Country/Service:([other])
Service:Call-waiting -> 13 Country/Service:([other])
Service:Forward -> 13 Country/Service:([other])
State: 13 Country/Service:([other])
Signal: default
Transitions:
Country:[other] -> 2 Country:([other])/Service:([other])
Country:Xa -> 6 Country:Xa/Service:([other])
Country:Xb -> 10 Country:Xb/Service:([other])
Service:[other] -> 13 Country/Service:([other])
Service:Call-waiting -> 13 Country/Service:([other])
Service:Forward -> 13 Country/Service:([other])
State: 14 Country/Service:Call-waiting
Signal: call-waiting
Transitions:
Country:[other] -> 3 Country:([other])/Service:Call-waiting
Country:Xa -> 7 Country:Xa/Service:Call-waiting
Country:Xb -> 15 Country:(Xb)/Service:Call-waiting
Service:[other] -> 14 Country/Service:Call-waiting
Service:Call-waiting -> 14 Country/Service:Call-waiting
Service:Forward -> 14 Country/Service:Call-waiting
State: 14 Country/Service:Call-waiting
Signal: call-waiting
Transitions:
Country:[other] -> 3 Country:([other])/Service:Call-waiting
Country:Xa -> 7 Country:Xa/Service:Call-waiting
Country:Xb -> 15 Country:(Xb)/Service:Call-waiting
Service:[other] -> 14 Country/Service:Call-waiting
Service:Call-waiting -> 14 Country/Service:Call-waiting
Service:Forward -> 14 Country/Service:Call-waiting
State: 15 Country:(Xb)/Service:Call-waiting
Signal: call-waiting
Transitions:
any -> 15 Country:(Xb)/Service:Call-waiting
State: 15 Country:(Xb)/Service:Call-waiting
Signal: call-waiting
Transitions:
any -> 15 Country:(Xb)/Service:Call-waiting
State: 16 Country/Service:(Forward)
Signal: default
Transitions:
Country:[other] -> 4 Country:([other])/Service:(Forward)
Country:Xa -> 8 Country:Xa/Service:Forward
Country:Xb -> 12 Country:Xb/Service:Forward
Service:[other] -> 16 Country/Service:(Forward)
Service:Call-waiting -> 16 Country/Service:(Forward)
Service:Forward -> 16 Country/Service:(Forward)
State: 16 Country/Service:(Forward)
Signal: default
Transitions:
Country:[other] -> 4 Country:([other])/Service:(Forward)
Country:Xa -> 8 Country:Xa/Service:Forward
Country:Xb -> 12 Country:Xb/Service:Forward
Service:[other] -> 16 Country/Service:(Forward)
Service:Call-waiting -> 16 Country/Service:(Forward)
Service:Forward -> 16 Country/Service:(Forward)
Call-waiting can be signaled in conjunction with country XA but not in conjunction with country XB, as the UA does not have a signal to present call-waiting alerts for country XB. Thus, the ordering of urn:alert:service:call-waiting with urn:alert:country:xa does not matter, but if urn:alert:country:xb appears before urn:alert:service:call-waiting, call-waiting cannot be signaled.
呼叫等待可以与国家XA一起发出信号，但不能与国家XB一起发出信号，因为UA没有向国家XB发出呼叫等待警报的信号。因此，urn:alert:service:call waiting与urn:alert:country:xa的顺序并不重要，但如果urn:alert:country:xb出现在urn:alert:service:call waiting之前，则无法发出呼叫等待信号。
On the other hand, if urn:alert:service:call-waiting appears before urn:alert:country:xb, then call-waiting is signaled, but using the non-country signal.
另一方面，如果urn:alert:service:call waiting出现在urn:alert:country:xb之前，则发出呼叫等待信号，但使用非国家信号。
Alert-Info: urn:alert:country:xa,
urn:alert:service:call-waiting
Alert-Info: urn:alert:country:xa,
urn:alert:service:call-waiting
State: 0 Country/Service
Process: Country:Xa (urn:alert:country:xa)
State: 5 Country:Xa/Service
Process: Service:Call-waiting (urn:alert:service:call-waiting)
State: 7 Country:Xa/Service:Call-waiting
Signal: XA call-waiting
State: 0 Country/Service
Process: Country:Xa (urn:alert:country:xa)
State: 5 Country:Xa/Service
Process: Service:Call-waiting (urn:alert:service:call-waiting)
State: 7 Country:Xa/Service:Call-waiting
Signal: XA call-waiting
Alert-Info: urn:alert:service:call-waiting,
urn:alert:country:xa
Alert-Info: urn:alert:service:call-waiting,
urn:alert:country:xa
State: 0 Country/Service
Process: Service:Call-waiting (urn:alert:service:call-waiting)
State: 14 Country/Service:Call-waiting
Process: Country:Xa (urn:alert:country:xa)
State: 7 Country:Xa/Service:Call-waiting
Signal: XA call-waiting
State: 0 Country/Service
Process: Service:Call-waiting (urn:alert:service:call-waiting)
State: 14 Country/Service:Call-waiting
Process: Country:Xa (urn:alert:country:xa)
State: 7 Country:Xa/Service:Call-waiting
Signal: XA call-waiting
Alert-Info: urn:alert:country:xb,
urn:alert:service:call-waiting
Alert-Info: urn:alert:country:xb,
urn:alert:service:call-waiting
State: 0 Country/Service
Process: Country:Xb (urn:alert:country:xb)
State: 9 Country:Xb/Service
Process: Service:Call-waiting (urn:alert:service:call-waiting)
State: 11 Country:Xb/Service:(Call-waiting)
Signal: XB default
State: 0 Country/Service
Process: Country:Xb (urn:alert:country:xb)
State: 9 Country:Xb/Service
Process: Service:Call-waiting (urn:alert:service:call-waiting)
State: 11 Country:Xb/Service:(Call-waiting)
Signal: XB default
Alert-Info: urn:alert:service:call-waiting,
urn:alert:country:xb
Alert-Info: urn:alert:service:call-waiting,
urn:alert:country:xb
State: 0 Country/Service
Process: Service:Call-waiting (urn:alert:service:call-waiting)
State: 14 Country/Service:Call-waiting
Process: Country:Xb (urn:alert:country:xb)
State: 15 Country:(Xb)/Service:Call-waiting
Signal: call-waiting
State: 0 Country/Service
Process: Service:Call-waiting (urn:alert:service:call-waiting)
State: 14 Country/Service:Call-waiting
Process: Country:Xb (urn:alert:country:xb)
State: 15 Country:(Xb)/Service:Call-waiting
Signal: call-waiting
The specifications provided in [RFC7462] are oriented toward giving the sender of Alert-Info control over which of the "alert" URNs are most important. But in some situations, the UA may prefer to prioritize expressing one URN category over another regardless of the order in which their URNs appear in Alert-Info. This section describes how that can be accommodated within the framework of [RFC7462] and presents an example FSM resulting from that approach.
[RFC7462]中提供的规范旨在让警报信息发送者控制哪些“警报”URN最重要。但在某些情况下，UA可能更倾向于优先表达一个URN类别而不是另一个URN类别，无论其URN在警报信息中的显示顺序如何。本节描述了如何在[RFC7462]的框架内适应这种情况，并给出了由此方法产生的FSM示例。
This example uses the signals of Section 5.2, viz., "external source", "internal source", "low priority", and "high priority", but this time, we want to signal "high priority" in preference to any other signal that might be applicable.
本示例使用第5.2节中的信号，即“外部源”、“内部源”、“低优先级”和“高优先级”，但这一次，我们希望优先于可能适用的任何其他信号，发出“高优先级”信号。
We accommodate this within the framework of [RFC7462] by assigning the signal "high priority" for each of these combinations of URNs:
我们在[RFC7462]的框架内通过为每个URN组合分配信号“高优先级”来实现这一点：
urn:alert:priority:high
urn:alert:priority:high, urn:alert:source:internal
urn:alert:priority:high, urn:alert:source:external
urn:alert:priority:high
urn:alert:priority:high, urn:alert:source:internal
urn:alert:priority:high, urn:alert:source:external
The result is that the signal "high priority" is the "best" signal for any combination of urn:alert:priority:high with "source" URNs.
结果是，对于urn:alert:priority:high与“source”urn的任何组合，信号“high priority”都是“最佳”信号。
Constructing the symbols produces the same results as before. The signals can express the following URNs:
构造符号会产生与以前相同的结果。这些信号可以表示以下URN：
urn:alert:source:external
urn:alert:source:internal
urn:alert:priority:low
urn:alert:priority:high
urn:alert:source:external
urn:alert:source:internal
urn:alert:priority:low
urn:alert:priority:high
The relevant categories of "alert" URNs are:
“警报”骨灰盒的相关类别包括：
source priority
源优先级
The alphabet of symbols is:
符号的字母表为：
Source Source:External Source:Internal Source:Other Priority Priority:Low Priority:High Priority:Other
源源：外部源：内部源：其他优先级优先级：低优先级：高优先级：其他
When the FSM is constructed, it is the same as the FSM of Section 5.2, except that certain states are effectively renamed and merged, because any "source" is defined to be expressed if high priority is expressed:
当构建FSM时，它与第5.2节中的FSM相同，只是某些状态被有效地重命名和合并，因为如果表示高优先级，任何“源”都被定义为表示：
Priority:(High)/Source:External and Priority:High/Source:(External) become:
优先级：（高）/来源：外部和优先级：高/来源：（外部）成为：
State: Priority:High/Source:External
Signal: high priority
State: Priority:High/Source:External
Signal: high priority
Priority:(High)/Source:Internal and Priority:High/Source:(Internal) become:
优先级：（高）/来源：内部和优先级：高/来源：（内部）成为：
State: Priority:High/Source:Internal
Signal: high priority
State: Priority:High/Source:Internal
Signal: high priority
This reduces the FSM to 18 states. In addition, these two new states, along with a number of other states, can be merged by FSM optimization, since all of them have the signal "high priority" and from them, there are no transitions to states outside this set. The optimized FSM has 10 states.
这将FSM减少到18个州。此外，这两个新状态以及许多其他状态可以通过FSM优化进行合并，因为它们都具有信号“高优先级”，并且从它们到该集合之外的状态没有转换。优化后的FSM有10种状态。
This section discusses how to construct FSMs for a UA that allows variable sets of signals -- for example, if the user can configure the use of ring tones. Several approaches can be used:
本节讨论如何为UA构建允许可变信号集的FSM——例如，如果用户可以配置铃声的使用。可以使用几种方法：
o Whenever the set of ring tones is changed, re-execute the processes of Section 4.
o 无论何时更改铃声集，请重新执行第4节中的过程。
o Whenever the set of ring tones is changed, rebuild the list of expressed URNs (Section 4.1) and reconstruct the alphabet of symbols (Section 4.2). Then, use an algorithm for dynamically constructing the states of the FSM as needed during Alert-Info processing.
o 无论何时更改铃声集，都要重新构建所表达的URN列表（第4.1节），并重新构建符号的字母表（第4.2节）。然后，在警报信息处理过程中，根据需要使用算法动态构建FSM的状态。
o If the sets of possible URNs expressed by the ring tones are sufficiently limited, the steps of Section 4 can be carried out "generically", and the generic FSM can be specialized for the current ring tone configuration.
o 如果由铃声表示的可能urn的集合被充分限制，则可以“一般地”执行第4节的步骤，并且可以针对当前铃声配置专门化一般FSM。
The remainder of this section gives an example of the third approach.
本节剩余部分给出了第三种方法的示例。
For the example, we will use a set of ring tones that express the identity of the caller. To signal this information, a private extension "alert" URN category, "caller@example", is used:
例如，我们将使用一组表示呼叫者身份的铃声。要发送此信息，请使用专用扩展“警报”URN类别caller@example“，用于：
urn:alert:caller@example:alice@example.com urn:alert:caller@example:bob@example.com etc.
urn：警报：caller@example:alice@example.comurn：警报：caller@example:bob@example.com等
which we can express by the generic pattern
我们可以用通用模式来表示
urn:alert:caller@example:IDENTITY
urn:alert:caller@example:IDENTITY
where "IDENTITY" is replaced in succession by the set of caller identities that have their own ring tones to generate the set of expressed URNs.
其中，“标识”被具有自己的铃声的呼叫方标识集连续替换，以生成表示的URN集。
The alphabet is then:
字母表是：
Caller@example
Caller@example:IDENTITY
Caller@example:Other
Caller@example
Caller@example:IDENTITY
Caller@example:Other
where "IDENTITY" is replaced in succession by the set of caller identities. The "Caller@example:Other" symbol includes all URNs of the category "caller@example" that are not included in any of the "Caller@example:IDENTITY" symbols, i.e, where the second alert-ind-part is not one of the known caller identities.
其中“标识”被呼叫方标识集连续替换。"Caller@example：Other“符号包括该类别的所有骨灰盒”caller@example“未包含在任何Caller@example：IDENTITY“符号，即第二个警报ind部分不是已知的呼叫方标识之一。
The states and transitions of the FSM are:
FSM的状态和转换为：
State: Caller@example (initial state)
Signal: default
Transitions:
Caller@example:IDENTITY -> Caller@example:IDENTITY
Caller@example:Other -> Caller@example:(Other)
State: Caller@example (initial state)
Signal: default
Transitions:
Caller@example:IDENTITY -> Caller@example:IDENTITY
Caller@example:Other -> Caller@example:(Other)
State: Caller@example:IDENTITY
Signal: signal for caller IDENTITY
Transitions:
any -> Caller@example:IDENTITY
State: Caller@example:IDENTITY
Signal: signal for caller IDENTITY
Transitions:
any -> Caller@example:IDENTITY
State: Caller@example:(Other)
Signal: default
Transitions:
any -> Caller@example:(Other)
State: Caller@example:(Other)
Signal: default
Transitions:
any -> Caller@example:(Other)
where again, the second state is replicated once for each caller identity that has a ring tone, with "IDENTITY" replaced with the caller identity.
其中，第二个状态对于具有铃声的每个呼叫者标识复制一次，其中“标识”替换为呼叫者标识。
The security considerations discussed in Section 16 of [RFC7462] regarding the use and processing of "alert" URNs MUST be followed when the algorithm described in this document is used.
当使用本文件中描述的算法时，必须遵循[RFC7462]第16节中讨论的关于使用和处理“警报”URN的安全注意事项。
Like any implementation of [RFC7462], implementations of the algorithm defined in this document MUST take into account that the value of a received Alert-Info header field may contain URIs of any scheme, may contain syntactically invalid values, and may be syntactically invalid overall. The handling of syntactically invalid values is specified by [RFC3261]. The handling of URIs other than "alert" URIs is outside the scope of this document (and outside the scope of [RFC7462]) and MAY be subject to local policy.
与[RFC7462]的任何实现一样，本文档中定义的算法的实现必须考虑到，接收到的警报信息报头字段的值可能包含任何方案的URI，可能包含语法无效值，并且可能整体语法无效。语法无效值的处理由[RFC3261]指定。除“警报”URI以外的其他URI的处理不在本文档的范围内（也不在[RFC7462]的范围内），可能受本地政策的约束。
Like the algorithm described in Section 12 of [RFC7462], the output of the algorithm defined in this document is limited to a choice among the signals that it has been configured for, limiting the security issues regarding the processing of its output. This algorithm will use at most linear time and constant space to process a sequence of "alert" URNs. This is significantly more efficient than the algorithm of [RFC7462] and minimizes the security vulnerabilities of this processing step that are due to resource consumption.
与[RFC7462]第12节中描述的算法一样，本文中定义的算法的输出仅限于为其配置的信号中的一个选择，从而限制了其输出处理的安全问题。该算法最多使用线性时间和恒定空间来处理一系列“警报”URN。这比[RFC7462]的算法效率更高，并且最大限度地减少了由于资源消耗导致的该处理步骤的安全漏洞。
However, the process defined in this document for constructing an FSM can use more than linear time and constant space -- probably exponential time and space in the worst case. This SHOULD be taken into consideration whenever an FSM is constructed using this algorithm and MUST be taken into consideration when it is done dynamically by a UA. Whenever an FSM is constructed by a process that is not under the direct supervision of a human user, procedures MUST be used to ensure that (1) the processing and memory consumption are limited to acceptable amounts and (2) if the FSM construction is aborted due to excessive consumption, the designated consumers of the FSM MUST have appropriate fallback procedures.
然而，本文中定义的用于构建FSM的过程可以使用的不仅仅是线性时间和恒定空间——在最坏的情况下可能是指数时间和空间。无论何时使用该算法构造FSM，都应该考虑到这一点，并且当UA动态完成FSM时，必须考虑到这一点。当FSM由不在人类用户直接监督下的进程构造时，必须使用程序来确保（1）处理和内存消耗限制在可接受的数量，以及（2）如果FSM构造因过度消耗而中止，FSM的指定消费者必须具有适当的回退程序。
This document has no IANA actions.
本文档没有IANA操作。
[ISO-3166-1] International Organization for Standardization, "Codes for the representation of names of countries and their subdivisions -- Part 1: Country codes", ISO Standard 3166-1:2013, November 2013, <https://www.iso.org/iso-3166-country-codes.html>.
[ISO-3166-1]国际标准化组织，“国家及其分支机构名称表示代码——第1部分：国家代码”，ISO标准3166-1:2013，2013年11月<https://www.iso.org/iso-3166-country-codes.html>.
[RFC2119] Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, DOI 10.17487/RFC2119, March 1997, <https://www.rfc-editor.org/info/rfc2119>.
[RFC2119]Bradner，S.，“RFC中用于表示需求水平的关键词”，BCP 14，RFC 2119，DOI 10.17487/RFC2119，1997年3月<https://www.rfc-editor.org/info/rfc2119>.
[RFC3261] Rosenberg, J., Schulzrinne, H., Camarillo, G., Johnston, A., Peterson, J., Sparks, R., Handley, M., and E. Schooler, "SIP: Session Initiation Protocol", RFC 3261, DOI 10.17487/RFC3261, June 2002, <https://www.rfc-editor.org/info/rfc3261>.
[RFC3261]Rosenberg，J.，Schulzrinne，H.，Camarillo，G.，Johnston，A.，Peterson，J.，Sparks，R.，Handley，M.，和E.Schooler，“SIP：会话启动协议”，RFC 3261，DOI 10.17487/RFC3261，2002年6月<https://www.rfc-editor.org/info/rfc3261>.
[RFC7462] Liess, L., Ed., Jesske, R., Johnston, A., Worley, D., and P. Kyzivat, "URNs for the Alert-Info Header Field of the Session Initiation Protocol (SIP)", RFC 7462, DOI 10.17487/RFC7462, March 2015, <https://www.rfc-editor.org/info/rfc7462>.
[RFC7462]Liess，L.，Ed.，Jeske，R.，Johnston，A.，Worley，D.，和P.Kyzivat，“会话启动协议（SIP）警报信息头字段的URN”，RFC 7462，DOI 10.17487/RFC7462，2015年3月<https://www.rfc-editor.org/info/rfc7462>.
[RFC8174] Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words", BCP 14, RFC 8174, DOI 10.17487/RFC8174, May 2017, <https://www.rfc-editor.org/info/rfc8174>.
[RFC8174]Leiba，B.，“RFC 2119关键词中大写与小写的歧义”，BCP 14，RFC 8174，DOI 10.17487/RFC8174，2017年5月<https://www.rfc-editor.org/info/rfc8174>.
[code] Worley, D., "draft-worley-alert-info-fsm.aux", February 2017, <http://svn.resiprocate.org/rep/ ietf-drafts/worley/draft-worley-alert-info-fsm.aux>.
[代码]Worley，D.，“Worley警报信息草案fsm.aux”，2017年2月<http://svn.resiprocate.org/rep/ ietf草稿/worley/草稿worley警报信息fsm.aux>。
Acknowledgments
致谢
Thanks to Paul Kyzivat, whose relentless identification of the weaknesses of earlier versions made the final document much, much better than it would have been, by changing it from the exposition of a concept into a practical tool. Thanks to Rifaat Shekh-Yusef, Eric Burger, and Gonzalo Camarillo for their thorough reviews. Thanks to the earlier Independent Submissions Editor, Nevil Brownlee, for his work obtaining reviewers, and the later Independent Submissions Editor, Adrian Farrel, for prompting me to write the Security Considerations section (which I had expected to be trivial but was not).
多亏了保罗·基齐瓦特（Paul Kyzivat），他坚持不懈地发现了早期版本的弱点，将最终文件从概念的阐述变成了实用的工具，从而使最终文件比原本要好得多。感谢Rifaat Shekh Yusef、Eric Burger和Gonzalo Camarillo的全面审查。感谢早期的独立投稿编辑内维尔·布朗利（Nevil Brownlee）为获得评论员所做的工作，以及后来的独立投稿编辑阿德里安·法雷尔（Adrian Farrel），他促使我编写了安全考虑部分（我原以为这一部分微不足道，但事实并非如此）。
Author's Address
作者地址
Dale R. Worley Ariadne Internet Services 738 Main St. Waltham, MA 02451 United States of America
Dale R.Worley Ariadne互联网服务738 Main St.Waltham，MA 02451美利坚合众国
Email: worley@ariadne.com
Email: worley@ariadne.com