Enum DefinedCondition

pub enum DefinedCondition {
    BadFormat,
    BadNamespacePrefix,
    Conflict,
    ConnectionTimeout,
    HostGone,
    HostUnknown,
    ImproperAddressing,
    InternalServerError,
    InvalidFrom,
    InvalidNamespace,
    InvalidXml,
    NotAuthorized,
    NotWellFormed,
    PolicyViolation,
    RemoteConnectionFailed,
    Reset,
    ResourceConstraint,
    RestrictedXml,
    SeeOtherHost(String),
    SystemShutdown,
    UndefinedCondition,
    UnsupportedEncoding,
    UnsupportedFeature,
    UnsupportedStanzaType,
    UnsupportedVersion,
}

Enumeration of all stream error conditions as defined in RFC 6120.

All variant documentation is directly quoted from RFC 6120.

Variants

BadFormat

The entity has sent XML that cannot be processed.

This error can be used instead of the more specific XML-related errors, such as <bad-namespace-prefix/>, <invalid-xml/>, <not-well-formed/>, <restricted-xml/>, and <unsupported-encoding/>. However, the more specific errors are RECOMMENDED.

BadNamespacePrefix

The entity has sent a namespace prefix that is unsupported, or has sent no namespace prefix on an element that needs such a prefix (see Section 11.2).

Conflict

The server either (1) is closing the existing stream for this entity because a new stream has been initiated that conflicts with the existing stream, or (2) is refusing a new stream for this entity because allowing the new stream would conflict with an existing stream (e.g., because the server allows only a certain number of connections from the same IP address or allows only one server-to- server stream for a given domain pair as a way of helping to ensure in-order processing as described under Section 10.1).

If a client receives a <conflict/> stream error, during the resource binding aspect of its reconnection attempt it MUST NOT blindly request the resourcepart it used during the former session but instead MUST choose a different resourcepart; details are provided under Section 7.

ConnectionTimeout

One party is closing the stream because it has reason to believe that the other party has permanently lost the ability to communicate over the stream. The lack of ability to communicate can be discovered using various methods, such as whitespace keepalives as specified under Section 4.4, XMPP-level pings as defined in XEP-0199, and XMPP Stream Management as defined in XEP-0198.

Interoperability Note: RFC 3920 specified that the <connection-timeout/> stream error is to be used if the peer has not generated any traffic over the stream for some period of time. That behavior is no longer recommended; instead, the error SHOULD be used only if the connected client or peer server has not responded to data sent over the stream.

HostGone

The value of the ‘to’ attribute provided in the initial stream header corresponds to an FQDN that is no longer serviced by the receiving entity.

HostUnknown

The value of the ‘to’ attribute provided in the initial stream header does not correspond to an FQDN that is serviced by the receiving entity.

ImproperAddressing

A stanza sent between two servers lacks a ‘to’ or ‘from’ attribute, the ‘from’ or ‘to’ attribute has no value, or the value violates the rules for XMPP addresses (see RFC 6122).

InternalServerError

The server has experienced a misconfiguration or other internal error that prevents it from servicing the stream.

InvalidFrom

The data provided in a ‘from’ attribute does not match an authorized JID or validated domain as negotiated (1) between two servers using SASL or Server Dialback, or (2) between a client and a server via SASL authentication and resource binding.

InvalidNamespace

The stream namespace name is something other than http://etherx.jabber.org/streams (see Section 11.2) or the content namespace declared as the default namespace is not supported (e.g., something other than jabber:client or jabber:server).

InvalidXml

The entity has sent invalid XML over the stream to a server that performs validation (see Section 11.4).

NotAuthorized

The entity has attempted to send XML stanzas or other outbound data before the stream has been authenticated, or otherwise is not authorized to perform an action related to stream negotiation; the receiving entity MUST NOT process the offending data before sending the stream error.

NotWellFormed

The initiating entity has sent XML that violates the well-formedness rules of XML or XML-NAMES.

PolicyViolation

The entity has violated some local service policy (e.g., a stanza exceeds a configured size limit); the server MAY choose to specify the policy in the <text/> element or in an application-specific condition element.

RemoteConnectionFailed

The server is unable to properly connect to a remote entity that is needed for authentication or authorization (e.g., in certain scenarios related to Server Dialback XEP-0220); this condition is not to be used when the cause of the error is within the administrative domain of the XMPP service provider, in which case the <internal-server-error/> condition is more appropriate.

Reset

The server is closing the stream because it has new (typically security-critical) features to offer, because the keys or certificates used to establish a secure context for the stream have expired or have been revoked during the life of the stream (Section 13.7.2.3), because the TLS sequence number has wrapped (Section 5.3.5), etc. The reset applies to the stream and to any security context established for that stream (e.g., via TLS and SASL), which means that encryption and authentication need to be negotiated again for the new stream (e.g., TLS session resumption cannot be used).

