xmpputils.h

 
#ifndef __XMPPUTILS_H
#define __XMPPUTILS_H
 
#include <yateclass.h>
#include <yatexml.h>
 
#ifdef _WINDOWS
 
#ifdef LIBYJABBER_EXPORTS
#define YJABBER_API __declspec(dllexport)
#else
#ifndef LIBYJABBER_STATIC
#define YJABBER_API __declspec(dllimport)
#endif
#endif
 
#endif /* _WINDOWS */
 
#ifndef YJABBER_API
#define YJABBER_API
#endif
 
// Support old RFC 3920
// If not defined RFC 3920bis changes will be used
#define RFC3920

namespace TelEngine {
 
class StringArray;                       // A String array
class XMPPNamespace;                     // XMPP namespaces
class XMPPError;                         // XMPP errors
class JabberID;                          // A Jabber ID (JID)
class JIDIdentity;                       // A JID's identity
class JIDIdentityList;                   // A list of JID identities
class XMPPFeature;                       // A feature (stream or JID)
class XMPPFeatureSasl;                   // A SASL feature
class XMPPFeatureCompress;               // A stream compression feature
class XMPPFeatureList;                   // Feature list
class XMPPUtils;                         // Utilities
class XMPPDirVal;                        // Direction flags
class XmlElementOut;                     // An outgoing xml element

class YJABBER_API StringArray
{
public:
    inline StringArray(const String* array, unsigned int len)
        : m_array((String*)array), m_length(len)
        {}

    inline const String& at(unsigned int index) const
        { return index < m_length ? m_array[index] : String::empty(); }

    inline const String& operator[](unsigned int index) const
        { return m_array[index]; }

    inline int operator[](const String& token) {
            unsigned int i = 0;
            for (; i < m_length; i++)
                if (m_array[i] == token)
                    return i;
            return m_length;
        }
 
protected:
    String* m_array;
    unsigned int m_length;
 
private:
    StringArray() {}
};
 

class YJABBER_API XMPPNamespace : public StringArray
{
public:
    enum Type {
        Stream = 0,                      // http://etherx.jabber.org/streams
        Client,                          // jabber:client
        Server,                          // jabber:server
        Dialback,                        // jabber:server:dialback
        StreamError,                     // urn:ietf:params:xml:ns:xmpp-streams
        StanzaError,                     // urn:ietf:params:xml:ns:xmpp-stanzas
        Ping,                            // urn:xmpp:ping
        Register,                        // http://jabber.org/features/iq-register
        IqRegister,                      // jabber:iq:register
        IqPrivate,                       // jabber:iq:private
        IqAuth,                          // jabber:iq:auth
        IqAuthFeature,                   // http://jabber.org/features/iq-auth
        IqVersion,                       // jabber:iq:version
        Delay,                           // urn:xmpp:delay
        Tls,                             // urn:ietf:params:xml:ns:xmpp-tls
        Sasl,                            // urn:ietf:params:xml:ns:xmpp-sasl
        Session,                         // urn:ietf:params:xml:ns:xmpp-session
        Bind,                            // urn:ietf:params:xml:ns:xmpp-bind
        Roster,                          // jabber:iq:roster
        DynamicRoster,                   // jabber:iq:roster-dynamic
        DiscoInfo,                       // http://jabber.org/protocol/disco#info
        DiscoItems,                      // http://jabber.org/protocol/disco#items
        EntityCaps,                      // http://jabber.org/protocol/caps
        VCard,                           // vcard-temp
        SIProfileFileTransfer,           // http://jabber.org/protocol/si/profile/file-transfer
        ByteStreams,                     // http://jabber.org/protocol/bytestreams
        Jingle,                          // urn:xmpp:jingle:1
        JingleError,                     // urn:xmpp:jingle:errors:1
        JingleAppsRtp,                   // urn:xmpp:jingle:apps:rtp:1
        JingleAppsRtpError,              // urn:xmpp:jingle:apps:rtp:errors:1
        JingleAppsRtpInfo,               // urn:xmpp:jingle:apps:rtp:info:1
        JingleAppsRtpAudio,              // urn:xmpp:jingle:apps:rtp:audio
        JingleAppsFileTransfer,          // urn:xmpp:jingle:apps:file-transfer:1
        JingleTransportIceUdp,           // urn:xmpp:jingle:transports:ice-udp:1
        JingleTransportRawUdp,           // urn:xmpp:jingle:transports:raw-udp:1
        JingleTransportRawUdpInfo,       // urn:xmpp:jingle:transports:raw-udp:info:1
        JingleTransportByteStreams,      // urn:xmpp:jingle:transports:bytestreams:1
        JingleTransfer,                  // urn:xmpp:jingle:transfer:0
        JingleDtmf,                      // urn:xmpp:jingle:dtmf:0
        JingleSession,                   // http://www.google.com/session
        JingleAudio,                     // http://www.google.com/session/phone
        JingleTransport,                 // http://www.google.com/transport/p2p
        JingleVoiceV1,                   // http://www.google.com/xmpp/protocol/voice/v1
        JingleRtpInfoOld,                // urn:xmpp:jingle:apps:rtp:info
        DtmfOld,                         // http://jabber.org/protocol/jingle/info/dtmf
        XOob,                            // jabber:x:oob
        Command,                         // http://jabber.org/protocol/command
        MsgOffline,                      // msgoffline
        ComponentAccept,                 // jabber:component:accept
        Muc,                             // http://jabber.org/protocol/muc
        MucAdmin,                        // http://jabber.org/protocol/muc#admin
        MucOwner,                        // http://jabber.org/protocol/muc#owner
        MucUser,                         // http://jabber.org/protocol/muc#user
        DialbackFeature,                 // urn:xmpp:features:dialback
        Compress,                        // http://jabber.org/protocol/compress
        CompressFeature,                 // http://jabber.org/features/compress
        XData,                           // jabber:x:data
        ChatStates,                      // http://jabber.org/protocol/chatstates
        YateCluster,                     // http://yate.null.ro/yate/cluster
        JingleTransportGoogleRawUdp,     // http://www.google.com/transport/raw-udp
        Hash,                            // urn:xmpp:hashes:1
        ResultSetMngt,                   // http://jabber.org/protocol/rsm
        FileInfoShare,                   // urn:xmpp:mam
        // This value MUST be the last one: it's used as array bound
        Count,
    };

