yatesip.h

 
#ifndef __YATESIP_H
#define __YATESIP_H
 
#include <yateclass.h>
#include <yatemime.h>
 
#ifdef _WINDOWS
 
#ifdef LIBYSIP_EXPORTS
#define YSIP_API __declspec(dllexport)
#else
#ifndef LIBYSIP_STATIC
#define YSIP_API __declspec(dllimport)
#endif
#endif
 
#endif /* _WINDOWS */
 
#ifndef YSIP_API
#define YSIP_API
#endif

namespace TelEngine {

extern YSIP_API TokenDict* SIPResponses;
 
class SIPEngine;
class SIPEvent;
 
class YSIP_API SIPParty : public RefObject
{
public:
    SIPParty(Mutex* mutex = 0);
    SIPParty(bool reliable, Mutex* mutex = 0);
    virtual ~SIPParty();
    virtual bool transmit(SIPEvent* event) = 0;
    virtual const char* getProtoName() const = 0;
    virtual bool setParty(const URI& uri) = 0;
    virtual void* getTransport() = 0;
    void setAddr(const String& addr, int port, bool local);
    void getAddr(String& addr, int& port, bool local);
    inline void appendAddr(String& buf, bool local, bool unsafe = true) {
            Lock lock(unsafe ? m_mutex : 0);
            if (local)
                SocketAddr::appendTo(buf,m_local,m_localPort);
            else
                SocketAddr::appendTo(buf,m_party,m_partyPort);
        }
    inline Mutex* mutex()
        { return m_mutex; }
    inline const String& getLocalAddr() const
        { return m_local; }
    inline const String& getPartyAddr() const
        { return m_party; }
    inline int getLocalPort() const
        { return m_localPort; }
    inline int getPartyPort() const
        { return m_partyPort; }
    inline bool isReliable() const
        { return m_reliable; }
protected:
    Mutex* m_mutex;
    bool m_reliable;
    String m_local;
    String m_party;
    int m_localPort;
    int m_partyPort;
};

class YSIP_API SIPSequence : public RefObject, public Mutex
{
public:
    inline SIPSequence(int32_t cseq = -1)
        : Mutex(false,"CSeq"), m_cseq(cseq)
        { }

    inline int32_t getLastCSeq() const
        { return m_cseq; }

    inline int32_t getNextCSeq()
        { Lock mylock(this); return (++m_cseq > 0) ? m_cseq : (m_cseq = 1); }

    inline void setCSeq(int32_t cseq)
        { m_cseq = cseq; }
 
private:
    int32_t m_cseq;
};

class YSIP_API SIPMessage : public RefObject
{
public:
    enum Flags {
        Defaults          =      0,
        NotReqRport       = 0x0001,
        NotAddAllow       = 0x0002,
        NotAddAgent       = 0x0004,
        RportAfterBranch  = 0x0008,
        NotSetRport       = 0x0010,
        NotSetReceived    = 0x0020,
        NoConnReuse       = 0x0040,      // Don't add 'alias' parameter to Via header (reliable only)
        NoTagFailure      = 0x0080,      // Don't add a To tag for 3xx/4xx/5xx/6xx answers
    };

    SIPMessage(const SIPMessage& original);

    SIPMessage(const char* _method, const char* _uri, const char* _version = "SIP/2.0");

    SIPMessage(SIPParty* ep, const char* buf, int len = -1, unsigned int* bodyLen = 0);

    SIPMessage(const SIPMessage* message, int _code, const char* _reason = 0);

    SIPMessage(const SIPMessage* original, const SIPMessage* answer);

    virtual ~SIPMessage();

    static SIPMessage* fromParsing(SIPParty* ep, const char* buf, int len = -1,
        unsigned int* bodyLen = 0);

    void buildBody(const char* buf, int len = -1);

    void complete(SIPEngine* engine, const char* user = 0, const char* domain = 0, const char* dlgTag = 0, int flags = -1);

