A virtual interface that allows implementors to receive data sent over a SOCKS5 Bytestream as defined in XEP-0066, or an In-Band Bytestream as defined in XEP-0047. You'll also need it for sending of data. More...

Enumeration Type Documentation

The receiving entity acknowledges an <abort/> element sent by the initiating entity; sent in reply to the <abort/> element.

SaslIncorrectEncoding

The data provided by the initiating entity could not be processed because the [BASE64] encoding is incorrect (e.g., because the encoding does not adhere to the definition in Section 3 of [BASE64]); sent in reply to a <response/> element or an <auth/> element with initial response data.

SaslInvalidAuthzid

The authzid provided by the initiating entity is invalid, either because it is incorrectly formatted or because the initiating entity does not have permissions to authorize that ID; sent in reply to a <response/> element or an <auth/> element with initial response data.

SaslInvalidMechanism

The initiating entity did not provide a mechanism or requested a mechanism that is not supported by the receiving entity; sent in reply to an <auth/> element.

SaslMalformedRequest

The request is malformed (e.g., the <auth/> element includes an initial response but the mechanism does not allow that); sent in reply to an <abort/>, <auth/>, <challenge/>, or <response/> element.

SaslMechanismTooWeak

The mechanism requested by the initiating entity is weaker than server policy permits for that initiating entity; sent in reply to a <response/> element or an <auth/> element with initial response data.

SaslNotAuthorized

The authentication failed because the initiating entity did not provide valid credentials (this includes but is not limited to the case of an unknown username); sent in reply to a <response/> element or an <auth/> element with initial response data.

SaslTemporaryAuthFailure

The authentication failed because of a temporary error condition within the receiving entity; sent in reply to an <auth/> element or <response/> element.

The last operation (account registration, account deletion or password change) was successful.

RegistrationNotAcceptable

406: Not all necessary information provided

RegistrationConflict

409: Username alreday exists.

RegistrationNotAuthorized

Account removal: Unregistered entity waits too long before authentication or performs tasks other than authentication after registration.
Password change: The server or service does not consider the channel safe enough to enable a password change.

RegistrationBadRequest

Account removal: The <remove/> element was not the only child element of the <query/> element. Should not happen when only gloox functions are being used.
Password change: The password change request does not contain complete information (both <username/> and <password/> are required).

RegistrationForbidden

Account removal: The sender does not have sufficient permissions to cancel the registration.

RegistrationRequired

Account removal: The entity sending the remove request was not previously registered.

RegistrationUnexpectedRequest

Account removal: The host is an instant messaging server and the IQ get does not contain a 'from' address because the entity is not registered with the server.
Password change: The host is an instant messaging server and the IQ set does not contain a 'from' address because the entity is not registered with the server.

RegistrationNotAllowed

Password change: The server or service does not allow password changes.

The sender has sent XML that is malformed or that cannot be processed (e.g., an IQ stanza that includes an unrecognized value of the 'type' attribute); the associated error type SHOULD be "modify".

StanzaErrorConflict

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

StanzaErrorFeatureNotImplemented

The feature requested is not implemented by the recipient or server and therefore cannot be processed; the associated error type SHOULD be "cancel".

StanzaErrorForbidden

The requesting entity does not possess the required permissions to perform the action; the associated error type SHOULD be "auth".

StanzaErrorGone

The recipient or server can no longer be contacted at this address (the error stanza MAY contain a new address in the XML character data of the <gone/> element); the associated error type SHOULD be "modify".

StanzaErrorInternalServerError

The server could not process the stanza because of a misconfiguration or an otherwise-undefined internal server error; the associated error type SHOULD be "wait".

StanzaErrorItemNotFound

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

StanzaErrorJidMalformed

The sending entity has provided or communicated an XMPP address (e.g., a value of the 'to' attribute) or aspect thereof (e.g., a resource identifier) that does not adhere to the syntax defined in Addressing Scheme (Section 3); the associated error type SHOULD be "modify".

StanzaErrorNotAcceptable

The recipient or server understands the request but is refusing to process it because it does not meet criteria defined by the recipient or server (e.g., a local policy regarding acceptable words in messages); the associated error type SHOULD be "modify".

StanzaErrorNotAllowed

The recipient or server does not allow any entity to perform the action; the associated error type SHOULD be "cancel".

StanzaErrorNotAuthorized

The sender must provide proper credentials before being allowed to perform the action, or has provided impreoper credentials; the associated error type should be "auth".

StanzaErrorNotModified

The item requested has not changed since it was last requested; the associated error type SHOULD be "continue".

StanzaErrorPaymentRequired

The requesting entity is not authorized to access the requested service because payment is required; the associated error type SHOULD be "auth".

StanzaErrorRecipientUnavailable

