retronetworking
/
yate
12
0
Fork 2
Code Issues Pull Requests Projects Releases Wiki Activity
yate/libs/yjingle/yatejabber.h

1908 lines
60 KiB
C++
Raw Blame History

/**
* yatejabber.h
* Yet Another Jabber Component Protocol Stack
* This file is part of the YATE Project http://YATE.null.ro
*
* Yet Another Telephony Engine - a fully featured software PBX and IVR
* Copyright (C) 2004-2006 Null Team
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#ifndef __YATEJABBER_H
#define __YATEJABBER_H
#include <xmpputils.h>
#include <xmlparser.h>
/**
* Holds all Telephony Engine related classes.
*/
namespace TelEngine {
class JBEvent;
class JBComponentStream;
class JBServerInfo;
class JBEngine;
class JBClient;
class JBPresence;
class JIDResource;
class JIDResourceList;
class XMPPUser;
class XMPPUserRoster;
/**
* This class holds a Jabber Component stream event.
* @short A Jabber Component event.
*/
class YJINGLE_API JBEvent : public RefObject
{
friend class JBComponentStream;
public:
enum Type {
// Stream events
Terminated = 1, // Stream terminated. Try to connect
Destroy = 2, // Stream is destroying
// Result events
WriteFail = 10, // Write failed
// m_element is the element
// m_id is the id set by the sender
// Stanza events
Presence = 20, // m_element is a 'presence' stanza
Message = 30, // m_element is a 'message' stanza
Iq = 50, // m_element is an unknown 'iq' element
// m_child may be an unexpected element
IqError = 51, // m_element is an 'iq' error
// m_child is the 'error' child if any
IqResult = 52, // m_element is an 'iq' result
IqDiscoGet = 60, // m_element is an 'iq' get
// m_child is a 'query' element qualified by
// XMPPNamespace::DiscoInfo namespace
IqDiscoSet = 61, // m_element is an 'iq' set
// m_child is a 'query' element qualified by
// XMPPNamespace::DiscoInfo namespace
IqDiscoRes = 62, // m_element is an 'iq' result
// m_child is a 'query' element qualified by
// XMPPNamespace::DiscoInfo namespace
IqCommandGet = 70, // m_element is an 'iq' of type get
// m_child is a 'command' element qualified by
// XMPPNamespace::Command namespace
IqCommandSet = 71, // m_element is an 'iq' of type set
// m_child is a 'command' element qualified by
// XMPPNamespace::Command namespace
IqCommandRes = 72, // m_element is an 'iq' result
// m_child is a 'command' element qualified by
// XMPPNamespace::Command namespace
IqJingleGet = 100, // m_element is an 'iq' get
// m_child is a 'jingle' element
IqJingleSet = 101, // m_element is an 'iq' set
// m_child is a 'jingle' element
// Invalid
Unhandled = 200, // m_element is an unhandled element
Invalid = 500, // m_element is 0
};
/**
* Destructor.
* Delete the XML element if valid.
*/
virtual ~JBEvent();
/**
* Get the event type.
* @return the type of this event as enumeration.
*/
inline Type type() const
{ return m_type; }
/**
* Get the element's 'type' attribute if any.
* @return The element's 'type' attribute.
*/
inline const String& stanzaType() const
{ return m_stanzaType; }
/**
* Get the 'from' data.
* @return The 'from' data.
*/
inline const String& from() const
{ return m_from; }
/**
* Get the 'to' data.
* @return The 'to' data.
*/
inline const String& to() const
{ return m_to; }
/**
* Get the 'id' data.
* @return The 'id' data.
*/
inline const String& id() const
{ return m_id; }
/**
* Get the stream.
* @return The stream.
*/
inline JBComponentStream* stream() const
{ return m_stream; }
/**
* Get the underlying XMLElement.
* @return XMLElement pointer or 0.
*/
inline XMLElement* element() const
{ return m_element; }
/**
* Get the first child of the underlying element if any.
* @return XMLElement pointer or 0.
*/
inline XMLElement* child() const
{ return m_child; }
/**
* Get the underlying XMLElement. Release the ownership.
* The caller is responsable of returned pointer.
* @return XMLElement pointer or 0.
*/
inline XMLElement* releaseXML() {
XMLElement* tmp = m_element;
m_element = 0;
return tmp;
}
/**
* Release the link with the stream to let the stream continue with events.
*/
void releaseStream();
protected:
/**
* Constructor.
* Constructs an internal stream event.
* @param type Type of this event.
* @param stream The stream that generated the event.
*/
JBEvent(Type type, JBComponentStream* stream);
/**
* Constructor.
* Constructs an event from a stream.
* @param type Type of this event.
* @param stream The stream that generated the event.
* @param element Element that generated the event.
* @param child Optional type depending element's child.
*/
JBEvent(Type type, JBComponentStream* stream,
XMLElement* element, XMLElement* child = 0);
/**
* Constructor.
* Constructs a WriteSuccess/WriteFail event from a stream.
* @param type Type of this event.
* @param stream The stream that generated the event.
* @param element Element that generated the event.
* @param senderID Sender's id.
*/
JBEvent(Type type, JBComponentStream* stream, XMLElement* element,
const String& senderID);
private:
JBEvent() {} // Don't use it!
bool init(JBComponentStream* stream, XMLElement* element);
Type m_type; // Type of this event
JBComponentStream* m_stream; // The stream that generated this event
bool m_link; // Stream link state
XMLElement* m_element; // Received XML element, if any
XMLElement* m_child; // The first child element for 'iq' elements
String m_stanzaType; // Stanza's 'type' attribute
String m_from; // Stanza's 'from' attribute
String m_to; // Stanza's 'to' attribute
String m_id; // Sender's id for Write... events
// 'id' attribute if the received stanza has one
};
/**
* This class holds a Jabber Component stream (implements the Jabber Component Protocol).
* @short A Jabber Component stream.
*/
class YJINGLE_API JBComponentStream : public RefObject, public Mutex
{
public:
friend class JBEngine;
public:
/**
* Stream state enumeration.
*/
enum State {
WaitToConnect, // Outgoing stream is waiting for the socket to connect
Started, // Stream start sent
Auth, // Authentication (handshake) sent
Running, // Authenticated. Allow any XML element to pass over the stream
Terminated, // Stream is terminated. Wait to be restarted or destroyed
Destroy, // Stream is destroying. No more traffic allowed
};
/**
* Values returned by send() methods.
*/
enum Error {
ErrorNone = 0, // No error
ErrorContext, // Invalid stream context (state) or parameters.
ErrorPending, // The operation is pending in the stream's queue.
ErrorNoSocket, // Unrecoverable socket error.
// The stream will be terminated.
};
/**
* Destructor.
* Close the stream and the socket.
*/
virtual ~JBComponentStream();
/**
* Get the stream state.
* @return The stream state as enumeration.
*/
inline State state() const
{ return m_state; }
/**
* Get the local name.
* @return The local name.
*/
inline const String& localName() const
{ return m_localName; }
/**
* Get the remote server name.
* @return The remote server name.
*/
inline const String& remoteName() const
{ return m_remoteName; }
/**
* Get the local name.
* @return The local name.
*/
inline const SocketAddr& remoteAddr() const
{ return m_remoteAddr; }
/**
* Get the stream id.
* @return The stream id.
*/
inline const String& id() const
{ return m_id; }
/**
* Get the stream's connection.
* @return The stream connection's pointer.
*/
inline JBEngine* engine() const
{ return m_engine; }
/**
* Connect the stream to the server.
*/
void connect();
/**
* Cleanup the stream. Terminate/Destroy it. Raise the appropriate event.
* This method is thread safe.
* @param destroy True to destroy. False to terminate.
* @param sendEnd True to send stream termination tag.
* @param error Optional XML element to send before termination tag.
* @param sendError True to send the error element.
*/
void terminate(bool destroy, bool sendEnd = false,
XMLElement* error = 0, bool sendError = false);
/**
* Read data from socket and pass it to the parser.
* Raise event on bad XML.
* This method is thread safe.
* @return True if data was received.
*/
bool receive();
/**
* Send a stanza.
* This method is thread safe.
* @param stanza Element to send.
* @param senderId Optional sender's id. Used for notification events.
* @return The result of posting the stanza.
*/
Error sendStanza(XMLElement* stanza, const char* senderId = 0);
/**
* Extract an element from parser and construct an event.
* This method is thread safe.
* @param time Current time.
* @return XMPPEvent pointer or 0.
*/
JBEvent* getEvent(u_int64_t time);
/**
* Cancel pending outgoing elements.
* @param raise True to raise WriteFail events.
* @param id Optional 'id' to cancel. 0 to cancel all elements without id.
*/
void cancelPending(bool raise, const String* id = 0);
/**
* Event termination notification.
* @param event The notifier. Must be m_lastEvent.
*/
void eventTerminated(const JBEvent* event);
protected:
/**
* Constructor.
* Constructs an outgoing stream.
* @param engine The engine that owns this stream.
* @param remoteName The remote domain name.
* @param remoteAddr The remote address to connect.
*/
JBComponentStream(JBEngine* engine, const String& remoteName,
const SocketAddr& remoteAddr);
/**
* Send data without passing it through the outgoing queue.
* Change state if operation succeeds. Terminate stream if it fails.
* This method is thread safe.
* @param element The XML element to send.
* @param newState The new state if the operation succeeds.
* @param before Optional XML element to send before element.
* @return False if the write operation fails.
*/
bool sendStreamXML(XMLElement* element, State newState,
XMLElement* before = 0);
/**
* Send a 'stream:error' element. Terminate the stream.
* @param error The XMPP defined condition.
* @param text Optional text to add to the error.
*/
inline void sendStreamError(XMPPError::Type error, const char* text = 0)
{ terminate(false,true,XMPPUtils::createStreamError(error,text)); }
/**
* Send an 'iq' of type 'error'.
* @param stanza Element that generated the error.
* @param eType The error type.
* @param eCond The error condition.
* @param eText Optional text to add to the error stanza.
* @return The result of posting the stanza.
*/
Error sendIqError(XMLElement* stanza, XMPPError::ErrorType eType,
XMPPError::Type eCond, const char* eText = 0);
/**
* Cleanup stream.
* Remove the first element from the outgoing list if partially sent.
* Send stream termination tag if requested.
* Cancel all outgoing elements without id. Destroy the socket.
* This method is thread safe.
* @param endStream True to send stream termination tag.
* @param element Optional element to send before.
*/
void cleanup(bool endStream, XMLElement* element = 0);
/**
* Post an XMLElement in the outgoing queue. Send the first element in the queue.
* This method is thread safe.
* @param element The XMLElementOut to post.
* @return ErrorNone, ErrorContext, ErrorPending, ErrorNoSocket.
*/
Error postXML(XMLElementOut* element);
/**
* Send the first element from the outgoing queue if state is Running.
* Raise WriteFail event if operation fails. Adjust buffer on partial writes.
* @return ErrorNone, ErrorContext, ErrorPending, ErrorNoSocket.
*/
Error sendXML();
/**
* Process the received XML elements. Validate them. Add events.
* @return True if generated any event(s).
*/
bool processIncomingXML();
/**
* Process a received element in state Started.
* @param e The element to process.
* @return True if generated any event(s).
*/
bool processStateStarted(XMLElement* e);
/**
* Process a received element in state Auth.
* @param e The element to process.
* @return True if generated any event(s).
*/
bool processStateAuth(XMLElement* e);
/**
* Process a received element in state Running.
* @param e The element to process.
* @return True if generated any event(s).
*/
bool processStateRunning(XMLElement* e);
/**
* Process a received 'iq' element.
* @param e The element to process.
* @return True if generated any event(s).
*/
bool processIncomingIq(XMLElement* e);
/**
* Add an event to the list.
* @param type Event type.
* @param element Optional XML element.
* @param child Optional child element.
* @return The added event.
*/
JBEvent* addEvent(JBEvent::Type type, XMLElement* element = 0,
XMLElement* child = 0);
/**
* Add a notification event to the list if the element has an id.
* Remove the element from the outgoing queue.
* @param type Event type.
* @param element XMLElementOut element that generated the event.
* @return True if the event was added.
*/
bool addEventNotify(JBEvent::Type type, XMLElementOut* element);
/**
* Actions to take when an invalid element is received.
* Delete element. Send a stream error to remote peer. Raise a Terminated event.
* @param e The invalid element.
* @param type Stream error type.
* @param text Optional text to add to the stream error.
* @return True.
*/
bool invalidElement(XMLElement* e, XMPPError::Type type,
const char* text = 0);
/**
* Actions to take when an unexpected element is received.
* Delete element.
* @param e The unexpected element.
* @return False.
*/
bool unexpectedElement(XMLElement* e);
/**
* Check if a given element is a termination one (stream error or stream end).
* Raise a Terminated event if so.
* If true is returned the element is still valid.
* @param e The element to check.
* @return True if a Terminated event was raised.
*/
bool isStreamEnd(XMLElement* e);
/**
* Read data from socket and pass it to the parser. Terminate on error.
* @param data The destination buffer.
* @param len The maximum number of bytes to read. Bytes read on exit.
* @return True if data was received.
*/
bool readSocket(char* data, u_int32_t& len);
/**
* Write data to socket. Terminate on error.
* @param data The source buffer.
* @param len The buffer length on input. Bytes written on output.
* @return False on socket error. State is Terminated on unrecoverable socket error.
*/
bool writeSocket(const char* data, u_int32_t& len);
private:
JBComponentStream() {} // Don't use it!
// State
State m_state; // Stream state
// Info
String m_id; // Stream id
String m_localName; // Local name received from the remote peer
String m_remoteName; // Remote peer's domain name
SocketAddr m_remoteAddr; // Socket's address
String m_password; // Password used for authentication
// Data
JBEngine* m_engine; // The owner of this stream
Socket* m_socket; // The socket used by this stream
XMLParser m_parser; // XML parser
Mutex m_receiveMutex; // Ensure serialization of received data
ObjList m_outXML; // Outgoing XML elements
ObjList m_events; // Event queue
JBEvent* m_lastEvent; // Last generated event
JBEvent* m_terminateEvent; // Destroy/Terminate event
};
/**
* This class holds info about a component server used by the Jabber engine.
* @short Server info.
*/
class YJINGLE_API JBServerInfo : public RefObject
{
public:
inline JBServerInfo(const char* name, const char* address, int port,
const char* password, const char* identity, const char* fullidentity,
bool roster, bool autoRestart, u_int32_t restartCount)
: m_name(name), m_address(address), m_port(port), m_password(password),
m_identity(identity), m_fullIdentity(fullidentity), m_roster(roster),
m_autoRestart(autoRestart), m_restartCount(restartCount)
{}
virtual ~JBServerInfo() {}
inline const String& address() const
{ return m_address; }
inline const String& name() const
{ return m_name; }
inline const int port() const
{ return m_port; }
inline const String& password() const
{ return m_password; }
inline const String& identity() const
{ return m_identity; }
inline const String& fullIdentity() const
{ return m_fullIdentity; }
inline bool roster() const
{ return m_roster; }
inline bool autoRestart() const
{ return m_autoRestart; }
inline u_int32_t restartCount() const
{ return m_restartCount; }
inline void incRestart()
{ m_restartCount++; }
inline bool getRestart() {
if (!restartCount())
return false;
m_restartCount--;
return true;
}
private:
String m_name; // Domain name
String m_address; // IP address
int m_port; // Port
String m_password; // Authentication data
String m_identity; // Identity. Used for Jabber Component protocol
String m_fullIdentity; // Full identity for this server
bool m_roster; // Keep roster for this server
bool m_autoRestart; // Automatically restart stream
u_int32_t m_restartCount; // Restart counter
};
/**
* This class holds a Jabber engine.
* @short A Jabber engine.
*/
class YJINGLE_API JBEngine : public DebugEnabler, public Mutex, public RefObject
{
friend class JBEvent;
friend class JBComponentStream;
friend class JBClient;
friend class JBPresence;
public:
/**
* Jabber protocol type.
*/
enum Protocol {
Component, // Use Jabber Component protocol
};
/**
* Constructor.
* Constructs a Jabber engine.
*/
JBEngine();
/**
* Destructor.
*/
virtual ~JBEngine();
/**
* Get the Jabber protocol this engine is using.
* @return The Jabber protocol as enumeration.
*/
inline Protocol jabberProtocol() const
{ return Component; }
/**
* Initialize the engine's parameters.
* Parameters:
* stream_restartupdateinterval : int Interval to update (increase) the stream restart counter. Defaults to 15000.
* stream_restartcount : int Max stream restart counter. Defaults to 4.
* xmlparser_maxbuffer : int The maximum allowed xml buffer length. Defaults to 8192.
* @param params Engine's parameters.
*/
void initialize(const NamedList& params);
/**
* Terminate all stream.
*/
void cleanup();
/**
* Set the default component server to use.
* The domain must be in the server list.
* Choose the first one from the server list if the given one doesn't exists.
* @param domain Domain name of the server.
*/
void setComponentServer(const char* domain);
/**
* Get the default component server.
* @return The default component server.
*/
const String& componentServer()
{ return m_componentDomain; }
/**
* Set the alternate domain name
* @param domain Name of an acceptable alternate domain
*/
inline void setAlternateDomain(const char* domain = 0)
{ m_alternateDomain = domain; }
/**
* Get the default stream restart count.
* @return The default stream restart count.
*/
inline u_int32_t restartCount() const
{ return m_restartCount; }
/**
* Get the default resource name.
* @return The default resource name.
*/
inline const String& defaultResource() const
{ return m_defaultResource; }
/**
* Check if a sender or receiver of XML elements should print them to output.
* @return True to print XML element to output.
*/
inline bool printXml() const
{ return m_printXml; }
/**
* Set/reset print XML elements to output permission.
* @param print True to allow XML elements printing to output.
*/
inline void printXml(bool print)
{ m_printXml = print; }
/**
* Check if a stream to the given server exists.
* If the stream doesn't exists creates it.
* This method is thread safe.
* @param domain The domain name to check. 0 to use the default server.
* @param create True to create a stream to the specified domain if none exists.
* @return Pointer to a JBComponentStream or 0.
*/
JBComponentStream* getStream(const char* domain = 0, bool create = true);
/**
* Keep calling receive() for each stream until no data is received.
* @return True if data was received.
*/
bool receive();
/**
* Keep calling receive().
*/
void runReceive();
/**
* Get events from the streams owned by this engine.
* This method is thread safe.
* @param time Current time.
* @return JBEvent pointer or 0.
*/
JBEvent* getEvent(u_int64_t time);
/**
* Check if an outgoing stream exists with the same id and remote peer.
* @param stream The calling stream.
* @return True if found.
*/
bool remoteIdExists(const JBComponentStream* stream);
/**
* Create an SHA1 value from 'id' + 'password'.
* @param sha Destination string.
* @param id First element (stream id).
* @param password The second element (stream password).
*/
void createSHA1(String& sha, const String& id, const String& password);
/**
* Check if a received value is correct.
* @param sha Destination string.
* @param id First element (stream id).
* @param password The second element (stream password).
* @return True if equal.
*/
bool checkSHA1(const String& sha, const String& id, const String& password);
/**
* Called to update time dependent values
* @param time Current time.
*/
virtual void timerTick(u_int64_t time);
/**
* Call the connect method of the given stream.
* @param stream The stream to connect.
* @return False if stream is 0.
*/
virtual bool connect(JBComponentStream* stream);
/**
* Return a non processed event to this engine.
* @param event The returned event.
*/
virtual void returnEvent(JBEvent* event);
/**
* Accept an outgoing stream. If accepted, deliver a password.
* @param remoteAddr The remote address.
* @param password Password to use.
* @return True if accepted. False to terminate the stream.
*/
virtual bool acceptOutgoing(const String& remoteAddr, String& password);
/**
* Deliver a port for an outgoing connection.
* @param remoteAddr The remote address.
* @return True if accepted. False to terminate the stream.
*/
virtual int getPort(const String& remoteAddr);
/**
* Check if the process is terminating.
* @return True if the process is terminating.
*/
virtual bool exiting()
{ return false; }
/**
* Append a servr info element to the list.
* @param server The object to add.
* @param open True to open the stream.
*/
void appendServer(JBServerInfo* server, bool open);
/**
* Find server info object.
* @param token The search string. If 0 the default server will be used.
* @param domain True to find by domain name. False to find by address.
* @return Referenced JBServerInfo pointer or 0.
*/
JBServerInfo* getServer(const char* token = 0, bool domain = true);
/**
* Get the identity of the given server for a component server.
* @param destination The destination.
* @param token The search string. If 0 the default server will be used.
* @param domain True to find by domain name. False to find by address.
* @return False if server doesn't exists.
*/
bool getServerIdentity(String& destination, const char* token = 0,
bool domain = true);
/**
* Get the full identity of the given server.
* @param destination The destination.
* @param token The search string. If 0 the default server will be used.
* @param domain True to find by domain name. False to find by address.
* @return False if server doesn't exists.
*/
bool getFullServerIdentity(String& destination, const char* token = 0,
bool domain = true);
/**
* Get the name of the alternate domain - if any
* @return Alternate domain name, empty string if not set
*/
inline const String& getAlternateDomain() const
{ return m_alternateDomain; }
/**
* Check if a stream to a remote server can be restarted.
* If true is returned, the stream restart counter has been decreased.
* @param token The remote server name or address.
* @param domain True to find by domain name. False to find by address.
* @return False if server doesn't exists.
*/
bool getStreamRestart(const char* token, bool domain = true);
protected:
/**
* Process a DiscoInfo event.
* @param event The received event.
* @return True if processed.
*/
bool processDiscoInfo(JBEvent* event);
/**
* Process a Command event.
* @param event The received event.
* @return True if processed.
*/
bool processCommand(JBEvent* event);
/**
* Check if a stream with a given remote address exists.
* @param remoteName The remote address to find.
* @return Stream pointer or 0.
*/
JBComponentStream* findStream(const String& remoteName);
/**
* Remove a stream from the list.
* @param stream The stream to remove.
* @param del Delete flag. If true the stream will be deleted.
*/
void removeStream(JBComponentStream* stream, bool del);
/**
* Add a client to this engine if not in it.
* @param client The client to add.
*/
void addClient(JBClient* client);
/**
* Remove a client to this engine if not in it.
* @param client The client to remove.
*/
void removeClient(JBClient* client);
/**
* Clear the server list.
*/
inline void clearServerList()
{ Lock lock(m_serverMutex); m_server.clear(); }
/**
* Process a message event.
* @param event The event to process. Always a valid message event.
* @return True if the event was processed (kept). False to destroy it.
*/
virtual bool processMessage(JBEvent* event);
private:
void processEventNew(JBEvent* event);
void processEventAuth(JBEvent* event);
bool getServerPassword(String& destination, const char* token = 0,
bool domain = true);
bool getServerPort(int& destination, const char* token = 0,
bool domain = true);
void setPresenceServer(JBPresence* presence);
void unsetPresenceServer(JBPresence* presence);
ObjList m_streams; // Streams belonging to this engine
Mutex m_clientsMutex; // Lock clients list
ObjList m_clients; // XMPP clients list
JBPresence* m_presence; // The presence server
JIDIdentity* m_identity; // Engine's identity
JIDFeatureList m_features; // Engine's features
u_int64_t m_restartUpdateTime; // Time to update the restart counter of all streams
u_int32_t m_restartUpdateInterval; // Update interval for restart counter of all streams
u_int32_t m_restartCount; // The default restart counter value
bool m_printXml; // Print XML data to output
// ID generation data
u_int64_t m_streamID; // Stream id counter
// Server list
String m_componentDomain; // Default server domain name
String m_componentAddr; // Default server address
ObjList m_server; // Server list
Mutex m_serverMutex; // Lock server list
String m_alternateDomain; // Alternate acceptable domain
// Misc
String m_defaultResource; // Default name for missing resources
};
/**
* This class is the base class for a Jabber client who wants
* to deliver protocol specific data to the engine.
* @short An Jabber client.
*/
class YJINGLE_API JBClient : public RefObject
{
public:
/**
* Constructor.
* @param engine The Jabber engine.
*/
JBClient(JBEngine* engine);
/**
* Destructor.
*/
virtual ~JBClient();
/**
* Get the Jabber engine.
* @return The Jabber engine.
*/
JBEngine* engine()
{ return m_engine; }
protected:
JBEngine* m_engine; // The Jabber Component engine
private:
inline JBClient() {} // Don't use it !
};
/**
* This class is the presence server for Jabber.
* @short A Jabber presence server.
*/
class YJINGLE_API JBPresence : public DebugEnabler, public JBClient, public Mutex
{
friend class XMPPUserRoster;
public:
/**
* Presence enumeration.
*/
enum Presence {
Error, // error
Probe, // probe
Subscribe, // subscribe request
Subscribed, // subscribe accepted
Unavailable, // unavailable
Unsubscribe, // unsubscribe request
Unsubscribed, // unsubscribe accepted
None,
};
/**
* Constructor.
* Constructs an Jabber Component presence server.
* @param engine The Jabber Component engine.
* @param params Engine's parameters.
*/
JBPresence(JBEngine* engine, const NamedList& params);
/**
* Destructor.
*/
virtual ~JBPresence();
/**
* Get the auto subscribe parameter.
* @return The auto subscribe parameter.
*/
inline int autoSubscribe() const
{ return m_autoSubscribe; }
/**
* Check if the unavailable resources must be deleted.
* @return The delete unavailable parameter.
*/
inline bool delUnavailable() const
{ return m_delUnavailable; }
/**
* Check if this server should add new users when receiving subscribe stanzas.
* @return True if should add a new user.
*/
inline bool addOnSubscribe() const
{ return m_addOnSubscribe; }
/**
* Check if this server should add new users when receiving presence probes.
* @return True if should add a new user.
*/
inline bool addOnProbe() const
{ return m_addOnProbe; }
/**
* Check if this server should add new users when receiving presence.
* @return True if should add a new user
*/
inline bool addOnPresence() const
{ return m_addOnPresence; }
/**
* Get the probe interval. Time to send a probe if nothing was received from that user.
* @return The probe interval.
*/
inline u_int32_t probeInterval()
{ return m_probeInterval; }
/**
* Get the expire after probe interval.
* @return The expire after probe interval.
*/
inline u_int32_t expireInterval()
{ return m_expireInterval; }
/**
* Initialize the engine.
* @param params Engine's parameters.
*/
void initialize(const NamedList& params);
/**
* Add an event to the list.
* This method is thread safe.
* @param event The event to add.
* @return False if the event is not a Presence one.
*/
bool receive(JBEvent* event);
/**
* Process an event from the receiving list.
* This method is thread safe.
* @return False if the list is empty.
*/
bool process();
/**
* Keep calling process().
*/
void runProcess();
/**
* Process disco info elements.
* @param event The event with the element.
* @param local The local (destination) user.
* @param remote The remote (source) user.
*/
virtual void processDisco(JBEvent* event, const JabberID& local,
const JabberID& remote);
/**
* Process a presence error element.
* @param event The event with the element.
* @param local The local (destination) user.
* @param remote The remote (source) user.
*/
virtual void processError(JBEvent* event, const JabberID& local,
const JabberID& remote);
/**
* Process a presence probe element.
* @param event The event with the element.
* @param local The local (destination) user.
* @param remote The remote (source) user.
*/
virtual void processProbe(JBEvent* event, const JabberID& local,
const JabberID& remote);
/**
* Process a presence subscribe element.
* @param event The event with the element.
* @param presence Presence type: Subscribe,Subscribed,Unsubscribe,Unsubscribed.
* @param local The local (destination) user.
* @param remote The remote (source) user.
*/
virtual void processSubscribe(JBEvent* event, Presence presence,
const JabberID& local, const JabberID& remote);
/**
* Process a presence unavailable element.
* @param event The event with the element.
* @param local The local (destination) user.
* @param remote The remote (source) user.
*/
virtual void processUnavailable(JBEvent* event, const JabberID& local,
const JabberID& remote);
/**
* Process a presence element.
* @param event The event with the element.
* @param local The local (destination) user.
* @param remote The remote (source) user.
*/
virtual void processPresence(JBEvent* event, const JabberID& local,
const JabberID& remote);
/**
* Notify on probe request with users we don't know about.
* @param event The event with the element.
* @param local The local (destination) user.
* @param remote The remote (source) user.
* @return False to send item-not-found error.
*/
virtual bool notifyProbe(JBEvent* event, const JabberID& local,
const JabberID& remote);
/**
* Notify on subscribe event with users we don't know about.
* @param event The event with the element.
* @param local The local (destination) user.
* @param remote The remote (source) user.
* @param presence Presence type: Subscribe,Subscribed,Unsubscribe,Unsubscribed.
* @return False to send item-not-found error.
*/
virtual bool notifySubscribe(JBEvent* event,
const JabberID& local, const JabberID& remote, Presence presence);
/**
* Notify on subscribe event.
* @param user The user that received the event.
* @param presence Presence type: Subscribe,Subscribed,Unsubscribe,Unsubscribed.
*/
virtual void notifySubscribe(XMPPUser* user, Presence presence);
/**
* Notify on presence event with users we don't know about or presence unavailable
* received without resource (the remote user is entirely unavailable).
* @param event The event with the element.
* @param local The local (destination) user.
* @param remote The remote (source) user.
* @param available The availability of the remote user.
* @return False to send item-not-found error.
*/
virtual bool notifyPresence(JBEvent* event, const JabberID& local,
const JabberID& remote, bool available);
/**
* Notify on state/capabilities change.
* @param user The user that received the event.
* @param resource The resource that changet its state or capabilities.
*/
virtual void notifyPresence(XMPPUser* user, JIDResource* resource);
/**
* Notify when a new user is added.
* Used basically to add a local resource.
* @param user The new user.
*/
virtual void notifyNewUser(XMPPUser* user);
/**
* Get a roster. Add a new one if requested.
* This method is thread safe.
* @param jid The user's jid.
* @param add True to add the user if doesn't exists.
* @param added Optional parameter to be set if a new user was added.
* @return Referenced pointer or 0 if none.
*/
XMPPUserRoster* getRoster(const JabberID& jid, bool add, bool* added);
/**
* Get a remote peer of a local one. Add a new one if requested.
* This method is thread safe.
* @param local The local peer.
* @param remote The remote peer.
* @param addLocal True to add the local user if doesn't exists.
* @param addedLocal Optional parameter to be set if a new local user was added.
* @param addRemote True to add the remote user if doesn't exists.
* @param addedRemote Optional parameter to be set if a new remote user was added.
* @return Referenced pointer or 0 if none.
*/
XMPPUser* getRemoteUser(const JabberID& local, const JabberID& remote,
bool addLocal, bool* addedLocal, bool addRemote, bool* addedRemote);
/**
* Remove a remote peer of a local one.
* This method is thread safe.
* @param local The local peer.
* @param remote The remote peer.
*/
void removeRemoteUser(const JabberID& local, const JabberID& remote);
/**
* Check if the given domain is a valid (known) one.
* @param domain The domain name to check.
* @return True if the given domain is a valid one.
*/
bool validDomain(const String& domain);
/**
* Try to get a stream from Jabber engine if stream parameter is 0.
* @param stream Stream to check.
* @param release Set to true on exit if the caller must deref the stream.
* @return True if stream is valid.
*/
bool getStream(JBComponentStream*& stream, bool& release);
/**
* Send an element through the given stream.
* If the stream is 0 try to get one from the engine.
* In any case the element is consumed (deleted).
* @param element Element to send.
* @param stream The stream to send through.
* @return The result of send operation. False if element is 0.
*/
bool sendStanza(XMLElement* element, JBComponentStream* stream);
/**
* Send an error. Error type is 'modify'.
* If id is 0 sent element will be of type 'presence'. Otherwise: 'iq'.
* @param type The error.
* @param from The from attribute.
* @param to The to attribute.
* @param element The element that generated the error.
* @param stream Optional stream to use.
* @param id Optional id. If present (even if empty) the error element will be of type 'iq'.
* @return The result of send operation.
*/
bool sendError(XMPPError::Type type, const String& from, const String& to,
XMLElement* element, JBComponentStream* stream = 0, const String* id = 0);
/**
* Check timeout.
* This method is thread safe.
* @param time Current time.
*/
void checkTimeout(u_int64_t time);
/**
* Keep calling checkTimeout().
*/
void runCheckTimeout();
/**
* Create an 'presence' element.
* @param from The 'from' attribute.
* @param to The 'to' attribute.
* @param type Presence type as enumeration.
* @return A valid XMLElement pointer.
*/
static XMLElement* createPresence(const char* from,
const char* to, Presence type = None);
/**
* Decode an error element.
* @param element The XML element.
* @param code The 'code' attribute.
* @param type The 'type' attribute.
* @param error The name of the 'error' child.
* @return False if 'element' is 0 or is not a presence one.
*/
static bool decodeError(const XMLElement* element,
String& code, String& type, String& error);
/**
* Get the type of a 'presence' stanza as enumeration.
* @param text The text to check.
* @return Presence type as enumeration.
*/
static inline Presence presenceType(const char* text)
{ return (Presence)lookup(text,s_presence,None); }
/**
* Get the text from a presence type.
* @param presence The presence type.
* @return The associated text or 0.
*/
static inline const char* presenceText(Presence presence)
{ return lookup(presence,s_presence,0); }
/**
* Cleanup rosters.
*/
void cleanup();
protected:
/**
* Check if the given jid has a valid domain. Send error if not.
* @param event The event with element.
* @param jid The destination jid.
* @return True if jid has a valid domain.
*/
bool checkDestination(JBEvent* event, const JabberID& jid);
static TokenDict s_presence[]; // Keep the types of 'presence'
int m_autoSubscribe; // Auto subscribe state
bool m_delUnavailable; // Delete unavailable user or resource
bool m_addOnSubscribe; // Add new user on subscribe request
bool m_addOnProbe; // Add new user on probe request
bool m_addOnPresence; // Add new user on presence
bool m_autoProbe; // Automatically respond to probe requests
u_int32_t m_probeInterval; // Interval to probe a remote user
u_int32_t m_expireInterval; // Expire interval after probe
ObjList m_events; // Incoming events from Jabber engine
ObjList m_rosters; // The rosters
private:
void addRoster(XMPPUserRoster* ur);
void removeRoster(XMPPUserRoster* ur);
};
/**
* This class holds a JID resource (name,presence,capabilities).
* @short A JID resource.
*/
class YJINGLE_API JIDResource : public RefObject
{
public:
/**
* Resource capabilities enumeration.
*/
enum Capability {
CapChat = 1, // Chat capability
CapAudio = 2, // Jingle capability
};
/**
* Resource presence enumeration.
*/
enum Presence {
Unknown = 0, // unknown
Available = 1, // available
Unavailable = 2, // unavailable
};
/**
* Values of the 'show' child of a presence element.
*/
enum Show {
ShowAway, // away : Temporarily away
ShowChat, // chat : Actively interested in chatting
ShowDND, // dnd : Busy
ShowXA, // xa : Extended away
ShowNone, // : Missing or no text
};
/**
* Constructor. Set data members.
* @param name The resource name.
* @param presence The resource presence.
* @param capability The resource capability.
*/
inline JIDResource(const char* name, Presence presence = Unknown,
u_int32_t capability = CapChat)
: m_name(name), m_presence(presence),
m_capability(capability), m_show(ShowNone)
{}
/**
* Destructor.
*/
inline virtual ~JIDResource()
{}
/**
* Get the resource name.
* @return The resource name.
*/
inline const String& name() const
{ return m_name; }
/**
* Get the presence attribute.
* @return The presence attribute.
*/
inline Presence presence() const
{ return m_presence; }
/**
* Check if the resource is available.
* @return True if the resource is available.
*/
inline bool available() const
{ return (m_presence == Available); }
/**
* Get the show attribute as enumeration.
* @return The show attribute as enumeration.
*/
inline Show show() const
{ return m_show; }
/**
* Set the show attribute.
* @param s The new show attribute.
*/
inline void show(Show s)
{ m_show = s; }
/**
* Get the status of this resource.
* @return The status of this resource.
*/
inline const String& status() const
{ return m_status; }
/**
* Set the status of this resource.
* @param s The new status of this resource.
*/
inline void status(const char* s)
{ m_status = s; }
/**
* Set the presence information.
* @param value True if available, False if not.
* @return True if presence changed.
*/
bool setPresence(bool value);
/**
* Check if the resource has the required capability.
* @param capability The required capability.
* @return True if the resource has the required capability.
*/
inline bool hasCap(Capability capability) const
{ return (m_capability & capability); }
/**
* Update resource from a presence element.
* @param element A presence element.
* @return True if presence or capability changed changed.
*/
bool fromXML(XMLElement* element);
/**
* Add capabilities to a presence element.
* @param element The target presence element.
*/
void addTo(XMLElement* element);
/**
* Get the 'show' child of a presence element.
* @param element The XML element.
* @return The text or 0.
*/
static const char* getShow(XMLElement* element);
/**
* Get the 'show' child of a presence element.
* @param element The XML element.
* @return The text or 0.
*/
static const char* getStatus(XMLElement* element);
/**
* Get the type of a 'show' element as enumeration.
* @param text The text to check.
* @return Show type as enumeration.
*/
static inline Show showType(const char* text)
{ return (Show)lookup(text,s_show,ShowNone); }
/**
* Get the text from a show type.
* @param show The type to get text for.
* @return The associated text or 0.
*/
static inline const char* showText(Show show)
{ return lookup(show,s_show,0); }
protected:
static TokenDict s_show[]; // Show texts
private:
String m_name; // Resource name
Presence m_presence; // Resorce presence
u_int32_t m_capability; // Resource capabilities
Show m_show; // Show attribute
String m_status; // Status attribute
};
/**
* This class holds a resource list.
* @short A resource list.
*/
class YJINGLE_API JIDResourceList : public Mutex
{
friend class XMPPUser;
public:
/**
* Constructor.
*/
inline JIDResourceList()
: Mutex(true)
{}
/**
* Add a resource to the list if a resource with the given name
* doesn't exists.
* @param name The resource name.
* @return False if the the resource already exists in the list.
*/
bool add(const String& name);
/**
* Add a resource to the list if a resource with the same doesn't already
* exists. Destroy the received resource if not added.
* @param resource The resource to add.
* @return False if the the resource already exists in the list.
*/
bool add(JIDResource* resource);
/**
* Remove a resource from the list.
* @param resource The resource to remove.
* @param del True to delete the resource.
*/
inline void remove(JIDResource* resource, bool del = true)
{ m_resources.remove(resource,del); }
/**
* Clear the list.
*/
inline void clear()
{ m_resources.clear(); }
/**
* Get a resource with the given name.
* @param name The resource name.
* @return A pointer to the resource or 0.
*/
JIDResource* get(const String& name);
/**
* Get the first resource from the list.
* @return A pointer to the resource or 0.
*/
inline JIDResource* getFirst() {
ObjList* obj = m_resources.skipNull();
return obj ? static_cast<JIDResource*>(obj->get()) : 0;
}
/**
* Get the first resource with audio capability.
* @param availableOnly True to get only if available.
* @return A pointer to the resource or 0.
*/
JIDResource* getAudio(bool availableOnly = true);
private:
ObjList m_resources; // The resources list
};
/**
* This class holds a remote XMPP user along with his resources and subscribe state.
* @short An XMPP remote user.
*/
class YJINGLE_API XMPPUser : public RefObject, public Mutex
{
friend class XMPPUserRoster;
public:
enum Subscription {
None = 0,
To = 1,
From = 2,
Both = 3,
};
/**
* Create a remote user.
* @param local The local (owner) user peer.
* @param node The node (username) of the remote peer.
* @param domain The domain of the remote peer.
* @param sub The subscription state.
* @param subTo True to force a subscribe request to remote peer if not subscribed.
* @param sendProbe True to probe the new user.
*/
XMPPUser(XMPPUserRoster* local, const char* node, const char* domain,
Subscription sub, bool subTo = true, bool sendProbe = true);
/**
* Destructor.
* Send unavailable if not already done.
*/
virtual ~XMPPUser();
/**
* Get the jid of this user.
* @return The jid of this user.
*/
const JabberID& jid() const
{ return m_jid; }
/**
* Get the roster this user belongs to.
* @return Pointer to the roster this user belongs to.
*/
inline XMPPUserRoster* local() const
{ return m_local; }
/**
* Add a local resource to the list.
* Send presence if the remote peer is subscribed to the local one.
* This method is thread safe.
* @param resource The resource to add.
* @return False if the the resource already exists in the list.
*/
bool addLocalRes(JIDResource* resource);
/**
* Remove a local resource from the list.
* Send unavailable if the remote peer is subscribed to the local one.
* This method is thread safe.
* @param resource The resource to remove.
*/
void removeLocalRes(JIDResource* resource);
/**
* Remove all local resources.
* Send unavailable if the remote peer is subscribed to the local one.
* This method is thread safe.
*/
void clearLocalRes();
/**
* Get the first remote resource with audio capability.
* @param local True to request a local resource, false for a remote one.
* @param availableOnly True to get only if available.
* @return A pointer to the resource or 0.
*/
inline JIDResource* getAudio(bool local, bool availableOnly = true) {
return local ? m_localRes.getAudio(availableOnly) :
m_remoteRes.getAudio(availableOnly);
}
/**
* Check if the local user is subscribed to the remote one.
* @return True if the local user is subscribed to the remote one.
*/
inline bool subscribedTo() const
{ return (m_subscription & To); }
/**
* Check if the remote user is subscribed to the local one.
* @return True if the remote user is subscribed to the local one.
*/
inline bool subscribedFrom() const
{ return (m_subscription & From); }
/**
* Process received error elements.
* This method is thread safe.
* @param event The event with the element.
*/
void processError(JBEvent* event);
/**
* Process received probe from remote peer.
* This method is thread safe.
* @param event The event with the element.
* @param resName The probed resource if any.
*/
void processProbe(JBEvent* event, const String* resName = 0);
/**
* Process received presence from remote peer.
* This method is thread safe.
* @param event The event with the element.
* @param available The availability of the user.
* @param from The sender's jid.
* @return False if remote user has no more resources available.
*/
bool processPresence(JBEvent* event, bool available, const JabberID& from);
/**
* Process received subscription from remote peer.
* This method is thread safe.
* @param event The event with the element.
* @param type The subscription type: subscribe/unsubscribe/subscribed/unsubscribed.
*/
void processSubscribe(JBEvent* event, JBPresence::Presence type);
/**
* Probe the remote user.
* This method is thread safe.
* @param stream Optional stream to use to send the request.
* @param time Probe time.
* @return True if send succeedded.
*/
bool probe(JBComponentStream* stream, u_int64_t time = Time::msecNow());
/**
* Send subscription to remote peer.
* This method is thread safe.
* @param type The subscription type: subscribe/unsubscribe/subscribed/unsubscribed.
* @param stream Optional stream to use to send the data.
* @return True if send succeedded.
*/
bool sendSubscribe(JBPresence::Presence type, JBComponentStream* stream);
/**
* Send unavailable to remote peer.
* This method is thread safe.
* @param stream Optional stream to use to send the data.
* @return True if send succeedded.
*/
bool sendUnavailable(JBComponentStream* stream);
/**
* Send presence to remote peer.
* This method is thread safe.
* @param resource The resource to send from.
* @param stream Optional stream to use to send the data.
* @param force True to send even if we've already sent presence from this resource.
* @return True if send succeedded.
*/
bool sendPresence(JIDResource* resource, JBComponentStream* stream = 0, bool force = false);
/**
* Check if this user sent us any presence data for a given interval.
* This method is thread safe.
* @param time Current time.
* @return True if the user timed out.
*/
bool timeout(u_int64_t time);
/**
* Notify the state of a resource.
* This method is thread safe.
* @param remote True for a remote resource: notify the presence engine.
* False for a local resource: send presence to remote user.
* @param name Resource name.
* @param stream Optional stream to use to send the data if remote is false.
* @param force True to send even if we've already sent presence from this resource.
*/
void notifyResource(bool remote, const String& name,
JBComponentStream* stream = 0, bool force = false);
/**
* Notify the state of all resources.
* This method is thread safe.
* @param remote True for remote resources: notify the presence engine.
* False for local resources: send presence to remote user.
* @param stream Optional stream to use to send the data if remote is false.
* @param force True to send even if we've already sent presence from a resource.
*/
void notifyResources(bool remote, JBComponentStream* stream = 0, bool force = false);
/**
* Get the string associated with a subscription enumeration value.
* @param value The subscription enumeration to get string for.
* @return Pointer to the string associated with the given subscription enumeration or 0 if none.
*/
static inline const char* subscribeText(int value)
{ return lookup(value,s_subscription); }
/**
* Get the subscription enumeration value associated with the given string.
* @param value The subscription string.
* @return the subscription as enumeration.
*/
static inline int subscribeType(const char* value)
{ return lookup(value,s_subscription,None); }
protected:
/**
* Update subscription state.
* @param from True for subscription from remote user. False for subscription to the remote user.
* @param value True if subscribed. False is unsubscribed.
* @param stream Optional stream to use to send presence if subscription from remote user changed to true.
*/
void updateSubscription(bool from, bool value, JBComponentStream* stream);
/**
* Update user timeout data.
* @param from True if the update is made on incoming data. False if timeout is made on outgoing probe.
* @param time Current time.
*/
void updateTimeout(bool from, u_int64_t time = Time::msecNow());
/**
* Keep the association between subscription enumeration and strings.
*/
static TokenDict s_subscription[];
private:
XMPPUserRoster* m_local; // Local user
JabberID m_jid; // User's JID
u_int8_t m_subscription; // Subscription state
JIDResourceList m_localRes; // Local user's resources
JIDResourceList m_remoteRes; // Remote user's resources
u_int64_t m_nextProbe; // Time to probe
u_int64_t m_expire; // Expire time
};
/**
* This class holds the roster for a local user.
* @short The roster of a local user.
*/
class YJINGLE_API XMPPUserRoster : public RefObject, public Mutex
{
friend class JBPresence;
friend class XMPPUser;
public:
/**
* Destructor.
* Remove this roster from engine's queue.
*/
virtual ~XMPPUserRoster();
/**
* Get the local user's jid.
* @return The local user's jid.
*/
const JabberID& jid() const
{ return m_jid; }
/**
* Get the presence engine this user belongs to.
* @return Pointer to the presence engine this user belongs to.
*/
JBPresence* engine()
{ return m_engine; }
/**
* Get a remote user.
* This method is thread safe.
* @param jid User's jid.
* @param add True to add if not found.
* @param added Optional flag to set if added a new user.
* @return Referenced pointer to the user or 0.
*/
XMPPUser* getUser(const JabberID& jid, bool add = false, bool* added = 0);
/**
* Remove a remote user.
* This method is thread safe.
* @param remote The user to remove.
* @return False if no more users.
*/
bool removeUser(const JabberID& remote);
/**
* Clear remote user list.
*/
inline void cleanup() {
Lock lock(this);
m_remote.clear();
}
/**
* Check timeout.
* This method is thread safe.
* @param time Current time.
* @return True to remove the roster.
*/
bool timeout(u_int64_t time);
protected:
/**
* Constructor.
* @param engine Pointer to the presence engine this user belongs to.
* @param node User's name.
* @param domain User's domain.
*/
XMPPUserRoster(JBPresence* engine, const char* node, const char* domain);
private:
inline void addUser(XMPPUser* u) {
Lock lock(this);
m_remote.append(u);
}
void removeUser(XMPPUser* u) {
Lock lock(this);
m_remote.remove(u,false);
}
JabberID m_jid; // User's bare JID
ObjList m_remote; // Remote users
JBPresence* m_engine; // Presence engine
};
};
#endif /* __YATEJABBER_H */
/* vi: set ts=8 sw=4 sts=4 noet: */
Reference in New Issue View Git Blame Copy Permalink