    inline XMPPNamespace()
        : StringArray(s_array,Count)
        {}
 
private:
    static const String s_array[Count];  // Namespace list
};
 

class YJABBER_API XMPPError : public StringArray
{
public:
    enum Type {
        NoError = 0,
        BadFormat,                       // bad-format
        BadNamespace,                    // bad-namespace-prefix
        Conflict,                        // conflict
        ConnTimeout,                     // connection-timeout
        HostGone,                        // host-gone
        HostUnknown,                     // host-unknown
        BadAddressing,                   // improper-addressing
        Internal,                        // internal-server-error
        InvalidFrom,                     // invalid-from
        InvalidId,                       // invalid-id
        InvalidNamespace,                // invalid-namespace
        InvalidXml,                      // invalid-xml
        NotAuth,                         // not-authorized
        Policy,                          // policy-violation
        RemoteConn,                      // remote-connection-failed
        ResConstraint,                   // resource-constraint
        RestrictedXml,                   // restricted-xml
        SeeOther,                        // see-other-host
        Shutdown,                        // system-shutdown
        UndefinedCondition,              // undefined-condition
        UnsupportedEnc,                  // unsupported-encoding
        UnsupportedStanza,               // unsupported-stanza-type
        UnsupportedVersion,              // unsupported-version
        Xml,                             // xml-not-well-formed
        Aborted,                         // aborted
        AccountDisabled,                 // account-disabled
        CredentialsExpired,              // credentials-expired
        EncryptionRequired,              // encryption-required
        IncorrectEnc,                    // incorrect-encoding
        InvalidAuth,                     // invalid-authzid
        InvalidMechanism,                // invalid-mechanism
        MalformedRequest,                // malformed-request
        MechanismTooWeak,                // mechanism-too-weak
        NotAuthorized,                   // not-authorized
        TempAuthFailure,                 // temporary-auth-failure
        TransitionNeeded,                // transition-needed
        ResourceConstraint,              // resource-constraint
        NotAllowed,                      // not-allowed
        BadRequest,                      // bad-request
        FeatureNotImpl,                  // feature-not-implemented
        Forbidden,                       // forbidden
        Gone,                            // gone
        ItemNotFound,                    // item-not-found
        BadJid,                          // jid-malformed
        NotAcceptable,                   // not-acceptable
        Payment,                         // payment-required
        Unavailable,                     // recipient-unavailable
        Redirect,                        // redirect
        Reg,                             // registration-required
        NoRemote,                        // remote-server-not-found
        RemoteTimeout,                   // remote-server-timeout
        ServiceUnavailable,              // service-unavailable
        Subscription,                    // subscription-required
        Request,                         // unexpected-request
        SocketError,                     // Don't send any error or stream end tag to remote party
        UnsupportedMethod,               // unsupported-method
        SetupFailed,                     // setup-failed
        // This value MUST be the last one: it's used as error type start
        TypeCount
    };

