yateiax.h

 
#ifndef __YATEIAX_H
#define __YATEIAX_H
 
#include <yateclass.h>
 
#ifdef _WINDOWS
 
#ifdef LIBYIAX_EXPORTS
#define YIAX_API __declspec(dllexport)
#else
#ifndef LIBYIAX_STATIC
#define YIAX_API __declspec(dllimport)
#endif
#endif
 
#endif /* _WINDOWS */
 
#ifndef YIAX_API
#define YIAX_API
#endif

namespace TelEngine {
 
class IAXInfoElement;                    // A single IAX2 Information Element
class IAXInfoElementString;              // A single IAX2 text Information Element
class IAXInfoElementNumeric;             // A single IAX2 numeric Information Element
class IAXInfoElementBinary;              // A single IAX2 numeric Information Element
class IAXIEList;                         // Information Element container
class IAXAuthMethod;                     // Wrapper class for authentication methods values
class IAXFormatDesc;                     // IAX format description
class IAXFormat;                         // Wrapper class for formats
class IAXControl;                        // Wrapper class for subclasses of frames of type IAX
class IAXFrame;                          // This class holds an IAX frame
class IAXFullFrame;                      // This class holds an IAX full frame
class IAXFrameOut;                       // This class holds an outgoing IAX full frame
class IAXTrunkInfo;                      // Trunk info
class IAXMetaTrunkFrame;                 // Meta trunk frame
class IAXMediaData;                      // IAX2 transaction media data
class IAXTransaction;                    // An IAX2 transaction
class IAXEvent;                          // Event class
class IAXEngine;                         // IAX engine
 
#define IAX_PROTOCOL_VERSION         0x0002           // Protocol version
#define IAX2_MAX_CALLNO              32767            // Max call number value
#define IAX2_MAX_TRANSINFRAMELIST    127              // Max transaction incoming frame list
 
// Trunk frame header length
#define IAX2_TRUNKFRAME_HEADERLENGTH 8
// Trunk frame length
#define IAX2_TRUNKFRAME_LEN_MIN 20                    // 16 bytes: meta header + miniframe with timestamps header
#define IAX2_TRUNKFRAME_LEN_DEF 1400
// Trunk frame send interval in milliseconds
#define IAX2_TRUNKFRAME_SEND_MIN 5
#define IAX2_TRUNKFRAME_SEND_DEF 20
 
// Frame retransmission
#define IAX2_RETRANS_COUNT_MIN 1
#define IAX2_RETRANS_COUNT_MAX 10
#define IAX2_RETRANS_COUNT_DEF 4
#define IAX2_RETRANS_INTERVAL_MIN 200
#define IAX2_RETRANS_INTERVAL_MAX 5000
#define IAX2_RETRANS_INTERVAL_DEF 500
 
// Ping
#define IAX2_PING_INTERVAL_MIN 10000
#define IAX2_PING_INTERVAL_DEF 20000
 
// Sent challenge timeout
#define IAX2_CHALLENGETOUT_MIN 5000
#define IAX2_CHALLENGETOUT_DEF 30000

class YIAX_API IAXInfoElement : public RefObject
{
public:
    enum Type {
        textframe = 0x00,        // Text        Used internally only to generate an event of type Text
        CALLED_NUMBER = 0x01,    // Text
        CALLING_NUMBER = 0x02,   // Text
        CALLING_ANI = 0x03,      // Text
        CALLING_NAME = 0x04,     // Text
        CALLED_CONTEXT = 0x05,   // Text
        USERNAME = 0x06,         // Text
        PASSWORD = 0x07,         // Text
        CAPABILITY = 0x08,       // DW
        FORMAT = 0x09,           // DW
        LANGUAGE = 0x0a,         // Text
        VERSION = 0x0b,          // W           Value: IAX_PROTOCOL_VERSION
        ADSICPE = 0x0c,          // W
        DNID = 0x0d,             // Text
        AUTHMETHODS = 0x0e,      // W
        CHALLENGE = 0x0f,        // Text
        MD5_RESULT = 0x10,       // Text
        RSA_RESULT = 0x11,       // Text
        APPARENT_ADDR = 0x12,    // BIN
        REFRESH = 0x13,          // W
        DPSTATUS = 0x14,         // W
        CALLNO = 0x15,           // W           Max value: IAX2_MAX_CALLNO
        CAUSE = 0x16,            // Text
        IAX_UNKNOWN = 0x17,      // B
        MSGCOUNT = 0x18,         // W
        AUTOANSWER = 0x19,       // Null
        MUSICONHOLD = 0x1a,      // Text
        TRANSFERID = 0x1b,       // DW
        RDNIS = 0x1c,            // Text
        PROVISIONING = 0x1d,     // BIN
        AESPROVISIONING = 0x1e,  // BIN
        DATETIME = 0x1f,         // DW
        DEVICETYPE = 0x20,       // Text
        SERVICEIDENT = 0x21,     // BIN
        FIRMWAREVER = 0x22,      // W
        FWBLOCKDESC = 0x23,      // DW
        FWBLOCKDATA = 0x24,      // BIN
        PROVVER = 0x25,          // DW
        CALLINGPRES = 0x26,      // B
        CALLINGTON = 0x27,       // B
        CALLINGTNS = 0x28,       // W
        SAMPLINGRATE = 0x29,     // DW
        CAUSECODE = 0x2a,        // B
        ENCRYPTION = 0x2b,       // B
        ENKEY = 0x2c,            // BIN
        CODEC_PREFS = 0x2d,      // Text
        RR_JITTER = 0x2e,        // DW
        RR_LOSS = 0x2f,          // DW
        RR_PKTS = 0x30,          // DW
        RR_DELAY = 0x31,         // W
        RR_DROPPED = 0x32,       // DW
        RR_OOO = 0x33,           // DW
        CALLTOKEN = 0x36,        // BIN
        CAPABILITY2 = 0x37,      // BIN         1 byte version + array
        FORMAT2 = 0x38,          // BIN         1 byte version + array
    };

    inline IAXInfoElement(Type type) : m_type(type) {}

    virtual ~IAXInfoElement() {}

    inline Type type() const
        { return m_type; }

    virtual void toBuffer(DataBlock& buf);

    virtual void toString(String& buf);

    static inline const char* ieText(u_int8_t ieCode)
        { return lookup(ieCode,s_ieData); }

    static inline const char* causeName(int code)
        { return lookup(code,s_causeName); }

    static inline int causeCode(const char* name, int defVal = 0)
        { return lookup(name,s_causeName,defVal); }

    static const TokenDict s_causeName[];

    static const TokenDict s_typeOfNumber[];

    static const TokenDict s_presentation[];

    static const TokenDict s_screening[];
 
private:
    static const TokenDict s_ieData[];// Association between IE type and text
    Type m_type;            // Type of this IE
};

class YIAX_API IAXInfoElementString : public IAXInfoElement
{
public:
    inline IAXInfoElementString(Type type, const char* buf, unsigned len) : IAXInfoElement(type), m_strData(buf,(int)len)
        {}

