yatejingle.h

 
#ifndef __YATEJINGLE_H
#define __YATEJINGLE_H
 
#include <yateclass.h>
#include <yatejabber.h>

namespace TelEngine {
 
class JGRtpMedia;                        // A Jingle RTP data payload
class JGCrypto;                          // Content crypto data
class JGRtpMediaList;                    // A list of Jingle RTP data payloads
class JGRtpCandidate;                    // A RTP transport candidate
class JGRtpCandidates;                   // A list of RTP transport candidates
class JGSessionContent;                  // A Jingle session content
class JGStreamHost;                      // A Jingle file transfer stream host
class JGSession;                         // A basic Jingle session
class JGSession0;                        // A session implementing the old jingle protocol
class JGSession1;                        // The version 1 of a jingle session
class JGEvent;                           // An event generated by a Jingle session
class JGEngine;                          // The Jingle engine
class JGSentStanza;                      // Sent stanza timeout info
 

class YJABBER_API JGRtpMedia : public GenObject
{
public:
    inline JGRtpMedia(const char* id, const char* name, const char* clockrate,
        const char* synonym, const char* channels = 0,
        const char* pTime = 0, const char* maxPTime = 0, const char* bitRate = 0)
        : m_params("")
        { set(id,name,clockrate,synonym,channels,pTime,maxPTime,bitRate); }

    inline JGRtpMedia(XmlElement* xml)
        : m_params("")
        { fromXml(xml); }

    inline JGRtpMedia(const JGRtpMedia& src)
        : m_params("") {
            set(src.m_id,src.m_name,src.m_clockrate,src.m_synonym,src.m_channels,
                src.m_pTime,src.m_maxPTime,src.m_bitRate);
            m_params = src.m_params;
        }

    inline void set(const char* id, const char* name, const char* clockrate,
        const char* synonym = 0, const char* channels = 0,
        const char* pTime = 0, const char* maxPTime = 0, const char* bitRate = 0) {
            m_id = id;
            m_name = name;
            m_clockrate = clockrate;
            m_synonym = synonym;
            m_channels = channels;
            m_pTime = pTime;
            m_maxPTime = maxPTime;
            m_bitRate = bitRate;
            m_params.clearParams();
        }

    virtual const String& toString() const
        { return m_id; }

    XmlElement* toXml() const;

    void fromXml(XmlElement* xml);

    String m_id;

    String m_name;

    String m_clockrate;

    String m_synonym;

    String m_channels;

    String m_pTime;

    String m_maxPTime;

    String m_bitRate;

    NamedList m_params;
};

class YJABBER_API JGCrypto : public String
{
public:
    inline JGCrypto(const char* tag = "1", const char* suite = 0,
        const char* key = 0, const char* session = 0)
        : String(tag),
        m_suite(suite), m_keyParams(key), m_sessionParams(session)
        {}

    inline JGCrypto(const XmlElement* xml)
        { fromXml(xml); }

    XmlElement* toXml() const;

    void fromXml(const XmlElement* xml);

    static XmlElement* buildEncryption(const ObjList& list, bool required);

    static void decodeEncryption(const XmlElement* xml, ObjList& list, bool& required);
 
    String m_suite;
    String m_keyParams;
    String m_sessionParams;
};

class YJABBER_API JGRtpMediaList : public ObjList
{
public:
    enum Media {
        MediaMissing = -1,
        MediaUnknown = 0,
        Audio        = 1,
    };

    inline JGRtpMediaList(Media m = MediaMissing, bool cryptoRequired = false)
        : m_media(m), m_bandwidth(0), m_cryptoRequired(cryptoRequired), m_ready(false),
        m_telEvent(101), m_telEventName("telephone-event")
        {}

    inline ~JGRtpMediaList()
        { TelEngine::destruct(m_bandwidth); }

    inline Media media() const
        { return m_media; }

    inline void add(const char* id, const char* name, const char* clockrate,
        const char* synonym = 0, const char* channels = 0,
        const char* pTime = 0, const char* maxPTime = 0, const char* bitRate = 0)
        { append(new JGRtpMedia(id,name,clockrate,synonym,channels,pTime,maxPTime,bitRate)); }