    enum ErrorType {
        TypeCancel = TypeCount,          // do not retry (the error is unrecoverable)
        TypeContinue,                    // proceed (the condition was only a warning)
        TypeModify,                      // retry after changing the data sent
        TypeAuth,                        // retry after providing credentials
        TypeWait,                        // retry after waiting (the error is temporary)
        // This value MUST be the last one: it's used as array bound
        Count
    };

    inline XMPPError()
        : StringArray(s_array,Count)
        {}
 
private:
    static const String s_array[Count];  // Error list
};

class YJABBER_API XmlTag : public StringArray
{
public:
    enum Type {
        Stream = 0,                      // stream
        Error,                           // error
        Features,                        // features
        Register,                        // register
        Starttls,                        // starttls
        Auth,                            // auth
        Challenge,                       // challenge
        Abort,                           // abort
        Aborted,                         // aborted
        Response,                        // response
        Proceed,                         // proceed
        Success,                         // success
        Failure,                         // failure
        Mechanisms,                      // mechanisms
        Mechanism,                       // mechanism
        Session,                         // session
        Iq,                              // iq
        Message,                         // message
        Presence,                        // presence
        Query,                           // query
        VCard,                           // vCard
        Jingle,                          // jingle
        Description,                     // description
        PayloadType,                     // payload-type
        Transport,                       // transport
        Candidate,                       // candidate
        Body,                            // body
        Subject,                         // subject
        Feature,                         // feature
        Bind,                            // bind
        Resource,                        // resource
        Transfer,                        // transfer
        Hold,                            // hold
        Active,                          // active
        Ringing,                         // ringing
        Mute,                            // mute
        Registered,                      // registered
        Remove,                          // remove
        Jid,                             // jid
        Username,                        // username
        Password,                        // password
        Digest,                          // digest
        Required,                        // required
        Optional,                        // optional
        Dtmf,                            // dtmf
        DtmfMethod,                      // dtmf-method
        Command,                         // command
        Text,                            // text
        Item,                            // item
        Group,                           // group
        Reason,                          // reason
        Content,                         // content
        Trying,                          // trying
        Received,                        // received
        File,                            // file
        Offer,                           // offer
        Request,                         // request
        StreamHost,                      // streamhost
        StreamHostUsed,                  // streamhost-used
        Ping,                            // ping
        Encryption,                      // encryption
        Crypto,                          // crypto
        Parameter,                       // parameter
        Identity,                        // identity
        Priority,                        // priority
        EntityCapsTag,                   // c
        Handshake,                       // handshake
        Dialback,                        // dialback
        Method,                          // method
        Compress,                        // compress
        Compressed,                      // compressed
        Compression,                     // compression
        X,                               // x
        Hash,                            // hash
        Algo,                            // algo
        Size,                            // size
        Date,                            // date
        Desc,                            // desc
        Set,                             // set
        After,                           // after
        Before,                          // before
        CountTag,                        // count
        First,                           // first
        Index,                           // index
        Last,                            // last
        Max,                             // max
        Match,                           // match
        Directory,                       // directory
        Name,                            // name
        Changed,                         // changed
        // This value MUST be the last one: it's used as array bound
        Count
    };

    inline XmlTag()
        : StringArray(s_array,Count)
        {}
 
private:
    static const String s_array[Count];  // Tag list
};
 

class YJABBER_API JabberID : public String
{
    YCLASS(JabberID,String)
public:
    inline JabberID() {}

    inline JabberID(const char* jid)
        { set(jid); }

    inline JabberID(const String& jid)
        { set(jid); }

    inline JabberID(const String* jid)
        { set(TelEngine::c_safe(jid)); }

    inline JabberID(const char* node, const char* domain, const char* resource = 0)
        { set(node,domain,resource); }

    inline JabberID(const JabberID& src)
        { *this = src; }

    inline bool valid() const
        { return null() || m_domain; }

    inline const String& node() const
        { return m_node; }

    inline const String& bare() const
        { return m_bare; }

    inline const String& domain() const
        { return m_domain; }

    inline void domain(const char* d)
        { set(m_node.c_str(),d,m_resource.c_str()); }

    inline const String& resource() const
        { return m_resource; }

    inline bool isFull() const
        { return m_node && m_domain && m_resource; }

    inline void clear() {
            String::clear();
            m_node.clear();
            m_domain.clear();
            m_resource.clear();
            m_bare.clear();
        }

    inline bool match(const JabberID& src) const
        { return (src.resource().null() || (resource() == src.resource())) && (bare() &= src.bare()); }

    JabberID& operator=(const JabberID& src);

    inline JabberID& operator=(const String& src)
        { set(src); return *this; }

    inline JabberID& operator=(const String* src)
        { set(TelEngine::c_safe(src)); return *this; }

    inline bool operator==(const JabberID& src) const
        { return (resource() == src.resource()) && (bare() &= src.bare()); }