    virtual ~IAXInfoElementString() {}

    inline int length() const
        { return m_strData.length(); }

    inline String& data()
        { return m_strData; }

    virtual void toBuffer(DataBlock& buf);

    virtual void toString(String& buf)
        { buf << m_strData; }
 
private:
    String m_strData;             // IE text data
};

class YIAX_API IAXInfoElementNumeric : public IAXInfoElement
{
public:
    IAXInfoElementNumeric(Type type, u_int32_t val, u_int8_t len);

    virtual ~IAXInfoElementNumeric() {}

    inline int length() const
        { return m_length; }

    inline u_int32_t data() const
        { return m_numericData; }

    virtual void toBuffer(DataBlock& buf);

    virtual void toString(String& buf);
 
private:
    u_int8_t m_length;          // IE data length
    u_int32_t m_numericData;    // IE numeric data
};

class YIAX_API IAXInfoElementBinary : public IAXInfoElement
{
public:
    IAXInfoElementBinary(Type type, unsigned char* buf, unsigned len) : IAXInfoElement(type), m_data(buf,len)
        {}

    virtual ~IAXInfoElementBinary() {}

    inline int length() const
        { return m_data.length(); }

    inline DataBlock& data()
        { return m_data; }

    inline void setData(void* buf, unsigned len)
        { m_data.assign(buf,len); }

    virtual void toBuffer(DataBlock& buf);

    static IAXInfoElementBinary* packIP(const SocketAddr& addr);

    static bool unpackIP(SocketAddr& addr, IAXInfoElementBinary* ie);

    virtual void toString(String& buf);
 
private:
    DataBlock m_data;          // IE binary data
};

class YIAX_API IAXIEList
{
public:
    IAXIEList();

    IAXIEList(const IAXFullFrame* frame, bool incoming = true);

    ~IAXIEList();

    inline bool invalidIEList() const
        { return m_invalidIEList; }

    inline void clear()
        { m_list.clear(); }

    inline bool empty()
        { return 0 == m_list.skipNull(); }

    void insertVersion();

    inline bool validVersion() {
            u_int32_t ver = 0xFFFF;
            getNumeric(IAXInfoElement::VERSION,ver);
            return ver == IAX_PROTOCOL_VERSION;
        }

    inline void appendIE(IAXInfoElement* ie)
        { m_list.append(ie); }

    inline bool appendIE(IAXIEList& src, IAXInfoElement::Type type) {
            IAXInfoElement* ie = src.getIE(type,true);
            if (ie)
                appendIE(ie);
            return ie != 0;
        }

    inline void appendNull(IAXInfoElement::Type type)
        { m_list.append(new IAXInfoElement(type)); }

    inline void appendString(IAXInfoElement::Type type, const String& src)
        { m_list.append(new IAXInfoElementString(type,src.c_str(),src.length())); }

    inline void appendString(IAXInfoElement::Type type, unsigned char* src, unsigned len)
        { m_list.append(new IAXInfoElementString(type,(char*)src,len)); }

    inline void appendNumeric(IAXInfoElement::Type type, u_int32_t value, u_int8_t len)
        { m_list.append(new IAXInfoElementNumeric(type,value,len)); }

    inline void appendBinary(IAXInfoElement::Type type, unsigned char* data, unsigned len)
        { m_list.append(new IAXInfoElementBinary(type,data,len)); }

    bool createFromFrame(const IAXFullFrame* frame, bool incoming = true);

    void toBuffer(DataBlock& buf);

    void toString(String& dest, const char* indent = 0);

    IAXInfoElement* getIE(IAXInfoElement::Type type, bool remove = false);

    bool getString(IAXInfoElement::Type type, String& dest);

    bool getNumeric(IAXInfoElement::Type type, u_int32_t& dest);

    bool getBinary(IAXInfoElement::Type type, DataBlock& dest);
 
private:
    bool m_invalidIEList;       // Invalid IE flag
    ObjList m_list;              // The IE list
};

class YIAX_API IAXAuthMethod
{
public:
    enum Type {
        Text = 1,
        MD5  = 2,
        RSA  = 4,
    };

    static void authList(String& dest, u_int16_t auth, char sep);
 
    static TokenDict s_texts[];
};
 

class YIAX_API IAXFormatDesc
{
public:
    inline IAXFormatDesc()
        : m_format(0), m_multiplier(1)
        {}

    inline u_int32_t format() const
        { return m_format; }

    inline unsigned int multiplier() const
        { return m_multiplier; }

    void setFormat(u_int32_t fmt, int type);
 
protected:
    u_int32_t m_format;                  // The format
    unsigned int m_multiplier;           // Format multiplier derived from sampling rate
};

class YIAX_API IAXFormat
{
public:
    enum Formats {
        G723_1 = (1 <<  0),
        GSM    = (1 <<  1),
        ULAW   = (1 <<  2),
        ALAW   = (1 <<  3),
        G726   = (1 <<  4),
        ADPCM  = (1 <<  5),
        SLIN   = (1 <<  6),
        LPC10  = (1 <<  7),
        G729   = (1 <<  8),
        SPEEX  = (1 <<  9),
        ILBC   = (1 << 10),
        G726AAL2 = (1 << 11),
        G722   = (1 << 12),
        AMR    = (1 << 13),
        // NOTE: GSM Half Rate is not defined in RFC5456
        GSM_HR    = (1 << 31),
        AudioMask = G723_1 | GSM | ULAW | ALAW | G726 | ADPCM | SLIN | LPC10 | G729 | SPEEX |
            ILBC | G726AAL2 | G722 | AMR | GSM_HR,
        JPEG   = (1 << 16),
        PNG    = (1 << 17),
        ImageMask = JPEG | PNG,
        H261   = (1 << 18),
        H263   = (1 << 19),
        H263p  = (1 << 20),
        H264   = (1 << 21),
        VideoMask = H261 | H263 | H263p | H264,
    };

    enum Media {
        Audio = 0,
        Video,
        Image,
        TypeCount
    };

    inline IAXFormat(int type = Audio)
        : m_type(type)
        {}

    inline int type() const
        { return m_type; }

    inline u_int32_t format() const
        { return m_format.format(); }

    inline u_int32_t in() const
        { return m_formatIn.format(); }

    inline u_int32_t out() const
        { return m_formatOut.format(); }

    inline const IAXFormatDesc& formatDesc(bool in) const
        { return in ? m_formatIn : m_formatOut; }

    inline const char* formatName() const
        { return formatName(format()); }

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

    void set(u_int32_t* fmt, u_int32_t* fmtIn, u_int32_t* fmtOut);

    static void formatList(String& dest, u_int32_t formats, const TokenDict* dict = 0,
        const char* sep = ",");

    static u_int32_t pickFormat(u_int32_t formats, u_int32_t format = 0);

    static u_int32_t encode(const String& formats, const TokenDict* dict, char sep = ',');

    static inline u_int32_t mask(u_int32_t value, int type) {
            if (type == Audio)
                return value & AudioMask;
            if (type == Video)
                return value & VideoMask;
            if (type == Image)
                return value & ImageMask;
            return 0;
        }