    void reset();

    void setMedia(const JGRtpMediaList& src, const String& only = String::empty());

    void filterMedia(const String& only);

    JGRtpMedia* findMedia(const String& id);

    JGRtpMedia* findSynonym(const String& value) const;

    XmlElement* toXml() const;

    void fromXml(XmlElement* xml);

    bool createList(String& dest, bool synonym, const char* sep = ",");

    void addTelEvent(XmlElement* xml, const char* name = 0) const;

    static const TokenDict s_media[];

    Media m_media;

    String m_ssrc;

    NamedString* m_bandwidth;

    bool m_cryptoRequired;
    ObjList m_cryptoLocal;
    ObjList m_cryptoRemote;

    bool m_ready;

    int m_telEvent;

    String m_telEventName;

    String m_telEventName2;
};
 

class YJABBER_API JGRtpCandidate : public String
{
public:
    inline JGRtpCandidate(const char* id, const char* component = "1",
        unsigned int generation = 0, unsigned int net = 0, int prio = 0)
        : String(id),
        m_port(0), m_component(component), m_generation(generation),
        m_network(net), m_priority(prio), m_protocol("udp"), m_type("host")
        {}

    inline JGRtpCandidate(XmlElement* xml, const JGRtpCandidates& container)
        { fromXml(xml,container); }

    virtual XmlElement* toXml(const JGRtpCandidates& container) const;

    void fromXml(XmlElement* xml, const JGRtpCandidates& container);
 
    String m_address;
    String m_port;
    String m_component;                  // Candidate component
    String m_generation;                 // Candidate generation
    String m_network;                    // NIC card (diagnostic only)
    String m_priority;                   // Candidate priority
    String m_protocol;                   // The only allowable value is "udp"
    String m_type;                       // A Candidate Type as defined in ICE-CORE
};
 

class YJABBER_API JGRtpCandidateP2P : public JGRtpCandidate
{
    YCLASS(JGRtpCandidateP2P,JGRtpCandidate)
public:
    inline JGRtpCandidateP2P()
        : JGRtpCandidate("")
        {}

    inline JGRtpCandidateP2P(XmlElement* xml, const JGRtpCandidates& container)
        : JGRtpCandidate("")
        { fromXml(xml,container); }

    virtual XmlElement* toXml(const JGRtpCandidates& container) const;

    void fromXml(XmlElement* xml, const JGRtpCandidates& container);
 
    String m_username;
    String m_password;
};
 

class YJABBER_API JGRtpCandidates : public ObjList
{
public:
    enum Type {
        Unknown   = -1,
        RtpIceUdp = 1,
        RtpRawUdp,
        RtpP2P,
        RtpGoogleRawUdp,
    };

    inline JGRtpCandidates(Type t = Unknown)
        : m_type(t)
        {}

    inline const char* typeName() const
        { return typeName(m_type); }

    inline void generateIceAuth() {
            generateIceToken(m_password,true);
            generateIceToken(m_ufrag,false);
        }

    inline void generateOldIceAuth() {
            generateOldIceToken(m_password);
            generateOldIceToken(m_ufrag);
        }

    JGRtpCandidate* findByComponent(unsigned int component);

    XmlElement* toXml(bool addCandidates, bool addAuth) const;

    void fromXml(XmlElement* element);

    static void generateIceToken(String& dest, bool pwd, unsigned int max = 0);

    static void generateOldIceToken(String& dest);

    static inline const char* typeName(int t, const char* defVal = "unknown")
        { return TelEngine::lookup(t,s_type,defVal); }

    static const TokenDict s_type[];
 
    Type m_type;
    String m_password;
    String m_ufrag;
};
 

class YJABBER_API JGSessionContent : public RefObject
{
public:
    enum Type {
        Unknown             = -1,        // Unknown
        UnknownFileTransfer = -2,        // Unknown (unsupported) file transfer content
        RtpIceUdp           = 1,         // Audio: RTP ICE-UDP transport
        RtpRawUdp,                       // Audio: RTP RAW-UDP transport
        RtpP2P,                          //
        RtpGoogleRawUdp,                 //
        FileBSBOffer,                    // File offer: byte stream (SOCKS) transport
        FileBSBRequest,                  // File request: byte stream (SOCKS) transport
    };