    inline bool operator==(const String& src) const
        { JabberID tmp(src); return operator==(tmp); }

    inline bool operator!=(const JabberID& src) const
        { return !operator==(src); }

    inline bool operator!=(const String& src) const
        { return !operator==(src); }

    inline void resource(const char* res)
        { set(m_node.c_str(),m_domain.c_str(),res); }

    void set(const char* jid);

    void set(const char* node, const char* domain, const char* resource = 0);

    static const JabberID& empty();

    static bool valid(const String& value);

    static Regexp s_regExpValid;
 
private:
    void parse();                        // Parse the string. Set the data
    void normalize();                    // Lowercase node and domain. Set bare jid and jid
 
    String m_node;                       // The node part
    String m_domain;                     // The domain part
    String m_resource;                   // The resource part
    String m_bare;                       // The bare JID: node@domain
};
 

class YJABBER_API JIDIdentity : public GenObject
{
    YCLASS(JIDIdentity,GenObject)
public:
    inline JIDIdentity(const char* c, const char* t, const char* name = 0)
        : m_category(c), m_type(t), m_name(name)
        {}

    inline JIDIdentity(XmlElement* identity)
        { fromXml(identity); }

    inline XmlElement* toXml() const {
            if (!(m_category && m_type))
                return 0;
            return createIdentity(m_category,m_type,m_name);
        }

    void fromXml(XmlElement* identity);

    static XmlElement* createIdentity(const char* category,
        const char* type, const char* name);
 
    String m_category;
    String m_type;
    String m_name;
};
 

class YJABBER_API JIDIdentityList : public ObjList
{
    YCLASS(JIDIdentityList,ObjList)
public:
    void toXml(XmlElement* parent) const;

    void fromXml(XmlElement* parent);
};

class YJABBER_API XMPPFeature : public String
{
    YCLASS(XMPPFeature,GenObject)
public:
    inline XMPPFeature(int xml, int feature, bool required = false)
        : m_xml(xml), m_required(required)
        { setFeature(feature); }

    inline XMPPFeature(int xml, const char* feature, bool required = false)
        : String(feature), m_xml(xml), m_required(required)
        {}

    inline XMPPFeature(int feature)
        : m_xml(XmlTag::Count), m_required(false)
        { setFeature(feature); }

    inline XMPPFeature(const char* feature)
        : String(feature), m_xml(XmlTag::Count), m_required(false)
        {}

    virtual ~XMPPFeature()
        {}

    inline bool required() const
        { return m_required; }

    virtual XmlElement* build(bool addReq = true);

    virtual XmlElement* buildFeature();

    void addReqChild(XmlElement& xml);

    static XMPPFeature* fromStreamFeature(XmlElement& xml);
 
private:
    void setFeature(int feature);
 
    int m_xml;                           // Element tag as enumeration
    bool m_required;                     // Required flag
};
 

class YJABBER_API XMPPFeatureSasl : public XMPPFeature
{
    YCLASS(XMPPFeatureSasl,XMPPFeature)
public:
    inline XMPPFeatureSasl(int mech, bool required = false)
        : XMPPFeature(XmlTag::Mechanisms,XMPPNamespace::Sasl,required),
        m_mechanisms(mech)
        {}

    inline int mechanisms() const
        { return m_mechanisms; }

    inline bool mechanism(int mech) const
        { return 0 != (m_mechanisms & mech); }

    virtual XmlElement* build(bool addReq = true);
 
private:
    int m_mechanisms;                    // Authentication mechanisms
};
 

class YJABBER_API XMPPFeatureCompress : public XMPPFeature
{
    YCLASS(XMPPFeatureCompress,XMPPFeature)
public:
    inline XMPPFeatureCompress(const String& meth, bool required = false)
        : XMPPFeature(XmlTag::Compression,XMPPNamespace::CompressFeature,required),
        m_methods(meth)
        {}

    inline const String& methods() const
        { return m_methods; }

    bool hasMethod(const String& method) const;

    virtual XmlElement* build(bool addReq = true);
 
private:
    String m_methods;                    // Compression methods
};
 

class YJABBER_API XMPPFeatureList : public ObjList
{
    YCLASS(XMPPFeatureList,ObjList)
public:
    inline bool add(int xml, int feature, bool required = false) {
            if (get(feature))
                return false;
            append(new XMPPFeature(xml,feature,required));
            return true;
        }

    inline bool add(int feature) {
            if (get(feature))
                return false;
            append(new XMPPFeature(feature));
            return true;
        }

    inline bool add(XMPPFeature* feature) {
            if (!feature || get(*feature)) {
                TelEngine::destruct(feature);
                return false;
            }
            append(feature);
            return true;
        }

    inline void reset() {
            clear();
            m_identities.clear();
            m_entityCapsHash.clear();
        }