    static inline u_int32_t clear(u_int32_t value, int type) {
            if (type == Audio)
                return value & ~AudioMask;
            if (type == Video)
                return value & ~VideoMask;
            if (type == Image)
                return value & ~ImageMask;
            return value;
        }

    static inline const char* formatName(u_int32_t fmt)
        { return lookup(fmt,s_formats); }

    static inline const char* typeName(int type)
        { return lookup(type,s_types); }

    static inline const String& typeNameStr(int type)
        { return s_typesList[type]; }

    static const TokenDict s_formats[];

    static const TokenDict s_types[];

    static const String s_typesList[TypeCount];
 
protected:
    int m_type;
    IAXFormatDesc m_format;
    IAXFormatDesc m_formatIn;
    IAXFormatDesc m_formatOut;
};

class YIAX_API IAXControl
{
public:
    enum Type {
        New       = 0x01,
        Ping      = 0x02,
        Pong      = 0x03,
        Ack       = 0x04,
        Hangup    = 0x05,
        Reject    = 0x06,
        Accept    = 0x07,
        AuthReq   = 0x08,
        AuthRep   = 0x09,
        Inval     = 0x0a,
        LagRq     = 0x0b,
        LagRp     = 0x0c,
        RegReq    = 0x0d,
        RegAuth   = 0x0e,
        RegAck    = 0x0f,
        RegRej    = 0x10,
        RegRel    = 0x11,
        VNAK      = 0x12,
        DpReq     = 0x13,
        DpRep     = 0x14,
        Dial      = 0x15,
        TxReq     = 0x16,
        TxCnt     = 0x17,
        TxAcc     = 0x18,
        TxReady   = 0x19,
        TxRel     = 0x1a,
        TxRej     = 0x1b,
        Quelch    = 0x1c,
        Unquelch  = 0x1d,
        Poke      = 0x1e,
        //Reserved  = 0x1f,
        MWI       = 0x20,
        Unsupport = 0x21,
        Transfer  = 0x22,
        Provision = 0x23,
        FwDownl   = 0x24,
        FwData    = 0x25,
        CallToken = 0x28,
    };

    static inline const char* typeText(int type)
        { return lookup(type,s_types,0); }
 
private:
    static TokenDict s_types[]; // Keep the association between IAX control codes and their name
};

class YIAX_API IAXFrame : public RefObject
{
public:
    enum Type {
        DTMF    = 0x01,
        Voice   = 0x02,
        Video   = 0x03,
        Control = 0x04,
        Null    = 0x05,
        IAX     = 0x06,
        Text    = 0x07,
        Image   = 0x08,
        HTML    = 0x09,
        Noise   = 0x0a,
    };

    IAXFrame(Type type, u_int16_t sCallNo, u_int32_t tStamp, bool retrans,
             const unsigned char* buf, unsigned int len, bool mark = false);

    virtual ~IAXFrame();

    inline Type type() const
        { return m_type; }

    inline DataBlock& data()
        { return m_data; }

    inline bool retrans() const
        { return m_retrans; }

    inline u_int16_t sourceCallNo() const
        { return m_sCallNo; }

    inline u_int32_t timeStamp() const
        { return m_tStamp; }

    inline bool mark() const
        { return m_mark; }

    virtual IAXFullFrame* fullFrame();

    static IAXFrame* parse(const unsigned char* buf, unsigned int len, IAXEngine* engine = 0, const SocketAddr* addr = 0);

    static inline void buildMiniFrame(DataBlock& dest, u_int16_t sCallNo, u_int32_t ts,
        void* data, unsigned int len) {
            unsigned char header[4] = {(unsigned char)(sCallNo >> 8),
                (unsigned char)sCallNo,(unsigned char)(ts >> 8),(unsigned char)ts};
            dest.assign(header,4);
            dest.append(data,len);
        }

    static void buildVideoMetaFrame(DataBlock& dest, u_int16_t sCallNo, u_int32_t tStamp,
        bool mark, void* data, unsigned int len);

    static u_int8_t packSubclass(u_int32_t value);

    static u_int32_t unpackSubclass(u_int8_t value);

    static inline const char* typeText(int type)
        { return lookup(type,s_types,0); }
 
protected:
    DataBlock m_data;

    bool m_retrans;
 
private:
    static TokenDict s_types[]; // Keep the association between IAX frame types and their names
    Type m_type;            // Frame type
    u_int16_t m_sCallNo;        // Source call number
    u_int32_t m_tStamp;         // Frame timestamp
    bool m_mark;                // Mark flag
};

class YIAX_API IAXFullFrame : public IAXFrame
{
public:
    enum ControlType {
        Hangup = 0x01,
        //Ring = 0x02,
        Ringing = 0x03,
        Answer = 0x04,
        Busy = 0x05,
        Congestion = 0x08,
        FlashHook = 0x09,
        Option = 0x0b,
        KeyRadio = 0x0c,
        UnkeyRadio = 0x0d,
        Progressing = 0x0e,
        Proceeding = 0x0f,
        Hold = 0x10,
        Unhold = 0x11,
        VidUpdate = 0x12,
        SrcUpdate = 0x14,
        StopSounds = 0xff,
    };

    IAXFullFrame(Type type, u_int32_t subclass, u_int16_t sCallNo, u_int16_t dCallNo,
                 unsigned char oSeqNo, unsigned char iSeqNo,
                 u_int32_t tStamp, bool retrans,
                 const unsigned char* buf, unsigned int len, bool mark = false);

    IAXFullFrame(Type type, u_int32_t subclass, u_int16_t sCallNo, u_int16_t dCallNo,
                 unsigned char oSeqNo, unsigned char iSeqNo,
                 u_int32_t tStamp,
                 const unsigned char* buf = 0, unsigned int len = 0, bool mark = false);

    IAXFullFrame(Type type, u_int32_t subclass, u_int16_t sCallNo, u_int16_t dCallNo,
                 unsigned char oSeqNo, unsigned char iSeqNo,
                 u_int32_t tStamp, IAXIEList* ieList, u_int16_t maxlen, bool mark = false);

    virtual ~IAXFullFrame();

    inline u_int16_t destCallNo() const
        { return m_dCallNo; }

    inline unsigned char oSeqNo() const
        { return m_oSeqNo; }

    inline unsigned char iSeqNo() const
        { return m_iSeqNo; }

    inline u_int32_t subclass() const
        { return m_subclass; }

    inline bool isAuthReq() const {
            return type() == IAXFrame::IAX &&
                (subclass() == IAXControl::AuthReq || subclass() == IAXControl::RegAuth);
        }

    inline bool isInval() const
        { return type() == IAXFrame::IAX && subclass() == IAXControl::Inval; }

    virtual IAXFullFrame* fullFrame();

    void updateBuffer(u_int16_t maxlen);

    inline IAXIEList* ieList()
        { return m_ieList; }

    bool updateIEList(bool incoming);

    IAXIEList* removeIEList(bool delObj = true);

    void toString(String& dest, const SocketAddr& local, const SocketAddr& remote,
        bool incoming);