    enum Senders {
        SendUnknown    = 0,
        SendBoth       = 1,
        SendInitiator  = 2,
        SendResponder  = 3
    };

    enum Creator {
        CreatorUnknown   = 0,
        CreatorInitiator = 1,
        CreatorResponder = 2
    };

    JGSessionContent(Type t, const char* name, Senders senders,
        Creator creator, const char* disposition = 0);

    inline Type type() const
        { return m_type; }

    inline Senders senders() const
        { return m_senders; }

    inline Creator creator() const
        { return m_creator; }

    inline bool isValidAudio() const
        { return (m_rtpMedia.media() == JGRtpMediaList::Audio) && (0 != m_rtpMedia.skipNull()); }

    virtual const String& toString() const
        { return m_name; }

    inline bool isSession() const
        { return !m_disposition || m_disposition == "session"; }

    inline bool isEarlyMedia() const
        { return m_disposition == "early-session"; }

    inline void setEarlyMedia()
        { m_disposition = "early-session"; }

    XmlElement* toXml(bool minimum, bool addDesc,
        bool addTrans, bool addCandidates, bool addAuth) const;

    static JGSessionContent* fromXml(XmlElement* xml, XMPPError::Type& err,
        String& error);

    static const TokenDict s_senders[];

    static const TokenDict s_creator[];

    JGRtpMediaList m_rtpMedia;

    JGRtpCandidates m_rtpLocalCandidates;

    JGRtpCandidates m_rtpRemoteCandidates;

    NamedList m_fileTransfer;
 
private:
    Type m_type;
    String m_name;
    Senders m_senders;
    Creator m_creator;
    String m_disposition;
};
 

class JGStreamHost : public String
{
public:
    JGStreamHost(bool local, const char* jid, const char* addr, int port, const char* zeroConf = 0)
        : String(jid),
        m_local(local), m_address(addr), m_port(port), m_zeroConf(zeroConf)
        {}

    inline JGStreamHost(const JGStreamHost& src)
        : String(src),
        m_local(src.m_local), m_address(src.m_address), m_port(src.m_port),
        m_zeroConf(src.m_zeroConf)
        {}

    XmlElement* toXml();

    static JGStreamHost* fromXml(XmlElement* xml);

    static XmlElement* buildHosts(const ObjList& hosts, const char* sid,
        const char* mode = "tcp");

    static XmlElement* buildRsp(const char* jid);
 
    bool m_local;
    String m_address;
    int m_port;
    String m_zeroConf;
};
 

class YJABBER_API JGSession : public RefObject, public Mutex
{
    friend class JGEvent;
    friend class JGEngine;
public:
    enum Version {
        Version0 = 0,
        Version1 = 1,
        VersionUnknown
    };

    enum Reason {
        ReasonUnknown = 0,
        // Session termination reason
        ReasonOk,                        // success
        ReasonBusy,                      // busy
        ReasonDecline,                   // decline
        ReasonCancel,                    // cancel
        ReasonExpired,                   // expired
        ReasonConn,                      // connectivity-error
        ReasonFailApp,                   // failed-application
        ReasonFailTransport,             // failed-transport
        ReasonGone,                      // gone
        ReasonParams,                    // incompatible-parameters
        ReasonMedia,                     // media-error
        ReasonTransport,                 // unsupported-transports
        ReasonApp,                       // unsupported-applications
        ReasonSecurity,                  // security-error
        ReasonTimeout,                   // timeout
        ReasonGeneral,                   // general-error
        ReasonAltSess,                   // alternative-session
        // Session transfer (XEP 0251)
        Transferred,                     // transferred
        // RTP session errors (XEP 0167)
        CryptoRequired,                  // crypto-required
        InvalidCrypto,                   // invalid-crypto
    };

    enum RtpInfo {
        RtpActive,                       // active
        RtpHold,                         // hold
        RtpMute,                         // mute
        RtpRinging,                      // ringing
    };