    void add(XMPPFeatureList& list);

    void fromStreamFeatures(XmlElement& xml);

    void fromDiscoInfo(XmlElement& xml);

    inline void remove(int feature)
        { ObjList::remove(get(feature),true); }

    XMPPFeature* get(int feature);

    inline XMPPFeature* get(const String& feature) {
            ObjList* o = find(feature);
            return o ? static_cast<XMPPFeature*>(o->get()) : 0;
        }

    inline XMPPFeatureSasl* getSasl()
        { return YOBJECT(XMPPFeatureSasl,get(XMPPNamespace::Sasl)); }

    inline XMPPFeatureCompress* getCompress()
        { return YOBJECT(XMPPFeatureCompress,get(XMPPNamespace::CompressFeature)); }

    XmlElement* buildStreamFeatures();

    XmlElement* buildDiscoInfo(const char* from, const char* to, const char* id,
        const char* node = 0, const char* cap = 0);

    void add(XmlElement& xml);

    void updateEntityCaps();
 
    JIDIdentityList m_identities;
    String m_entityCapsHash;             // SHA-1 entity caps as defined in XEP 0115
};
 

class YJABBER_API XMPPUtils
{
public:
    enum Presence {
        Probe,                           // probe
        Subscribe,                       // subscribe request
        Subscribed,                      // subscribe accepted
        Unavailable,                     // unavailable
        Unsubscribe,                     // unsubscribe request
        Unsubscribed,                    // unsubscribe accepted
        PresenceError,                   // error
        PresenceNone
    };

    enum MsgType {
        Chat,                            // chat
        GroupChat,                       // groupchat
        HeadLine,                        // headline
        Normal,                          // normal
        MsgError,                        // error
    };

    enum IqType {
        IqSet,                           // set
        IqGet,                           // get
        IqResult,                        // result
        IqError,                         // error
        IqCount
    };

    enum CommandAction {
        CommExecute,
        CommCancel,
        CommPrev,
        CommNext,
        CommComplete,
    };

    enum CommandStatus {
        CommExecuting,
        CommCompleted,
        CommCancelled,
    };

    enum AuthMethod {
        AuthNone     = 0x00,             // No authentication mechanism
        AuthSHA1     = 0x01,             // SHA1 digest
        AuthMD5      = 0x02,             // MD5 digest
        AuthPlain    = 0x04,             // Plain text password
        AuthDialback = 0x08,             // Dialback authentication
    };

    static int findTag(const String& tag, int* tags);

    static inline bool isResponse(const XmlElement& xml) {
            String* tmp = xml.getAttribute("type");
            return tmp && (*tmp == "result" || *tmp == "error");
        }

    static inline void getJIDTo(const NamedList& params, JabberID& jid) {
            jid = params[YSTRING("to")];
            if (jid && !jid.resource())
                jid.resource(params[YSTRING("to_instance")]);
        }

    static inline void getJIDFrom(const NamedList& params, JabberID& jid) {
            jid = params[YSTRING("from")];
            if (jid && !jid.resource())
                jid.resource(params[YSTRING("from_instance")]);
        }

    static inline XmlElement* createElement(const char* name, const char* text = 0,
            const String& ns = String::empty()) {
            XmlElement* xml = new XmlElement(String(name),true);
            if (!TelEngine::null(text))
                xml->addText(text);
            if (ns)
                xml->setXmlns(String::empty(),true,ns);
            return xml;
        }

    static inline XmlElement* createElement(int type, const char* text = 0)
        { return createElement(s_tag[type],text); }

    static inline XmlElement* createElement(const char* name, int ns,
        const char* text = 0) {
            XmlElement* xml = createElement(name,text);
            setXmlns(*xml,String::empty(),true,ns);
            return xml;
        }

    static inline XmlElement* createElement(int type, int ns, const char* text = 0)
        { return createElement(s_tag[type],ns,text); }

    static XmlElement* createElement(const XmlElement& src, bool response, bool result);

    static inline XmlElement* createElementAttr(int tag, const String& attrName,
        const char* attrValue, int ns = XMPPNamespace::Count) {
            XmlElement* x = createElement(tag,ns);
            x->setAttributeValid(attrName,attrValue);
            return x;
        }

    static XmlElement* createIq(IqType type, const char* from = 0,
        const char* to = 0, const char* id = 0);

    static inline XmlElement* createIqResult(const char* from, const char* to,
        const char* id, XmlElement* child = 0) {
            XmlElement* xml = createIq(IqResult,from,to,id);
            if (child)
                xml->addChild(child);
            return xml;
        }

    static XmlElement* createIqError(const char* from, const char* to, XmlElement*& xml,
        int type, int error, const char* text = 0);

