Overview | Package | Class | Tree | Deprecated | Index | Help
| Openfire 3.4.4 Javadoc
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.jivesoftware.openfire.session
Class LocalClientSession

    java.lang.Object
      org.jivesoftware.openfire.session.LocalSession
          org.jivesoftware.openfire.session.LocalClientSession

All Implemented Interfaces:
  ChannelHandler, RoutableChannelHandler, ClientSession, Session

Direct Known Subclasses:
  HttpSession

    public class LocalClientSession

extends LocalSession
implements ClientSession

Represents a session between the server and a client.

Author:
  Gaston Dombiak

Field Summary
`protected AuthToken` | `authToken` The authentication token for this session.

Fields inherited from class org.jivesoftware.openfire.session.LocalSession
`CHARSET, conn, sessionManager, status`

Fields inherited from interface org.jivesoftware.openfire.session.Session
`MAJOR_VERSION, MINOR_VERSION, STATUS_AUTHENTICATED, STATUS_CLOSED, STATUS_CONNECTED`

Constructor Summary
`LocalClientSession(String serverName, Connection connection, StreamID streamID)` Creates a session with an underlying connection and permission protection.

Method Summary
`boolean` | `canFloodOfflineMessages()` Returns true if the offline messages of the user should be sent to the user when the user becomes online.
`boolean` | `canProcess(Packet packet)` Returns true if the specified packet must not be blocked based on the active or default privacy list rules.
`static LocalClientSession` | `createSession(String serverName, org.xmlpull.v1.XmlPullParser xpp, Connection connection)` Returns a newly created session between the server and a client.
`PrivacyList` | `getActiveList()` Returns the Privacy list that overrides the default privacy list.
`static Map<String,String>` | `getAllowedIPs()` Returns the list of IP address that are allowed to connect to the server.
`AuthToken` | `getAuthToken()` Returns the authentication token associated with this session.
`String` | `getAvailableStreamFeatures()` Returns a text with the available stream features.
`static Connection.CompressionPolicy` | `getCompressionPolicy()` Returns whether compression is optional or is disabled for clients.
`int` | `getConflictCount()` Returns the number of conflicts detected on this session.
`PrivacyList` | `getDefaultList()` Returns the default Privacy list used for the session's user.
`Presence` | `getPresence()` Obtain the presence of this session.
`static Connection.TLSPolicy` | `getTLSPolicy()` Returns whether TLS is mandatory, optional or is disabled for clients.
`String` | `getUsername()` Returns the username associated with this session.
`void` | `incrementConflictCount()` Increments the conflict by one.
`boolean` | `isAnonymousUser()` Returns true if the authetnicated user is an anonymous user or if the use has not authenticated yet.
`boolean` | `isInitialized()` Flag indicating if this session has been initialized once coming online.
`boolean` | `isOfflineFloodStopped()` Returns true if the user requested to not receive offline messages when sending an available presence.
`void` | `setActiveList(PrivacyList activeList)` Sets the Privacy list that overrides the default privacy list.
`static void` | `setAllowedIPs(Map<String,String> allowed)` Sets the list of IP address that are allowed to connect to the server.
`void` | `setAnonymousAuth()` Initialize the session as an anonymous login.
`void` | `setAuthToken(AuthToken auth)` Sets the new Authorization Token for this session.
`void` | `setAuthToken(AuthToken auth, String resource)` Initialize the session with a valid authentication token and resource name.
`static void` | `setCompressionPolicy(Connection.CompressionPolicy policy)` Sets whether compression is optional or is disabled for clients.
`void` | `setDefaultList(PrivacyList defaultList)` Sets the default Privacy list used for the session's user.
`void` | `setInitialized(boolean isInit)` Sets the initialization state of the session.
`void` | `setOfflineFloodStopped(boolean offlineFloodStopped)` Sets if the user requested to not receive offline messages when sending an available presence.
`void` | `setPresence(Presence presence)` Set the presence of this session
`static void` | `setTLSPolicy(Connection.TLSPolicy policy)` Sets whether TLS is mandatory, optional or is disabled for clients.
`String` | `toString()`
`boolean` | `wasAvailable()` Returns true if the session was available ever.

Methods inherited from class org.jivesoftware.openfire.session.LocalSession
`close, decodeVersion, deliverRawText, getAddress, getConnection, getCreationDate, getHostAddress, getHostName, getLastActiveDate, getNumClientPackets, getNumServerPackets, getServerName, getSessionData, getStatus, getStreamID, incrementClientPacketCount, incrementServerPacketCount, isClosed, isSecure, process, removeSessionData, setAddress, setSessionData, setStatus, validate`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

Methods inherited from interface org.jivesoftware.openfire.session.Session
`close, deliverRawText, getAddress, getCreationDate, getHostAddress, getHostName, getLastActiveDate, getNumClientPackets, getNumServerPackets, getServerName, getStatus, getStreamID, isClosed, isSecure, process, validate`

Field Detail

### authToken

    protected AuthToken authToken

  The authentication token for this session.

Constructor Detail