    bool copyHeader(const SIPMessage* message, const char* name, const char* newName = 0);

    int copyAllHeaders(const SIPMessage* message, const char* name, const char* newName = 0);

    inline SIPParty* getParty() const
        { return m_ep; }

    void setParty(SIPParty* ep = 0);

    inline bool isValid() const
        { return m_valid; }

    inline bool isAnswer() const
        { return m_answer; }

    inline bool isOutgoing() const
        { return m_outgoing; }

    inline bool isACK() const
        { return m_ack; }

    inline bool isReliable() const
        { return m_ep ? m_ep->isReliable() : false; }

    inline int32_t getCSeq() const
        { return m_cseq; }

    inline void setCSeq(int32_t cseq)
        { m_cseq = cseq; }

    inline int getFlags() const
        { return m_flags; }

    inline bool dontSend() const
        { return m_dontSend; }

    inline void dontSend(bool val)
        { m_dontSend = val; }

    const MimeHeaderLine* getHeader(const char* name) const;

    const MimeHeaderLine* getLastHeader(const char* name) const;

    int countHeaders(const char* name) const;

    const NamedString* getParam(const char* name, const char* param, bool last = false) const;

    const String& getHeaderValue(const char* name, bool last = false) const;

    const String& getParamValue(const char* name, const char* param, bool last = false) const;

    inline void addHeader(const char* name, const char* value = 0)
        { header.append(new MimeHeaderLine(name,value)); }

    inline void addHeader(MimeHeaderLine* line)
        { header.append(line); }

    void clearHeaders(const char* name);

    inline void setHeader(const char* name, const char* value = 0)
        { clearHeaders(name); addHeader(name,value); }

    MimeAuthLine* buildAuth(const String& username, const String& password,
        const String& meth, const String& uri, bool proxy = false, SIPEngine* engine = 0) const;

    MimeAuthLine* buildAuth(const SIPMessage& original, SIPEngine* engine = 0) const;

    inline void setAutoAuth(const char* username = 0, const char* password = 0)
        { m_authUser = username; m_authPass = password; }

    inline const String& getAuthUsername() const
        { return m_authUser; }

    inline const String& getAuthPassword() const
        { return m_authPass; }

    ObjList* getRoutes() const;

    void addRoutes(const ObjList* routes);

    inline SIPSequence* getSequence() const
        { return m_seq; }

    inline void setSequence(SIPSequence* seq)
        { m_seq = seq; }

    const DataBlock& getBuffer() const;

    const String& getHeaders() const;

    void setBody(MimeBody* newbody = 0);

    const String& traceId() const 
        { return msgTraceId; }

    String version;

    String method;

    String uri;

    int code;

    String reason;

    ObjList header;

    MimeBody* body;

    String msgTraceId;

    bool msgPrint;
 
protected:
    bool parse(const char* buf, int len, unsigned int* bodyLen);
    bool parseFirst(String& line);
    SIPParty* m_ep;
    RefPointer<SIPSequence> m_seq;
    bool m_valid;
    bool m_answer;
    bool m_outgoing;
    bool m_ack;
    int32_t m_cseq;
    int m_flags;
    mutable String m_string;
    mutable DataBlock m_data;
    String m_authUser;
    String m_authPass;
    bool m_dontSend;
private:
    SIPMessage(); // no, thanks
};

class YSIP_API SIPDialog : public String
{
public:
    inline SIPDialog()
        : remoteCSeq(-1)
        { }

    SIPDialog(const SIPDialog& original);

    explicit SIPDialog(const SIPMessage& message);

    inline explicit SIPDialog(const String& callid)
        : String(callid), remoteCSeq(-1)
        { }

    SIPDialog& operator=(const SIPDialog& original);

    SIPDialog& operator=(const SIPMessage& message);

    SIPDialog& operator=(const String& callid);