    enum State {
        Idle    = 0,                     // Outgoing stream is waiting for
        Pending = 1,                     // Session is pending, session-initiate sent/received
        Active  = 2,                     // Session is active, session-accept sent/received
        Ending  = 3,                     // Session terminated: Wait for write result
        Destroy = 4,                     // The session will be destroyed
    };

    enum Action {
        ActAccept,                       // session-accept
        ActInitiate,                     // session-initiate
        ActTerminate,                    // session-terminate
        ActReject,                       // reject
        ActInfo,                         // session-info
        ActTransportInfo,                // transport-info
        ActTransportAccept,              // transport-accept
        ActTransportReject,              // transport-reject
        ActTransportReplace,             // transport-replace
        ActCandidates,                   // candidates
        ActContentAccept,                // content-accept
        ActContentAdd,                   // content-add
        ActContentModify,                // content-modify
        ActContentReject,                // content-reject
        ActContentRemove,                // content-remove
        ActContentInfo,                  // content-info
        ActDescriptionInfo,              // description-info
        ActTransfer,                     // session-info: Transfer
        ActRinging,                      // session-info: Ringing
        ActTrying,                       // session-info: Trying
        ActReceived,                     // session-info: Received
        ActHold,                         // session-info: Hold
        ActActive,                       // session-info: Active
        ActMute,                         // session-info: Mute
        ActDtmf,                         // session-info: Dtmf
        ActStreamHost,
        ActCount,
    };

    enum SessionFlag {
        FlagNoPing = 0x0001,             // Don't send ping
        FlagRingNsRtp = 0x0002,          // Send ringing using rtp namespace instead of rtp info namespace
        FlagNoOkInitiate = 0x0004,       // Don't raise a ResultOk when initiate stanza is confirmed
    };

    virtual ~JGSession();

    inline Version version() const
        { return m_version; }

    inline JGEngine* engine() const
        { return m_engine; }

    inline bool outgoing() const
        { return m_outgoing; }

    inline const String& sid() const
        { return m_sid; }

    inline const JabberID& local() const
        { return m_local; }

    inline const JabberID& remote() const
        { return m_remote; }

    inline State state() const
        { return m_state; }

    inline int flag(int mask) const
        { return m_flags & mask; }

    inline void setFlags(int value)
        { m_flags = value; }

    inline void* userData()
        { return m_private; }

    inline void userData(void* userdata)
        { m_private = userdata; }

    inline const String& line() const
        { return m_line; }

    inline void line(const String& acc)
        { m_line = acc; }

    Action getAction(XmlElement* xml);

    bool acceptIq(XMPPUtils::IqType type, const JabberID& from, const JabberID& to,
        const String& id, XmlElement* xml);

    bool confirmResult(XmlElement* xml);

    bool confirmError(XmlElement*& xml, XMPPError::Type error,
        const char* text = 0, XMPPError::ErrorType type = XMPPError::TypeModify);

    virtual bool accept(const ObjList& contents, String* stanzaId = 0)
        { return false; }

    virtual bool hangup(XmlElement* reason = 0);

    virtual XmlElement* createRtpInfoXml(RtpInfo info)
        { return 0; }

    virtual XmlElement* createReason(int reason, const char* text = 0,
        XmlElement* child = 0)
        { return 0; }

    virtual XmlElement* createTransferReason(int reason)
        { return 0; }

    virtual XmlElement* createRtpSessionReason(int reason)
        { return 0; }

    virtual bool sendContent(Action action, const ObjList& contents, String* stanzaId = 0)
        { return false; }

    inline bool sendContent(Action action, const JGSessionContent* content,
        String* stanzaId = 0) {
            if (!content)
                return false;
            ObjList tmp;
            tmp.append(content)->setDelete(false);
            return sendContent(action,tmp,stanzaId);
        }

    virtual bool sendStreamHosts(const ObjList& hosts, String* stanzaId = 0)
        { return false; }

    virtual bool sendStreamHostUsed(const char* jid, const char* stanzaId)
        { return false; }

    void buildSocksDstAddr(String& buf);

    bool sendInfo(XmlElement* xml, String* stanzaId = 0, XmlElement* extra = 0);

    bool sendDtmf(const char* dtmf, unsigned int msDuration = 0, String* stanzaId = 0);