    static inline const char* controlTypeText(int type)
        { return lookup(type,s_controlTypes,0); }
 
protected:
    virtual void destroyed();
 
private:
    // Build frame buffer header
    void setDataHeader();
    static TokenDict s_controlTypes[]; // Keep the association between control types and their names
    u_int16_t m_dCallNo;        // Destination call number
    unsigned char m_oSeqNo;     // Out sequence number
    unsigned char m_iSeqNo;     // In sequence number
    u_int32_t m_subclass;       // Subclass
    IAXIEList* m_ieList;        // List of IEs
};

class YIAX_API IAXFrameOut : public IAXFullFrame
{
public:
    inline IAXFrameOut(Type type, u_int32_t subclass, u_int16_t sCallNo, u_int16_t dCallNo,
                       unsigned char oSeqNo, unsigned char iSeqNo, u_int32_t tStamp,
                       const unsigned char* buf, unsigned int len,
                       u_int16_t retransCount, u_int32_t retransIntervalMs,
                       bool ackOnly, bool mark = false)
        : IAXFullFrame(type,subclass,sCallNo,dCallNo,oSeqNo,iSeqNo,tStamp,buf,len,mark),
          m_ack(false), m_ackOnly(ackOnly), m_retransCount(retransCount),
          m_retransTimeInterval(retransIntervalMs * 1000),
          m_nextTransTime(Time::now() + m_retransTimeInterval)
        {}

    inline IAXFrameOut(Type type, u_int32_t subclass, u_int16_t sCallNo, u_int16_t dCallNo,
                       unsigned char oSeqNo, unsigned char iSeqNo, u_int32_t tStamp,
                       IAXIEList* ieList, u_int16_t maxlen,
                       u_int16_t retransCount, u_int32_t retransIntervalMs, bool ackOnly,
                       bool mark = false)
        : IAXFullFrame(type,subclass,sCallNo,dCallNo,oSeqNo,iSeqNo,tStamp,ieList,maxlen,mark),
          m_ack(false), m_ackOnly(ackOnly), m_retransCount(retransCount),
          m_retransTimeInterval(retransIntervalMs * 1000),
          m_nextTransTime(Time::now() + m_retransTimeInterval)
        {}

    virtual ~IAXFrameOut()
        {}

    inline unsigned int retransCount() const
        { return m_retransCount; }

    inline bool timeForRetrans(u_int64_t time) const
        { return time >= m_nextTransTime; }

    inline void setRetrans() {
            if (m_retrans)
                return;
            m_retrans = true;
            ((unsigned char*)m_data.data())[2] |= 0x80;
        }

    inline void transmitted() {
            if (!m_retransCount)
                return;
            m_retransCount--;
            m_retransTimeInterval *= 2;
            m_nextTransTime += m_retransTimeInterval;
        }

    inline bool ack() const
        { return m_ack; }

    inline void setAck()
        { m_ack = true; }

    inline bool ackOnly() const
        { return m_ackOnly; }

    inline bool canSetTimeout()
        { return m_retransTimeInterval != 0; }

    inline void setTimeout(u_int64_t tout) {
            if (!m_retransTimeInterval)
                return;
            m_retransTimeInterval = 0;
            m_retransCount = 0;
            m_nextTransTime = tout;
        }
 
private:
    bool m_ack;                         // Acknoledge flag
    bool m_ackOnly;                     // Frame need only ACK as a response
    u_int16_t m_retransCount;           // Retransmission counter
    u_int32_t m_retransTimeInterval;    // Retransmission interval
    u_int64_t m_nextTransTime;          // Next transmission time
};

class YIAX_API IAXTrunkInfo : public RefObject
{
public:
    inline IAXTrunkInfo()
        : m_timestamps(true), m_sendInterval(IAX2_TRUNKFRAME_SEND_DEF),
        m_maxLen(IAX2_TRUNKFRAME_LEN_DEF),
        m_efficientUse(false), m_trunkInSyncUsingTs(true),
        m_trunkInTsDiffRestart(5000),
        m_retransCount(IAX2_RETRANS_COUNT_DEF),
        m_retransInterval(IAX2_RETRANS_INTERVAL_DEF),
        m_pingInterval(IAX2_PING_INTERVAL_DEF)
        {}

    void init(const NamedList& params, const String& prefix = String::empty(),
        const IAXTrunkInfo* def = 0);

    void initTrunking(const NamedList& params, const String& prefix = String::empty(),
        const IAXTrunkInfo* def = 0, bool out = true, bool in = true);

    void updateTrunking(const NamedList& params, const String& prefix = String::empty(),
        bool out = true, bool in = true);

    void dump(String& buf, const char* sep = " ", bool out = true, bool in = true,
        bool other = true);
 
    bool m_timestamps;                   // Trunk type: with(out) timestamps
    unsigned int m_sendInterval;         // Send interval
    unsigned int m_maxLen;               // Max frame length
    bool m_efficientUse;                 // Outgoing trunking: use or not the trunk based on calls using it
    bool m_trunkInSyncUsingTs;           // Incoming trunk without timestamps: use trunk
                                         //  time or trunk timestamp to re-build frame ts
    u_int32_t m_trunkInTsDiffRestart;    // Incoming trunk without timestamp: diff between
                                         //  timestamps at which we restart
    unsigned int m_retransCount;         // Frame retransmission counter
    unsigned int m_retransInterval;      // Frame retransmission interval in milliseconds
    unsigned int m_pingInterval;         // Ping interval in milliseconds
};

class YIAX_API IAXMetaTrunkFrame : public RefObject, public Mutex
{
public:
    IAXMetaTrunkFrame(IAXEngine* engine, const SocketAddr& addr, bool timestamps,
        unsigned int maxLen, unsigned int sendInterval);

    virtual ~IAXMetaTrunkFrame();

    inline const SocketAddr& addr() const
        { return m_addr; }

    inline unsigned int calls() const
        { return m_calls; }

    inline void changeCalls(bool add) {
            Lock lck(this);
            if (add)
                m_calls++;
            else if (m_calls)
                m_calls--;
        }

    inline bool trunkTimestamps() const
        { return m_trunkTimestamps; }

    inline unsigned int sendInterval() const
        { return m_sendInterval; }

    inline unsigned int maxLen() const
        { return m_maxLen; }

    unsigned int add(u_int16_t sCallNo, const DataBlock& data, u_int32_t tStamp);

    inline bool timerTick(const Time& now = Time()) {
            if (m_dataAddIdx == IAX2_TRUNKFRAME_HEADERLENGTH || !m_send)
                return false;
            Lock lck(this);
            return (now > m_send) && doSend(now,true);
        }

    inline bool send() {
            if (m_dataAddIdx == IAX2_TRUNKFRAME_HEADERLENGTH)
                return false;
            Lock lck(this);
            return m_dataAddIdx != IAX2_TRUNKFRAME_HEADERLENGTH && doSend();
        }
 
private:
    IAXMetaTrunkFrame() {}      // No default constructor
    // Send this frame to remote peer
    bool doSend(const Time& now = Time(), bool onTime = false);
    // Set timestamp and next time to send
    inline void setTimestamp(u_int64_t now) {
            m_timeStamp = now;
            m_send = now + (u_int64_t)m_sendInterval * 1000;
        }
    // Set next time to send
    inline void setSendTime(u_int64_t now)
        { m_send = now + (u_int64_t)m_sendInterval * 1000; }
 