    bool matches(const SIPDialog& other, bool ignoreURIs) const;

    inline bool operator==(const SIPDialog& other) const
        { return matches(other,false); }

    inline bool operator!=(const SIPDialog& other) const
        { return !matches(other,false); }

    inline bool operator&=(const SIPDialog& other) const
        { return matches(other,true); }

    inline bool operator|=(const SIPDialog& other) const
        { return !matches(other,true); }

    inline const String& fromURI(bool outgoing) const
        { return outgoing ? localURI : remoteURI; }

    inline const String& fromTag(bool outgoing) const
        { return outgoing ? localTag : remoteTag; }

    inline const String& toURI(bool outgoing) const
        { return outgoing ? remoteURI : localURI; }

    inline const String& toTag(bool outgoing) const
        { return outgoing ? remoteTag : localTag; }

    inline SIPSequence* getSequence() const
        { return m_seq; }

    inline void setSequence(SIPSequence* seq)
        { m_seq = seq; }

    void setCSeq(int32_t cseq);

    inline int32_t getLastCSeq() const
        { return m_seq ? m_seq->getLastCSeq() : -1; }

    inline int32_t getNextCSeq()
        { return m_seq ? m_seq->getNextCSeq() : -1; }

    inline bool adjustCSeq(int cseq)
        { return (cseq > remoteCSeq) && ((remoteCSeq = cseq) >= 0); }

    inline bool adjustCSeq(const SIPMessage* message)
        { return message && adjustCSeq(message->getCSeq()); }

    String localURI;

    String localTag;

    String remoteURI;

    String remoteTag;

    int remoteCSeq;
 
protected:
    RefPointer<SIPSequence> m_seq;
};

class YSIP_API SIPTransaction : public RefObject
{
public:
    enum State {
        // Invalid state - before constructor or after destructor
        Invalid,
 
        // Initial state - after the initial message was inserted
        Initial,
 
        // Trying state - got the message but no decision made yet
        Trying,
 
        // Process state - while locally processing the event
        Process,
 
        // Retrans state - retransmits latest message until getting ACK
        Retrans,
 
        // Finish state - transmits the last message on client retransmission
        Finish,
 
        // Cleared state - removed from engine, awaiting destruction
        Cleared
    };

    enum Processed {
        // Not matched at all
        NoMatch,
 
        // Belongs to another dialog - probably result of a fork
        NoDialog,
 
        // Matched to transaction/dialog and processed
        Matched
    };

    SIPTransaction(SIPMessage* message, SIPEngine* engine, bool outgoing = true,
        bool* autoChangeParty = 0);

    SIPTransaction(const SIPTransaction& original, const String& tag);

    virtual ~SIPTransaction();

    static const char* stateName(int state);

    inline int getState() const
        { return m_state; }

    inline bool isActive() const
        { return (Invalid < m_state) && (m_state < Finish); }

    inline const SIPMessage* initialMessage() const
        { return m_firstMessage; }

    inline const SIPMessage* latestMessage() const
        { return m_lastMessage; }

    inline const SIPMessage* recentMessage() const
        { return m_lastMessage ? m_lastMessage : m_firstMessage; }

    inline SIPEngine* getEngine() const
        { return m_engine; }

    inline bool isOutgoing() const
        { return m_outgoing; }

    inline bool isIncoming() const
        { return !m_outgoing; }

    inline bool isInvite() const
        { return m_invite; }

    inline bool isReliable() const
        { return m_firstMessage ? m_firstMessage->isReliable() : false; }

    inline const String& getMethod() const
        { return m_firstMessage ? m_firstMessage->method : String::empty(); }

    inline const String& getURI() const
        { return m_firstMessage ? m_firstMessage->uri : String::empty(); }

    inline const String& getBranch() const
        { return m_branch; }

    inline const String& getCallID() const
        { return m_callid; }

    inline const String& getDialogTag() const
        { return m_tag; }