    bool hasFeature(XMPPNamespace::Type feature);

    static XmlElement* buildTransfer(const String& transferTo, const String& transferFrom,
        const String& sid = String::empty());

    static inline Version lookupVersion(const char* value, Version def = VersionUnknown)
        { return (Version)lookup(value,s_versions,def); }

    static inline const char* lookupVersion(int value, const char* def = "unknown")
        { return lookup(value,s_versions,def); }

    static inline int lookupReason(const char* value, int def = ReasonOk)
        { return lookup(value,s_reasons,def); }

    static inline const char* lookupReason(int value, const char* def = 0)
        { return lookup(value,s_reasons,def); }

    static const char* lookupState(int state)
        { return lookup(state,s_states); }

    static const char* lookupAction(int act, Version ver);

    static Action lookupAction(const char* str, Version ver);

    static const TokenDict s_versions[];

    static const TokenDict s_reasons[];

    static const TokenDict s_rtpInfo[];

    static const TokenDict s_states[];

    static const TokenDict s_actions0[];

    static const TokenDict s_actions1[];

    static const TokenDict s_flagName[];
 
protected:
    JGSession(Version ver, JGEngine* engine,
        const JabberID& caller, const JabberID& called);

    JGSession(Version ver, JGEngine* engine, const JabberID& caller,
        const JabberID& called, XmlElement* xml, const String& id);

    virtual bool initiate(const ObjList& contents, XmlElement* extra,
        const char* subject = 0) = 0;

    virtual JGEvent* getEvent(u_int64_t time);

    virtual void destroyed();

    bool sendStanza(XmlElement* stanza, String* stanzaId = 0, bool confirmation = true,
        bool ping = false, unsigned int toutMs = 0);

    bool sendPing(u_int64_t msecNow);

    virtual JGEvent* decodeJingle(XmlElement*& xml, XmlElement* child) = 0;

    virtual XmlElement* createJingle(Action action, XmlElement* element1 = 0,
        XmlElement* element2 = 0, XmlElement* element3 = 0) = 0;

    virtual XmlElement* createDtmf(const char* dtmf, unsigned int msDuration = 0) = 0;

    virtual JGEvent* processJingleSetEvent(JGEvent*& ev);

    virtual JGEvent* processJabberIqResponse(bool result, XmlElement*& xml);

    virtual JGEvent* processFileTransfer(bool set, XmlElement*& xml, XmlElement* child);

    void eventTerminated(JGEvent* event);

    void changeState(State newState);
 
    Version m_version;                   // Session version
    State m_state;                       // Session state
    int m_flags;                         // Session flags
    u_int64_t m_timeToPing;              // Time to send ping (empty session-info)
    JGEngine* m_engine;                  // The engine that owns this session
    bool m_outgoing;                     // Session direction
    String m_sid;                        // Session id
    JabberID m_local;                    // Local peer's JID
    JabberID m_remote;                   // Remote peer's JID
    XmlFragment m_queue;                 // Incoming, unprocessed, xml elements
    JGEvent* m_lastEvent;                // Last generated event
    bool m_recvTerminate;                // Flag indicating whether session-terminate was received
    void* m_private;                     // Arbitrary user data
    String m_localSid;                   // Local session id (used to generate element's id)
    u_int32_t m_stanzaId;                // Sent stanza id counter
    ObjList m_sentStanza;                // Sent stanzas' id
    String m_line;                       // Session account
 
private:
    JGSession() {}                       // Don't use it
};
 

class YJABBER_API JGSession0 : public JGSession
{
    friend class JGEvent;
    friend class JGEngine;
public:
    virtual ~JGSession0();

    virtual bool accept(const ObjList& contents, String* stanzaId = 0);
 
protected:
    JGSession0(JGEngine* engine, const JabberID& caller, const JabberID& called);

    JGSession0(JGEngine* engine, const JabberID& caller, const JabberID& called,
        XmlElement* xml, const String& id);

    virtual bool initiate(const ObjList& contents, XmlElement* extra,
        const char* subject = 0);

    virtual bool sendContent(Action action, const ObjList& contents, String* stanzaId = 0);

    virtual JGEvent* decodeJingle(XmlElement*& xml, XmlElement* child);