    // Set the timestamp of this frame
    inline void setTimestamp(u_int32_t tStamp) {
            m_data[4] = (u_int8_t)(tStamp >> 24);
            m_data[5] = (u_int8_t)(tStamp >> 16);
            m_data[6] = (u_int8_t)(tStamp >> 8);
            m_data[7] = (u_int8_t)tStamp;
        }
 
    unsigned int m_calls;       // The number of calls using it
    u_int8_t* m_data;           // Data buffer
    u_int16_t m_dataAddIdx;     // Current add index
    u_int64_t m_timeStamp;      // First time data was added
    u_int64_t m_send;           // Time to send
    u_int32_t m_lastSentTs;     // Last sent timestamp
    unsigned int m_sendInterval;// Send interval in milliseconds
    IAXEngine* m_engine;        // The engine that owns this frame
    SocketAddr m_addr;          // Remote peer address
    bool m_trunkTimestamps;     // Trunk type: with(out) timestamps
    unsigned int m_maxLen;      // Max frame length
    unsigned int m_maxDataLen;  // Max frame data length
    unsigned char m_miniHdrLen; // Miniframe header length
};

class YIAX_API IAXMediaData
{
    friend class IAXTransaction;
public:
    inline IAXMediaData()
        : m_inMutex(false,"IAXTransaction::InMedia"),
        m_outMutex(false,"IAXTransaction::OutMedia"),
        m_startedIn(false), m_startedOut(false),
        m_outStartTransTs(0), m_outFirstSrcTs(0),
        m_lastOut(0), m_lastIn(0), m_sent(0), m_sentBytes(0),
        m_recv(0), m_recvBytes(0), m_ooPackets(0), m_ooBytes(0),
        m_showInNoFmt(true), m_showOutOldTs(true),
        m_dropOut(0), m_dropOutBytes(0)
        {}

    inline void dropOut(unsigned int len) {
            if (len) {
                m_dropOut++;
                m_dropOutBytes += len;
            }
        }

    void print(String& buf);
 
protected:
    Mutex m_inMutex;
    Mutex m_outMutex;
    bool m_startedIn;                    // Incoming media started
    bool m_startedOut;                   // Outgoing media started
    int m_outStartTransTs;               // Transaction timestamp where media send started
    unsigned int m_outFirstSrcTs;        // First outgoing source packet timestamp as received from source
    u_int32_t m_lastOut;                 // Last transmitted mini timestamp
    u_int32_t m_lastIn;                  // Last received timestamp
    unsigned int m_sent;                 // Packets sent
    unsigned int m_sentBytes;            // Bytes sent
    unsigned int m_recv;                 // Packets received
    unsigned int m_recvBytes;            // Bytes received
    unsigned int m_ooPackets;            // Dropped received out of order packets
    unsigned int m_ooBytes;              // Dropped received out of order bytes
    bool m_showInNoFmt;                  // Show incoming media arrival without format debug
    bool m_showOutOldTs;                 // Show dropped media out debug message
    unsigned int m_dropOut;              // The number of dropped outgoing packets
    unsigned int m_dropOutBytes;         // The number of dropped outgoing bytes
};

class YIAX_API IAXTransaction : public RefObject, public Mutex
{
    friend class IAXEvent;
    friend class IAXEngine;
public:
    enum Type {
        Incorrect,                      // Unsupported/unknown type
        New,                            // Media exchange call
        RegReq,                         // Registration
        RegRel,                         // Registration release
        Poke,                           // Ping
        //FwDownl,
    };

    enum State {
        Connected,                      // Call leg established (Accepted) for transactions of type New
        NewLocalInvite,                 // New outgoing transaction: Poke/New/RegReq/RegRel
        NewLocalInvite_AuthRecv,        // Auth request received for an outgoing transaction
        NewLocalInvite_RepSent,         // Auth reply sent for an outgoing transaction
        NewRemoteInvite,                // New incoming transaction: Poke/New/RegReq/RegRel
        NewRemoteInvite_AuthSent,       // Auth sent for an incoming transaction
        NewRemoteInvite_RepRecv,        // Auth reply received for an incoming transaction
        Unknown,                        // Initial state
        Terminated,                     // Terminated. No more frames accepted
        Terminating,                    // Terminating. Wait for ACK or timeout to terminate
    };

    static IAXTransaction* factoryIn(IAXEngine* engine, IAXFullFrame* frame, u_int16_t lcallno, const SocketAddr& addr,
                void* data = 0);

    static IAXTransaction* factoryOut(IAXEngine* engine, Type type, u_int16_t lcallno, const SocketAddr& addr,
                IAXIEList& ieList, void* data = 0);

    virtual ~IAXTransaction();

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

    inline Type type() const
        { return m_type; }

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

    inline State state() const
        { return m_state; }

    inline const char* stateName()
        { return stateName(state()); }

    inline u_int64_t timeStamp() const
        { return Time::msecNow() - m_timeStamp; }

    inline bool outgoing() const
        { return m_localInitTrans; }

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

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

    inline u_int16_t localCallNo() const
        { return m_lCallNo; }

    inline u_int16_t remoteCallNo() const
        { return m_rCallNo; }

    inline const SocketAddr& remoteAddr() const
        { return m_addr; }

    inline const String& username()
        { return m_username; }

    inline const String& callingNo()
        { return m_callingNo; }

    inline const String& callingName()
        { return m_callingName; }

    inline const String& calledNo()
        { return m_calledNo; }

    inline const String& calledContext()
        { return m_calledContext; }

    inline const String& challenge()
        { return m_challenge; }

    inline IAXFormat* getFormat(int type) {
            if (type == IAXFormat::Audio)
                return &m_format;
            if (type == IAXFormat::Video)
                return &m_formatVideo;
            return 0;
        }

    inline IAXMediaData* getData(int type) {
            if (type == IAXFormat::Audio)
                return &m_dataAudio;
            if (type == IAXFormat::Video)
                return &m_dataVideo;
            return 0;
        }

    inline u_int32_t format(int type) {
            IAXFormat* fmt = getFormat(type);
            return fmt ? fmt->format() : 0;
        }

    inline u_int32_t formatIn(int type) {
            IAXFormat* fmt = getFormat(type);
            return fmt ? fmt->in() : 0;
        }

    inline u_int32_t formatOut(int type) {
            IAXFormat* fmt = getFormat(type);
            return fmt ? fmt->out() : 0;
        }

    inline u_int32_t capability() const
        { return m_capability; }

    inline u_int32_t expire() const
        { return m_expire; }

    inline const String& authdata()
        { return m_authdata; }

    inline void setDestroy()
        { m_destroy = true; }

    void start();

    IAXTransaction* processFrame(IAXFrame* frame);