### LocalClientSession

    public LocalClientSession(String serverName,
                              Connection connection,
                              StreamID streamID)

  Creates a session with an underlying connection and permission protection.

  Parameters:
    `serverName` - name of the server.
    `connection` - The connection we are proxying.
    `streamID` - unique identifier of this session.

Method Detail

### getAllowedIPs

    public static Map<String,String> getAllowedIPs()

  Returns the list of IP address that are allowed to connect to the server. If the list is empty then anyone is allowed to connect to the server.

  Returns:
    the list of IP address that are allowed to connect to the server.

### createSession

    public static LocalClientSession createSession(String serverName,
                                                   org.xmlpull.v1.XmlPullParser xpp,
                                                   Connection connection)
                                            throws org.xmlpull.v1.XmlPullParserException

  Returns a newly created session between the server and a client. The session will be created and returned only if correct name/prefix (i.e. 'stream' or 'flash') and namespace were provided by the client.

  Parameters:
    `serverName` - the name of the server where the session is connecting to.
    `xpp` - the parser that is reading the provided XML through the connection.
    `connection` - the connection with the client.
  Returns:
    a newly created session between the server and a client.
  Throws:
    `org.xmlpull.v1.XmlPullParserException` - if an error occurs while parsing incoming data.

### setAllowedIPs

    public static void setAllowedIPs(Map<String,String> allowed)

  Sets the list of IP address that are allowed to connect to the server. If the list is empty then anyone is allowed to connect to the server.

  Parameters:
    `allowed` - the list of IP address that are allowed to connect to the server.

### getTLSPolicy

    public static Connection.TLSPolicy getTLSPolicy()

  Returns whether TLS is mandatory, optional or is disabled for clients. When TLS is mandatory clients are required to secure their connections or otherwise their connections will be closed. On the other hand, when TLS is disabled clients are not allowed to secure their connections using TLS. Their connections will be closed if they try to secure the connection. in this last case.

  Returns:
    whether TLS is mandatory, optional or is disabled.

### setTLSPolicy

    public static void setTLSPolicy(Connection.TLSPolicy policy)

  Sets whether TLS is mandatory, optional or is disabled for clients. When TLS is mandatory clients are required to secure their connections or otherwise their connections will be closed. On the other hand, when TLS is disabled clients are not allowed to secure their connections using TLS. Their connections will be closed if they try to secure the connection. in this last case.

  Parameters:
    `policy` - whether TLS is mandatory, optional or is disabled.

### getCompressionPolicy

    public static Connection.CompressionPolicy getCompressionPolicy()

  Returns whether compression is optional or is disabled for clients.

  Returns:
    whether compression is optional or is disabled.

### setCompressionPolicy

    public static void setCompressionPolicy(Connection.CompressionPolicy policy)

  Sets whether compression is optional or is disabled for clients.

  Parameters:
    `policy` - whether compression is optional or is disabled.

### getActiveList

    public PrivacyList getActiveList()

  Returns the Privacy list that overrides the default privacy list. This list affects only this session and only for the duration of the session.

  Specified by:
    `getActiveList` in interface `ClientSession`
  Returns:
    the Privacy list that overrides the default privacy list.

### setActiveList

    public void setActiveList(PrivacyList activeList)

  Sets the Privacy list that overrides the default privacy list. This list affects only this session and only for the duration of the session.

  Specified by:
    `setActiveList` in interface `ClientSession`
  Parameters:
    `activeList` - the Privacy list that overrides the default privacy list.

### getDefaultList

    public PrivacyList getDefaultList()

  Returns the default Privacy list used for the session's user. This list is processed if there is no active list set for the session.

  Specified by:
    `getDefaultList` in interface `ClientSession`
  Returns:
    the default Privacy list used for the session's user.

### setDefaultList

    public void setDefaultList(PrivacyList defaultList)

  Sets the default Privacy list used for the session's user. This list is processed if there is no active list set for the session.

  Specified by:
    `setDefaultList` in interface `ClientSession`
  Parameters:
    `defaultList` - the default Privacy list used for the session's user.

### getUsername

    public String getUsername()
                       throws UserNotFoundException

  Returns the username associated with this session. Use this information with the user manager to obtain the user based on username.

  Specified by:
    `getUsername` in interface `ClientSession`
  Returns:
    the username associated with this session
  Throws:
    `UserNotFoundException` - if a user is not associated with a session (the session has not authenticated yet)

### setAuthToken

    public void setAuthToken(AuthToken auth)

  Sets the new Authorization Token for this session. The session is not yet considered fully authenticated (i.e. active) since a resource has not been binded at this point. This message will be sent after SASL authentication was successful but yet resource binding is required.

  Parameters:
    `auth` - the authentication token obtained from SASL authentication.

### setAuthToken

    public void setAuthToken(AuthToken auth,
                             String resource)

  Initialize the session with a valid authentication token and resource name. This automatically upgrades the session's status to authenticated and enables many features that are not available until authenticated (obtaining managers for example).

  Parameters:
    `auth` - the authentication token obtained from the AuthFactory.
    `resource` - the resource this session authenticated under.