The intended recipient is temporarily unavailable; the associated error type SHOULD be "wait" (note: an application MUST NOT return this error if doing so would provide information about the intended recipient's network availability to an entity that is not authorized to know such information).

StanzaErrorRedirect

The recipient or server is redirecting requests for this information to another entity, usually temporarily (the error stanza SHOULD contain the alternate address, which MUST be a valid JID, in the XML character data of the <redirect/> element); the associated error type SHOULD be "modify".

StanzaErrorRegistrationRequired

The requesting entity is not authorized to access the requested service because registration is required; the associated error type SHOULD be "auth".

StanzaErrorRemoteServerNotFound

A remote server or service specified as part or all of the JID of the intended recipient does not exist; the associated error type SHOULD be "cancel".

StanzaErrorRemoteServerTimeout

A remote server or service specified as part or all of the JID of the intended recipient (or required to fulfill a request) could not be contacted within a reasonable amount of time; the associated error type SHOULD be "wait".

StanzaErrorResourceConstraint

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

StanzaErrorServiceUnavailable

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

StanzaErrorSubscribtionRequired

The requesting entity is not authorized to access the requested service because a subscription is required; the associated error type SHOULD be "auth".

StanzaErrorUndefinedCondition

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

StanzaErrorUnexpectedRequest

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".

StanzaErrorUnknownSender

The stanza 'from' address specified by a connected client is not valid for the stream (e.g., the stanza does not include a 'from' address when multiple resources are bound to the stream); the associated error type SHOULD be "modify".

The entity has sent XML that cannot be processed; this error MAY be used instead of the more specific XML-related errors, such as <bad-namespace-prefix/>, <invalid-xml/>, <restricted-xml/>, <unsupported-encoding/>, and <xml-not-well-formed/>, although the more specific errors are preferred.

StreamErrorBadNamespacePrefix

The entity has sent a namespace prefix that is unsupported, or has sent no namespace prefix on an element that requires such a prefix (see XML Namespace Names and Prefixes (Section 11.2)).

StreamErrorConflict

The server is closing the active stream for this entity because a new stream has been initiated that conflicts with the existing stream.

StreamErrorConnectionTimeout

The entity has not generated any traffic over the stream for some period of time (configurable according to a local service policy).

StreamErrorHostGone

the value of the 'to' attribute provided by the initiating entity in the stream header corresponds to a hostname that is no longer hosted by the server.

StreamErrorHostUnknown

The value of the 'to' attribute provided by the initiating entity in the stream header does not correspond to a hostname that is hosted by the server.

StreamErrorImproperAddressing

A stanza sent between two servers lacks a 'to' or 'from' attribute (or the attribute has no value).

StreamErrorInternalServerError

the server has experienced a misconfiguration or an otherwise-undefined internal error that prevents it from servicing the stream.

StreamErrorInvalidFrom

The JID or hostname provided in a 'from' address does not match an authorized JID or validated domain negotiated between servers via SASL or dialback, or between a client and a server via authentication and resource binding.

StreamErrorInvalidId

The stream ID or dialback ID is invalid or does not match an ID previously provided.

StreamErrorInvalidNamespace

The streams namespace name is something other than "http://etherx.jabber.org/streams" or the dialback namespace name is something other than "jabber:server:dialback" (see XML Namespace Names and Prefixes (Section 11.2)).

StreamErrorInvalidXml

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

StreamErrorNotAuthorized

The entity has attempted to send 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 stanza before sending the stream error.

StreamErrorPolicyViolation

The entity has violated some local service policy; the server MAY choose to specify the policy in the <text/> element or an application-specific condition element.

StreamErrorRemoteConnectionFailed

The server is unable to properly connect to a remote entity that is required for authentication or authorization.

StreamErrorResourceConstraint

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

StreamErrorRestrictedXml

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

StreamErrorSeeOtherHost

The server will not provide service to the initiating entity but is redirecting traffic to another host; the server SHOULD specify the alternate hostname or IP address (which MUST be a valid domain identifier) as the XML character data of the <see-other-host/> element.

StreamErrorSystemShutdown

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

StreamErrorUndefinedCondition

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

StreamErrorUnsupportedEncoding

The initiating entity has encoded the stream in an encoding that is not supported by the server (see Character Encoding (Section 11.5)).

StreamErrorUnsupportedStanzaType

The initiating entity has sent a first-level child of the stream that is not supported by the server.

StreamErrorUnsupportedVersion

The value of the 'version' attribute provided by the initiating entity in the stream header specifies a version of XMPP that is not supported by the server; the server MAY specify the version(s) it supports in the <text/> element.

StreamErrorXmlNotWellFormed

The initiating entity has sent XML that is not well-formed as defined by [XML].

StreamErrorUndefined

An undefined/unknown error occured. Also used if a diconnect was user-initiated. Also set before and during a established connection (where obviously no error occured).

Contact and user are not subscribed to each other, and neither has requested a subscription from the other.

S10nNoneOut

Contact and user are not subscribed to each other, and user has sent contact a subscription request but contact has not replied yet.

S10nNoneIn

Contact and user are not subscribed to each other, and contact has sent user a subscription request but user has not replied yet (note: contact's server SHOULD NOT push or deliver roster items in this state, but instead SHOULD wait until contact has approved subscription request from user).

S10nNoneOutIn

Contact and user are not subscribed to each other, contact has sent user a subscription request but user has not replied yet, and user has sent contact a subscription request but contact has not replied yet.

S10nTo

User is subscribed to contact (one-way).

S10nToIn

User is subscribed to contact, and contact has sent user a subscription request but user has not replied yet.

S10nFrom

Contact is subscribed to user (one-way).

S10nFromOut

Contact is subscribed to user, and user has sent contact a subscription request but contact has not replied yet.