    void setDialogTag(const char* tag = 0);

    inline void setTransmit()
        { m_transmit = true; }

    inline void setCleared()
        { changeState(Cleared); }

    inline unsigned int getTransCount() const
        { return m_transCount; }

    void setTransCount(int count);

    inline bool autoAck() const
        { return m_autoAck; }

    inline void autoAck(bool setAuto)
        { m_autoAck = setAuto; }

    void requestAuth(const String& realm, const String& domain, bool stale, bool proxy = false);

    int authUser(String& user, bool proxy = false, GenObject* userData = 0);

    virtual Processed processMessage(SIPMessage* message, const String& branch);

    virtual void processMessage(SIPMessage* message);

    virtual SIPEvent* getEvent(bool pendingOnly = false, u_int64_t time = 0);

    bool setResponse() const;

    bool setResponse(int code, const char* reason = 0);

    void setResponse(SIPMessage* message);

    inline int getResponseCode() const
        { return m_response; }

    bool setAcknowledge(MimeBody* ackBody = 0);

    void msgTransmitFailed(SIPMessage* msg);

    inline void setUserData(void* data)
        { m_private = data; }

    inline void* getUserData() const
        { return m_private; }

    void setSilent();
    
    const String& traceId() const
        { return m_traceId; }
 
protected:
    SIPTransaction(SIPTransaction& original, SIPMessage* answer);

    virtual void destroyed();

    bool tryAutoAuth(SIPMessage* answer);

    virtual SIPEvent* getClientEvent(int state, int timeout);

    virtual SIPEvent* getServerEvent(int state, int timeout);

    virtual void processClientMessage(SIPMessage* message, int state);

    virtual void processServerMessage(SIPMessage* message, int state);

    bool changeState(int newstate);

    void setLatestMessage(SIPMessage* message = 0);

    void setPendingEvent(SIPEvent* event = 0, bool replace = false);

    inline bool isPendingEvent() const
        { return (m_pending != 0); }

    void setTimeout(u_int64_t delay = 0, unsigned int count = 1);
 
    bool m_outgoing;
    bool m_invite;
    bool m_transmit;
    int m_state;
    int m_response;
    unsigned int m_transCount;
    unsigned int m_timeouts;
    u_int64_t m_delay;
    u_int64_t m_timeout;
    SIPMessage* m_firstMessage;
    SIPMessage* m_lastMessage;
    SIPEvent* m_pending;
    SIPEngine* m_engine;
    String m_branch;
    String m_callid;
    String m_tag;
    void *m_private;
    bool m_autoChangeParty;
    bool m_autoAck;
    bool m_silent;
    String m_traceId;
};

class YSIP_API SIPEvent
{
    friend class SIPTransaction;
public:
 
    SIPEvent()
        : m_message(0), m_transaction(0), m_state(SIPTransaction::Invalid)
        { }
 
    SIPEvent(SIPMessage* message, SIPTransaction* transaction = 0);
 
    ~SIPEvent();

    inline SIPEngine* getEngine() const
        { return m_transaction ? m_transaction->getEngine() : 0; }

    inline SIPMessage* getMessage() const
        { return m_message; }

    inline SIPTransaction* getTransaction() const
        { return m_transaction; }

    inline bool isOutgoing() const
        { return m_message && m_message->isOutgoing(); }

    inline bool isIncoming() const
        { return m_message && !m_message->isOutgoing(); }

    inline SIPParty* getParty() const
        { return m_message ? m_message->getParty() : 0; }

    inline void* getUserData() const
        { return m_transaction ? m_transaction->getUserData() : 0; }

    inline int getState() const
        { return m_state; }

    inline bool isActive() const
        { return (SIPTransaction::Invalid < m_state) && (m_state < SIPTransaction::Finish); }