    IAXTransaction* processMedia(DataBlock& data, u_int32_t tStamp,
        int type = IAXFormat::Audio, bool full = false, bool mark = false);

    unsigned int sendMedia(const DataBlock& data, unsigned int tStamp, u_int32_t format,
        int type = IAXFormat::Audio, bool mark = false);

    IAXEvent* getEvent(const Time& now = Time());

    static unsigned char getMaxFrameList();

    static bool setMaxFrameList(unsigned char value);

    inline bool sendAnswer()
        { return sendConnected(IAXFullFrame::Answer); }

    inline bool sendRinging()
        { return sendConnected(IAXFullFrame::Ringing); }

    inline bool sendProgress()
        { return sendConnected(IAXFullFrame::Proceeding); }

    bool sendAccept(unsigned int* expires = 0);

    bool sendHangup(const char* cause = 0, u_int8_t code = 0);

    bool sendReject(const char* cause = 0, u_int8_t code = 0);

    bool sendAuth();

    bool sendAuthReply(const String& response);

    inline bool sendDtmf(u_int8_t dtmf)
        { return dtmf <= 127 ? sendConnected((IAXFullFrame::ControlType)dtmf,IAXFrame::DTMF) : false; }

    bool sendText(const char* text);

    inline bool sendNoise(u_int8_t noise)
        { return noise <= 127 ? sendConnected((IAXFullFrame::ControlType)noise,IAXFrame::Noise) : false; }

    bool abortReg();

    bool enableTrunking(IAXMetaTrunkFrame* trunkFrame, bool efficientUse);

    void processCallToken(const DataBlock& callToken);

    void processMiniNoTs(u_int32_t ts, ObjList& blocks, const Time& now = Time());

    void print(bool printStats = false, bool printFrames = false, const char* location = "status");

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

    static inline const char* stateName(int state)
        { return lookup(state,s_stateName); }

    static const TokenDict s_typeName[];

    static const TokenDict s_stateName[];

    static String s_iax_modNoAuthMethod;

    static String s_iax_modNoMediaFormat;

    static String s_iax_modInvalidAuth;

    static String s_iax_modNoUsername;
 
protected:
    IAXTransaction(IAXEngine* engine, IAXFullFrame* frame, u_int16_t lcallno, const SocketAddr& addr,
        void* data = 0);

    IAXTransaction(IAXEngine* engine, Type type, u_int16_t lcallno, const SocketAddr& addr, IAXIEList& ieList,
        void* data = 0);

    virtual void destroyed();

    void init(IAXIEList& ieList);

    bool incrementSeqNo(const IAXFullFrame* frame, bool inbound);

    bool isFrameAcceptable(const IAXFullFrame* frame);

    bool changeState(State newState);

    IAXEvent* terminate(u_int8_t evType, bool local, IAXFullFrame* frame = 0, bool createIEList = true);

    IAXEvent* waitForTerminate(u_int8_t evType = 0, bool local = true, IAXFullFrame* frame = 0);

    void postFrame(IAXFrame::Type type, u_int32_t subclass, void* data = 0, u_int16_t len = 0, u_int32_t tStamp = 0,
        bool ackOnly = false, bool mark = false);

    void postFrameIes(IAXFrame::Type type, u_int32_t subclass, IAXIEList* ies, u_int32_t tStamp = 0,
                bool ackOnly = false);

    bool sendFrame(IAXFrameOut* frame, bool vnak = false);

    IAXEvent* createEvent(u_int8_t evType, bool local, IAXFullFrame* frame, State newState);

    IAXEvent* createResponse(IAXFrameOut* frame, u_int8_t findType, u_int8_t findSubclass, u_int8_t evType, bool local, State newState);

    IAXEvent* getEventResponse(IAXFrameOut* frame, bool& delFrame);

    IAXEvent* getEventResponse_New(IAXFrameOut* frame, bool& delFrame);

    IAXEvent* processAuthReq(IAXEvent* event);

    IAXEvent* processAccept(IAXEvent* event);

    IAXEvent* processAuthRep(IAXEvent* event);

    IAXEvent* getEventResponse_Reg(IAXFrameOut* frame, bool& delFrame);

    IAXEvent* processRegAck(IAXEvent* event);

    IAXEvent* getEventStartTrans(IAXFullFrame* frame, bool& delFrame);

    IAXEvent* getEventRequest(IAXFullFrame* frame, bool& delFrame);

    IAXEvent* getEventRequest_New(IAXFullFrame* frame, bool& delFrame);

    IAXFullFrame* findInFrame(IAXFrame::Type type, u_int32_t subclass);

    bool findInFrameTimestamp(const IAXFullFrame* frameOut, IAXFrame::Type type, u_int32_t subclass);

    bool findInFrameAck(const IAXFullFrame* frameOut);

    void ackInFrames();

    bool sendConnected(IAXFullFrame::ControlType subclass, IAXFrame::Type frametype = IAXFrame::Control);

    void sendAck(const IAXFullFrame* frame);

    void sendVNAK();

    void sendUnsupport(u_int32_t subclass);

    IAXEvent* processInternalOutgoingRequest(IAXFrameOut* frame, bool& delFrame);

    IAXEvent* processInternalIncomingRequest(const IAXFullFrame* frame, bool& delFrame);

    IAXEvent* processMidCallControl(IAXFullFrame* frame, bool& delFrame);

    IAXEvent* processMidCallIAXControl(IAXFullFrame* frame, bool& delFrame);

    IAXEvent* remoteRejectCall(IAXFullFrame* frame, bool& delFrame);

    IAXTransaction* processMediaFrame(const IAXFullFrame* frame, int type);

    IAXTransaction* retransmitOnVNAK(u_int16_t seqNo);

    IAXEvent* internalReject(const char* reason, u_int8_t code);

    void eventTerminated(IAXEvent* event);

    inline IAXEvent* keepEvent(IAXEvent* event) {
        m_currentEvent = event;
        return event;
    }
 
private:
    void adjustTStamp(u_int32_t& tStamp);
    void postFrame(IAXFrameOut* frame);
    void receivedVoiceMiniBeforeFull();
    void resetTrunk();
    void init();
    void setPendingEvent(IAXEvent* ev = 0);
    inline void restartTrunkIn(u_int64_t now, u_int32_t ts) {
            m_trunkInStartTime = now;
            u_int64_t dt = (now - m_lastVoiceFrameIn) / 1000;
            m_trunkInTsDelta = m_lastVoiceFrameInTs + (u_int32_t)dt;
            m_trunkInFirstTs = ts;
        }
    // Process accept format and caps
    bool processAcceptFmt(IAXIEList* list);
    // Process queued ACCEPT. Reject with given reason/code if not found
    // Reject with 'nomedia' if found and format is not acceptable
    IAXEvent* checkAcceptRecv(const char* reason, u_int8_t code);
 