ResourceConstraint

The server lacks the system resources necessary to service the stream.

RestrictedXml

The entity has attempted to send restricted XML features such as a comment, processing instruction, DTD subset, or XML entity reference (see Section 11.1).

SeeOtherHost(String)

The server will not provide service to the initiating entity but is redirecting traffic to another host under the administrative control of the same service provider. The XML character data of the <see-other-host/> element returned by the server MUST specify the alternate FQDN or IP address at which to connect, which MUST be a valid domainpart or a domainpart plus port number (separated by the ‘:’ character in the form “domainpart:port”). If the domainpart is the same as the source domain, derived domain, or resolved IPv4 or IPv6 address to which the initiating entity originally connected (differing only by the port number), then the initiating entity SHOULD simply attempt to reconnect at that address. (The format of an IPv6 address MUST follow IPv6-ADDR, which includes the enclosing the IPv6 address in square brackets ‘[’ and ‘]’ as originally defined by URI. ) Otherwise, the initiating entity MUST resolve the FQDN specified in the <see-other-host/> element as described under Section 3.2.

When negotiating a stream with the host to which it has been redirected, the initiating entity MUST apply the same policies it would have applied to the original connection attempt (e.g., a policy requiring TLS), MUST specify the same ‘to’ address on the initial stream header, and MUST verify the identity of the new host using the same reference identifier(s) it would have used for the original connection attempt (in accordance with TLS-CERTS). Even if the receiving entity returns a <see-other-host/> error before the confidentiality and integrity of the stream have been established (thus introducing the possibility of a denial-of-service attack), the fact that the initiating entity needs to verify the identity of the XMPP service based on the same reference identifiers implies that the initiating entity will not connect to a malicious entity. To reduce the possibility of a denial-of-service attack, (a) the receiving entity SHOULD NOT close the stream with a <see-other-host/> stream error until after the confidentiality and integrity of the stream have been protected via TLS or an equivalent security layer (such as the SASL GSSAPI mechanism), and (b) the receiving entity MAY have a policy of following redirects only if it has authenticated the receiving entity. In addition, the initiating entity SHOULD abort the connection attempt after a certain number of successive redirects (e.g., at least 2 but no more than 5).

SystemShutdown

The server is being shut down and all active streams are being closed.

UndefinedCondition

The error condition is not one of those defined by the other conditions in this list; this error condition SHOULD NOT be used except in conjunction with an application-specific condition.

UnsupportedEncoding

The initiating entity has encoded the stream in an encoding that is not supported by the server (see Section 11.6) or has otherwise improperly encoded the stream (e.g., by violating the rules of the UTF-8 encoding).

UnsupportedFeature

The receiving entity has advertised a mandatory-to-negotiate stream feature that the initiating entity does not support, and has offered no other mandatory-to-negotiate feature alongside the unsupported feature.

UnsupportedStanzaType

The initiating entity has sent a first-level child of the stream that is not supported by the server, either because the receiving entity does not understand the namespace or because the receiving entity does not understand the element name for the applicable namespace (which might be the content namespace declared as the default namespace).

UnsupportedVersion

The ‘version’ attribute provided by the initiating entity in the stream header specifies a version of XMPP that is not supported by the server.

Trait Implementations

impl AsXml for DefinedCondition

type ItemIter<'xso_proc_as_xml_iter_lifetime> = DefinedConditionAsXmlIterator<'xso_proc_as_xml_iter_lifetime>

The iterator type.

fn as_xml_iter(&self) -> Result<Self::ItemIter<'_>, Error>

Return an iterator which emits the contents of the struct or enum as serialisable Item items.

impl Clone for DefinedCondition

fn clone(&self) -> DefinedCondition

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DefinedCondition

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for DefinedCondition

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<DefinedCondition> for Element

fn from(other: DefinedCondition) -> Self

Converts to this type from the input type.

impl FromXml for DefinedCondition

type Builder = DefinedConditionFromXmlBuilder

A builder type used to construct the element.

fn from_events( name: QName, attrs: AttrMap, ) -> Result<Self::Builder, FromEventsError>

Attempt to initiate the streamed construction of this struct from XML.

impl PartialEq for DefinedCondition

fn eq(&self, other: &DefinedCondition) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TryFrom<Element> for DefinedCondition

type Error = FromElementError

The type returned in the event of a conversion error.

fn try_from(other: Element) -> Result<Self, Self::Error>

Performs the conversion.

impl StructuralPartialEq for DefinedCondition