Enum xmpp_parsers::stanza_error::DefinedCondition

pub enum DefinedCondition {
    BadRequest,
    Conflict,
    FeatureNotImplemented,
    Forbidden,
    Gone,
    InternalServerError,
    ItemNotFound,
    JidMalformed,
    NotAcceptable,
    NotAllowed,
    NotAuthorized,
    PolicyViolation,
    RecipientUnavailable,
    Redirect,
    RegistrationRequired,
    RemoteServerNotFound,
    RemoteServerTimeout,
    ResourceConstraint,
    ServiceUnavailable,
    SubscriptionRequired,
    UndefinedCondition,
    UnexpectedRequest,
}

List of valid error conditions.

Variants

BadRequest

The sender has sent a stanza containing XML that does not conform to the appropriate schema or that cannot be processed (e.g., an IQ stanza that includes an unrecognized value of the ‘type’ attribute, or an element that is qualified by a recognized namespace but that violates the defined syntax for the element); the associated error type SHOULD be “modify”.

Conflict

Access cannot be granted because an existing resource exists with the same name or address; the associated error type SHOULD be “cancel”.

FeatureNotImplemented

The feature represented in the XML stanza is not implemented by the intended recipient or an intermediate server and therefore the stanza cannot be processed (e.g., the entity understands the namespace but does not recognize the element name); the associated error type SHOULD be “cancel” or “modify”.

Forbidden

The requesting entity does not possess the necessary permissions to perform an action that only certain authorized roles or individuals are allowed to complete (i.e., it typically relates to authorization rather than authentication); the associated error type SHOULD be “auth”.

Gone

The recipient or server can no longer be contacted at this address, typically on a permanent basis (as opposed to the <redirect/> error condition, which is used for temporary addressing failures); the associated error type SHOULD be “cancel” and the error stanza SHOULD include a new address (if available) as the XML character data of the <gone/> element (which MUST be a Uniform Resource Identifier (URI) or Internationalized Resource Identifier (IRI) at which the entity can be contacted, typically an XMPP IRI as specified in XMPP‑URI).

InternalServerError

The server has experienced a misconfiguration or other internal error that prevents it from processing the stanza; the associated error type SHOULD be “cancel”.

ItemNotFound

The addressed JID or item requested cannot be found; the associated error type SHOULD be “cancel”.

JidMalformed

The sending entity has provided (e.g., during resource binding) or communicated (e.g., in the ‘to’ address of a stanza) an XMPP address or aspect thereof that violates the rules defined in [XMPP‑ADDR]; the associated error type SHOULD be “modify”.

NotAcceptable

The recipient or server understands the request but cannot process it because the request does not meet criteria defined by the recipient or server (e.g., a request to subscribe to information that does not simultaneously include configuration parameters needed by the recipient); the associated error type SHOULD be “modify”.

NotAllowed

The recipient or server does not allow any entity to perform the action (e.g., sending to entities at a blacklisted domain); the associated error type SHOULD be “cancel”.

NotAuthorized

The sender needs to provide credentials before being allowed to perform the action, or has provided improper credentials (the name “not-authorized”, which was borrowed from the “401 Unauthorized” error of HTTP, might lead the reader to think that this condition relates to authorization, but instead it is typically used in relation to authentication); the associated error type SHOULD be “auth”.

PolicyViolation

The entity has violated some local service policy (e.g., a message contains words that are prohibited by the service) and the server MAY choose to specify the policy in the <text/> element or in an application-specific condition element; the associated error type SHOULD be “modify” or “wait” depending on the policy being violated.

RecipientUnavailable

The intended recipient is temporarily unavailable, undergoing maintenance, etc.; the associated error type SHOULD be “wait”.

Redirect

The recipient or server is redirecting requests for this information to another entity, typically in a temporary fashion (as opposed to the <gone/> error condition, which is used for permanent addressing failures); the associated error type SHOULD be “modify” and the error stanza SHOULD contain the alternate address in the XML character data of the <redirect/> element (which MUST be a URI or IRI with which the sender can communicate, typically an XMPP IRI as specified in XMPP‑URI).

RegistrationRequired

The requesting entity is not authorized to access the requested service because prior registration is necessary (examples of prior registration include members-only rooms in XMPP multi-user chat [XEP‑0045] and gateways to non-XMPP instant messaging services, which traditionally required registration in order to use the gateway [XEP‑0100]); the associated error type SHOULD be “auth”.

RemoteServerNotFound

A remote server or service specified as part or all of the JID of the intended recipient does not exist or cannot be resolved (e.g., there is no _xmpp-server._tcp DNS SRV record, the A or AAAA fallback resolution fails, or A/AAAA lookups succeed but there is no response on the IANA-registered port 5269); the associated error type SHOULD be “cancel”.

RemoteServerTimeout

A remote server or service specified as part or all of the JID of the intended recipient (or needed to fulfill a request) was resolved but communications could not be established within a reasonable amount of time (e.g., an XML stream cannot be established at the resolved IP address and port, or an XML stream can be established but stream negotiation fails because of problems with TLS, SASL, Server Dialback, etc.); the associated error type SHOULD be “wait” (unless the error is of a more permanent nature, e.g., the remote server is found but it cannot be authenticated or it violates security policies).

ResourceConstraint

The server or recipient is busy or lacks the system resources necessary to service the request; the associated error type SHOULD be “wait”.

ServiceUnavailable

The server or recipient does not currently provide the requested service; the associated error type SHOULD be “cancel”.

SubscriptionRequired

The requesting entity is not authorized to access the requested service because a prior subscription is necessary (examples of prior subscription include authorization to receive presence information as defined in [XMPP‑IM] and opt-in data feeds for XMPP publish-subscribe as defined in [XEP‑0060]); the associated error type SHOULD be “auth”.

UndefinedCondition

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

UnexpectedRequest

The recipient or server understood the request but was not expecting it at this time (e.g., the request was out of order); the associated error type SHOULD be “wait” or “modify”.

Trait Implementations

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 From<DefinedCondition> for Element

fn from(elem: DefinedCondition) -> Element

Converts to this type from the input type.

impl PartialEq for DefinedCondition

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

This method tests for self and other values to be equal, and is used by ==.

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

This method 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(elem: Element) -> Result<DefinedCondition, FromElementError>

Performs the conversion.

impl StructuralPartialEq for DefinedCondition