    inline const String& traceId() const
        { return m_transaction ? m_transaction->traceId() : String::empty(); }
 
protected:
    SIPMessage* m_message;
    SIPTransaction* m_transaction;
    int m_state;
};

class YSIP_API SIPEngine : public DebugEnabler, public Mutex
{
public:
    SIPEngine(const char* userAgent = 0);

    virtual ~SIPEngine();

    virtual bool buildParty(SIPMessage* message) = 0;

    virtual void allocTraceId(String& id) = 0;

    virtual void traceMsg(SIPMessage* message, bool incoming = true) = 0;

    virtual bool checkUser(String& username, const String& realm, const String& nonce,
        const String& method, const String& uri, const String& response,
        const SIPMessage* message, const MimeHeaderLine* authLine, GenObject* userData);

    virtual bool checkAuth(bool noUser, String& username, const SIPMessage* message,
        const MimeHeaderLine* authLine, GenObject* userData);

    int authUser(const SIPMessage* message, String& user, bool proxy = false, GenObject* userData = 0);

    SIPTransaction* addMessage(SIPParty* ep, const char* buf, int len = -1);

    SIPTransaction* addMessage(SIPMessage* message, bool* autoChangeParty = 0);

    SIPEvent *getEvent();

    bool process();

    virtual void processEvent(SIPEvent *event);

    virtual SIPTransaction* forkInvite(SIPMessage* answer, SIPTransaction* trans);

    virtual u_int64_t getUserTimeout() const;

    u_int64_t getTimer(char which, bool reliable = false) const;

    inline unsigned int getReqTransCount() const
        { return m_reqTransCount; }

    inline unsigned int getRspTransCount() const
        { return m_rspTransCount; }

    inline unsigned int getMaxForwards() const
        { return m_maxForwards; }

    inline const String& getUserAgent() const
        { return m_userAgent; }

    inline SIPSequence* getSequence() const
        { return m_seq; }

    inline int32_t getNextCSeq()
        { return m_seq->getNextCSeq(); }

    inline bool lazyTrying() const
        { return m_lazyTrying; }

    inline void lazyTrying(bool lazy100)
        { m_lazyTrying = lazy100; }

    inline int flags() const
        { return m_flags; }

    inline bool autoChangeParty() const
        { return m_autoChangeParty; }

    void nonceGet(String& nonce);

    long nonceAge(const String& nonce);

    void ncGet(String& nc);

    static void buildAuth(const String& username, const String& realm, const String& passwd,
        const String& nonce, const String& method, const String& uri, String& response,
        const NamedList& qop = NamedList::empty());

    static void buildAuth(const String& hash_a1, const String& nonce, const String& hash_a2,
        String& response);

    bool isAllowed(const char* method) const;

    void addAllowed(const char* method);

    inline const String& getAllowed() const
        { return m_allowed; }

    inline void remove(SIPTransaction* transaction)
        { lock(); m_transList.remove(transaction,false); unlock(); }

    inline void append(SIPTransaction* transaction)
        { lock(); m_transList.append(transaction); unlock(); }

    inline void insert(SIPTransaction* transaction)
        { lock(); m_transList.insert(transaction); unlock(); }

    inline unsigned int transactionCount()
        { Lock mylock(this); return m_transList.count(); }
 
protected:
    ObjList m_transList;
 
    u_int64_t m_t1;
    u_int64_t m_t4;
    int m_reqTransCount;
    int m_rspTransCount;
    unsigned int m_maxForwards;
    int m_flags;
    bool m_lazyTrying;
    String m_userAgent;
    String m_allowed;
    RefPointer<SIPSequence> m_seq;
    u_int32_t m_nc;
    String m_nonce;
    String m_nonce_secret;
    u_int32_t m_nonce_time;
    Mutex m_nonce_mutex;
    bool m_autoChangeParty;
};
 
}
 
#endif /* __YATESIP_H */
 
/* vi: set ts=8 sw=4 sts=4 noet: */