    static XmlElement* createPing(const char* id = 0, const char* from = 0,
        const char* to = 0);

    static XmlElement* createVCard(bool get, const char* from, const char* to, const char* id);

    static XmlElement* createCommand(CommandAction action, const char* node,
        const char* sessionId = 0);

    static XmlElement* createIqDisco(bool info, bool req, const char* from, const char* to,
        const char* id, const char* node = 0, const char* cap = 0);

    static XmlElement* createIqVersionRes(const char* from, const char* to,
        const char* id, const char* name, const char* version, const char* os = 0);

    static XmlElement* createError(int type, int error, const char* text = 0);

    static XmlElement* createError(XmlElement* xml, int type, int error,
        const char* text = 0);

    static XmlElement* createStreamError(int error, const char* text = 0, const char* content = 0);

    static XmlElement* createRegisterQuery(IqType type, const char* from,
        const char* to, const char* id,
        XmlElement* child1 = 0, XmlElement* child2 = 0, XmlElement* child3 = 0);

    static inline XmlElement* createIqAuthGet(const char* id) {
            XmlElement* iq = createIq(IqGet,0,0,id);
            iq->addChild(createElement(XmlTag::Query,XMPPNamespace::IqAuth));
            return iq;
        }

    static XmlElement* createIqAuthSet(const char* id, const char* username,
        const char* resource, const char* authStr, bool digest);

    static XmlElement* createIqAuthOffer(const char* id, bool digest = true,
        bool plain = false);

    static inline XmlElement* createRegisterQuery(const char* from,
        const char* to, const char* id,
        const char* username, const char* password) {
            return createRegisterQuery(XMPPUtils::IqSet,from,to,id,
                createElement(XmlTag::Username,username),
                createElement(XmlTag::Password,password));
        }

    static inline XmlElement* createFailure(XMPPNamespace::Type ns,
        XMPPError::Type error = XMPPError::NoError) {
            XmlElement* xml = createElement(XmlTag::Failure,ns);
            if (error != XMPPError::NoError)
                xml->addChild(new XmlElement(s_error[error]));
            return xml;
        }

    static inline XmlElement* createXOobUrl(const char* url, const char* desc = 0) {
            XmlElement* xml = createElement(XmlTag::X,XMPPNamespace::XOob);
            xml->addChild(createElement("url",url));
            if (desc)
                xml->addChild(createElement("desc",desc));
            return xml;
        }

    static XmlElement* createDelay(unsigned int timeSec, const char* from = 0,
        unsigned int fractions = 0, const char* text = 0);

    static XmlElement* createFileNsTransfer(const char* name = 0);

    static XmlElement* createHash(const char* name, const char* value);

    static void decodeHash(XmlElement& xml, const char*& name, const char*& value);

    static inline XmlElement* createFileInfoShareMatch(XmlElement* child = 0) {
            XmlElement* m = createElement(XmlTag::Match,XMPPNamespace::FileInfoShare);
            if (child)
                m->addChildSafe(child);
            return m;
        }

    static XmlElement* createRSM(const NamedList& params, const String& prefix = "rsm_");

    static void addRSM(XmlElement* rsm, NamedList& params, const String& prefix = "rsm_");

    static inline bool remove(XmlElement& xml)
        { return 0 != findFirstChild(xml,XmlTag::Remove); }

    static inline bool required(XmlElement& xml)
        { return 0 != findFirstChild(xml,XmlTag::Required); }

    static int priority(XmlElement& xml, int defVal = 0);

    static inline void setPriority(XmlElement& xml, const char* prio)
        { xml.addChild(createElement(XmlTag::Priority,prio)); }

    static inline int xmlns(XmlElement& xml) {
            String* x = xml.xmlns();
            return x ? s_ns[*x] : XMPPNamespace::Count;
        }

    static inline bool hasDefaultXmlns(const XmlElement& xml, int ns) {
            String* s = xml.xmlnsAttribute(XmlElement::s_ns);
            return s && *s == s_ns[ns];
        }

    static inline bool hasXmlns(const XmlElement& xml, int ns)
        { return xml.hasXmlns(s_ns[ns]); }

    static inline bool setXmlns(XmlElement& xml, const String& name = String::empty(),
        bool addAttr = false, int ns = XMPPNamespace::Count) {
            if (ns < XMPPNamespace::Count)
                return xml.setXmlns(name,addAttr,s_ns[ns]);
            return xml.setXmlns(name);
        }

    static inline bool setStreamXmlns(XmlElement& xml, bool addAttr = true)
        { return setXmlns(xml,"stream",addAttr,XMPPNamespace::Stream); }

    static inline bool setDbXmlns(XmlElement& xml)
        { return setXmlns(xml,"db",true,XMPPNamespace::Dialback); }

