All Classes and Interfaces
Class
Description
An implementation of the Connection interface that wraps an underlying
Connection object.
A partial implementation of the
Connection interface, implementing functionality
that's commonly shared by Connection implementations.Shared base class for Openfire GroupProvider implementations.
Policy that defines who is allowed to subscribe and retrieve items.
Command that allows to create and configure new groups.
Command that allows to add members or admins to a given group.
Adds a user to Openfire if the provider is not read-only.
An ad-hoc command is a stateless object responsible for executing the provided service.
An AdHocCommandHandler is responsible for providing discoverable information about the
supported commands and for handling commands requests.
An AdHocCommandManager is responsible for keeping the list of available commands offered
by a service and for processing commands requests.
A model for admin tab and sidebar info.
The admin console plugin.
Adds Content-Security-Policy headers to HTTP responses based on configuration from Admin Console properties.
The AdminManager manages the AdminProvider configured for this server, caches knowledge of
accounts with admin permissions, and provides a single point of entry for handling
getting and setting administrative accounts.
A bean to hold page information for the admin console.
A simple model of a breadcrumb.
An AdminProvider handles storage of information about admin accounts, and requests to
set the list of admin users.
Utility class providing symmetric AES encryption/decryption.
A long-lived association or connection with a room.
Updates the affiliation of a particular entity, for a particular pubsub node.
Flags an exception when something to be created or added already exists.
Implementation of the SASL ANONYMOUS mechanism.
A to-be-archived entity.
A manager of tasks that write archives into storage.
An abstract runnable that adds to-be-archived data to the database.
Creates a table that represents an ASN.1 encoded DER value.
Defines the known event types used with audits on arbitrary
data/events.
Manages and directs server message auditing behavior.
Implementation of the AuditManager interface.
Use auditors to audit events and messages on the server.
Factory for producing audit stream IDs.
Thrown if a reading is not permitted with the configured SecurityAuditProvider.
A simple filter which checks for the auth token in the user's session.
Takes a user's username and password to authenticate them against the Openfire authprovider.
Pluggable authentication service.
An
AuthProvider that delegates to one or more 'backing' AuthProviders.A
AuthProviderMapper that can be used to draw administrative users from another source than the regular, non-
administrative users.A
UserProviderMapper that can be used to draw administrative users from another source than the regular, non-
administrative users.Manages the AuthorizationProvider objects.
This is the interface the used to provide default authorization identity when none was selected by the client.
This is the interface the AuthorizationManager uses to conduct authorizations.
Subscription requests must be approved and only subscribers may retrieve items.
Provider interface for authentication.
Implementations are used to determine what AuthProvider is to be used for a particular username.
A token that proves that a user has successfully authenticated.
A token that proves that a user uses a one time access token.
A
ReentrantLock lock that can be unlocked using an AutoCloseable.Plugin available at igniterealtime.org.
A default Module implementation that basically avoids subclasses having to implement the whole
Module interface.
A basic stream ID factory that produces IDs using a cryptographically strong random number generator.
A utility class that provides methods that are useful for dealing with
Java Beans.
Servlet used for retrieval of IgniteRealtime's blog's RSS feed.
A class that provides easy Blowfish encryption.
An enum defining all errors which can happen during a BOSH session.
Task that will broadcast a message to local connected client sessions.
A formatter for formatting byte sizes.
General purpose cache.
Defines the unit used to calculate the capacity of the cache.
Interface that defines the necessary behavior for objects added to a Cache.
Some times it is desirable to store in a
Cache the absence of a value.Allows PreparedStatement information to be cached.
Creates Cache objects.
Implementation of CacheFactory that relies on the specific clustering solution.
Configuration to use when creating caches.
Utility class for determining the sizes in bytes of commonly used objects.
Utility methods for working with caches.
Acts as a proxy for a Cache implementation.
A persistence provider for Pub/Sub functionality that adds caching behavior.
Wraps an instance of Ben Manes' Caffeine cache in a class that inherits from
Cache.An implementation of the CallableStatement interface that wraps an underlying
CallableStatement object.
A cluster task used to cancel a pubsub node subscription (a relation between an entity an a pubsub node).
Exception used for representing the error when an external MUC delegate responds to an invite-user packet by rejecting the invitation attempt.
Flags an exception when we cannot determine size of the object to be cached.
Interface to listen for certificate events.
Servlet for the admin console page that configures the automated, continuous checks of TLS certificate expiry.
Periodically evaluates the TLS certificates in all identity stores of Openfire.
This is the interface used to map identity credentials from certificates.
Utility class that provides similar functionality to the keytool tool.
A wrapper class for a Java store of certificates, its metadata (password, location) and related functionality.
A checked exception that indicates problems related to Certificate Store functionality.
Certificate stores are configured using a defined set of properties.
A manager of certificate stores.
Detects file-system based changes to (Java) keystores that back Openfire Certificate Stores, reloading them when
needed.
Utility methods for working with
Certificate instances.Command that allows to change password of existing users.
A channel provides a mechanism to queue work units for processing.
ChannelHandler<T extends org.xmpp.packet.Packet>
Interface to handle packets delivered by Channels.
Thrown when a channel lookup fails to find the specified channel.
A utility class to assist with loading classes or resources by name.
Internal object used by RoutingTableImpl to keep track of the node that own a ClientSession
and whether the session is available or not.
Represents a session between the server and a client.
Represents a connection of a Client Session that was established to a Connection Manager.
Client session information to be used when running in a cluster.
Class that defines possible remote operations that could be performed
on remote client sessions.
Handler of XML stanzas sent by clients connected directly to the server.
ClientTrustManager is a Trust Manager that is only used for c2s connections.
An event listener for changes made to entries of a clustered cache.
Listener for cluster events.
A cluster manager is responsible for triggering events related to clustering.
Monitors the state of the cluster, and warns admins when nodes leave or rejoin the cluster
Basic information about a cluster node.
Route packets to other nodes of the cluster.
An interface to mix in
Externalizable and Runnable, which are both required for
sending invokable tasks across a cluster.Certificate identity mapping that uses the CommonName as the
identity credentials
A type of node that contains nodes and/or other collections but no published
items.
Policy that defines who may associate leaf nodes with a collection.
A utility class that provides re-usable functionality that relates to Java collections.
This specialized wrapper is used for the Components cache, which
should not be purged.
Interface to listen for component events.
Represents a session between the server and an external component.
The ExternalComponent acts as a proxy of the remote connected component.
Class that defines possible remote operations that could be performed
on remote component sessions (for external components only).
Handler of XML stanzas sent by external components connected directly to the server.
This list specifies additional methods that understand groups among
the items in the list.
This extension class provides additional methods that understand groups among
the entries in the map.
Exception used for representing a conflict error in a MUCRoom.
Represents a connection on the server.
Enumeration that specifies if clients should be authenticated (and how) while
negotiating TLS.
Enumeration of possible compression policies required to interact with the server.
Used to specify operational status for the corresponding connection
Enumeration of possible TLS policies required to interact with the server.
ConnectionAcceptors are responsible for accepting new (typically socket) connections from peers.
Implement and register with a connection to receive notification
of the connection closing.
Configuration for a socket connection.
Thrown when Openfire is not able to connect to the user and group system.
As a server, Openfire accepts connection requests from other network entities.
An event listener for events related to a SocketAcceptor instance.
Coordinates connections (accept, read, termination) on the server.
A ConnectionMultiplexerManager is responsible for keeping track of the connected
Connection Managers and the sessions that were established with the Connection
Managers.
Represents a session between the server and a connection manager.
Class that defines possible remote operations that could be performed
on remote connection manager sessions.
Abstract class that defines the connection provider framework.
Types of (socket-based, including HTTP) connections.
This class defines methods that verify that the state of a cache and its various supporting data structures (in which
some data duplication is expected) is consistent.
Caches, especially clustered caches, have various supporting data structures that allow them to work properly in
certain conditions.
Adds Content-Security-Policy headers to HTTP responses.
Allows via AdHoc commands the creation of a Multi-User Chat room.
Admin provider which will map a crowd group with openfire authorized admin users
Auth provider for Atlassian Crowd
Atlassian Crowd implementation of the GroupProvider.
Reading the file crowd.properties which should be found in the conf folder
of openfire
Atlassian Crowd implementation of the UserProvider.
VCard provider for Crowd.
Handles Client State Indication nonzas for one particular client session.
Listener for datagram packets received.
Central manager of database connections.
A class that identifies the type of the database that Jive is connected
to.
Handles default management of admin users, which stores the list if accounts as a system property.
The default implementation that defines the default authorization identity to be used, when none was selected by the
client.
Different clients perform authentication differently, so this policy will authorize any authentication identity, or
'principal' (identity whose password will be used) to a requested authorization identity (identity to act as) that
match specific conditions that are considered secure defaults for most installations.
Default AuthProvider implementation.
Default, non-distributed implementation of the Cache interface.
Default Jive connection provider, which uses an internal connection pool.
BeanInfo class for the DefaultConnectionProvider class.
Default serialization strategy.
Provides several utility methods for file transfer manager implementations to utilize.
Default implementation of a writable
Map to manage group properties.Database implementation of the GroupManager interface.
CacheFactoryStrategy for use in Openfire.
The DefaultLockOutProvider works with the ofUserFlag table to maintain a list of disabled/locked out
accounts., and as the name implies, is the default LockOutProvider implementation.
A DefaultNodeConfiguration keeps the default configuration values for leaf or collection
nodes of a particular publish-subscribe service.
Tracks the different connections related to a file transfer.
A manager responsible for ensuring node persistence.
Defines the provider methods required for creating, reading, updating and deleting roster
items.
The default security audit provider stores the logs in a ofSecurityAuditLog table.
Default implementation of the UserPropertyProvider interface, which reads and writes data from the
ofUserProp database table.Default implementation of the UserProvider interface, which reads and writes data
from the
ofUser database table.Default implementation of the VCardProvider interface, which reads and writes data
from the
ofVCard database table.Command that allows to delete existing groups.
Command that allows to delete members or admins from a given group.
Delete a user from Openfire if the provider is not read-only.
Cluster task that will ask a remote cluster node to deliver some raw text to a local session.
Represents a directed presence sent from a session hosted in a cluster node
to another entity (e.g.
Disables (locks) a user.
A DiscoInfoProvider is responsible for providing information about a JID's name and its node.
An item is associated with an XMPP Entity, usually thought of a children of
the parent entity and normally are addressable as a JID.
A DiscoItemsProvider is responsible for providing the items associated with a JID's name and
node.
Represent a DiscoItem provided by the server.
Utility class to perform DNS lookups for XMPP services.
Deprecated, for removal: This API element is subject to removal in a future version.
Deprecated, for removal: This API element is subject to removal in a future version.
Holds a (possibly authenticated) domain pair.
Simple data model to handle success/failure of downloads using AJAX.
Listen packets from defined dataSocket and send packets to the defined host.
Edits the list of Openfire administrators
Edits the list of external domains that are allowed to connect to Openfire
Edits the list of external domains that are disallowed to connect to Openfire
We use a simple
naming convention of meta-data key names: data is stored
hierarchically separated by dots.
A service to send email.
A connection provider for the embedded hsqlDB database.
Instances of this class will be able to generate various encryption-related artifacts based on a specific connection
configuration.
End a user session
Contains identities and supported features describing client capabilities
for an entity.
Interface to listen for entity capabilities events.
Implements server side mechanics for XEP-0115: "Entity Capabilities"
Version 1.4
In particular, EntityCapabilitiesManager is useful for processing
"filtered-notifications" for use with Pubsub (XEP-0060) for contacts that
may not want to receive notifications for all payload types.
Thrown if an event looked up (typically by id) was not found.
Implementation of the SASL EXTERNAL mechanism with PKIX to be used for client-to-server connections.
Holds the configuration for external components that want to connect to this server.
Manages the connection permissions for external components.
Listener that will be alerted when an external component is disabled/enabled,
the port is changed or configuration about an external component is modified.
Utility methods to assist in working with the
Externalizable interfaces.Interface that allows to provide different ways for implementing serialization of objects.
Implementation of the SASL EXTERNAL mechanism with PKIX to be used for server-to-server connections.
XMPP specified SASL errors.
Deprecated, for removal: This API element is subject to removal in a future version.
Use instead thread-safe implementations provided by Java, such as
DateTimeFormatterServlet that gets favicons of webservers and includes them in HTTP responses.
Contains all of the meta information associated with a file transfer.
An event listener for File Transfer related events.
Manages all file transfer currently happening originating from and/or ending at users of the
server.
An interface to track the progress of a file transfer through the server.
Manages the transferring of files between two remote entities on the jabber network.
Thrown by a
FileTransferEventListener when a file transfer is rejected by the Interceptor.A cluster task used to instruct other cluster nodes that they must flush pending changes to pubsub nodes to the
persistent data storage.
Exception used for representing unavailability of FMUC (XEP-0289).
Configuration mode for Federated Multi-User Chat.
Exception used for representing that the requested operation is forbidden for the user in
the MUCRoom.
Command that returns information about the admin console.
Task that will return the bind interface and ports being used by the admin
console of the node where the task will be executed.
A task that retrieves a time estimation on the time it takes for data to have been written to persistent storage.
Command that returns basic information about this JVM like number of client sessions,
server sessions and amount of free and used memory.
Command that allows to retrieve a list of all active users.
Command that allows to retrieve a list of all disabled users.
Command that allows to retrieve a list of existing groups.
Command that allows to retrieve list members of a given group.
Command that allows to retrieve the list of idle users.
Command that allows to retrieve the number of registered users who are online at
any one moment.
Command that allows to retrieve a list of all registered users.
Command that allows to retrieve the number of online users who are active at any one moment.
Command that allows to retrieve the number of disabled users
Command that allows to retrieve the number of idle users.
Command that allows to retrieve the number of registered users who are online at
any one moment.
Command that allows to retrieve the number of registered users
Command that allows to retrieve the number of user sessions at any one moment.
Command that returns information about the server and some basic statistics.
Task that will be executed in cluster nodes to get the number of sessions hosted by the
cluster node.
Gets the roster of a user
The implementation uses Openfire's LockOutManager to apply the configuration state.
Command that allows to retrieve the presence of all active users.
Utilities for working with graphics-related data.
Groups organize users into a single entity for easier management.
Notifies the that an admin was added to the group.
Notifies the that an admin was removed from the group.
Thrown when attempting to create a group that already exists.
This list specifies additional methods that understand groups among
the items in the list.
This map specifies additional methods that understand groups among
the entries in the map.
Makes the users of specific group Openfire administrators.
Provides a view of an array of group names as a Collection of Group objects.
Notifies the that a group was created.
Notifies the that a group is being deleted.
An abstract adapter class for receiving group events.
Dispatches group events.
Represents valid event types.
Interface to listen for group events.
This class is designed to identify and manage custom JIDs
that represent Groups (rather than Users or Components).
Manages groups.
Notifies the that a member was added to the group.
Notifies the that a member was removed from the group.
Notifies the that a group was modified.
A
GroupProvider that delegates to one or more 'backing' GroupProvider.Thrown when attempting to set or rename a group, passing an unacceptable name.
Thrown when unable to find or load a group.
Provider interface for groups.
Implementations are used to determine what GroupProvider is to be used for a particular group name.
Represents the amount of history requested by an occupant while joining a room.
Multi-User Chat rooms may cache history of the conversations in the room in order to
play them back to newly arriving members.
A wrapper for a collection of Message instances that is cached.
Strategy type.
Representation of the 'body' element of an HTTP-Bind defined request.
Adds Content-Security-Policy headers to HTTP responses based on configuration from HTTP Binding / Bosh properties.
Responsible for making available BOSH (functionality to the outside world, using an embedded web server.
Servlet which handles requests to the HTTP binding service.
AdHoc command to return the current status of the HTTP-bind service.
Represents one HTTP connection with a client using the HTTP Binding service.
This exception is thrown when an action attempted on the connection to the client but the
connection has been closed.
Exception class that wraps an HTTP error code.
A session represents a series of interactions with an XMPP client sending packets using the HTTP
Binding protocol specified in XEP-0124.
A virtual server connection relates to a http session which its self can relate to many http
connections.
Manages sessions for all users connecting to Openfire using the HTTP binding protocol,
XEP-0124.
The hybrid auth provider allows up to three AuthProvider implementations to
be strung together to do chained authentication checking.
Delegate GroupProvider operations among up to three configurable provider implementation classes.
Delegate UserPropertyProvider operations among up to three configurable provider implementation classes.
Delegate UserProvider operations among up to three configurable provider implementation classes.
A convience class to build statistic parameters out of a resource bundle.
A wrapper class for a store of certificates, its metadata (password, location) and related functionality that is
used to provide credentials (that represent this Openfire instance), an identity store
An identity store should contain private keys, each associated with its certificate chain.
A Future that returns immediately.
An Exception indicating that the inbound buffer has exceeded its limit.
Server-to-server communication is done using two TCP connections between the servers.
Incoming server session information to be used when running in a cluster.
Class that defines possible remote operations that could be performed
on remote incoming server sessions.
Exception thrown during application or component initialization failure.
An memory-based PubSub persistence provider.
An InterceptorManager manages the list of global interceptors and per-user
interceptors that are invoked before and after packets are read and sent.
Manages the registration and delegation of Components, which includes External Components as well as components
that run in the Openfire JVM.
Thrown when Openfire is not able to authenticate itself into the user and group system.
Various utility methods for working with (string representations of) IP-addresses.
A handler for the IQ packet with namespace http://jabber.org/protocol/muc#admin.
Binds a resource to the stream so that the client's address becomes a full JID.
Implementation of XEP-0191 "Blocking Command".
IQDiscoInfoHandler is responsible for handling disco#info requests.
IQDiscoItemsHandler is responsible for handling disco#items requests.
This IQ handler implements XEP-0202: Entity Time.
This class adds support for the search functionality for MUC rooms as defined in XEP-0433: Extended Channel Search.
Base class whose main responsibility is to handle IQ packets.
A simple meta-data class that stores several related tools for
generic IQ protocol handling.
Implements the TYPE_IQ jabber:iq:last protocol (last activity).
This handler manages XEP-0280 Message Carbons.
Deprecated, for removal: This API element is subject to removal in a future version.
The protocol defined herein was formalized (with minor changes) as XEP-0433, which is implemented in
IQExtendedChannelSearchHandlerThis class adds jabber:iq:search combined with 'result set management'
functionality to the MUC service of Openfire.
Implements the TYPE_IQ vcard-temp protocol, to be used for MUC rooms.
Implements JEP-0013: Flexible Offline Message Retrieval.
A handler for the IQ packet with namespace http://jabber.org/protocol/muc#owner.
An
IQHandler used to implement XEP-0163: "Personal Eventing via Pubsub"
Version 1.0
An
IQHandler used to implement XEP-0163: "Personal Eventing via Pubsub"
Version 1.0Implements the XMPP Ping as defined by XEP-0199.
IQPrivacyHandler is responsible for handling privacy lists.
Implements the TYPE_IQ jabber:iq:private protocol.
Implements the TYPE_IQ jabber:iq:register protocol (plain only).
Handle the various user registration settings that are
valid under XMPP.
Implements the TYPE_IQ jabber:iq:roster protocol.
Routes iq packets throughout the server.
Activate client sessions once resource binding has been done.
Handler of IQ packets whose child element is "sharedgroup" with namespace
"http://www.jivesoftware.org/protocol/sharedgroup".
Implements the TYPE_IQ vcard-temp protocol.
Implements the TYPE_IQ jabber:iq:version protocol (version info).
Task that will be run in each cluster node to learn if the specified plugin
is installed or not.
Holds version information for Java specification (a major and minor version, eg: 1.8,
or just a number, eg: 11).
The JDBC admin provider allows you to use an external database to define the administrators
users.
The JDBC auth provider allows you to authenticate users against any database
that you can connect to with JDBC.
Indicates how the password is stored.
The JDBC group provider allows you to use an external database to define the composition of groups.
The JDBC user property provider allows you to use an external database to define the user properties.
The JDBC user provider allows you to use an external database to define the users.
An abstract BeanInfo implementation that automatically constructs
PropertyDescriptors and handles i18n through ResourceBundles.
Contains constant values representing various objects in Jive.
Controls Jive properties.
Used to specify what jive id an object should have
A class that extends the Java's InitialLdapContext class with
two properties to store the SSLSession and the StartTlsResponse
objects.
Retrieves and stores Jive properties.
Implementation of a proprietary Jive Software SASL mechanism that is based on a shared secret.
Manages the JMX configuration for Openfire.
An implementation of ConnectionProvider that utilizes a JDBC 2.0 DataSource
made available via JNDI.
Utility functions that are exposed through a taglib.
Provider for authorization mapping using LDAP.
Provider for authorization using LDAP.
Implementation of auth provider interface for LDAP authentication service plug-in.
LDAP implementation of the GroupProvider interface.
Class that assists during the testing of the ldap groups.
Representation of a group found in LDAP.
Centralized administration of LDAP connections.
Bean that stores the vcard mapping.
LDAP implementation of the UserProvider interface.
Class that assists during the testing of the user-ldap mapping.
Read-only LDAP provider for vCards.Configuration consists of adding a provider:
A type of node that contains published items only.
Simple LinkedList implementation.
Doubly linked node in a LinkedList.
This class provides an easy way to page through a filterable list of items from a JSP page.
Represents a session between the server and a client.
Represents a session between the server and a component.
The ExternalComponent acts as a proxy of the remote connected component.
Represents a session between the server and a connection manager.
Sets the locale context-wide.
A set of methods for retrieving and converting locale specific strings and numbers.
Server-to-server communication is done using two TCP connections between the servers.
Each instance of this class takes responsibility of maintaining the in-memory representation of MUCRooms for exactly
one instance of
MultiUserChatService, which is expected to be the sole invoking
entity.Server-to-server communication is done using two TCP connections between the servers.
The session represents a connection between the server and a client (c2s) or
another server (s2s) as well as a connection with a component.
Dispatches lockout events.
Interface to listen for lockout events.
A LockOutFlag represents the current disabled status set on a particular user account.
The LockOutManager manages the LockOutProvider configured for this server, caches knowledge of
whether accounts are disabled or enabled, and provides a single point of entry for handling
locked/disabled accounts.
A LockOutProvider handles storage of information about disabled accounts, and requests for
whether an account is currently disabled.
Openfire makes use of a logging facade (slf4j) to manage its log output.
Handles recording admin console login attempts and handling temporary lockouts where necessary.
A
AuthProvider that delegates to a user-specific AuthProvider.A
GroupProvider that delegates to a group-specific GroupProvider.A
UserPropertyProvider that delegates to a user-specific UserPropertyProvider.A
UserProvider that delegates to a user-specific UserProvider.A Media Proxy relays UDP traffic between two IPs to provide connectivity between
two parties that are behind NAT devices.
A proxy service for UDP traffic such as RTP.
A media proxy session enables two clients to exchange UDP traffic.
Records meory usage (based on the 'heap') of Openfire.
Memory usage statistics.
Route message packets throughout the server.
Exception thrown when a modification was not allowed.
A cluster task used to modify a pubsub node subscription (a relation between an entity an a pubsub node).
Logical, server-managed entities must implement this interface.
Gives the implementer the ability to react to, allow, or deny MUC related events.
Dispatches MUC events.
Interface to listen for MUC events.
Defines the permissions and actions that a user currently may use in a particular room.
A manager responsible for ensuring room persistence.
A chat room on the chat server manages its users, and enforces its own security rules.
Represent the data model for one
MUCRoom history.Represents information about a retired MUC room.
Retrieves and stores MUC service properties.
This task updates or deletes a property in a cluster node's muc service property map.
Dispatches property events.
Represents valid event types.
Interface to listen for property events.
Publishes Openfire information as a service using the Multicast DNS (marketed by Apple
as Rendezvous) protocol.
Router of packets with multiple recipients.
Fallback method used by
NettyConnection when
connected to a connection manager.IQ packets sent from Connection Managers themselves to the server will be handled by
instances of this class.
Handler of XML stanzas sent by Connection Managers.
Provides centralized management of all configured Multi User Chat (MUC) services.
Manages groupchat conversations, chatrooms, and users.
Implements the chat server as a cached memory resident chat server.
MXParser that returns an IGNORABLE_WHITESPACE event when a whitespace character or a
line feed is received.
A thread factory that allows threads to be named.
Authenticates using the native operating system authentication method.
A UserProvider to be used in conjunction with
NativeAuthProvider, which
authenticates using OS-level authentication.Defines a factory for
ChannelHandler instances.Client-specific ConnectionHandler that knows which subclass of
StanzaHandler should be created
and how to build and configure a NettyConnection.ConnectionHandler that knows which subclass of
StanzaHandler should
be created and how to build and configure a NettyConnection.Implementation of
Connection interface specific for Netty connections.Responsible for accepting new (socket) connections, using Java NIO implementation provided by the Netty framework.
A NettyConnectionHandler is responsible for creating new sessions, destroying sessions and delivering
received XML stanzas to the proper StanzaHandler.
Responsible for creating the NettyConnectionHandler for the connection type.
A NettyIdleStateKeepAliveHandler listens for IdleStateEvents triggered by an IdleStateHandler.
ConnectionHandler that knows which subclass of
StanzaHandler should
be created and how to build and configure a NettyConnection.Outbound (S2S) specific ConnectionHandler that knows which subclass of
StanzaHandler should be created
and how to build and configure a NettyConnection.Server-specific ConnectionHandler that knows which subclass of
StanzaHandler should be created
and how to build and configure a NettyConnection.Creates a newly configured
ChannelPipeline for a new channel.Initialises an outgoing netty channel for outbound S2S
Decoder that parses ByteBuffers and generates XML stanzas.
Represents a generic issue with connecting to a remote network entity.
Task that is used by a newly joined cluster node to inform other cluster nodes that it has joined the cluster.
A cluster task used to create a pubsub node subscription (a relation between an entity an a pubsub node).
A virtual location to which information can be published and from which event
notifications and/or payloads can be received (in other pubsub systems, this may
be labelled a "topic").
Policy that defines whether owners or publisher should receive replies to items.
A unique identifier for a node, in context of all services in the system.
A NodeAffiliate keeps information about the affiliation of an entity with a node.
Affiliation with a node defines user permissions.
Class which wraps the byte[] we use to identify cluster members.
A subscription to a node.
Subscriptions to a node may exist in several states.
A cluster task used work with a particular pubsub node.
Exception used for representing that the nickname used by the user is not acceptable.
Exception used for representing that the specified node configuration is not acceptable.
Exception used for representing that the user is not allowed to perform the requested operation
in the MUCRoom.
Flags an exception when something requested is not found.
Task that will be executed on other cluster nodes to trigger the event that a component has
send its disco#info to the server.
Task that will be executed on other cluster nodes to trigger the event that a component was
added to a cluster node.
Task that will be executed on other cluster nodes to trigger the event that a component was
removed from a cluster node.
Task that informs cluster nodes that a XMPP entity is now an occupant of a MUC room.
Maintains an in-memory inventory of what XMPP entity (user) is in what chatroom, across the entire XMPP cluster.
Representation of a user that is an occupant of a chatroom.
A
PKIXCertPathChecker that uses
Online Certificate Status Protocol (OCSP)
See RFC 2560.This class implements a fix for a problem identified as issue OF-1515 in the bugtracker of Openfire.
This class implements a fix for a problem identified as issue OF-33 in the
bugtracker of Openfire.
Subclass of Message that keeps the date when the offline message was stored in the database.
Interface to listen for offline message events.
Represents the user's offline message storage.
Controls what is done with offline messages.
Strategy types.
Fallback method used by
NettyConnection when a
connection fails to send a Packet (likely because it was closed).Publishers and owners may publish items to the node.
Subscribers, publishers and owners may publish items to the node.
Anyone may subscribe and retrieve items.
This Servlet enables XMPP over WebSocket (RFC 7395) for Openfire.
A Trust Manager implementation that adds Openfire-proprietary functionality.
Anyone may publish items to the node.
Server-to-server communication is done using two TCP connections between the servers.
Class that defines possible remote operations that could be performed
on remote outgoing server sessions.
An OutgoingServerSocketReader is responsible for reading and queueing the DOM Element sent by
a remote server.
An OutgoingSessionPromise provides an asynchronous way for sending packets to remote servers.
Packet interceptor that notifies of packets activity to components that previously
subscribed to the notificator.
Delivers packets to locally connected streams.
In-memory implementation of the packet deliverer service
Represents a runtime packet exception typically from a malformed
packet.
A packet interceptor encapsulates an action that is invoked on a packet immediately
before or after it was received by a SocketReader and also when the packet is about to
be sent in SocketConnection.
Thrown by a PacketInterceptor when a stanza is prevented from being processed.
A router that handles incoming packets.
An uber router that can handle any packet type.
Command that allows to retrieve the presence of all active users.
In-memory implementation of the packet transporter service.
Assists JSP writers in getting parameters and attributes.
Ad-hoc command that sends pending subscriptions to node owners.
A PEPService is a
PubSubService for use with XEP-0163: "Personal Eventing via
Pubsub" Version 1.0
Note: Although this class implements Cacheable, instances should only be
cached in caches that have time-based (as opposed to size-based) eviction policies.A PubSubService manager that is specific to the implemenation of XEP-163: Personal Eventing Protocol.
Manages the creation, persistence and removal of
PEPService
instances.This acts as a tag interface.
Image resizing utility methods.
A (very) basic ad-hoc command that returns the server time in UTC.
Plugin interface.
A helper class to read cache configuration data for a plugin and register the defined caches with
the cache factory.
A simple registry of cache configuration data for plugins.
ClassLoader for plugins.
Service that allow for aysynchrous calling of system managers.
A servlet filter that plugin classes can use to dynamically register and un-register filter logic.
Servlet is used for retrieval of plugin icons.
Allows for notifications that a plugin has been either created or destroyed.
Manages plugins.
Interface to listen for plugin manager events.
A bean-like representation of the metadata of a plugin.
Various helper methods to retrieve plugin metadat from plugin.xml files.
A service that monitors the plugin directory for plugins.
The plugin servlet acts as a proxy for web requests (in the admin console)
to plugins.
A Servlet Context to be used by Openfire plugins.
An AuthProvider that authenticates using a POP3 server.
A UserProvider to be used in conjunction with
POP3AuthProvider, which
authenticates using a POP3 server.An implementation of the PreparedStatement interface that wraps an underlying
PreparedStatement object.
Anyone with a presence subscription of both or from may subscribe and retrieve items.
Dispatches presence events.
Interface to listen for presence events.
The presence manager tracks on a global basis who's online.
Simple in memory implementation of the PresenceManager interface.
Route presence packets throughout the server.
Implements the presence protocol.
Indicate a state change.
Implements the presence protocol.
A privacy item acts a rule that when matched defines if a packet should be blocked or not.
Type defines if the rule is based on JIDs, roster groups or presence subscription types.
A privacy list contains a set of rules that define if communication with the list owner
is allowed or denied.
/**
Interface to listen for privacy list events.
A Privacy list manager creates, gets, updates and removes privacy lists.
Provider for the privacy lists system.
Private storage for user accounts (XEP-0049).
Cluster task that will ask a remote cluster node to deliver some packet to a local session.
Wraps a Connection object and collects statistics about the database queries
that are performed.
Simple class for tracking profiling stats for individual SQL queries.
A
AuthProviderMapper that can be used to draw some users from another source than the other users.A
UserProviderMapper that can be used to draw some users from another source than the other users.This task updates or deletes a property in a cluster node's property map.
Dispatches property events.
Represents valid event types.
Interface to listen for property events.
Basic interface to access a Candidate provided by a Session
Manages the connections to the proxy server.
An output stream which tracks the amount of bytes transfered by proxy sockets.
Tracks the different connections related to a proxy file transfer.
A published item to a node.
A unique identifier for an item, in context of all nodes of all services in the system.
Policy that defines who is allowed to publish items to the node.
A PubSubEngine is responsible for handling packets sent to a pub-sub service.
Response Object returned by createNodeHelper method
A PubSubService manager that is specific to the implemenation of XEP-60: Publish-Subscribe.
Module that implements XEP-60: Publish-Subscribe.
Filters and sorts lists of pubsub nodes.
Defines an implementation responsible for persisting pubsub-related data
to a backend data store.
Manages the persistence provider used to manage pubsub data in persistent storage.
A PubSubService is responsible for keeping the hosted nodes by the service, the default
configuration to use for newly created nodes and specify the policy to use regarding
node management.
A unique identifier for an item, in context of all nodes of all services in the system.
The implementation of the
<received xmlns="urn:xmpp:carbons:2"/> extension.Re-Enables a user.
Forces the node to be refreshed from the database.
Exception used for representing that the user needs to register with the room in order to perform
the requested operation.
A Session Class will control "receive and relay" proccess.
Surrogate for client sessions hosted in some remote cluster node.
Surrogate for sessions of external components hosted in some remote cluster node.
Thrown when something failed verifying the key of a Originating Server with an Authoritative
Server in a dialback operation.
Surrogate for connection manager sessions hosted in some remote cluster node.
Surrogate for incoming server sessions hosted in some remote cluster node.
Surrogate for outgoing server sessions hosted in some remote cluster node.
Task to be executed by remote nodes to deliver the requested packet to the requested
receiver.
A RemotePacketRouter is responsible for delivering packets to entities hosted
in remote nodes of the cluster.
Holds the configuration when connecting to/from a remote server.
Manages the connection permissions for remote servers.
Base class for sessions being hosted in other cluster nodes.
Locator of sessions that are being hosted by other cluster nodes.
Locator of sessions that know how to talk to Hazelcast cluster nodes.
Operations to be executed in a remote session hosted in a remote cluster node.
Removes a newly deleted node from memory across the cluster.
A representation of an Internet Protocol-based socket address (an IP address and port) for a (presumably XMPP) service.
Combines and serves resources, such as javascript or css files.
Stanza handler for responding to incoming stanzas when the server is acting as the client in an S2S scenario.
Cache entry listener implementation that maintains a reverse lookup map for the cache that is being observed, which
is used to identify what cluster nodes are the logical owner of a particular cache entry.
Cache entry listener implementation that maintains a reverse lookup map for the cache that is being observed, which
is used to identify what cluster node is the logical owner of a particular cache entry.
A temporary position or privilege level within a room, distinct from a user's long-lived affiliation with the
room.
Exception used for representing that the user can't join a room since it's been locked.
A roster is a list of users that the user wishes to know if they are online.
Anyone in the specified roster group(s) may subscribe and retrieve items.
Dispatches roster events.
Interface to listen for roster events.
Represents a single roster item for a User's Roster.
A simple service that allows components to retrieve a roster based solely on the ID
of the owner.
Route packets identify target sessions by their stream ID and contain a single
wrapped stanza that should be processed by the target session.
Maintains server-wide knowledge of routes to any node.
Routing table that stores routes to client sessions, outgoing server sessions
and components.
Runs server to server test.
Certificate identity mapping that uses SubjectAlternativeName as the identity credentials.
SASLAuthentication is responsible for returning the available SASL mechanisms to use and for
actually performing the SASL authentication.
A SaslException with XMPP 'failure' context.
This is the Provider object providing the SaslServerFactory written by Jive Software.
Server Factory for supported mechanisms.
Implements the PLAIN server-side mechanism.
A utility class that provides a level of abstraction around the creation of a SAXReader instance suitable for XMPP
parsing, as well as maintaining a set of readers ready, available for (bulk) processing.
A CompletionService that allows solvers to be scheduled.
Manages database schemas for Openfire and Openfire plugins.
Implements the SCRAM-SHA-1 server-side mechanism.
A utility class that provides methods that are useful for dealing with
Salted Challenge Response Authentication Mechanism (SCRAM).
Representation of a single security event retrieved from the logs.
The SecurityAuditManager manages the SecurityAuditProvider configured for this server, and provides
a proper conduit for making security log entries and looking them up.
A SecurityAuditProvider handles storage and retrieval of security audit logs.
Sends a message to all online users
The implementation of the
<sent xmlns="urn:xmpp:carbons:2"/> extension.Manages sequences of unique ID's that get stored in the database.
A Cache implementation that stores data in serialized form.
Implementation of the Server Dialback method as defined by the RFC3920.
Representation of an error result of the Server Dialback authentication mechanism.
Representation of an invalid-key result of the Server Dialback authentication mechanism.
ServerFeaturesProviders are responsible for providing the features offered and supported
protocols by the SERVER.
A
ServerIdentitiesProvider is responsible for providing the identities
of protocols supported by the SERVER.ServerItemsProvider are responsible for providing the items associated with the SERVER.
Dispatches session events (s2s).
Represents valid event types.
Interface to listen for server session events (s2s).
Handler of XML stanzas sent by remote servers.
A ServerTrafficCounter counts the number of bytes read and written by the server.
ServerTrustManager is a Trust Manager that is only used for s2s connections.
Task that will add a service to the cluster node.
Task that will remove a service from the cluster node.
Exception used for representing that the MultiUserChat service is not available at the moment.
Task that will update a service configuring in the cluster node.
The session represents a link (often a socket connection) between the server and a remote XMPP entity.
A SessionData instance is responsible for keeping information gathered during the many stages
of the command being executed.
Events that occur during the session life cycle are repreented
by SessionEvents.
Dispatches session events.
Represents valid event types.
Interface to listen for session events.
A http session listener that implements a configurable session timeout.
Listens for HTTP binding session events.
Listener for media proxy session events.
Manages the sessions associated with an account.
Handles the routing of packets to a particular session.
Filters and sorts lists of sessions.
Servlet for the admin console page that configures what columns are visible on the 'client sessions' page.
Sets the character encoding to UTF-8.
Thrown when a a user is trying to add or remove a contact from his/her roster that belongs to a
shared group.
Describes with which users a group is shared as a group on their roster.
A simple JSP tag for displaying sidebar information in the admin console.
SSLSocketFactory that accepts any certificate chain and also accepts expired
certificates.
Enables CA SiteMinder/Single Sign-On authentication to the admin console - https://www.ca.com/gb/products/ca-single-sign-on.html
A service to send SMS messages.
Deprecated.
Old, pre NIO / MINA code.
This ChannelHandler writes packet data to connections.
Deprecated.
Old, pre NIO / MINA code.
Utility class to generate Socket instances.
A SoftwareServerVersionManager is the main responsible for sending query to remote entity and
Obtain software information from the remote entity server using XEP-0092 .
A SoftwareVersionManager is the main responsible for sending query to remote entity and
Obtain software information from the remote entity using XEP-0092 .
A (partial) representation of an SRV record, containing an (unresolved) hostname, port, priority and weight attributes.
A StanzaHandler is the main responsible for handling incoming stanzas.
Utility methods that implement XEP-0359: Unique and Stable Stanza IDs.
An implementation of the Statement interface that wraps an underlying
Statement object.
A statistic being tracked by the server.
The type of statistic.
Stores statistics being tracked by the server.
An exception that wraps a
StreamErrorA unique identifier for a stream.
Generates stream ids in different ways depending on the server set up.
This class extends Openfire's session packet router with the ACK capabilities
specified by XEP-0198: Stream Management.
XEP-0198 Stream Manager.
Utility class to perform common String manipulation algorithms.
A simple JSP tag for displaying sub-navigation bar information in the admin console.
A cluster task used work with a particular subscription (a relation between an entity an a pubsub node) of a pubsub node.
A simple tag to gather its body content and pass it to the parent tag.
Task that is used by a cluster node to inform other cluster nodes of its local occupants.
Represents the entries being searched for
Not every entry in the ofProperty table will have a matching
SystemProperty - so this class exists so
that the admin UI can display eitherRepresents the properties being searched for
Represents a system property - also accessible via
JiveGlobals.Used to build a
SystemPropertyA simple JSP tag for displaying tab information in the admin console.
Performs tasks using worker threads.
A task that, periodically, updates the 'last modified' date of all files in the Jetty 'tmp' directories.
Determines if a session that is detached (in context of Stream Management) can be terminated.
A delegate for a
ThreadPoolExecutor instance, to expose a subset of its functionality as an MBean (as defined by
ThreadPoolExecutorDelegateMBean.MBean definition for a Threadpool-based executor (@link
ThreadPoolExecutorA TLSStatus enum describing the current handshaking state of this TLS connection.
TLSStreamHandler is responsible for securing plain connections by negotiating TLS.
A
TLSStreamReader that returns a special InputStream that hides the ByteBuffers
used by the underlying Channels.A
TLSStreamWriter that returns a special OutputStream that hides the ByteBuffers
used by the underlying Channels.Creates and initializes the SSLContext instance to use to encrypt the plain connection.
Routes packets to the appropriate transport gateway or drops the packet.
Configuration of Openfire's 'gateway' or 'trunking' functionality, which allows Openfire to act as a gateway to
transfer data between other XMPP domains.
A wrapper class for a store of certificates, its metadata (password, location) and related functionality that is
used to verify credentials, a trust store
The trust store should only contain certificates for the "most-trusted" Certificate Authorities (the store should not
contain Intermediates").
Thrown if a user does not have permission to access a particular method.
Thrown if a user does not have permission to access a particular method.
An Update represents a component that needs to be updated.
Command that allows to update a given group.
Service that frequently checks for new server or plugins releases.
Encapsulates information about a user.
Thrown when attempting to create a user that already exists.
Provides a view of an array of usernames as a Collection of User objects.
Notifies the that a user was created.
Notifies the deletion of a user.
An abstract adapter class for receiving user events.
Dispatches user events.
Represents valid event types.
Interface to listen for group events.
A
UserFeatureProvider is responsible for providing the features
of protocols supported by users.
A
UserIdentitiesProvider is responsible for providing the identities
of protocols supported by users.
A
UserItemsProvider is responsible for providing the items associated with a user
that are to be discovered during a disco#items query sent to the user.Manages users, including loading, creating and deleting.
Notifies the that a user was modified.
A
UserProvider that delegates to one or more 'backing' UserProvider.Main responsibility of this class is to return the correct name of XMPP entities.
Interface to be implemented by components that are capable of returning the name of entities
when running as internal components.
Thrown when User cannot be found.
An adhoc command to retrieve the properties of the user.
A
UserPropertyProvider that delegates to one or more 'backing' UserProvider.A provider for user properties.
Implementations are used to determine what UserPropertyProvider is to be used for a particular username.
Provider interface for the user system.
Implementations are used to determine what UserProvider is to be used for a particular username.
Notifies the that a vcard was created.
Notifies the deletion of a vCard.
Dispatches vCard events.
Interface to listen for vCard changes.
Manages VCard information for users.
Notifies the that a vCard was modified.
Provider interface for users vcards.
This callback issued by SaslServer to determine if a password supplied by a
client is verified.
Holds version information for Openfire.
A class to represent the release status of the server.
Abstract implementation of the Connection interface that models abstract connections.
A utility bean for Openfire admin console pages.
This class handles all WebSocket events for the corresponding connection with a remote peer, analogous to the
function of
NettyClientConnectionHandler for TCP connections.A
StanzaHandler that is able to process the specific framing that is used by
clients connecting via websockets.Following the conventions of the BOSH implementation, this class extends
VirtualConnection
and delegates the expected XMPP connection behaviors to the corresponding WebSocketClientConnectionHandler.Utilities to extract data from a web.xml file.
Only those on a whitelist may subscribe and retrieve items.
This is a Light-Weight XML Parser.
An Exception indicating that evaluated content is not valid XML.
Provides the ability to use simple XML property files.
XMLWriter whose writer is actually sending data on a socket connection.
Replacement class of the original XMLWriter.java (version: 1.77) since the original is still
using StringBuffer which is not fast.
Callback handler that may be used when doing SASL authentication.
An XMPPContextListener starts an XMPPServer when a ServletContext is initialized and stops
the xmpp server when the servlet context is destroyed.
XMPPPacketReader is a Reader of DOM4J documents that
uses the fast
XML Pull Parser 3.x.The main XMPP server that will load, initialize and start all the server's
modules.
Information 'snapshot' of a server's state.
Implements the server info for a basic server.
Interface that let observers be notified when the server has been started or is
about to be stopped.
SrvRecord