### setAnonymousAuth

    public void setAnonymousAuth()

  Initialize the session as an anonymous login. This automatically upgrades the session's status to authenticated and enables many features that are not available until authenticated (obtaining managers for example).

### getAuthToken

    public AuthToken getAuthToken()

  Returns the authentication token associated with this session.

  Returns:
    the authentication token associated with this session (can be null).

### isAnonymousUser

    public boolean isAnonymousUser()

  Description copied from interface: `ClientSession`
  Returns true if the authetnicated user is an anonymous user or if the use has not authenticated yet.

  Specified by:
    `isAnonymousUser` in interface `ClientSession`
  Returns:
    true if the authetnicated user is an anonymous user or if the use has not authenticated yet.

### isInitialized

    public boolean isInitialized()

  Flag indicating if this session has been initialized once coming online. Session initialization occurs after the session receives the first "available" presence update from the client. Initialization actions include pushing offline messages, presence subscription requests, and presence statuses to the client. Initialization occurs only once following the first available presence transition.

  Specified by:
    `isInitialized` in interface `ClientSession`
  Returns:
    True if the session has already been initializsed

### setInitialized

    public void setInitialized(boolean isInit)

  Sets the initialization state of the session.

  Specified by:
    `setInitialized` in interface `ClientSession`
  Parameters:
    `isInit` - True if the session has been initialized
  See Also:
    `isInitialized()`

### wasAvailable

    public boolean wasAvailable()

  Returns true if the session was available ever.

  Returns:
    true if the session was available ever.

### canFloodOfflineMessages

    public boolean canFloodOfflineMessages()

  Returns true if the offline messages of the user should be sent to the user when the user becomes online. If the user sent a disco request with node "http://jabber.org/protocol/offline" before the available presence then do not flood the user with the offline messages. If the user is connected from many resources then if one of the sessions stopped the flooding then no session should flood the user.

  Specified by:
    `canFloodOfflineMessages` in interface `ClientSession`
  Returns:
    true if the offline messages of the user should be sent to the user when the user becomes online.

### isOfflineFloodStopped

    public boolean isOfflineFloodStopped()

  Returns true if the user requested to not receive offline messages when sending an available presence. The user may send a disco request with node "http://jabber.org/protocol/offline" so that no offline messages are sent to the user when he becomes online. If the user is connected from many resources then if one of the sessions stopped the flooding then no session should flood the user.

  Specified by:
    `isOfflineFloodStopped` in interface `ClientSession`
  Returns:
    true if the user requested to not receive offline messages when sending an available presence.

### setOfflineFloodStopped

    public void setOfflineFloodStopped(boolean offlineFloodStopped)

  Sets if the user requested to not receive offline messages when sending an available presence. The user may send a disco request with node "http://jabber.org/protocol/offline" so that no offline messages are sent to the user when he becomes online. If the user is connected from many resources then if one of the sessions stopped the flooding then no session should flood the user.

  Parameters:
    `offlineFloodStopped` - if the user requested to not receive offline messages when sending an available presence.

### getPresence

    public Presence getPresence()

  Obtain the presence of this session.

  Specified by:
    `getPresence` in interface `ClientSession`
  Returns:
    The presence of this session or null if not authenticated

### setPresence

    public void setPresence(Presence presence)

  Set the presence of this session

  Specified by:
    `setPresence` in interface `ClientSession`
  Parameters:
    `presence` - The presence for the session

### getConflictCount

    public int getConflictCount()

  Returns the number of conflicts detected on this session. Conflicts typically occur when another session authenticates properly to the user account and requests to use a resource matching the one in use by this session. Administrators may configure the server to automatically kick off existing sessions when their conflict count exceeds some limit including 0 (old sessions are kicked off immediately to accommodate new sessions). Conflicts typically signify the existing (old) session is broken/hung.

  Specified by:
    `getConflictCount` in interface `ClientSession`
  Returns:
    The number of conflicts detected for this session

### getAvailableStreamFeatures

    public String getAvailableStreamFeatures()

  Description copied from class: `LocalSession`
  Returns a text with the available stream features. Each subclass may return different values depending whether the session has been authenticated or not.

  Specified by:
    `getAvailableStreamFeatures` in class `LocalSession`
  Returns:
    a text with the available stream features or `null` to add nothing.

### incrementConflictCount

    public void incrementConflictCount()

  Increments the conflict by one.

  Specified by:
    `incrementConflictCount` in interface `ClientSession`

### canProcess

    public boolean canProcess(Packet packet)

  Returns true if the specified packet must not be blocked based on the active or default privacy list rules. The active list will be tried first. If none was found then the default list is going to be used. If no default list was defined for this user then allow the packet to flow.

  Parameters:
    `packet` - the packet to analyze if it must be blocked.
  Returns:
    true if the specified packet must be blocked.

### toString

    public String toString()

  Overrides:
    `toString` in class `LocalSession`

Overview | Package | Class | Tree | Deprecated | Index | Help
| Openfire 3.4.4 Javadoc
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2003-2007 Jive Software.