    static XmlElement* findFirstChild(const XmlElement& xml, int t = XmlTag::Count,
        int ns = XMPPNamespace::Count);

    static XmlElement* findNextChild(const XmlElement& xml, XmlElement* start,
        int t = XmlTag::Count, int ns = XMPPNamespace::Count);

    static inline const String* childText(XmlElement& xml, int tag, int ns = XMPPNamespace::Count) {
            XmlElement* c = findFirstChild(xml,tag,ns);
            return c ? &(c->getText()) : 0;
        }

    static inline int childTextInt(XmlElement& xml, int tag, int ns = XMPPNamespace::Count,
        int defVal = 0, int base = 0, int minvalue = INT_MIN, int maxvalue = INT_MAX,
        bool clamp = true) {
            const String* tmp = childText(xml,tag,ns);
            return tmp ? tmp->toInteger(defVal,base,minvalue,maxvalue,clamp) : defVal;
        }

    static void decodeError(XmlElement* xml, int ns = XMPPNamespace::Count,
        String* error = 0, String* text = 0, String* content = 0);

    static void decodeError(XmlElement* xml, String& error, String& text);

    static void encodeDateTimeSec(String& buf, unsigned int timeSec,
        unsigned int fractions = 0);

    static unsigned int decodeDateTimeSec(const String& time, unsigned int* fractions = 0);

    static unsigned int decodeDateTimeSecXDelay(const String& time);

    static void print(String& xmlStr, XmlChild& xml, bool verbose);

    static void toList(XmlElement& xml, NamedList& dest, const char* prefix);

    static bool split(NamedList& dest, const char* src, const char sep,
        bool nameFirst);

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

    static void buildFlags(String& dest, int src, const TokenDict* dict);

    static bool addChidren(XmlElement* dest, ObjList& list);

    static XmlElement* createEntityCaps(const String& hash, const char* node);

    static XmlElement* createEntityCapsGTalkV1(const char* node = 0,
        bool muc = false);

    static XmlElement* createPresence(const char* from,
        const char* to, Presence type = PresenceNone);

    static XmlElement* createMessage(const char* type, const char* from,
        const char* to, const char* id, const char* body);

    static inline XmlElement* createMessage(MsgType type, const char* from,
        const char* to, const char* id, const char* body)
        { return createMessage(msgText(type),from,to,id,body); }

    static XmlElement* createDialbackKey(const char* from, const char* to,
        const char* key);

    static XmlElement* createDialbackResult(const char* from, const char* to,
        XMPPError::Type rsp = XMPPError::NoError);

    static XmlElement* createDialbackVerify(const char* from, const char* to,
        const char* id, const char* key);

    static XmlElement* createDialbackVerifyRsp(const char* from, const char* to,
        const char* id, XMPPError::Type rsp = XMPPError::NoError);

    static int decodeDbRsp(XmlElement* xml);

    static inline XmlElement* createSubject(const char* subject)
        { return createElement(XmlTag::Subject,subject); }

    static inline const String& subject(XmlElement& xml) {
            XmlElement* s = findFirstChild(xml,XmlTag::Subject);
            return s ? s->getText() : String::empty();
        }

    static inline XmlElement* createBody(const char* body, int ns = XMPPNamespace::Count)
        { return createElement(XmlTag::Body,ns,body); }

    static const String& body(XmlElement& xml, int ns = XMPPNamespace::Count);

    static inline XmlElement* createParameter(const char* name, const char* value,
        const char* tag = "parameter") {
            XmlElement* tmp = new XmlElement(tag);
            tmp->setAttributeValid("name",name);
            tmp->setAttributeValid("value",value);
            return tmp;
        }

    static inline XmlElement* createParameter(const NamedString& pair,
        const char* tag = "parameter")
        { return createParameter(pair.name(),pair,tag); }

    static inline int ns(const XmlElement& xml) {
            String* xmlns = xml.xmlns();
            return xmlns ? s_ns[*xmlns] : XMPPNamespace::Count;
        }

    static inline int tag(const XmlElement& xml)
        { return s_tag[xml.getTag()]; }

    static inline bool getTag(const XmlElement& xml, int& tag, int& ns) {
             const String* t = 0;
             const String* n = 0;
             if (!xml.getTag(t,n))
                return false;
             tag = s_tag[*t];
             ns = n ? s_ns[*n] : XMPPNamespace::Count;
             return tag != XmlTag::Count;
        }

    static inline bool isTag(const XmlElement& xml, int tag, int ns) {
            int t,n;
            return getTag(xml,t,n) && tag == t && n == ns;
        }

    static inline bool isUnprefTag(const XmlElement& xml, int tag)
        { return xml.unprefixedTag() == s_tag[tag]; }