    // Params
    bool m_localInitTrans;                      // True: local initiated transaction
    bool m_localReqEnd;                         // Local client requested terminate
    Type m_type;                                // Transaction type
    State m_state;                              // Transaction state
    bool m_destroy;                             // Destroy flag
    bool m_accepted;                            // ACCEPT received and processed
    u_int64_t m_timeStamp;                      // Transaction creation timestamp
    u_int64_t m_timeout;                        // Transaction timeout in Terminating state
    SocketAddr m_addr;                          // Socket
    u_int16_t m_lCallNo;                        // Local peer call id
    u_int16_t m_rCallNo;                        // Remote peer call id
    unsigned char m_oSeqNo;                     // Outgoing frame sequence number
    unsigned char m_iSeqNo;                     // Incoming frame sequence number
    IAXEngine* m_engine;                        // Engine that owns this transaction
    void* m_userdata;                           // Arbitrary user data
    u_int32_t m_lastFullFrameOut;               // Last transmitted full frame timestamp
    IAXMediaData m_dataAudio;
    IAXMediaData m_dataVideo;
    u_int16_t m_lastAck;                        // Last ack'd received frame's oseqno
    IAXEvent* m_pendingEvent;                   // Pointer to a pending event or 0
    IAXEvent* m_currentEvent;                   // Pointer to last generated event or 0
    // Outgoing frames management
    ObjList m_outFrames;                        // Transaction & protocol control outgoing frames
    unsigned int m_retransCount;                // Retransmission counter. 0 --> Timeout
    unsigned int m_retransInterval;             // Frame retransmission interval
    // Incoming frames management
    ObjList m_inFrames;                         // Transaction & protocol control incoming frames
    static unsigned char m_maxInFrames;         // Max frames number allowed in m_inFrames
    // Call leg management
    u_int32_t m_pingInterval;                   // Ping remote peer interval
    u_int64_t m_timeToNextPing;                 // Time of the next Ping
    // Statistics
    u_int32_t m_inTotalFramesCount;             // Total received frames
    u_int32_t m_inOutOfOrderFrames;             // Total out of order frames
    u_int32_t m_inDroppedFrames;                // Total dropped frames
    // Data
    IAXAuthMethod::Type m_authmethod;                // Authentication method to use
    String m_username;                          // Username
    String m_callingNo;                         // Calling number
    String m_callingName;                       // Calling name
    String m_calledNo;                          // Called number
    String m_calledContext;                     // Called context
    String m_challenge;                         // Challenge
    String m_authdata;                          // Auth data received with auth reply
    u_int32_t m_expire;                         // Registration expiring time
    IAXFormat m_format;                         // Audio format
    IAXFormat m_formatVideo;                    // Video format
    u_int32_t m_capability;                     // Media capability of this transaction
    bool m_callToken;                           // Call token supported/expected
    unsigned int m_adjustTsOutThreshold;        // Adjust outgoing data timestamp threshold
    unsigned int m_adjustTsOutOverrun;          // Value used to adjust outgoing data timestamp on data
                                                //  overrun (incoming data with rate greater then expected)
    unsigned int m_adjustTsOutUnderrun;         // Value used to adjust outgoing data timestamp on data
                                                //  underrun (incoming data with rate less then expected)
    u_int64_t m_lastVoiceFrameIn;               // Time we received the last voice frame
    u_int32_t m_lastVoiceFrameInTs;             // Timestamp in the last received voice frame
    int m_reqVoiceVNAK;                         // Send VNAK if not received full voice frame
    // Meta trunking
    IAXMetaTrunkFrame* m_trunkFrame;            // Reference to a trunk frame if trunking is enabled for this transaction
    bool m_trunkFrameCallsSet;                  // Trunk frame calls increased
    bool m_trunkOutEfficientUse;                // Use or not the trunk frame based on calls using it
    bool m_trunkOutSend;                        // Currently using the trunk frame
    bool m_trunkInSyncUsingTs;                  // Incoming trunk without timestamps: generate timestamp
                                                //  using time or using trunk timestamp
    u_int64_t m_trunkInStartTime;               // First time we received trunk in data
    u_int32_t m_trunkInTsDelta;                 // Value used to re-build ts: last voice timestamp
    u_int32_t m_trunkInTsDiffRestart;           // Incoming trunk without timestamp: diff between timestamps at which we restart
    u_int32_t m_trunkInFirstTs;                 // Incoming trunk without timestamp: first trunk timestamp
    // Postponed start
    IAXIEList* m_startIEs;                      // Postponed start
};

class YIAX_API IAXEvent
{
    friend class IAXTransaction;
    friend class IAXConnectionlessTransaction;
public:
    enum Type {
        DontSet = 0,            // Used internal
        Invalid,                // Invalid frame received
        Terminated,             // Transaction terminated
        Timeout,                // Transaction timeout
        NotImplemented,         // Feature not implemented
        New,                    // New remote transaction
        AuthReq,                // Auth request
        AuthRep,                // Auth reply
        Accept,                 // Request accepted
        Hangup,                 // Remote hangup
        Reject,                 // Remote reject
        Busy,                   // Call busy
        Text,                   // Text frame received
        Dtmf,                   // DTMF frame received
        Noise,                  // Noise frame received
        Answer,                 // Call answered
        Quelch,                 // Quelch the call
        Unquelch,               // Unquelch the call
        Progressing,            // Call progressing
        Ringing,                // Ringing
    };

    ~IAXEvent();

    inline Type type() const
        { return m_type; }

    inline bool local() const
        { return m_local; }

    inline bool final() const
        { return m_final; }

    inline void setFinal()
        { m_final = true; }

    inline u_int8_t frameType()
        { return m_frameType; }

    inline u_int32_t subclass()
        { return m_subClass; }

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

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

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

    inline IAXIEList& getList()
        { return *m_ieList; }
 
protected:
    IAXEvent(Type type, bool local, bool final, IAXTransaction* transaction, u_int8_t frameType = 0, u_int32_t subclass = 0);

    IAXEvent(Type type, bool local, bool final, IAXTransaction* transaction, IAXFullFrame* frame = 0);
 
private:
    inline IAXEvent() {}                // Default constructor
 
    Type m_type;                        // Event type
    u_int8_t m_frameType;               // Frame type
    u_int32_t m_subClass;               // Frame subclass
    bool m_local;                       // If true the event is generated locally, the receiver MUST not respond
    bool m_final;                       // Final event flag
    IAXTransaction* m_transaction;        // Transaction that generated this event
    IAXIEList* m_ieList;               // IAXInfoElement list
};

class YIAX_API IAXEngine : public DebugEnabler, public Mutex
{
public:
    IAXEngine(const char* iface, int port, u_int32_t format, u_int32_t capab,
        const NamedList* params = 0, const char* name = "iaxengine");

    virtual ~IAXEngine();

    inline const String& name() const
        { return m_name; }

    inline u_int8_t callerNumType() const
        { return m_callerNumType; }

    inline u_int8_t callingPres() const
        { return m_callingPres; }

    IAXTransaction* addFrame(const SocketAddr& addr, IAXFrame* frame);

    IAXTransaction* addFrame(const SocketAddr& addr, const unsigned char* buf, unsigned int len);

    IAXTransaction* findTransaction(const SocketAddr& addr, u_int16_t rCallNo);