    virtual XmlElement* createJingle(Action action, XmlElement* element1 = 0,
        XmlElement* element2 = 0, XmlElement* element3 = 0);

    virtual XmlElement* createDtmf(const char* dtmf, unsigned int msDuration = 0);
 
protected:
    String m_sessContentName;            // Content name advertised to upper layer
    Action m_candidatesAction;           // Use candidates/transport-info for candidates
};

class YJABBER_API JGSession1 : public JGSession
{
    friend class JGEvent;
    friend class JGEngine;
public:
    virtual ~JGSession1();

    virtual bool accept(const ObjList& contents, String* stanzaId = 0);

    virtual XmlElement* createRtpInfoXml(RtpInfo info);

    virtual XmlElement* createReason(int reason, const char* text = 0,
        XmlElement* child = 0);

    virtual XmlElement* createTransferReason(int reason);

    virtual XmlElement* createRtpSessionReason(int reason);

    virtual bool sendContent(Action action, const ObjList& contents, String* stanzaId = 0);

    virtual bool sendStreamHosts(const ObjList& hosts, String* stanzaId = 0);

    virtual bool sendStreamHostUsed(const char* jid, const char* stanzaId);
 
protected:
    JGSession1(JGEngine* engine, const JabberID& caller, const JabberID& called);

    JGSession1(JGEngine* engine, const JabberID& caller, const JabberID& called,
        XmlElement* xml, const String& id);

    virtual bool initiate(const ObjList& contents, XmlElement* extra,
        const char* subject = 0);

    virtual JGEvent* decodeJingle(XmlElement*& xml, XmlElement* child);

    virtual XmlElement* createJingle(Action action, XmlElement* element1 = 0,
        XmlElement* element2 = 0, XmlElement* element3 = 0);

    virtual XmlElement* createDtmf(const char* dtmf, unsigned int msDuration = 0);

    virtual JGEvent* processFileTransfer(bool set, XmlElement*& xml, XmlElement* child);
 
};

class YJABBER_API JGEvent
{
    friend class JGSession;
    friend class JGSession0;
    friend class JGSession1;
public:
    enum Type {
        Jingle,                          //
        ResultOk,                        // Response for a sent stanza (iq with type=result)
        ResultError,                     // Response for a sent stanza (iq with type=error)
        ResultTimeout,                   // Response for a sent stanza (stanza timeout)
        // Final
        Terminated,                      // m_element is the element that caused the termination
                                         //  m_reason contains the reason
        Destroy,                         // The engine sould delete the event (causing session destruction)
    };

    virtual ~JGEvent();

    inline Type type() const
        { return m_type; }

    inline const char* name()
        { return lookupType(m_type); }

    inline JGSession* session() const
        { return m_session; }

    inline XmlElement* element() const
        { return m_element; }

    inline XmlElement* jingle() const
        { return m_jingle; }

    inline JGSession::Action action() const
        { return m_action; }

    inline const char* actionName() const
        { return m_session ? JGSession::lookupAction(m_action,m_session->version()) : ""; }

    inline const String& id() const
        { return m_id; }

    inline const String& reason() const
        { return m_reason; }

    inline const String& text() const
        { return m_text; }

    inline XmlElement* releaseXml() {
            XmlElement* tmp = m_element;
            m_jingle = m_element = 0;
            return tmp;
         }

    inline bool final() const
        { return m_type == Terminated || m_type == Destroy; }

    inline bool confirmElement(XMPPError::Type error = XMPPError::NoError,
        const char* text = 0, XMPPError::ErrorType type = XMPPError::TypeModify) {
            if (m_session && element() && !m_confirmed) {
                m_confirmed = true;
                if (error == XMPPError::NoError)
                    return m_session->confirmResult(element());
                XmlElement* err = releaseXml();
                return m_session->confirmError(err,error,text,type);
            }
            return false;
        }

    inline void setConfirmed()
        { m_confirmed = true; }

    void setAction(JGSession::Action act);

    static inline const char* lookupType(int type)
        { return lookup(type,s_typeName); }

    static const TokenDict s_typeName[];

    ObjList m_contents;