    static inline bool isStanza(const XmlElement& xml) {
            int t,n;
            return getTag(xml,t,n) &&
                (t == XmlTag::Iq || t == XmlTag::Presence || t == XmlTag::Message);
        }

    static XmlElement* getXml(GenObject* gen, bool takeOwnerShip = true);

    static XmlElement* getXml(const String& data);

    static XmlElement* getXml(NamedList& list, const char* param = "xml",
        const char* extra = "data");

    static XmlElement* getPresenceXml(NamedList& list, const char* param = "xml",
        const char* extra = "data", Presence type = PresenceNone, bool build = true);

    static XmlElement* getChatXml(NamedList& list, const char* param = "xml",
        const char* extra = "data", bool build = true);

    static int cmpBytes(const String& s1, const String& s2);

    static inline Presence presenceType(const char* text)
        { return (Presence)lookup(text,s_presence,PresenceNone); }

    static inline const char* presenceText(Presence presence)
        { return lookup(presence,s_presence,0); }

    static inline MsgType msgType(const char* text)
        { return (MsgType)lookup(text,s_msg,Normal); }

    static inline const char* msgText(MsgType msg)
        { return lookup(msg,s_msg,0); }

    static inline IqType iqType(const char* text)
        { return (IqType)lookup(text,s_iq,IqCount); }

    static inline int authMeth(const char* text, int defVal = AuthNone)
        { return lookup(text,s_authMeth,defVal); }

    static XMPPNamespace s_ns;

    static XMPPError s_error;

    static XmlTag s_tag;

    static const TokenDict s_presence[];

    static const TokenDict s_msg[];

    static const TokenDict s_iq[];

    static const TokenDict s_commandAction[];

    static const TokenDict s_commandStatus[];

    static const TokenDict s_authMeth[];
};

class YJABBER_API XMPPDirVal
{
public:
    enum Direction {
        None = 0x00,
        To = 0x01,
        From = 0x02,
        PendingIn = 0x10,
        PendingOut = 0x20,
        // Masks
        Both = 0x03,
        Pending = 0x30
    };

    inline XMPPDirVal(int flags = None)
        : m_value(flags)
        {}

    inline XMPPDirVal(const String& flags)
        : m_value(0)
        { replace(flags); }

    inline XMPPDirVal(const XMPPDirVal& other)
        : m_value(other.m_value)
        {}

    inline void replace(int flag)
        { m_value = flag; }

    inline void replace(const String& flags)
        { m_value = XMPPUtils::decodeFlags(flags,s_names); }

    void toString(String& buf, bool full) const;

    void toSubscription(String& buf) const;

    inline void set(int flag)
        { m_value |= flag; }

    inline void reset(int flag)
        { m_value &= ~flag; }

    inline bool test(int mask) const
        { return (m_value & mask) != 0; }

    inline bool to() const
        { return test(To); }

    inline bool from() const
        { return test(From); }

    inline operator int()
        { return m_value; }

    static const TokenDict s_names[];
 
private:
    int m_value;                         // The value
};

class YJABBER_API XmlElementOut : public RefObject
{
public:
    inline XmlElementOut(XmlElement* element, const char* senderID = 0,
        bool unclose = false)
        : m_element(element), m_offset(0), m_id(senderID), m_unclose(unclose),
        m_sent(false)
        {}

    virtual ~XmlElementOut()
        { TelEngine::destruct(m_element); }

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

    inline bool sent() const
        { return m_sent; }

    inline const String& buffer()
        { return m_buffer; }

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

    inline unsigned int dataCount()
        { return m_buffer.length() - m_offset; }

    inline const char* getData(unsigned int& nCount) {
            if (!m_buffer)
                prepareToSend();
            nCount = dataCount();
            return m_buffer.c_str() + m_offset;
        }

    inline void dataSent(unsigned int nCount) {
            m_sent = true;
            m_offset += nCount;
            if (m_offset > m_buffer.length())
                m_offset = m_buffer.length();
        }

    inline XmlElement* release() {
            XmlElement* e = m_element;
            m_element = 0;
            return e;
        }

    inline void toBuffer(String& buffer) {
            if (m_element)
                m_element->toString(buffer,true,String::empty(),String::empty(),!m_unclose);
        }

    inline void prepareToSend()
        { toBuffer(m_buffer); }
 
private:
    XmlElement* m_element;               // The XML element
    String m_buffer;                     // Data to send
    unsigned int m_offset;               // Offset to send
    String m_id;                         // Sender's id
    bool m_unclose;                      // Close or not the element's tag
    bool m_sent;                         // Sent flag (true if an attempt to send was done)
};
 
};
 
#endif /* __XMPPUTILS_H */
 
/* vi: set ts=8 sw=4 sts=4 noet: */