    virtual void processMedia(IAXTransaction* transaction, DataBlock& data, u_int32_t tStamp,
        int type, bool mark)
        {}

    bool process();

    inline unsigned int challengeTout() const
        { return m_challengeTout; }

    inline u_int16_t maxFullFrameDataLen() const
        { return m_maxFullFrameDataLen; }

    inline u_int32_t format(bool audio = true) const
        { return audio ? m_format : m_formatVideo; }

    inline u_int32_t capability() const
        { return m_capability; }

    inline void getOutDataAdjust(unsigned int& thres, unsigned int& over,
        unsigned int& under) const {
            thres = m_adjustTsOutThreshold;
            over = m_adjustTsOutOverrun;
            under = m_adjustTsOutUnderrun;
        }

    void initOutDataAdjust(const NamedList& params, IAXTransaction* tr = 0);

    void initialize(const NamedList& params);

    void readSocket(SocketAddr& addr);

    bool writeSocket(const void* buf, int len, const SocketAddr& addr, IAXFullFrame* frame = 0,
        unsigned int* sent = 0);

    inline bool writeSocket(const SocketAddr& addr, IAXFullFrame* frame)
        { return !frame || writeSocket(frame->data().data(),frame->data().length(),addr,frame); }

    void runGetEvents();

    void removeTransaction(IAXTransaction* transaction);

    bool haveTransactions();

    u_int32_t transactionCount();

    void keepAlive(const SocketAddr& addr);

    virtual bool mediaFormatChanged(IAXTransaction* trans, int type, u_int32_t format)
        { return false; }

    virtual bool checkCallToken(const SocketAddr& addr, IAXFullFrame& frame);

    bool acceptFormatAndCapability(IAXTransaction* trans, unsigned int* caps = 0,
        int type = IAXFormat::Audio);

    virtual void defaultEventHandler(IAXEvent* event);

    inline bool exiting() const
        { return m_exiting; }

    virtual void setExiting();

    void enableTrunking(IAXTransaction* trans, const NamedList* params,
        const String& prefix = String::empty());

    void enableTrunking(IAXTransaction* trans, IAXTrunkInfo& data);

    void initTrunkIn(IAXTransaction* trans, const NamedList* params,
        const String& prefix = String::empty());

    void initTrunkIn(IAXTransaction* trans, IAXTrunkInfo& data);

    inline bool trunkInfo(RefPointer<IAXTrunkInfo>& info) {
            Lock lck(m_trunkInfoMutex);
            info = m_trunkInfoDef;
            return info != 0;
        }

    void sendInval(IAXFullFrame* frame, const SocketAddr& addr);

    void runProcessTrunkFrames();

    inline Socket& socket()
        { return m_socket; }

    inline const SocketAddr& addr() const
        { return m_addr; }

    inline void setFormats(u_int32_t caps, u_int32_t fmtAudio, u_int32_t fmtVideo) {
            m_format = fmtAudio;
            m_formatVideo = fmtVideo;
            m_capability = caps;
        }

    static inline int getPort(const NamedList& params, const String& param = "port")
        { return params.getIntValue(param,4569); }

    static void getMD5FromChallenge(String& md5data, const String& challenge, const String& password);

    static bool isMD5ChallengeCorrect(const String& md5data, const String& challenge, const String& password);

    static void buildAddrSecret(String& buf, const String& secret,
        const SocketAddr& addr);

    static int addrSecretAge(const String& buf, const String& secret,
        const SocketAddr& addr);

    static inline void addKeyword(NamedList& list, const char* param,
        const TokenDict* tokens, unsigned int val) {
            const char* value = lookup(val,tokens);
            if (value)
                list.addParam(param,value);
            else
                list.addParam(param,String(val));
        }

    static void decodeDateTime(u_int32_t dt, unsigned int& year, unsigned int& month,
        unsigned int& day, unsigned int& hour, unsigned int& minute, unsigned int& sec);

    static unsigned int overallTout(unsigned int interval = IAX2_RETRANS_INTERVAL_DEF,
        unsigned int nRetrans = IAX2_RETRANS_COUNT_DEF);
 
protected:
    bool processTrunkFrames(const Time& time = Time());

    virtual void processEvent(IAXEvent* event);

    IAXEvent* getEvent(const Time& now = Time());

    u_int16_t generateCallNo();

    void releaseCallNo(u_int16_t lcallno);

    IAXTransaction* startLocalTransaction(IAXTransaction::Type type,
        const SocketAddr& addr, IAXIEList& ieList,
        bool refTrans = false, bool startTrans = true);

    bool bind(const char* iface, int port, bool force);
 
    int m_trunking;                             // Trunking capability: negative: ok, otherwise: not enabled
 
private:
    String m_name;                              // Engine name
    Socket m_socket;                              // Socket
    SocketAddr m_addr;                          // Address we are bound on
    ObjList** m_transList;                       // Full transactions
    ObjList m_incompleteTransList;               // Incomplete transactions (no remote call number)
    bool m_lUsedCallNo[IAX2_MAX_CALLNO + 1];    // Used local call numnmbers flags
    int m_lastGetEvIndex;                       // getEvent: keep last array entry
    bool m_exiting;                             // Exiting flag
    // Parameters
    int m_maxFullFrameDataLen;                  // Max full frame data (IE list) length
    u_int16_t m_startLocalCallNo;               // Start index of local call number allocation
    u_int16_t m_transListCount;                 // m_transList count
    unsigned int m_challengeTout;               // Sent challenge timeout interval
    bool m_callToken;                           // Call token required on incoming calls
    String m_callTokenSecret;                   // Secret used to generate call tokens
    int m_callTokenAge;                         // Max allowed call token age
    bool m_showCallTokenFailures;               // Print incoming call token failures to output
    bool m_rejectMissingCallToken;              // Reject/ignore incoming calls without call token if mandatory
    bool m_printMsg;                            // Print frame to output
    u_int8_t m_callerNumType;                   // Caller number type
    u_int8_t m_callingPres;                     // Caller presentation + screening
    // Media
    u_int32_t m_format;                         // The default media format
    u_int32_t m_formatVideo;                    // Default video format
    u_int32_t m_capability;                     // The media capability
    unsigned int m_adjustTsOutThreshold;        // Adjust outgoing data timestamp threshold
    unsigned int m_adjustTsOutOverrun;          // Value used to adjust outgoing data timestamp on data
                                                //  overrun (incoming data with rate greater then expected)
    unsigned int m_adjustTsOutUnderrun;         // Value used to adjust outgoing data timestamp on data
                                                //  underrun (incoming data with rate less then expected)
    // Trunking
    Mutex m_mutexTrunk;                            // Mutex for trunk operations
    ObjList m_trunkList;                 // Trunk frames list
    Mutex m_trunkInfoMutex;                     // Trunk info mutex
    RefPointer<IAXTrunkInfo> m_trunkInfoDef;    // Defaults for trunk data
};
 
}
 
#endif /* __YATEIAX_H */
 
/* vi: set ts=8 sw=4 sts=4 noet: */