    ObjList m_streamHosts;
 
protected:
    inline JGEvent(Type type, JGSession* session, XmlElement* element = 0,
        const char* reason = 0, const char* text = 0)
        : m_type(type), m_confirmed(true), m_session(0), m_element(element),
        m_jingle(0), m_action(JGSession::ActCount), m_reason(reason), m_text(text)
        { init(session); }

    inline JGEvent(JGSession::Action act, JGSession* session, XmlElement* element,
        const char* reason = 0, const char* text = 0)
        : m_type(Jingle), m_confirmed(false), m_session(0), m_element(element), m_jingle(0),
        m_action(act), m_reason(reason), m_text(text) {
            init(session);
            setAction(act);
        }
 
private:
    JGEvent() {}                         // Don't use it
    void init(JGSession* session);
 
    Type m_type;                         // The type of this event
    bool m_confirmed;                    // Flag indicating that element was confirmed
    JGSession* m_session;                // Jingle session that generated this event
    XmlElement* m_element;               // XML element that generated this event
    XmlElement* m_jingle;                // The session child, if present
    // Event specific
    JGSession::Action m_action;          // The action if type is Jingle
    String m_id;                         // The element's id attribute
    String m_reason;                     // The reason if type is Error or Terminated
    String m_text;                       // Dtmf text
};

class YJABBER_API JGEngine : public DebugEnabler, public Mutex
{
    friend class JGSession;
public:
    JGEngine(const char* name = "jgengine");

    virtual ~JGEngine();

    inline int sessionFlags() const
        { return m_sessionFlags; }

    inline u_int64_t stanzaTimeout() const
        { return m_stanzaTimeout; }

    inline u_int64_t streamHostTimeout() const
        { return m_streamHostTimeout; }

    inline u_int64_t pingInterval() const
        { return m_pingInterval; }

    virtual void initialize(const NamedList& params);

    virtual bool sendStanza(JGSession* session, XmlElement*& stanza);

    virtual bool sendMessage(JGSession* session, const char* body);

    JGEvent* getEvent(u_int64_t time);

    JGSession* call(JGSession::Version ver, const JabberID& caller, const JabberID& called,
        const ObjList& contents, XmlElement* extra = 0, const char* msg = 0,
        const char* subject = 0, const char* line = 0, int* flags = 0);

    bool acceptIq(XMPPUtils::IqType type, const JabberID& from, const JabberID& to,
        const String& id, XmlElement* xml, const char* line,
        XMPPError::Type& error, String& text);

    void defProcessEvent(JGEvent* event);

    virtual void processEvent(JGEvent* event);

    static int decodeFlags(const String& list, const TokenDict* dict);

    static void encodeFlags(String& buf, int flags, const TokenDict* dict);
 
private:
    // Create a local session id
    void createSessionId(String& id);
 
    ObjList m_sessions;                  // List of sessions
    u_int32_t m_sessionId;               // Session id counter
    u_int64_t m_stanzaTimeout;           // The timeout of a sent stanza
    u_int64_t m_streamHostTimeout;       // The timeout of a sent stream host stanza
    u_int64_t m_pingInterval;            // Interval to send ping (empty session-info)
    int m_sessionFlags;                  // Default session flags
};
 

class YJABBER_API JGSentStanza : public String
{
public:
    JGSentStanza(const char* id, u_int64_t time, bool notif = false, bool ping = false,
        JGSession::Action action = JGSession::ActCount)
        : String(id), m_time(time), m_notify(notif), m_ping(ping), m_action(action)
        {}

    inline u_int64_t timeout() const
        { return m_time; }

    inline bool timeout(u_int64_t time) const
        { return time > m_time; }

    inline bool notify() const
        { return m_notify; }

    inline bool ping() const
        { return m_ping; }

    inline JGSession::Action action() const
        { return m_action; }
 
private:
    u_int64_t m_time;                    // Timeout
    bool m_notify;                       // Notify timeout to sender
    bool m_ping;                         // Sent stanza is a ping one
    JGSession::Action m_action;          // Sent stanza action
};
 
};
 
#endif /* __YATEJINGLE_H */
 
/* vi: set ts=8 sw=4 sts=4 noet: */