yatesig.h

 
#ifndef __YATESIG_H
#define __YATESIG_H
 
#include <yateclass.h>
 
#ifdef _WINDOWS
 
#ifdef LIBYSIG_EXPORTS
#define YSIG_API __declspec(dllexport)
#else
#ifndef LIBYSIG_STATIC
#define YSIG_API __declspec(dllimport)
#endif
#endif
 
#endif /* _WINDOWS */
 
#ifndef YSIG_API
#define YSIG_API
#endif

namespace TelEngine {
 
// Signalling classes
class SignallingDumper;                  // A generic data dumper
class SignallingDumpable;                // A component that can dump data
class SignallingNotifier;                // A signalling notifier
class SignallingTimer;                   // A signalling timer
class SignallingCounter;                 // A signalling counter
class SignallingFactory;                 // A signalling component factory
class SignallingComponent;               // Abstract signalling component that can be managed by the engine
class SignallingEngine;                  // Main signalling component holder
class SignallingThreadPrivate;           // Engine private thread
class SignallingMessage;                 // Abstract signalling message
class SignallingCallControl;             // Abstract phone call signalling
class SignallingCall;                    // Abstract single phone call
class SignallingEvent;                   // A single signalling related event
class SignallingCircuitEvent;            // A single signalling circuit related event
class SignallingCircuit;                 // Abstract data circuit used by signalling
class SignallingCircuitRange;            // A circuit range (set of circuits)
class SignallingCircuitGroup;            // Group of data circuits used by signalling
class SignallingCircuitSpan;             // A span in a circuit group
class SignallingInterface;               // Abstract digital signalling interface (hardware access)
class SignallingReceiver;                // Abstract Layer 2 packet data receiver
struct SignallingFlags;                  // Description of parameter flags
class SignallingUtils;                   // Library wide services and data provider
class SignallingMessageTimer;            // A pending signalling message
class SignallingMessageTimerList;        // A pending signalling message list
// Analog lines
class AnalogLine;                        // An analog line
class AnalogLineEvent;                   // A single analog line related event
class AnalogLineGroup;                   // A group of analog lines
// SS7
class SS7PointCode;                      // SS7 Code Point
class SS7Label;                          // SS7 Routing Label
class SS7MSU;                            // A block of data that holds a Message Signal Unit
class SIGTRAN;                           // Abstract SIGTRAN component
class SIGTransport;                      // Abstract transport for SIGTRAN
class SIGAdaptation;                     // Abstract Adaptation style SIGTRAN
class SIGAdaptClient;                    // Client side of adaptation (ASP)
class SIGAdaptServer;                    // Server side of adaptation (SG)
class SIGAdaptUser;                      // Abstract Adaptation User SIGTRAN
class ASPUser;                           // Abstract SS7 ASP user interface
class SCCP;                              // Abstract SS7 SCCP interface
class GTT;                               // Abstract SCCP Global Title Translation interface
class SCCPManagement;                    // Abstract SCCP Management interface
class SCCPUser;                          // Abstract SS7 SCCP user interface
class TCAPUser;                          // Abstract SS7 TCAP user interface
class SS7L2User;                         // Abstract user of SS7 layer 2 (data link) message transfer part
class SS7Layer2;                         // Abstract SS7 layer 2 (data link) message transfer part
class SS7L3User;                         // Abstract user of SS7 layer 3 (network) message transfer part
class SS7Layer3;                         // Abstract SS7 layer 3 (network) message transfer part
class SS7Layer4;                         // Abstract SS7 layer 4 (application) protocol
class SS7Route;                          // A SS7 MSU route
class SS7Router;                         // Main router for SS7 message transfer and applications
class SS7M2PA;                           // SIGTRAN MTP2 User Peer-to-Peer Adaptation Layer
class SS7M2UA;                           // SIGTRAN MTP2 User Adaptation Layer
class SS7M3UA;                           // SIGTRAN MTP3 User Adaptation Layer
class SS7MTP2;                           // SS7 Layer 2 implementation on top of a hardware interface
class SS7MTP3;                           // SS7 Layer 3 implementation on top of Layer 2
class SS7MsgSNM;                         // SNM signalling message
class SS7MsgMTN;                         // MTN signalling message
class SS7MsgISUP;                        // ISUP signalling message
class SS7MsgSCCP;                        // SCCP signalling message
class SS7Management;                     // SS7 SNM implementation
class SS7ISUPCall;                       // A SS7 ISUP call
class SS7ISUP;                           // SS7 ISUP implementation
class SS7BICC;                           // SS7 BICC implementation
class SS7TUP;                            // SS7 TUP implementation
class SS7SCCP;                           // SS7 SCCP implementation
class SccpSubsystem;                     // Helper class to keep a SCCP subsystem
class SccpLocalSubsystem;                // Helper class to keep s sccp local subsystem informations
class SccpRemote;                        // Helper class to keep a remote sccp
class SS7AnsiSccpManagement;             // SS7 SCCP management implementation for ANSI
class SS7ItuSccpManagement;              // SS7 SCCP management implementation for ITU
class SS7SUA;                            // SIGTRAN SCCP User Adaptation Layer
class SS7ASP;                            // SS7 ASP implementation
class SS7TCAPMessage;                    // SS7 TCAP message wrapper
class SS7TCAPError;                      // SS7 TCAP errors
class SS7TCAP;                           // SS7 TCAP implementation
class SS7TCAPTransaction;                // SS7 TCAP transaction base class
class SS7TCAPComponent;                  // SS7 TCAP component
class SS7TCAPANSI;                       // SS7 ANSI TCAP implementation
class SS7TCAPTransactionANSI;            // SS7 TCAP ANSI Transaction
class SS7TCAPITU;                        // SS7 ITU TCAP implementation
class SS7TCAPTransactionITU;             // SS7 TCAP ITU Transaction
// ISDN
class ISDNLayer2;                        // Abstract ISDN layer 2 (Q.921) message transport
class ISDNLayer3;                        // Abstract ISDN layer 3 (Q.931) message transport
class ISDNFrame;                         // An ISDN Q.921 frame
class ISDNQ921;                          // ISDN Q.921 implementation on top of a hardware interface
class ISDNQ921Passive;                   // Stateless ISDN Q.921 implementation on top of a hardware interface
class ISDNQ921Management;                // ISDN Layer 2 BRI TEI management or PRI with D-channel(s) backup
class ISDNIUA;                           // SIGTRAN ISDN Q.921 User Adaptation Layer
class ISDNQ931IE;                        // A Q.931 ISDN Layer 3 message Information Element
class ISDNQ931Message;                   // A Q.931 ISDN Layer 3 message
class ISDNQ931IEData;                    // A Q.931 message IE data processor
class ISDNQ931State;                     // Q.931 ISDN call and call controller state
class ISDNQ931Call;                      // A Q.931 ISDN call
class ISDNQ931CallMonitor;               // A Q.931 ISDN call monitor
class ISDNQ931ParserData;                // Q.931 message parser data
class ISDNQ931;                          // ISDN Q.931 implementation on top of Q.921
class ISDNQ931Monitor;                   // ISDN Q.931 implementation on top of Q.921 of call controller monitor
 
// Macro to create a factory that builds a component by class name
#define YSIGFACTORY(clas) \
class clas ## Factory : public SignallingFactory \
{ \
protected: \
virtual SignallingComponent* create(const String& type, NamedList& name) \
    { return (type == #clas) ? new clas : 0; } \
}; \
static clas ## Factory s_ ## clas ## Factory
 
// Macro to create a factory that calls a component's static create method
#define YSIGFACTORY2(clas) \
class clas ## Factory : public SignallingFactory \
{ \
protected: \
virtual SignallingComponent* create(const String& type, NamedList& name) \
    { return clas::create(type,name); } \
}; \
static clas ## Factory s_ ## clas ## Factory
 
// Macro to call the factory creation method and return the created component
#define YSIGCREATE(type,name) (static_cast<type*>(SignallingFactory::buildInternal(#type,name)))

class YSIG_API SignallingDumper
{
public:
    enum Type {
        Raw,
        Hexa,
        Hdlc,
        Q921,
        Q931,
        Mtp2,
        Mtp3,
        Sccp,
    };

    SignallingDumper(Type type = Hexa, bool network = false);

    ~SignallingDumper();

    inline Type type() const
        { return m_type; }

    inline bool network() const
        { return m_network; }

    bool active() const;

    void terminate();

    void setStream(Stream* stream = 0, bool writeHeader = true);

    bool dump(void* buf, unsigned int len, bool sent = false, int link = 0);

    inline bool dump(const DataBlock& data, bool sent = false, int link = 0)
        { return dump(data.data(),data.length(),sent,link); }

    static SignallingDumper* create(DebugEnabler* dbg, const char* filename, Type type,
        bool network = false, bool create = true, bool append = false);

    static SignallingDumper* create(Stream* stream, Type type, bool network = false, bool writeHeader = true);
 
private:
    void head();
    Type m_type;
    bool m_network;
    Stream* m_output;
};

class YSIG_API SignallingDumpable
{
public:
    inline ~SignallingDumpable()
        { setDumper(); }
 
protected:
    inline SignallingDumpable(SignallingDumper::Type type, bool network = false)
        : m_type(type), m_dumpNet(network), m_dumper(0)
        { }

    inline bool dump(void* buf, unsigned int len, bool sent = false, int link = 0)
        { return (m_dumper && m_dumper->dump(buf,len,sent,link)); }

    inline bool dump(const DataBlock& data, bool sent = false, int link = 0)
        { return dump(data.data(),data.length(),sent,link); }

    inline void setDumpNetwork(bool network)
        { m_dumpNet = network; }

    void setDumper(SignallingDumper* dumper = 0);

    bool setDumper(const String& name, bool create = true, bool append = false);

    bool control(NamedList& params, SignallingComponent* owner = 0);
 
private:
    SignallingDumper::Type m_type;
    bool m_dumpNet;
    SignallingDumper* m_dumper;
};

 
class YSIG_API SignallingNotifier
{
public:
    virtual inline ~SignallingNotifier()
        { cleanup(); }

    virtual void notify(NamedList& notifs);
    virtual void cleanup();
};

class YSIG_API SignallingTimer
{
public:
    inline SignallingTimer(u_int64_t interval, u_int64_t time = 0)
        : m_interval(interval), m_timeout(0)
        { if (time) start(time); }

    inline void interval(u_int64_t value)
        { m_interval = value; }

    inline void interval(const NamedList& params, const char* param,
        unsigned int minVal, unsigned int defVal, bool allowDisable, bool sec = false) {
            m_interval = getInterval(params,param,minVal,defVal,0,allowDisable);
            if (sec)
                m_interval *= 1000;
        }

    inline u_int64_t interval() const
        { return m_interval; }

    inline u_int64_t fireTime() const
        { return m_timeout; }

    inline void start(u_int64_t time = Time::msecNow())
        { if (m_interval) m_timeout = time + m_interval; }

    inline void fire(u_int64_t time = Time::msecNow())
        { m_timeout = time; }

    inline void stop()
        { m_timeout = 0; }

    inline bool started() const
        { return m_timeout > 0; }

    inline bool timeout(u_int64_t time = Time::msecNow()) const
        { return started() && (m_timeout < time); }

    static unsigned int getInterval(const NamedList& params, const char* param,
        unsigned int minVal, unsigned int defVal, unsigned int maxVal = 0,
        bool allowDisable = false);
 
private:
    u_int64_t m_interval;                // Timer interval
    u_int64_t m_timeout;                 // Timeout value
};

class YSIG_API SignallingCounter
{
public:
    inline SignallingCounter(u_int32_t maxVal)
        : m_max(maxVal), m_count(0)
        { }

    inline void maxVal(u_int32_t value)
        { m_max = value; }

    inline u_int32_t maxVal() const
        { return m_max; }

    inline u_int32_t count() const
        { return m_count; }

    inline void reset(bool down = true)
        { m_count = down ? 0 : m_max; }

    inline bool inc()
    {
        if (full())
            return false;
        m_count++;
        return true;
    }

    inline bool dec()
    {
        if (empty())
            return false;
        m_count--;
        return true;
    }

    inline bool empty() const
        { return m_count == 0; }

    inline bool full() const
        { return m_count == maxVal(); }
 
private:
    u_int32_t m_max;                     // Maximum counter value
    u_int32_t m_count;                   // Current counter value
};

class YSIG_API SignallingFactory : public GenObject
{
public:
    SignallingFactory(bool fallback = false);

    virtual ~SignallingFactory();

    static SignallingComponent* build(const String& type, NamedList* name = 0);

    static void* buildInternal(const String& type, NamedList* name);
 
protected:
    virtual SignallingComponent* create(const String& type, NamedList& name) = 0;
};

class YSIG_API SignallingComponent : public RefObject, public DebugEnabler
{
    YCLASS(SignallingComponent,RefObject)
    friend class SignallingEngine;
public:
    virtual ~SignallingComponent();

    virtual const String& toString() const;

    virtual bool initialize(const NamedList* config);

    static bool resolveConfig(const String& cmpName, NamedList& params, const NamedList* config);

    virtual bool control(NamedList& params);

    virtual NamedList* controlCreate(const char* oper = 0);

    virtual bool controlExecute(NamedList* params);

    virtual void engine(SignallingEngine* eng);

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

    inline int debugLevel(int level)
        { return (level >= 0) ? DebugEnabler::debugLevel(level) : DebugEnabler::debugLevel(); }

    inline const String& componentType() const
        { return m_compType; }
 
protected:
    SignallingComponent(const char* name = 0, const NamedList* params = 0, const char* type = "unknown");

    virtual void destroyed();

    void insert(SignallingComponent* component);

    virtual void detach();

    virtual void timerTick(const Time& when);

    void setName(const char* name);

    inline void setCompType(const char* type)
        { m_compType = type; }

    unsigned long tickSleep(unsigned long usec = 1000000) const;
 
private:
    SignallingEngine* m_engine;
    String m_name;
    String m_compType;
};

class YSIG_API SignallingEngine : public DebugEnabler, public Mutex
{
    friend class SignallingComponent;
    friend class SignallingThreadPrivate;
public:
    SignallingEngine(const char* name = "signalling");

    virtual ~SignallingEngine();

    static SignallingEngine* self(bool create = false);

    void insert(SignallingComponent* component);

    void remove(SignallingComponent* component);

    bool remove(const String& name);

    SignallingComponent* find(const String& name);

    SignallingComponent* find(const String& name, const String& type, const SignallingComponent* start = 0);

    SignallingComponent* build(const String& type, NamedList& params, bool init = false, bool ref = true);

    bool control(NamedList& params);

    bool find(const SignallingComponent* component);

    void notify(SignallingComponent* component, NamedList notifs);

    bool start(const char* name = "Sig Engine", Thread::Priority prio = Thread::Normal, unsigned long usec = 0);

    void stop();

    inline void setNotifier(SignallingNotifier* notifier)
        { m_notifier = notifier; }

    inline void removeNotifier(SignallingNotifier* notifier)
    {
        if (m_notifier == notifier)
            m_notifier = 0;
    }

    Thread* thread() const;

    unsigned long tickSleep(unsigned long usec = 1000000);

    inline unsigned long tickDefault() const
        { return m_usecSleep; }

    inline static long maxLockWait()
        { return s_maxLockWait; }

    static void maxLockWait(long maxWait);

    template <class Obj> static inline void destruct(Obj*& obj)
    {
        if (!obj)
            return;
        if (obj->engine())
            obj->engine()->remove(obj);
        TelEngine::destruct(obj);
    }
 
protected:
    virtual unsigned long timerTick(const Time& when);

    ObjList m_components;
 
private:
    SignallingThreadPrivate* m_thread;
    SignallingNotifier* m_notifier;
    unsigned long m_usecSleep;
    unsigned long m_tickSleep;
    static long s_maxLockWait;
};

class YSIG_API SignallingMessage : public RefObject
{
    YCLASS(SignallingMessage,RefObject)
public:
    inline SignallingMessage(const char* name = 0)
        : m_params(name)
        { }

    inline const char* name() const
        { return m_params.c_str(); }

    inline NamedList& params()
        { return m_params; }

    inline const NamedList& params() const
        { return m_params; }
 
protected:
    NamedList m_params;
};

class YSIG_API SignallingCallControl : public Mutex
{
    friend class SignallingCall;
    friend class SS7ISUPCall;
    friend class ISDNQ931Call;
    friend class ISDNQ931CallMonitor;
public:

    enum MediaRequired {
        MediaNever,
        MediaAnswered,
        MediaRinging,
        MediaAlways
    };

    SignallingCallControl(const NamedList& params, const char* msgPrefix = 0);

    virtual ~SignallingCallControl();

    inline const String& location() const
        { return m_location; }

    inline void setExiting()
        { m_exiting = true; }

    inline bool exiting() const
        { return m_exiting; }

    inline bool verify()
    {
        Lock lock(this);
        if (!m_verifyEvent)
            return false;
        m_verifyEvent = false;
        return true;
    }

    inline MediaRequired mediaRequired() const
        { return m_mediaRequired; }

    inline const String& msgPrefix() const
        { return m_msgPrefix; }

    inline SignallingCircuitGroup* circuits() const
        { return m_circuits; }

    inline const ObjList& calls() const
        { return m_calls; }

    virtual const char* statusName() const = 0;

    SignallingCircuitGroup* attach(SignallingCircuitGroup* circuits);

    bool reserveCircuit(SignallingCircuit*& cic, const char* range = 0, int checkLock = -1,
        const String* list = 0,   bool mandatory = true, bool reverseRestrict = false);

    bool releaseCircuit(SignallingCircuit*& cic, bool sync = false);

    bool releaseCircuit(unsigned int code, bool sync = false);

    virtual void cleanup(const char* reason = "net-out-of-order")
        { }

    virtual SignallingEvent* getEvent(const Time& when);

    virtual SignallingCall* call(SignallingMessage* msg, String& reason)
        { reason = "not-implemented"; return 0; }

    virtual void buildVerifyEvent(NamedList& params)
        { }
 
protected:
    inline int strategy() const
        { return m_strategy; }

    virtual bool processEvent(SignallingEvent* event)
        { return false; }

    virtual SignallingEvent* processCircuitEvent(SignallingCircuitEvent*& event,
        SignallingCall* call = 0)
        { TelEngine::destruct(event); return 0; }

    void clearCalls();

    void removeCall(SignallingCall* call, bool del = false);

    void setVerify(bool restartTimer = false, bool fireNow = false, const Time* time = 0);

    ObjList m_calls;

    String m_msgPrefix;

    MediaRequired m_mediaRequired;

    bool m_verifyEvent;

    SignallingTimer m_verifyTimer;

    String m_location;

    static const TokenDict s_mediaRequired[];
 
private:
    SignallingCircuitGroup* m_circuits;  // Circuit group
    int m_strategy;                      // Strategy to allocate circuits for outgoing calls
    bool m_exiting;                      // Call control is terminating. Generate a Disable event when no more calls
};

class YSIG_API SignallingCall : public RefObject, public Mutex
{
public:
    SignallingCall(SignallingCallControl* controller, bool outgoing, bool signalOnly = false);

    virtual ~SignallingCall();

    inline bool outgoing() const
        { return m_outgoing; }

    inline SignallingCallControl* controller() const
        { return m_controller; }

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

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

    inline bool signalOnly() const
        { return m_signalOnly; }

    inline bool overlapDialing() const
        { return m_overlap; }

    virtual bool sendEvent(SignallingEvent* event)
        { return false; }

    virtual SignallingEvent* getEvent(const Time& when) = 0;

    virtual void eventTerminated(SignallingEvent* event);
 
protected:
    void enqueue(SignallingMessage* msg);

    SignallingMessage* dequeue(bool remove = true);

    void clearQueue()
    {
        Lock lock(m_inMsgMutex);
        m_inMsg.clear();
    }

    SignallingEvent* m_lastEvent;

    bool m_overlap;
 
private:
    SignallingCallControl* m_controller; // Call controller this call belongs to
    bool m_outgoing;                     // Call direction
    bool m_signalOnly;                   // Just signalling flag
    ObjList m_inMsg;                     // Incoming messages queue
    Mutex m_inMsgMutex;                  // Lock incoming messages queue
    void* m_private;                     // Private user data
};

class YSIG_API SignallingEvent
{
public:
    enum Type {
        Unknown = 0,
        Generic,
        // Call related
        NewCall,
        Accept,
        Connect,
        Complete,
        Progress,
        Ringing,
        Answer,
        Transfer,
        Suspend,
        Resume,
        Release,
        Info,
        Charge,
        // Non-call related
        Message,
        Facility,
        Circuit,
        // Controller related
        Enable,
        Disable,
        Reset,
        Verify,
    };

    SignallingEvent(Type type, SignallingMessage* message, SignallingCall* call);

    SignallingEvent(Type type, SignallingMessage* message, SignallingCallControl* controller = 0);

    SignallingEvent(SignallingCircuitEvent*& event, SignallingCall* call);

    virtual ~SignallingEvent();

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

    inline Type type() const
        { return m_type; }

    inline SignallingCall* call() const
        { return m_call; }

    inline SignallingMessage* message() const
        { return m_message; }

    inline SignallingCallControl* controller() const
        { return m_controller; }

    inline SignallingCircuitEvent* cicEvent() const
        { return m_cicEvent; }

    static inline const char* typeName(Type t)
        { return lookup(t,s_types,0); }

    bool sendEvent();
 
private:
    Type m_type;
    SignallingMessage* m_message;
    SignallingCall* m_call;
    SignallingCallControl* m_controller;
    SignallingCircuitEvent* m_cicEvent;
    static const TokenDict s_types[];
};

class YSIG_API SignallingCircuitEvent : public NamedList
{
public:
    enum Type {
        Unknown      = 0,
        Dtmf         = 1,                // Transfer tones: param: tone
        GenericTone  = 2,                // Play or detect tones: param: tone
        // Analog line events
        Timeout      = 10,               //
        Polarity     = 11,               // Line's polarity changed
        StartLine    = 15,               // Initialize FXO line
        LineStarted  = 16,               // FXO line initialized: send number
        DialComplete = 17,               // FXO line completed dialing the number
        OnHook       = 20,               // The hook is down
        OffHook      = 21,               // The hook is up
        RingBegin    = 22,               // Start ringing
        RingEnd      = 23,               // Stop ringing
        RingerOn     = 30,               // An FXS started the FXO's ringer
        RingerOff    = 31,               // An FXS stopped the FXO's ringer
        Wink         = 32,               // On hook momentarily
        Flash        = 33,               // Off hook momentarily
        PulseStart   = 40,               // Pulse dialing start
        PulseDigit   = 41,               // Transfer pulse digits: param: pulse
        // Remote circuit events
        Connect      = 50,               // Request connect
        Disconnect   = 51,               // Request disconnect
        Connected    = 52,               // Connected notification
        Disconnected = 53,               // Disconnected notification
        // Errors
        Alarm        = 100,              // Param: alarms (comma separated list of strings)
        NoAlarm      = 101,              // No more alarms
    };

    SignallingCircuitEvent(SignallingCircuit* cic, Type type, const char* name = 0);

    virtual ~SignallingCircuitEvent();

    inline Type type() const
        { return m_type; }

    inline SignallingCircuit* circuit()
        { return m_circuit; }

    bool sendEvent();
 
private:
    SignallingCircuit* m_circuit;
    Type m_type;
};

class YSIG_API SignallingCircuit : public RefObject
{
    YCLASS(SignallingCircuit,RefObject)
    friend class SignallingCircuitGroup;
    friend class SignallingCircuitEvent;
public:
    enum Type {
        Unknown = 0,
        Local, // not really a circuit
        TDM,
        RTP,
        IAX,
    };

    enum Status {
        Missing = 0,
        Disabled,
        Idle,
        Reserved,
        Starting,
        Stopping,
        Special,
        Connected,
    };

    enum LockFlags {
        LockLocalHWFail       = 0x0001,  // Local side of the circuit is locked due to HW failure
        LockLocalMaint        = 0x0002,  // Local side of the circuit is locked for maintenance
        LockingHWFail         = 0x0004,  // Circuit (un)lock due to HW failure in progress
        LockingMaint          = 0x0008,  // Circuit (un)lock due to maintenance in progress
        LockLocalHWFailChg    = 0x0010,  // Local HW failure flag changed
        LockLocalMaintChg     = 0x0020,  // Local maintenance flag changed
        Resetting             = 0x0040,  // Circuit is beeing reset
        LockRemoteHWFail      = 0x0100,  // Remote side of the circuit is locked due to HW failure
        LockRemoteMaint       = 0x0200,  // Remote side of the circuit is locked for maintenance
        LockRemoteHWFailChg   = 0x1000,  // Remote HW failure flag changed
        LockRemoteMaintChg    = 0x2000,  // Remote maintenance flag changed
        // Masks used to test lock conditions
        LockLocal             = LockLocalHWFail | LockLocalMaint,
        LockRemote            = LockRemoteHWFail | LockRemoteMaint,
        LockLocked            = LockLocal | LockRemote,
        LockBusy              = LockingHWFail | LockingMaint | Resetting,
        LockLockedBusy        = LockLocked | LockBusy,
        LockLocalChg          = LockLocalHWFailChg | LockLocalMaintChg,
        LockRemoteChg         = LockRemoteHWFailChg | LockRemoteMaintChg,
        LockChanged           = LockLocalChg | LockRemoteChg,
    };

    virtual ~SignallingCircuit();

    virtual bool status(Status newStat, bool sync = false)
        { m_status = newStat; return true; }

    inline Type type() const
        { return m_type; }

    inline Status status() const
        { return m_status; }

    inline int locked(int flags = -1) const
        { return (m_lock & flags); }

    inline void setLock(int flags)
        { m_lock |= flags; }

    inline void resetLock(int flags)
        { m_lock &= ~flags; }

    virtual bool updateFormat(const char* format, int direction)
        { return false; }

    virtual bool setParam(const String& param, const String& value)
        { return false; }

    virtual bool setParams(const NamedList& params);

    virtual bool getParam(const String& param, String& value) const
        { return false; }

    virtual bool getBoolParam(const String& param, bool defValue = false) const
        { return defValue; }

    virtual int getIntParam(const String& param, int defValue = 0) const
        { return defValue; }

    virtual bool getParams(NamedList& params, const String& category = String::empty())
        { return false; }

    inline SignallingCircuitGroup* group()
        { return m_group; }

    inline SignallingCircuitSpan* span()
        { return m_span; }

    inline const SignallingCircuitGroup* group() const
        { return m_group; }

    inline const SignallingCircuitSpan* span() const
        { return m_span; }

    inline unsigned int code() const
        { return m_code; }

    inline bool available() const
        { return m_status == Idle; }

    inline bool connected() const
        { return m_status == Connected; }

    inline bool reserve()
        { return available() && status(Reserved,true); }

    inline bool connect(const char* format = 0)
        { updateFormat(format,0); return status(Connected,true); }

    inline bool disconnect()
        { return status() == Connected && status(Reserved,true); }

    inline bool disable()
        { return status(Disabled,true); }

    bool hwLock(bool set, bool remote, bool changed = false, bool setChanged = false);

    bool maintLock(bool set, bool remote, bool changed = false, bool setChanged = false);

    void addEvent(SignallingCircuitEvent* event);

    SignallingCircuitEvent* getEvent(const Time& when);

    virtual bool sendEvent(SignallingCircuitEvent::Type type, NamedList* params = 0);

    static const char* lookupType(int type);

    static const char* lookupStatus(int status);

    static const TokenDict s_lockNames[];
 
protected:
    SignallingCircuit(Type type, unsigned int code, SignallingCircuitGroup* group = 0,
        SignallingCircuitSpan* span = 0);

    SignallingCircuit(Type type, unsigned int code, Status status,
        SignallingCircuitGroup* group = 0, SignallingCircuitSpan* span = 0);

    virtual void clearEvents();

    void eventTerminated(SignallingCircuitEvent* event);

    Mutex m_mutex;
 
private:
    SignallingCircuitGroup* m_group;     // The group owning this circuit
    SignallingCircuitSpan* m_span;       // The span this circuit belongs to
    unsigned int m_code;                 // Circuit id
    Type m_type;                         // Circuit type (see enumeration)
    Status m_status;                     // Circuit local status
    int m_lock;                          // Circuit lock flags
    ObjList m_events;                    // In-band events
    SignallingCircuitEvent* m_lastEvent; // The last generated event
    bool m_noEvents;                     // No events pending, exit quickly
};

class YSIG_API SignallingCircuitRange : public String
{
    YCLASS(SignallingCircuitRange,String)
    friend class SignallingCircuitGroup;
public:
    SignallingCircuitRange(const String& rangeStr, const char* name = 0,
        int strategy = -1);

    virtual ~SignallingCircuitRange()
        { clear(); }

    inline unsigned int count() const
        { return m_count; }

    inline const unsigned int* range() const
        { return (const unsigned int*)m_range.data(); }

    unsigned int* copyRange(unsigned int& count) const;

    inline void clear()
        { m_range.clear(); m_count = 0; }

    inline unsigned int operator[](unsigned int index)
        { return range()[index]; }

    inline bool set(const String& rangeStr)
    {
        clear();
        return add(rangeStr);
    }

    bool add(const String& rangeStr);

    void add(unsigned int* codes, unsigned int len);

    inline void add(unsigned int code)
        { add(&code,1); }

    void add(unsigned int first, unsigned int last);

    void remove(unsigned int code);

    bool find(unsigned int code);

    virtual void destruct()
    {
        clear();
        String::destruct();
    }
 
protected:
    void updateLast();                   // Update last circuit code
 
    DataBlock m_range;                   // Array containing the circuit codes
    unsigned int m_count;                // The number of elements in the array
    unsigned int m_last;                 // Last (the greater) not used circuit code within this range
    int m_strategy;                      // Keep the strategy used to allocate circuits from this range
    unsigned int m_used;                 // Last used circuit code
};

class YSIG_API SignallingCircuitGroup : public SignallingComponent, public Mutex
{
    YCLASS(SignallingCircuitGroup,SignallingComponent)
    friend class SignallingCircuit;
    friend class SignallingCallControl;
    friend class SS7ISUP;
    friend class ISDNQ931;
public:
    enum Strategy {
        Other     = 0,
        // basic strategies
        Increment = 0x0001, // round-robin, up
        Decrement = 0x0002, // round-robin, down
        Lowest    = 0x0003, // pick first available
        Highest   = 0x0004, // pick last available
        Random    = 0x0005, // pick random circuit
        // even/odd strict select (glare avoidance)
        OnlyEven  = 0x1000,
        OnlyOdd   = 0x2000,
        // glare avoidance with fallback (to be able to use all circuits)
        Fallback  = 0x4000,
    };

    SignallingCircuitGroup(unsigned int base = 0, int strategy = Increment,
        const char* name = "circgroup");

    virtual ~SignallingCircuitGroup();

    inline unsigned int count() const
        { return m_circuits.count(); }

    inline unsigned int base() const
        { return m_base; }

    inline unsigned int last() const
        { return m_range.m_last; }

    inline int strategy() const
        { return m_range.m_strategy; }

    inline void setStrategy(int strategy)
        { Lock lock(this); m_range.m_strategy = strategy; }

    inline ObjList& circuits()
        { return m_circuits; }

    void getCicList(String& dest);

    bool insert(SignallingCircuit* circuit);

    void remove(SignallingCircuit* circuit);

    SignallingCircuitSpan* buildSpan(const String& name, unsigned int start = 0, NamedList* params = 0);

    bool insertSpan(SignallingCircuitSpan* span);

    void insertRange(SignallingCircuitSpan* span, const char* name,
        int strategy = -1);

    void insertRange(const String& range, const char* name,
        int strategy = -1);

    void removeSpan(SignallingCircuitSpan* span, bool delCics = true, bool delSpan = false);

    void removeSpanCircuits(SignallingCircuitSpan* span);

    SignallingCircuit* find(unsigned int cic, bool local = false);

    SignallingCircuitRange* findRange(const char* name);

    SignallingCircuit::Status status(unsigned int cic);

    bool status(unsigned int cic, SignallingCircuit::Status newStat, bool sync = false);

    SignallingCircuit* reserve(int checkLock = -1, int strategy = -1,
        SignallingCircuitRange* range = 0);

    SignallingCircuit* reserve(const String& list, bool mandatory,
        int checkLock = -1, int strategy = -1, SignallingCircuitRange* range = 0);

    inline bool release(SignallingCircuit* cic, bool sync = false)
        { return cic && cic->status(SignallingCircuit::Idle,sync); }

    static int str2strategy(const char* name, int def = Increment)
        { return lookup(name,s_strategy,def); }

    static const TokenDict s_strategy[];
 
protected:
    virtual void destroyed()
    {
        clearAll();
        SignallingComponent::destroyed();
    }
 
private:
    unsigned int advance(unsigned int n, int strategy, SignallingCircuitRange& range);
    void clearAll();
 
    ObjList m_circuits;                  // The circuits belonging to this group
    ObjList m_spans;                     // The spans belonging to this group
    ObjList m_ranges;                    // Additional circuit ranges
    SignallingCircuitRange m_range;      // Range containing all circuits belonging to this group
    unsigned int m_base;
};

class YSIG_API SignallingCircuitSpan : public SignallingComponent
{
    YCLASS(SignallingCircuitSpan,SignallingComponent)
public:
    virtual ~SignallingCircuitSpan();

    inline SignallingCircuitGroup* group() const
        { return m_group; }

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

    inline unsigned int increment() const
        { return m_increment; }
 
protected:
    SignallingCircuitSpan(const char* id = 0, SignallingCircuitGroup* group = 0);

    SignallingCircuitGroup* m_group;

    unsigned int m_increment;
 
private:
    String m_id;                         // Span's id
};

class YSIG_API SignallingInterface : virtual public SignallingComponent
{
    YCLASS(SignallingInterface,SignallingComponent)
    friend class SignallingReceiver;
public:
    enum Operation {
        Specific  = 0,
        EnableTx  = 0x01,
        EnableRx  = 0x02,
        Enable    = 0x03,
        DisableTx = 0x04,
        DisableRx = 0x08,
        Disable   = 0x0c,
        FlushTx   = 0x10,
        FlushRx   = 0x20,
        Flush     = 0x30,
        QueryTx   = 0x40,
        QueryRx   = 0x80,
        Query     = 0xc0
    };

    enum Notification {
        LinkUp = 0,
        LinkDown,
        HardwareError,
        TxClockError,
        RxClockError,
        AlignError,
        CksumError,
        TxOversize,
        RxOversize,
        TxOverflow,
        RxOverflow,
        TxUnderrun,
        RxUnderrun,
    };

    enum PacketType {
        Unknown = 0,
        SS7Fisu,
        SS7Lssu,
        SS7Msu,
        Q921
    };

    inline SignallingInterface()
        : m_recvMutex(true,"SignallingInterface::recv"), m_receiver(0)
        { }

    virtual ~SignallingInterface();

    virtual void attach(SignallingReceiver* receiver);

    inline SignallingReceiver* receiver() const
        { return m_receiver; }

    virtual bool control(Operation oper, NamedList* params = 0);

    static const TokenDict s_notifName[];
 
protected:
    virtual bool transmitPacket(const DataBlock& packet, bool repeat, PacketType type) = 0;

    bool receivedPacket(const DataBlock& packet);

    bool notify(Notification event);
 
private:
    Mutex m_recvMutex;                   // Lock receiver pointer operations
    SignallingReceiver* m_receiver;
};

class YSIG_API SignallingReceiver : virtual public SignallingComponent
{
    YCLASS(SignallingReceiver,SignallingComponent)
    friend class SignallingInterface;
public:
    SignallingReceiver(const char* name = 0);

    virtual ~SignallingReceiver();

    virtual SignallingInterface* attach(SignallingInterface* iface);

    inline SignallingInterface* iface() const
        { return m_interface; }

    bool control(SignallingInterface::Operation oper, NamedList* params = 0);
 
protected:
    bool transmitPacket(const DataBlock& packet, bool repeat,
        SignallingInterface::PacketType type = SignallingInterface::Unknown);

    virtual bool receivedPacket(const DataBlock& packet) = 0;

    virtual bool notify(SignallingInterface::Notification event);
 
private:
    Mutex m_ifaceMutex;                  // Lock interface pointer operations
    SignallingInterface* m_interface;
};
 

struct SignallingFlags
{
    unsigned int mask;

    unsigned int value;

    const char* name;
};

class YSIG_API SignallingUtils
{
public:
    static const TokenDict* codings();

    static const TokenDict* locations();

    static inline const TokenDict* dict(unsigned int index, unsigned char coding = 0)
    {
        if (index > 4)
            return 0;
        return (!coding ? s_dictCCITT[index] : 0);
    }

    static bool hasFlag(const String& flags, const char* flag);

    static bool appendFlag(String& flags, const char* flag);

    static bool removeFlag(String& flags, const char* flag);

    static bool hasFlag(const NamedList& list, const char* param, const char* flag);

    static bool appendFlag(NamedList& list, const char* param, const char* flag);

    static void addKeyword(NamedList& list, const char* param,
        const TokenDict* tokens, unsigned int val);

    static void dumpData(const SignallingComponent* comp, NamedList& list, const char* param,
        const unsigned char* buf, unsigned int len, char sep = ' ');

    static unsigned int dumpDataExt(const SignallingComponent* comp, NamedList& list, const char* param,
        const unsigned char* buf, unsigned int len, char sep = ' ');

    static bool decodeFlags(const SignallingComponent* comp, NamedList& list, const char* param,
        const SignallingFlags* flags, const unsigned char* buf, unsigned int len);

    static bool decodeCause(const SignallingComponent* comp, NamedList& list, const unsigned char* buf,
        unsigned int len, const char* prefix, bool isup);

    static bool decodeCaps(const SignallingComponent* comp, NamedList& list, const unsigned char* buf,
        unsigned int len, const char* prefix, bool isup);

    static void encodeFlags(const SignallingComponent* comp, int& dest, const String& flags,
        const TokenDict* dict);

    static unsigned int encodeFlags(const SignallingComponent* comp, const String& flags,
        const SignallingFlags* dict, const char* paramName = 0);

    static bool encodeCause(const SignallingComponent* comp, DataBlock& buf, const NamedList& params,
        const char* prefix, bool isup, bool fail = false);

    static bool encodeCaps(const SignallingComponent* comp, DataBlock& buf, const NamedList& params,
        const char* prefix, bool isup);

    static unsigned int* parseUIntArray(const String& source, unsigned int minVal, unsigned int maxVal,
        unsigned int& count, bool discardDup);
 
private:
    static const TokenDict* s_dictCCITT[5];
};

class YSIG_API SignallingMessageTimer : public GenObject, public SignallingTimer
{
public:
    inline SignallingMessageTimer(u_int64_t interval, u_int64_t global = 0)
        : SignallingTimer(interval),
          m_globalTimer(global), m_msg(0)
        { }

    virtual ~SignallingMessageTimer()
        { TelEngine::destruct(m_msg); }

    inline SignallingMessage* message() const
        { return m_msg; }

    inline void message(SignallingMessage* msg)
        { m_msg = msg; }
 

    inline SignallingTimer& global()
        { return m_globalTimer; }

    inline const SignallingTimer& global() const
        { return m_globalTimer; }

    inline u_int64_t fireTime() const {
        if (!m_globalTimer.started() || m_globalTimer.fireTime() > SignallingTimer::fireTime())
            return SignallingTimer::fireTime();
        return m_globalTimer.fireTime();
    }
 
protected:
    SignallingTimer m_globalTimer;
    SignallingMessage* m_msg;
};

class YSIG_API SignallingMessageTimerList : public ObjList
{
public:
    inline SignallingMessageTimerList()
        { }

    inline SignallingMessageTimer* add(u_int64_t interval, const Time& when = Time())
        { return interval ? add(new SignallingMessageTimer(interval),when) : 0; }

    SignallingMessageTimer* add(SignallingMessageTimer* m, const Time& when = Time());

    SignallingMessageTimer* timeout(const Time& when = Time());
};

class YSIG_API AnalogLine : public RefObject, public Mutex
{
    YCLASS(AnalogLine,RefObject)
    friend class AnalogLineGroup;        // Reset group if destroyed before the line
public:
    enum Type {
        FXO,                             // Telephone linked to an exchange
        FXS,                             // Telephone exchange linked to a telephone
        Recorder,                        // Passive FXO recording a 2 wire line
        Monitor,                         // Monitor (a pair of FXS/FXO lines)
        Unknown
    };

    enum State {
        OutOfService   = -1,             // Line is out of service
        Idle           = 0,              // Line is idle (on hook)
        Dialing        = 1,              // FXS line is waiting for the FXO to dial the number
        DialComplete   = 2,              // FXS line: got enough digits from the FXO to reach a destination
        Ringing        = 3,              // Line is ringing
        Answered       = 4,              // Line is answered
        CallEnded      = 5,              // FXS line: notify the FXO on call termination
        OutOfOrder     = 6,              // FXS line: notify the FXO that the hook is off after call ended notification
    };

    enum CallSetupInfo {
        After,                           // Send/detect call setup after the first ring
        Before,                          // Send/detect call setup before the first ring
        NoCallSetup                      // No call setup detect or send
    };

    AnalogLine(AnalogLineGroup* grp, unsigned int cic, const NamedList& params);

    virtual ~AnalogLine();

    inline Type type() const
        { return m_type; }

    inline State state() const
        { return m_state; }

    inline AnalogLineGroup* group()
        { return m_group; }

    inline AnalogLine* getPeer()
        { return m_peer; }

    void setPeer(AnalogLine* line = 0, bool sync = true);

    inline SignallingCircuit* circuit()
        { return m_circuit; }

    inline const char* address() const
        { return m_address; }

    inline bool outbandDtmf() const
        { return !m_inband; }

    inline bool answerOnPolarity() const
        { return m_answerOnPolarity; }

    inline bool hangupOnPolarity() const
        { return m_hangupOnPolarity; }

    inline bool polarityControl() const
        { return m_polarityControl; }

    inline CallSetupInfo callSetup() const
        { return m_callSetup; }

    inline u_int64_t callSetupTimeout() const
        { return m_callSetupTimeout; }

    inline u_int64_t noRingTimeout() const
        { return m_noRingTimeout; }

    inline u_int64_t alarmTimeout() const
        { return m_alarmTimeout; }

    inline u_int64_t delayDial() const
        { return m_delayDial; }

    inline void acceptPulseDigit(bool ok)
        { m_acceptPulseDigit = ok; }

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

    inline void userdata(void* data, bool sync = true)
    {
        Lock lock(this);
        m_private = data;
        if (sync && m_peer)
            m_peer->userdata(data,false);
    }

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

    void resetEcho(bool train);

    inline bool resetCircuit()
        { return state() != OutOfService && m_circuit && m_circuit->reserve(); }

    inline bool setCircuitParam(const char* param, const char* value = 0)
        { return m_circuit && m_circuit->setParam(param,value); }

    bool connect(bool sync);

    bool disconnect(bool sync);

    bool sendEvent(SignallingCircuitEvent::Type type, NamedList* params = 0);

    inline bool sendEvent(SignallingCircuitEvent::Type type, State newState,
        NamedList* params = 0)
    {
        if (!sendEvent(type,params))
            return false;
        changeState(newState,false);
        return true;
    }

    virtual AnalogLineEvent* getEvent(const Time& when);

    virtual AnalogLineEvent* getMonitorEvent(const Time& when);

    virtual void checkTimeouts(const Time& when)
        { }

    bool changeState(State newState, bool sync = false);

    bool enable(bool ok, bool sync, bool connectNow = true);

    static const TokenDict* typeNames();

    static const TokenDict* stateNames();

    static const TokenDict* csNames();
 
protected:
    virtual void destroyed();
 
private:
    Type m_type;                               // Line type
    State m_state;                             // Line state
    bool m_inband;                             // Refuse to send DTMFs if they should be sent in band
    int m_echocancel;                          // Default echo canceller state (0: managed by the circuit, -1: off, 1: on)
    bool m_acceptPulseDigit;                   // Accept incoming pulse digits
    bool m_answerOnPolarity;                   // Answer on line polarity change
    bool m_hangupOnPolarity;                   // Hangup on line polarity change
    bool m_polarityControl;                    // Set line polarity flag
    CallSetupInfo m_callSetup;                 // Call setup management
    u_int64_t m_callSetupTimeout;              // FXO: timeout period for received call setup data before first ring
    u_int64_t m_noRingTimeout;                 // FXO: timeout period with no ring received on incoming calls
    u_int64_t m_alarmTimeout;                  // Timeout period to stay in alarms
    u_int64_t m_delayDial;                     // FXO: Time to delay sending number
    AnalogLineGroup* m_group;                  // The group owning this line
    SignallingCircuit* m_circuit;              // The circuit managed by this line
    String m_address;                          // Line address: group and circuit
    void* m_private;                           // Private data used by this line's user
    // Monitor data
    AnalogLine* m_peer;                        // This line's peer if any
    bool m_getPeerEvent;                       // Flag used to get events from peer
};

class YSIG_API AnalogLineEvent : public GenObject
{
public:
    AnalogLineEvent(AnalogLine* line, SignallingCircuitEvent* event)
        : m_line(0), m_event(event)
        { if (line && line->ref()) m_line = line; }

    virtual ~AnalogLineEvent()
    {
        TelEngine::destruct(m_line);
        TelEngine::destruct(m_event);
    }

    inline AnalogLine* line()
        { return m_line; }

    inline SignallingCircuitEvent* event()
        { return m_event; }

    virtual void destruct()
    {
        TelEngine::destruct(m_line);
        TelEngine::destruct(m_event);
        GenObject::destruct();
    }
 
private:
    AnalogLine* m_line;
    SignallingCircuitEvent* m_event;
};

class YSIG_API AnalogLineGroup : public SignallingCircuitGroup
{
    YCLASS(AnalogLineGroup,SignallingCircuitGroup)
public:
    AnalogLineGroup(AnalogLine::Type type, const char* name, bool slave = false);

    AnalogLineGroup(const char* name, AnalogLineGroup* fxo);

    virtual ~AnalogLineGroup();

    inline AnalogLine::Type type() const
        { return m_type; }

    inline ObjList& lines()
        { return m_lines; }

    inline AnalogLineGroup* fxo()
        { return m_fxo; }

    inline bool slave()
        { return m_slave; }

    bool appendLine(AnalogLine* line, bool destructOnFail = true);

    void removeLine(unsigned int cic);

    void removeLine(AnalogLine* line);

    AnalogLine* findLine(unsigned int cic);

    AnalogLine* findLine(const String& address);

    virtual AnalogLineEvent* getEvent(const Time& when);
 
protected:
    virtual void destroyed();

    ObjList m_lines;
 
private:
    AnalogLine::Type m_type;             // Line type
    AnalogLineGroup* m_fxo;              // The group containing the FXO lines if this is a monitor
    bool m_slave;                        // True if this is an FXO group owned by an FXS one
};

class YSIG_API SS7PointCode : public GenObject
{
    YCLASS(SS7PointCode,GenObject)
public:
    enum Type {
        Other  = 0,
        ITU    = 1, // ITU-T Q.704
        ANSI   = 2, // ANSI T1.111.4
        ANSI8  = 3, // 8-bit SLS
        China  = 4, // GF 001-9001
        Japan  = 5, // JT-Q704, NTT-Q704
        Japan5 = 6, // 5-bit SLS
        // Do not change the next line, must be past last defined type
        DefinedTypes
    };

    inline SS7PointCode(unsigned char network = 0, unsigned char cluster = 0, unsigned char member = 0)
        : m_network(network), m_cluster(cluster), m_member(member)
        { }

    inline SS7PointCode(Type type, unsigned int packed)
        : m_network(0), m_cluster(0), m_member(0)
        { unpack(type,packed); }

    inline SS7PointCode(const SS7PointCode& original)
        : m_network(original.network()), m_cluster(original.cluster()), m_member(original.member())
        { }

    inline ~SS7PointCode()
        { }

    inline unsigned char network() const
        { return m_network; }

    inline unsigned char cluster() const
        { return m_cluster; }

    inline unsigned char member() const
        { return m_member; }

    inline void assign(unsigned char network, unsigned char cluster, unsigned char member)
        { m_network = network; m_cluster = cluster; m_member = member; }

    bool assign(const String& src, Type type = Other);

    bool assign(Type type, const unsigned char* src, int len = -1, unsigned char* spare = 0);

    inline SS7PointCode& operator=(const SS7PointCode& original)
        { assign(original.network(),original.cluster(),original.member()); return *this; }

    inline bool operator==(const SS7PointCode& original) const
        { return m_network == original.network() && m_cluster == original.cluster() && m_member == original.member(); }

    inline bool operator!=(const SS7PointCode& original) const
        { return m_network != original.network() || m_cluster != original.cluster() || m_member != original.member(); }

    bool compatible(Type type) const;

    unsigned int pack(Type type) const;

    bool unpack(Type type, unsigned int packed);

    bool store(Type type, unsigned char* dest, unsigned char spare = 0) const;

    static unsigned char size(Type type);

    static unsigned char length(Type type);

    static Type lookup(const char* text)
        { return (Type)TelEngine::lookup(text,s_names,(int)Other); }

    static const char* lookup(Type type)
        { return TelEngine::lookup((int)type,s_names); }
 
private:
    static const TokenDict s_names[];    // Keep the strigns associated with point code type
    unsigned char m_network;
    unsigned char m_cluster;
    unsigned char m_member;
};
 
// The number of valid point code types
#define YSS7_PCTYPE_COUNT (SS7PointCode::DefinedTypes-1)

YSIG_API String& operator<<(String& str, const SS7PointCode& cp);

class YSIG_API SS7Label
{
public:
    SS7Label();

    SS7Label(const SS7Label& original);

    SS7Label(const SS7Label& original, unsigned char sls, unsigned char spare = 0);

    SS7Label(SS7PointCode::Type type, const SS7PointCode& dpc,
        const SS7PointCode& opc, unsigned char sls, unsigned char spare = 0);

    SS7Label(SS7PointCode::Type type, unsigned int dpc,
        unsigned int opc, unsigned char sls, unsigned char spare = 0);

    SS7Label(SS7PointCode::Type type, const SS7MSU& msu);

    void assign(SS7PointCode::Type type, const SS7PointCode& dpc,
        const SS7PointCode& opc, unsigned char sls, unsigned char spare = 0);

    void assign(SS7PointCode::Type type, unsigned int dpc,
        unsigned int opc, unsigned char sls, unsigned char spare = 0);

    bool assign(SS7PointCode::Type type, const SS7MSU& msu);

    bool assign(SS7PointCode::Type type, const unsigned char* src, int len = -1);

    bool store(unsigned char* dest) const;

    bool compatible(SS7PointCode::Type type) const;

    inline SS7PointCode::Type type() const
        { return m_type; }

    inline const SS7PointCode& dpc() const
        { return m_dpc; }

    inline SS7PointCode& dpc()
        { return m_dpc; }

    inline const SS7PointCode& opc() const
        { return m_opc; }

    inline SS7PointCode& opc()
        { return m_opc; }

    inline unsigned char sls() const
        { return m_sls; }

    inline void setSls(unsigned char sls)
        { m_sls = sls; }

    inline unsigned char spare() const
        { return m_spare; }

    inline void setSpare(unsigned char spare)
        { m_spare = spare; }

    inline unsigned int length() const
        { return length(m_type); }

    static unsigned int length(SS7PointCode::Type type);

    inline unsigned char size() const
        { return size(m_type); }

    static unsigned char size(SS7PointCode::Type type);
 
private:
    SS7PointCode::Type m_type;
    SS7PointCode m_dpc;
    SS7PointCode m_opc;
    unsigned char m_sls;
    unsigned char m_spare;
};

YSIG_API String& operator<<(String& str, const SS7Label& label);
 
// Maximum size of a MTP2 MSU including SIO + Routing Label + data (Q.703 2.3.8)
#define MAX_TDM_MSU_SIZE 273

class YSIG_API SS7MSU : public DataBlock
{
    YCLASS(SS7MSU,DataBlock)
public:
    enum Services {
        // Signalling Network Management
        SNM   =  0,
        // Maintenance
        MTN   =  1,
        // Maintenance special
        MTNS  =  2,
        // Signalling Connection Control Part
        SCCP  =  3,
        // Telephone User Part
        TUP   =  4,
        // ISDN User Part
        ISUP  =  5,
        // Data User Part - call and circuit related
        DUP_C =  6,
        // Data User Part - facility messages
        DUP_F =  7,
        // MTP Testing User Part (reserved)
        MTP_T =  8,
        // Broadband ISDN User Part
        BISUP =  9,
        // Satellite ISDN User Part
        SISUP = 10,
        // AAL type2 Signaling
        AAL2  = 12,
        // Bearer Independent Call Control
        BICC  = 13,
        // Gateway Control Protocol
        GCP   = 14,
    };

    enum Priority {
        Regular  = 0x00,
        Special  = 0x10,
        Circuit  = 0x20,
        Facility = 0x30
    };

    enum NetIndicator {
        International      = 0x00,
        SpareInternational = 0x40,
        National           = 0x80,
        ReservedNational   = 0xc0
    };

    inline SS7MSU()
        { }

    inline SS7MSU(const SS7MSU& value)
        : DataBlock(value)
        { }

    inline SS7MSU(const DataBlock& value)
        : DataBlock(value)
        { }

    inline SS7MSU(void* value, unsigned int len, bool copyData = true)
        : DataBlock(value,len,copyData)
        { }

    SS7MSU(unsigned char sio, const SS7Label label, void* value = 0, unsigned int len = 0);

    SS7MSU(unsigned char sif, unsigned char ssf, const SS7Label label, void* value = 0, unsigned int len = 0);

    virtual ~SS7MSU();

    inline SS7MSU& operator=(const SS7MSU& value)
        { DataBlock::operator=(value); return *this; }

    inline SS7MSU& operator=(const DataBlock& value)
        { DataBlock::operator=(value); return *this; }

    bool valid() const;

    inline unsigned char* getData(unsigned int offs, unsigned int len = 1)
        { return (offs+len <= length()) ? offs + (unsigned char*)data() : 0; }

    inline const unsigned char* getData(unsigned int offs, unsigned int len = 1) const
        { return (offs+len <= length()) ? offs + (const unsigned char*)data() : 0; }

    inline unsigned char* getData(const SS7Label& label, unsigned int len = 1)
        { return getData(label.length()+1,len); }

    inline const unsigned char* getData(const SS7Label& label, unsigned int len = 1) const
        { return getData(label.length()+1,len); }

    inline int getSIO() const
        { return null() ? -1 : *(const unsigned char*)data(); }

    inline int getSIF() const
        { return null() ? -1 : 0x0f & *(const unsigned char*)data(); }

    inline int getSSF() const
        { return null() ? -1 : 0xf0 & *(const unsigned char*)data(); }

    inline int getPrio() const
        { return null() ? -1 : 0x30 & *(const unsigned char*)data(); }

    inline int getNI() const
        { return null() ? -1 : 0xc0 & *(const unsigned char*)data(); }

    const char* getServiceName() const;

    const char* getPriorityName() const;

    const char* getIndicatorName() const;

    static unsigned char getPriority(const char* name, unsigned char defVal = Regular);

    static unsigned char getNetIndicator(const char* name, unsigned char defVal = National);
};

class HandledMSU
{
public:
    enum Result {
        Rejected     =  0,
        Unequipped   =  1,
        Inaccessible =  2,
        // private used (non Q.704)
        Accepted     = 16,
        Failure      = 17,
        NoAddress    = 18,
        NoCircuit    = 19,
    };

    inline HandledMSU(Result result = Rejected)
        { m_result = result; }

    inline HandledMSU(bool success)
        { m_result = success ? Accepted : Failure; }

    inline HandledMSU(const HandledMSU& original)
        { m_result = original; }

    inline HandledMSU& operator=(Result result)
        { m_result = result; return *this; }

    inline HandledMSU& operator=(const HandledMSU& original)
        { m_result = original; return *this; }

    inline bool operator==(Result result)
        { return m_result == result; }

    inline bool operator==(const HandledMSU& result)
        { return m_result == result; }

    inline bool operator!=(Result result)
        { return m_result != result; }

    inline bool operator!=(const HandledMSU& result)
        { return m_result != result; }

    inline operator Result() const
        { return m_result; }

    inline bool ok() const
        { return Accepted == m_result; }

    inline unsigned char upu() const
        { return (Accepted > m_result) ? m_result : Rejected; }
 
private:
    Result m_result;
};

class YSIG_API SIGTransport : public SignallingComponent
{
    YCLASS(SIGTransport,SignallingComponent)
    friend class SIGTRAN;
public:
    enum Transport {
        None = 0,
        Sctp,
        // All the following transports are not standard
        Tcp,
        Udp,
        Unix,
    };

     inline SIGTRAN* sigtran() const
        { return m_sigtran; }

    u_int32_t defPort() const;

    virtual bool reliable() const = 0;

    void notifyLayer(SignallingInterface::Notification status);

    virtual bool initialize(const NamedList* config)
        { return false;}

    virtual bool connected(int streamId) const = 0;

    void attach(SIGTRAN* sigtran);

    bool processMSG(unsigned char msgVersion, unsigned char msgClass,
        unsigned char msgType, const DataBlock& msg, int streamId) const;

    virtual void reconnect(bool force = false)
        { }

    virtual bool getSocketParams(const String& params, NamedList& result)
        { return false; }

    virtual bool transportNotify(SIGTransport* newTransport, const SocketAddr& addr);

    virtual bool hasThread()
        { return false; }

    virtual void stopThread()
        { }
protected:
    inline explicit SIGTransport(const char* name = 0)
        : SignallingComponent(name), m_sigtran(0)
        { }

    virtual void attached(bool hasUAL) = 0;

    virtual bool transmitMSG(unsigned char msgVersion, unsigned char msgClass,
        unsigned char msgType, const DataBlock& msg, int streamId = 0);

    virtual bool transmitMSG(const DataBlock& header, const DataBlock& msg, int streamId = 0) = 0;
 
private:
    SIGTRAN* m_sigtran;
};

class YSIG_API SIGTRAN
{
    friend class SIGTransport;
public:
    enum MsgClass {
        // Management (IUA/M2UA/M3UA/SUA)
        MGMT  =  0,
        // Transfer (M3UA)
        TRAN  =  1,
        // SS7 Signalling Network Management (M3UA/SUA)
        SSNM  =  2,
        // ASP State Maintenance (IUA/M2UA/M3UA/SUA)
        ASPSM =  3,
        // ASP Traffic Maintenance (IUA/M2UA/M3UA/SUA)
        ASPTM =  4,
        // Q.921/Q.931 Boundary Primitives Transport (IUA)
        QPTM  =  5,
        // MTP2 User Adaptation (M2UA)
        MAUP  =  6,
        // Connectionless Messages (SUA)
        CLMSG =  7,
        // Connection-Oriented Messages (SUA)
        COMSG =  8,
        // Routing Key Management (M3UA/SUA)
        RKM   =  9,
        // Interface Identifier Management (M2UA)
        IIM   = 10,
        // M2PA Messages (M2PA)
        M2PA  = 11,
    };

    enum MsgMGMT {
        MgmtERR  =  0,
        MgmtNTFY =  1,
    };

    enum MsgSSNM {
        SsnmDUNA =  1, // Destination Unavailable
        SsnmDAVA =  2, // Destination Available
        SsnmDAUD =  3, // Destination State Audit
        SsnmSCON =  4, // Signalling Congestion
        SsnmDUPU =  5, // Destination User Part Unavailable
        SsnmDRST =  6, // Destination Restricted
    };

    enum MsgASPSM {
        AspsmUP       =  1,
        AspsmDOWN     =  2,
        AspsmBEAT     =  3,
        AspsmUP_ACK   =  4,
        AspsmDOWN_ACK =  5,
        AspsmBEAT_ACK =  6,
    };

    enum MsgASPTM {
        AsptmACTIVE       =  1,
        AsptmINACTIVE     =  2,
        AsptmACTIVE_ACK   =  3,
        AsptmINACTIVE_ACK =  4,
    };

    enum MsgRKM {
        RkmREG_REQ    =  1,
        RkmREG_RSP    =  2,
        RkmDEREG_REQ  =  3,
        RkmDEREG_RSP  =  4,
    };

    enum MsgIIM {
        IimREG_REQ    =  1,
        IimREG_RSP    =  2,
        IimDEREG_REQ  =  3,
        IimDEREG_RSP  =  4,
    };

    explicit SIGTRAN(u_int32_t payload = 0, u_int16_t port = 0);

    virtual ~SIGTRAN();

    virtual void attach(SIGTransport* trans);

    inline SIGTransport* transport() const
        { return m_trans; }

    inline u_int32_t payload() const
        { return m_payload; }

    inline u_int16_t defPort() const
        { return m_defPort; }

    bool connected(int streamId = 0) const;
 
    virtual void notifyLayer(SignallingInterface::Notification status)
        { }

    static const TokenDict* classNames();

    static const char* typeName(unsigned char msgClass, unsigned char msgType,
        const char* defValue = 0);

    bool transmitMSG(unsigned char msgVersion, unsigned char msgClass,
        unsigned char msgType, const DataBlock& msg, int streamId = 0) const;

    inline bool transmitMSG(unsigned char msgClass, unsigned char msgType,
        const DataBlock& msg, int streamId = 0) const
        { return transmitMSG(1,msgClass,msgType,msg,streamId); }

    bool restart(bool force);

    bool getSocketParams(const String& params, NamedList& result);

    virtual bool transportNotify(SIGTransport* newTransport, const SocketAddr& addr)
        { TelEngine::destruct(newTransport); return false; }

    bool hasTransportThread();

    void stopTransportThread();
 
protected:
    virtual bool processMSG(unsigned char msgVersion, unsigned char msgClass,
        unsigned char msgType, const DataBlock& msg, int streamId) = 0;
 
private:
    SIGTransport* m_trans;
    u_int32_t m_payload;
    u_int16_t m_defPort;
    mutable Mutex m_transMutex;
};

class YSIG_API SIGAdaptation : public SignallingComponent, public SIGTRAN, public Mutex
{
    YCLASS(SIGAdaptation,SignallingComponent)
public:
    enum TrafficMode {
        TrafficUnused    = 0,
        TrafficOverride  = 1,
        TrafficLoadShare = 2,
        TrafficBroadcast = 3,
    };
 
    enum HeartbeatState {
        HeartbeatDisabled     = 0,
        HeartbeatEnabled      = 1,
        HeartbeatWaitResponse = 2,
    };
 
    enum Errors {
        InvalidVersion            = 0x01,
        InvalidIID                = 0x02,
        UnsupportedMessageClass   = 0x03,
        UnsupportedMessageType    = 0x04,
        UnsupportedTrafficMode    = 0x05,
        UnexpectedMessage         = 0x06,
        ProtocolError             = 0x07,
        UnsupportedIIDType        = 0x08,
        InvalidStreamIdentifier   = 0x09,
        UnassignedTEI             = 0x0a,
        UnrecognizedSAPI          = 0x0b,
        InvalidTEISAPI            = 0x0c,
        ManagementBlocking        = 0x0d,
        ASPIDRequired             = 0x0e,
        InvalidASPID              = 0x0f,
        ASPActiveIID              = 0x10,
        InvalidParameterValue     = 0x11,
        ParameterFieldError       = 0x12,
        UnexpectedParameter       = 0x13,
        DestinationStatusUnknown  = 0x14,
        InvalidNetworkAppearance  = 0x15,
        MissingParameter          = 0x16,
        InvalidRoutingContext     = 0x19,
        NotConfiguredAS           = 0x1a,
        SubsystemStatusUnknown    = 0x1b,
        InvalidLoadsharingLabel   = 0x1c
    };

    virtual ~SIGAdaptation();

    virtual bool initialize(const NamedList* config);

    static bool nextTag(const DataBlock& data, int& offset, uint16_t& tag, uint16_t& length);

    static bool findTag(const DataBlock& data, int& offset, uint16_t tag, uint16_t& length);

    static bool getTag(const DataBlock& data, uint16_t tag, uint32_t& value);

    static bool getTag(const DataBlock& data, uint16_t tag, String& value);

    static bool getTag(const DataBlock& data, uint16_t tag, DataBlock& value);

    static void addTag(DataBlock& data, uint16_t tag, uint32_t value);

    static void addTag(DataBlock& data, uint16_t tag, const String& value);

    static void addTag(DataBlock& data, uint16_t tag, const DataBlock& value);

    void notifyLayer(SignallingInterface::Notification status);
 
protected:
    explicit SIGAdaptation(const char* name = 0, const NamedList* params = 0,
        u_int32_t payload = 0, u_int16_t port = 0);

    virtual bool processCommonMSG(unsigned char msgClass,
        unsigned char msgType, const DataBlock& msg, int streamId);

    virtual bool processMgmtMSG(unsigned char msgType, const DataBlock& msg, int streamId) = 0;

    virtual bool processAspsmMSG(unsigned char msgType, const DataBlock& msg, int streamId) = 0;

    virtual bool processAsptmMSG(unsigned char msgType, const DataBlock& msg, int streamId) = 0;

    virtual void timerTick(const Time& when);

    bool processHeartbeat(unsigned char msgType, const DataBlock& msg,
        int streamId);

    inline void resetHeartbeat()
    {
        Lock myLock(this);
        for (int i = 0;i < 32;i++)
            m_streamsHB[i] = HeartbeatDisabled;
    }

    inline void enableHeartbeat(unsigned char streamId) {
        if (streamId > 31)
            return;
        m_streamsHB[streamId] = HeartbeatEnabled;
    }
private:
    unsigned int m_maxRetransmit;
    SignallingTimer m_sendHeartbeat;
    SignallingTimer m_waitHeartbeatAck;
    unsigned char m_streamsHB[32];
};

class YSIG_API SIGAdaptClient : public SIGAdaptation
{
    friend class SIGAdaptUser;
    YCLASS(SIGAdaptClient,SIGAdaptation)
public:
    enum AspState {
        AspDown = 0,
        AspUpRq,
        AspUp,
        AspActRq,
        AspActive
    };

    virtual void notifyLayer(SignallingInterface::Notification status);
 
protected:
    explicit SIGAdaptClient(const char* name = 0, const NamedList* params = 0,
        u_int32_t payload = 0, u_int16_t port = 0);

    virtual bool processMgmtMSG(unsigned char msgType, const DataBlock& msg, int streamId);

    virtual bool processAspsmMSG(unsigned char msgType, const DataBlock& msg, int streamId);

    virtual bool processAsptmMSG(unsigned char msgType, const DataBlock& msg, int streamId);

    virtual void activeChange(bool active);

    inline bool aspUp() const
        { return m_state >= AspUp; }

    inline bool aspActive() const
        { return m_state >= AspActive; }

    bool activate();

    void setState(AspState state, bool notify = true);

    inline ObjList& users()
        { return m_users; }

    int32_t m_aspId;

    TrafficMode m_traffic;
 
private:
    void attach(SIGAdaptUser* user);
    void detach(SIGAdaptUser* user);
    ObjList m_users;
    AspState m_state;
};

class YSIG_API SIGAdaptServer : public SIGAdaptation
{
    YCLASS(SIGAdaptServer,SIGAdaptation)
protected:
    inline explicit SIGAdaptServer(const char* name = 0, const NamedList* params = 0,
        u_int32_t payload = 0, u_int16_t port = 0)
        : SIGAdaptation(name,params,payload,port)
        { }

    virtual bool processMgmtMSG(unsigned char msgType, const DataBlock& msg, int streamId);

    virtual bool processAspsmMSG(unsigned char msgType, const DataBlock& msg, int streamId);

    virtual bool processAsptmMSG(unsigned char msgType, const DataBlock& msg, int streamId);
};

class YSIG_API SIGAdaptUser
{
    friend class SIGAdaptClient;
public:
    virtual ~SIGAdaptUser();
 
protected:
    inline SIGAdaptUser()
        : m_autostart(false), m_streamId(1), m_adaptation(0)
        { }

    inline SIGAdaptClient* adaptation() const
        { return m_adaptation; }

    inline SIGTransport* transport() const
        { return m_adaptation ? m_adaptation->transport() : 0; }

    void adaptation(SIGAdaptClient* adapt);

    virtual void activeChange(bool active) = 0;

    inline bool activate()
        { return m_adaptation && m_adaptation->activate(); }

    inline bool aspUp() const
        { return m_adaptation && m_adaptation->aspUp(); }

    inline bool aspActive() const
        { return m_adaptation && m_adaptation->aspActive(); }

    inline unsigned char getStreamId()
        { return m_streamId; }

    bool m_autostart;

    unsigned char m_streamId;
 
private:
    SIGAdaptClient* m_adaptation;
};

class YSIG_API ASPUser
{
};

class YSIG_API GTT : virtual public SignallingComponent
{
public:
    GTT(const NamedList& config);

    virtual ~GTT();

    virtual NamedList* routeGT(const NamedList& gt, const String& prefix, const String& nextPrefix);

    virtual bool initialize(const NamedList* config);

    virtual void attach(SCCP* sccp);

    virtual void updateTables(const NamedList& params)
        { }

    inline SCCP* sccp() const
        { return m_sccp; }
 
protected:
    virtual void destroyed();
 
private:
    SCCP* m_sccp;
 
};

class YSIG_API SCCP : virtual public SignallingComponent
{
    YCLASS(SCCP,SignallingComponent)
    friend class SCCPManagement;
public:
 
    enum Type {                     // used in management status method                                 Flow
         CoordinateRequest         = 0, // Request that a subsystem to go oos (out of service)              (User->SCCP)
         CoordinateConfirm         = 1, // Confirmation that a subsystem can go oos                         (SCCP->User)
         CoordinateIndication      = 2, // Indication that a subsystem requires to go oos                   (SCCP->User)
         CoordinateResponse        = 3, // Response to a subsystem requires to go oos                       (User->SCCP)
         StatusIndication          = 4, // Indication form SCCP that a subsystem status has been changed    (SCCP->User)
         StatusRequest             = 5, // Indication from a user that a subsystem status has been changed  (User->SCCP)
         PointCodeStatusIndication = 6, // Indication to User that a point code is available / unavailable  (SCCP->User)
         TraficIndication          = 7, // ANSI only! Indication that a traffic mix has been detected       (SCCP->User).
         SubsystemStatus           = 8, // Request from sccp t users to find the status of a local subsystem
     };

    SCCP();

    virtual ~SCCP();

    virtual int sendMessage(DataBlock& data, const NamedList& params);

     virtual bool managementStatus(Type type, NamedList& params);

    virtual void attach(SCCPUser* user);

    virtual void detach(SCCPUser* user);

    virtual void attachGTT(GTT* gtt);

    static const TokenDict* notifTypes();
 
    virtual void updateTables(const NamedList& params)
        {
            Lock lock(m_translatorLocker);
            if (m_translator)
                m_translator->updateTables(params);
        }
protected:
    NamedList* translateGT(const NamedList& params, const String& prefix,
            const String& nextPrefix);

    HandledMSU pushMessage(DataBlock& data, NamedList& params, int ssn);

    HandledMSU notifyMessage(DataBlock& data, NamedList& params, int ssn);

    bool managementMessage(Type type, NamedList& params);

    virtual bool isEndpoint()
        { return false; }

    void resolveGTParams(SS7MsgSCCP* msg, const NamedList* gtParams);
private:
    ObjList m_users;
    Mutex m_translatorLocker;
    Mutex m_usersLocker;
    GTT* m_translator;
};
 
class YSIG_API SubsystemStatusTest : public RefObject
{
    YCLASS(SubsystemStatusTest,RefObject)
public:
    inline SubsystemStatusTest(u_int32_t interval)
        : m_interval(interval), m_statusInfo(interval), m_remoteSccp(0), m_remoteSubsystem(0),
        m_markAllowed(false)
        { }

    virtual ~SubsystemStatusTest();

    bool startTest(SccpRemote* remoteSccp, SccpSubsystem* rSubsystem);

    inline SccpRemote* getRemote()
        { return m_remoteSccp; };

    inline bool timeout()
        { return m_statusInfo.started() && m_statusInfo.timeout(); }

    inline SccpSubsystem* getSubsystem()
        { return m_remoteSubsystem; }

    void restartTimer();

    inline bool markAllowed()
        { return m_markAllowed; }

    inline void setAllowed(bool allowed)
        { m_markAllowed = allowed; }
private:
    u_int32_t m_interval;
    SignallingTimer m_statusInfo;
    SccpRemote* m_remoteSccp;
    SccpSubsystem* m_remoteSubsystem;
    bool m_markAllowed;
};

class YSIG_API SCCPUser : virtual public SignallingComponent
{
    YCLASS(SCCPUser,SignallingComponent)
public:
    SCCPUser(const NamedList& params);

    virtual ~SCCPUser();

    virtual bool initialize(const NamedList* config);

    virtual bool sendData(DataBlock& data, NamedList& params);

    virtual bool sccpNotify(SCCP::Type type, NamedList& params);

     virtual HandledMSU receivedData(DataBlock& data, NamedList& params);

     virtual HandledMSU notifyData(DataBlock& data, NamedList& params);

     virtual bool managementNotify(SCCP::Type type, NamedList& params);

    virtual void attach(SCCP* sccp);

    inline SCCP* sccp() const
        { return m_sccp; }
 
protected:
    virtual void destroyed();
 
private:
    SCCP* m_sccp;
    Mutex m_sccpMutex;
    int m_sls;
};

class YSIG_API TCAPUser : public SignallingComponent
{
    YCLASS(TCAPUser,SignallingComponent)
    friend class SS7TCAP;
public:
    TCAPUser(const char* name, const NamedList* params = 0)
      : SignallingComponent(name,params),
        m_tcap(0)
        {}
    virtual ~TCAPUser();

    virtual void attach(SS7TCAP* tcap);

    virtual bool tcapIndication(NamedList& params);

    inline SS7TCAP* tcap() const
        { return m_tcap; }

    virtual bool managementNotify(SCCP::Type type, NamedList& params);

    virtual int managementState();

    virtual void  destroyed();
 
protected:
    inline void setTCAP(SS7TCAP* tcap)
    {
        Lock l(m_tcapMtx);
        m_tcap = tcap;
    }
 
private:
    SS7TCAP* m_tcap;
    Mutex m_tcapMtx;
};
 

class YSIG_API SS7L2User : virtual public SignallingComponent
{
    YCLASS(SS7L2User,SignallingComponent)
    friend class SS7Layer2;
public:
    virtual void attach(SS7Layer2* link) = 0;

    virtual void detach(SS7Layer2* link) = 0;
 
protected:
    virtual bool receivedMSU(const SS7MSU& msu, SS7Layer2* link, int sls) = 0;

    virtual bool recoveredMSU(const SS7MSU& msu, SS7Layer2* link, int sls) = 0;

    virtual void notify(SS7Layer2* link) = 0;
};

class YSIG_API SS7Layer2 : virtual public SignallingComponent
{
    YCLASS(SS7Layer2,SignallingComponent)
    friend class SS7MTP3;
public:
    enum LinkStatus {
        OutOfAlignment = 0,
        NormalAlignment = 1,
        EmergencyAlignment = 2,
        OutOfService = 3,
        ProcessorOutage = 4,
        Busy = 5,
        // short versions as defined by RFC
        O = OutOfAlignment,
        N = NormalAlignment,
        E = EmergencyAlignment,
        OS = OutOfService,
        PO = ProcessorOutage,
        B = Busy,
    };

    enum Operation {
        // take link out of service
        Pause  = 0x100,
        // start link operation, align if it needs to
        Resume = 0x200,
        // start link, force realignment
        Align  = 0x300,
        // get operational status
        Status = 0x400,
    };

    enum Inhibitions {
        // basic maintenance checks not performed
        Unchecked = 0x01,
        // management inactivation
        Inactive  = 0x02,
        // locally inhibited
        Local     = 0x04,
        // remotely inhibited
        Remote    = 0x08,
    };

    virtual bool transmitMSU(const SS7MSU& msu) = 0;

    virtual void recoverMSU(int sequence)
        { }

    virtual unsigned int status() const;

    virtual const char* statusName(unsigned int status, bool brief) const;

    inline const char* statusName(bool brief = false) const
        { return statusName(status(),brief); }

    virtual bool operational() const = 0;

    unsigned int upTime() const
        { return m_lastUp ? (Time::secNow() - m_lastUp) : 0; }

    void attach(SS7L2User* l2user);

    inline SS7L2User* user() const
        { return m_l2user; }

    inline int sls() const
        { return m_sls; }

    inline void sls(int linkSel)
        { if ((m_sls < 0) || !m_l2user) m_sls = linkSel; }

    inline int inhibited() const
        { return m_inhibited; }

    inline bool inhibited(int flags) const
        { return (m_inhibited & flags) != 0; }

    virtual unsigned int congestion()
        { return m_congestion; }

    virtual int getSequence()
        { return m_lastSeqRx; }

    virtual bool control(Operation oper, NamedList* params = 0);

    virtual bool control(NamedList& params);
 
protected:
    inline SS7Layer2()
        : m_autoEmergency(true), m_lastSeqRx(-1), m_congestion(0),
          m_l2userMutex(true,"SS7Layer2::l2user"), m_l2user(0), m_sls(-1),
          m_checkTime(0), m_checkFail(0), m_inhibited(Unchecked), m_lastUp(0),
          m_notify(false)
        { }

    virtual void timerTick(const Time& when);

    inline bool receivedMSU(const SS7MSU& msu)
    {
        m_l2userMutex.lock();
        RefPointer<SS7L2User> tmp = m_l2user;
        m_l2userMutex.unlock();
        return tmp && tmp->receivedMSU(msu,this,m_sls);
    }

    inline bool recoveredMSU(const SS7MSU& msu)
    {
        m_l2userMutex.lock();
        RefPointer<SS7L2User> tmp = m_l2user;
        m_l2userMutex.unlock();
        return tmp && tmp->recoveredMSU(msu,this,m_sls);
    }

    void notify();

    bool inhibit(int setFlags, int clrFlags = 0);

    bool getEmergency(NamedList* params = 0, bool emg = false) const;

    bool m_autoEmergency;

    int m_lastSeqRx;

    unsigned int m_congestion;
 
private:
    Mutex m_l2userMutex;
    SS7L2User* m_l2user;
    int m_sls;
    u_int64_t m_checkTime;
    int m_checkFail;
    int m_inhibited;
    u_int32_t m_lastUp;
    bool m_notify;                       // Notify on timer tick
};

class YSIG_API SS7Route : public RefObject, public Mutex
{
    friend class SS7Layer3;
    friend class SS7Router;
public:
    enum State {
        Unknown       = 0x80,
        // Standard route states
        Prohibited    = 0x01,
        Restricted    = 0x02,
        Congestion    = 0x04,
        Allowed       = 0x08,
        // Masks for typical combinations
        NotAllowed    = 0x77,
        NotCongested  = 0x78,
        NotRestricted = 0x7c,
        NotProhibited = 0x7e,
        KnownState    = 0x7f,
        AnyState      = 0xff
    };

    inline SS7Route(unsigned int packed, SS7PointCode::Type type,
            unsigned int priority = 0, unsigned int shift = 0,
            unsigned int maxDataLength = MAX_TDM_MSU_SIZE)
        : Mutex(true,"SS7Route"), m_packed(packed), m_type(type),
        m_priority(priority), m_shift(shift),m_maxDataLength(maxDataLength),
        m_state(Unknown),m_buffering(0), m_congCount(0),m_congBytes(0)
        { m_networks.setDelete(false); }

    inline SS7Route(const SS7Route& original)
        : Mutex(true,"SS7Route"), m_packed(original.packed()),
          m_type(original.m_type), m_priority(original.priority()),
          m_shift(original.shift()), m_maxDataLength(original.getMaxDataLength()),
          m_state(original.state()), m_buffering(0), m_congCount(0), m_congBytes(0)
        { m_networks.setDelete(false); }

    virtual ~SS7Route()
        { }

    State state() const
        { return m_state; }

    static const TokenDict* stateNames();

    const char* stateName() const
        { return lookup(m_state,stateNames()); }

    static const char* stateName(State state)
        { return lookup(state,stateNames()); }

    unsigned int priority() const
        { return m_priority; }

    unsigned int getMaxDataLength() const
        { return m_maxDataLength; }

    unsigned int packed() const
        { return m_packed; }

    unsigned int shift() const
        { return m_shift; }

    void attach(SS7Layer3* network, SS7PointCode::Type type);

    bool detach(SS7Layer3* network);

    bool hasNetwork(const SS7Layer3* network);

    bool hasNetwork(const SS7Layer3* network) const;

    bool operational(int sls = -1);

    int transmitMSU(const SS7Router* router, const SS7MSU& msu,
        const SS7Label& label, int sls, State states, const SS7Layer3* source = 0);

    bool congested();

    void reroute();
 
private:
    int transmitInternal(const SS7Router* router, const SS7MSU& msu,
        const SS7Label& label, int sls, State states, const SS7Layer3* source);
    void rerouteCheck(u_int64_t when);
    void rerouteFlush();
    unsigned int m_packed;               // Packed destination point code
    SS7PointCode::Type m_type;           // The point code type
    unsigned int m_priority;             // Network priority for the given destination (used by SS7Layer3)
    unsigned int m_shift;                // SLS right shift when selecting linkset
    unsigned int m_maxDataLength;        // The maximum data length that can be transported on this route
    ObjList m_networks;                  // List of networks used to route to the given destination (used by SS7Router)
    State m_state;                       // State of the route
    u_int64_t m_buffering;               // Time when controlled rerouting ends
    ObjList m_reroute;                   // Controlled rerouting buffer
    unsigned int m_congCount;            // Congestion event count
    unsigned int m_congBytes;            // Congestion MSU bytes count
};

class YSIG_API SS7L3User : virtual public SignallingComponent
{
    friend class SS7Layer3;
    friend class SS7Router;
public:
    virtual void attach(SS7Layer3* network) = 0;
 
protected:
    virtual HandledMSU receivedMSU(const SS7MSU& msu, const SS7Label& label, SS7Layer3* network, int sls) = 0;

    virtual bool recoveredMSU(const SS7MSU& msu, const SS7Label& label, SS7Layer3* network, int sls)
        { return false; }

    virtual void receivedUPU(SS7PointCode::Type type, const SS7PointCode node,
        SS7MSU::Services part, unsigned char cause, const SS7Label& label, int sls)
        { }

    virtual void notify(SS7Layer3* link, int sls);

    virtual void routeStatusChanged(SS7PointCode::Type type, const SS7PointCode& node, SS7Route::State state)
        { }

    static ObjList* getNetRoutes(SS7Layer3* network, SS7PointCode::Type type);

    static const ObjList* getNetRoutes(const SS7Layer3* network, SS7PointCode::Type type);
};

class YSIG_API SS7Layer3 : virtual public SignallingComponent
{
    YCLASS(SS7Layer3,SignallingComponent)
    friend class SS7L3User;
    friend class SS7Router;              // Access the data members to build the routing table
    friend class SS7Route;
public:
    virtual ~SS7Layer3()
         { attach(0); }

    virtual bool initialize(const NamedList* config);

    virtual int transmitMSU(const SS7MSU& msu, const SS7Label& label, int sls = -1) = 0;

    virtual bool operational(int sls = -1) const = 0;

    virtual int inhibited(int sls) const
        { return 0; }

    inline bool inhibited(int sls, int flags) const
        { return (inhibited(sls) & flags) != 0; }

    virtual bool inhibit(int sls, int setFlags, int clrFlags = 0)
        { return false; }

    inline bool inService(int sls, int ignore = 0)
        { return operational(sls) && !inhibited(sls,~ignore); }

    virtual unsigned int congestion(int sls)
        { return 0; }

    virtual int getSequence(int sls) const
        { return -1; }

    virtual void recoverMSU(int sls, int sequence)
        { }

    virtual bool restart()
        { return false; }

    void attach(SS7L3User* l3user);

    inline SS7L3User* user() const
        { return m_l3user; }

    SS7PointCode::Type type(unsigned char netType) const;

    void setType(SS7PointCode::Type type, unsigned char netType);

    void setType(SS7PointCode::Type type);

    bool hasType(SS7PointCode::Type pcType) const;

    virtual unsigned char getNI(SS7PointCode::Type pcType, unsigned char defNI) const;

    inline unsigned char getNI(SS7PointCode::Type pcType) const
        { return getNI(pcType,m_defNI); }

    inline unsigned char getNI() const
        { return m_defNI; }

    void setNI(unsigned char defNI);

    bool buildRoutes(const NamedList& params);

    unsigned int getRouteMaxLength(SS7PointCode::Type type, unsigned int packedPC);

    unsigned int getRoutePriority(SS7PointCode::Type type, unsigned int packedPC);

    inline unsigned int getRoutePriority(SS7PointCode::Type type, const SS7PointCode& dest)
        { return getRoutePriority(type,dest.pack(type)); }

    SS7Route::State getRouteState(SS7PointCode::Type type, unsigned int packedPC, bool checkAdjacent = false);

    inline SS7Route::State getRouteState(SS7PointCode::Type type, const SS7PointCode& dest, bool checkAdjacent = false)
        { return getRouteState(type,dest.pack(type),checkAdjacent); }

    virtual bool allowedTo(SS7PointCode::Type type, unsigned int packedPC) const
        { return true; }

    void printRoutes();

    inline unsigned int getLocal(SS7PointCode::Type type) const
        { return (type < SS7PointCode::DefinedTypes) ? m_local[type-1] : 0; }

    virtual unsigned int getDefaultLocal(SS7PointCode::Type type) const
        { return getLocal(type); }
 
protected:
    SS7Layer3(SS7PointCode::Type type = SS7PointCode::Other);

    inline HandledMSU receivedMSU(const SS7MSU& msu, const SS7Label& label, int sls)
    {
        m_l3userMutex.lock();
        RefPointer<SS7L3User> tmp = m_l3user;
        m_l3userMutex.unlock();
        return tmp ? tmp->receivedMSU(msu,label,this,sls) : HandledMSU(HandledMSU::Unequipped);
    }

    inline bool recoveredMSU(const SS7MSU& msu, const SS7Label& label, int sls)
    {
        m_l3userMutex.lock();
        RefPointer<SS7L3User> tmp = m_l3user;
        m_l3userMutex.unlock();
        return tmp && tmp->recoveredMSU(msu,label,this,sls);
    }

    inline void notify(int sls = -1)
    {
        m_l3userMutex.lock();
        RefPointer<SS7L3User> tmp = m_l3user;
        m_l3userMutex.unlock();
        if (tmp)
            tmp->notify(this,sls);
    }

    virtual void linkChecked(int sls, bool remote)
        { }

    virtual bool maintenance(const SS7MSU& msu, const SS7Label& label, int sls);

    virtual bool management(const SS7MSU& msu, const SS7Label& label, int sls);

    virtual bool unavailable(const SS7MSU& msu, const SS7Label& label, int sls, unsigned char cause = 0);

    virtual bool prohibited(unsigned char ssf, const SS7Label& label, int sls);

    virtual bool responder() const
        { return true; }

    SS7Route* findRoute(SS7PointCode::Type type, unsigned int packed);

    inline ObjList* getRoutes(SS7PointCode::Type type)
        { return (type < SS7PointCode::DefinedTypes) ? &m_route[type-1] : 0; }

    inline const ObjList* getRoutes(SS7PointCode::Type type) const
        { return (type < SS7PointCode::DefinedTypes) ? &m_route[type-1] : 0; }

    Mutex m_routeMutex;

    ObjList m_route[YSS7_PCTYPE_COUNT];
 
private:
    Mutex m_l3userMutex;                 // Mutex to lock L3 user pointer
    SS7L3User* m_l3user;
    SS7PointCode::Type m_cpType[4];      // Map incoming MSUs net indicators to point code type
                                         // or the routing table of a message router
    unsigned int m_local[YSS7_PCTYPE_COUNT];
    unsigned char m_defNI;               // Default Network Indicator
};

class YSIG_API SS7Layer4 : public SS7L3User
{
public:
    virtual void destroyed();

    virtual bool initialize(const NamedList* config);

    virtual void attach(SS7Layer3* network);

    inline SS7Layer3* network() const
        { return m_layer3; }

    inline unsigned char sio() const
        { return m_sio; }

    inline unsigned char sif() const
        { return m_sio & 0x0f; }

    inline unsigned char ssf() const
        { return m_sio & 0xf0; }

    inline unsigned char prio() const
        { return m_sio & 0x30; }

    inline unsigned char ni() const
        { return m_sio & 0xc0; }

    static unsigned char getSIO(const NamedList& params, unsigned char sif, unsigned char prio, unsigned char ni);

    static inline unsigned char getSIO(const NamedList& params, unsigned char sif, unsigned char ssf)
        { return getSIO(params,sif,ssf & 0x30,ssf & 0xc0); }

    static inline unsigned char getSIO(const NamedList& params, unsigned char sio)
        { return getSIO(params,sio & 0x0f,sio & 0x30,sio & 0xc0); }

    inline unsigned char getSIO(const NamedList& params) const
        { return getSIO(params,m_sio); }
 
protected:
    SS7Layer4(unsigned char sio = SS7MSU::National, const NamedList* params = 0);

    inline int transmitMSU(const SS7MSU& msu, const SS7Label& label, int sls = -1)
    {
        m_l3Mutex.lock();
        RefPointer<SS7Layer3> tmp = m_layer3;
        m_l3Mutex.unlock();
        return tmp ? tmp->transmitMSU(msu,label,sls) : -1;
    }

    unsigned char m_sio;
 
private:
    Mutex m_l3Mutex;                     // Lock pointer use operations
    SS7Layer3* m_layer3;
};

class YSIG_API SS7Router : public SS7L3User, public SS7Layer3, public Mutex
{
    YCLASS2(SS7Router,SS7L3User,SS7Layer3)
public:
    enum Operation {
        // stop MTP operation, disable the router
        Pause     = 0x100,
        // start router, restart MTP if needed
        Resume    = 0x200,
        // forcibly execute MTP restart
        Restart   = 0x300,
        // get operational status
        Status    = 0x400,
        // forcibly advertise availability to adjacent routes
        Traffic   = 0x500,
        // forcibly advertise available routes
        Advertise = 0x600,
    };

    SS7Router(const NamedList& params);

    virtual ~SS7Router();

    virtual bool initialize(const NamedList* config);

    virtual int transmitMSU(const SS7MSU& msu, const SS7Label& label, int sls = -1);

    virtual bool operational(int sls = -1) const;

    virtual bool restart();

    virtual void attach(SS7Layer3* network);

    virtual void detach(SS7Layer3* network);

    void attach(SS7Layer4* service);

    void detach(SS7Layer4* service);

    bool uninhibit(SS7Layer3* network, int sls, bool remote);

    bool inhibit(const SS7Label& link, int setFlags, int clrFlags = 0, bool notLast = false);

    bool inhibited(const SS7Label& link, int flags);

    int getSequence(const SS7Label& link);

    void recoverMSU(const SS7Label& link, int sequence);

    virtual void receivedUPU(SS7PointCode::Type type, const SS7PointCode node,
        SS7MSU::Services part, unsigned char cause, const SS7Label& label, int sls);

    inline bool transfer() const
        { return m_transfer; }

    inline bool transferring() const
        { return m_transfer || m_transferSilent; }

    inline bool starting() const
        { return !m_started; }

    inline SS7Management* getManagement() const
        { return m_mngmt; }

    virtual unsigned char getNI(SS7PointCode::Type pcType, unsigned char defNI) const;

    virtual unsigned int getDefaultLocal(SS7PointCode::Type type) const;
 
protected:
    void clearView(const SS7Layer3* network);

    SS7Route::State getRouteView(SS7PointCode::Type type, unsigned int packedPC,
        unsigned int remotePC = 0, const SS7Layer3* network = 0);

    bool setRouteState(SS7PointCode::Type type, unsigned int packedPC, SS7Route::State state,
        unsigned int remotePC = 0, const SS7Layer3* network = 0);

    inline bool setRouteState(SS7PointCode::Type type, const SS7PointCode& dest, SS7Route::State state,
        unsigned int remotePC = 0, const SS7Layer3* network = 0)
        { return setRouteState(type,dest.pack(type),state,remotePC,network); }

    void loadLocalPC(const NamedList& params);

    virtual void timerTick(const Time& when);

    virtual HandledMSU receivedMSU(const SS7MSU& msu, const SS7Label& label, SS7Layer3* network, int sls);

    void updateRoutes(SS7Layer3* network);

    void removeRoutes(SS7Layer3* network);

    void notifyRoutes(SS7Route::State states = SS7Route::AnyState, unsigned int onlyPC = 0);

    void notifyRoutes(SS7Route::State states, const SS7Layer3* network);

    virtual void routeChanged(const SS7Route* route, SS7PointCode::Type type,
        unsigned int remotePC = 0, const SS7Layer3* network = 0,
        unsigned int onlyPC = 0, bool forced = false);

    virtual void notify(SS7Layer3* network, int sls);

    virtual bool control(NamedList& params);

    virtual void destroyed();

    ObjList m_layer3;
    ObjList m_layer4;
    int m_changes;
    bool m_transfer;
    bool m_phase2;
    bool m_started;
    SignallingTimer m_restart;
    SignallingTimer m_isolate;
 
private:
    void restart2();
    void disable();
    void sendRestart(const SS7Layer3* network = 0);
    void sendRestart(SS7PointCode::Type type, unsigned int packedPC);
    void silentAllow(const SS7Layer3* network = 0);
    void silentAllow(SS7PointCode::Type type, unsigned int packedPC);
    void checkRoutes(const SS7Layer3* noResume = 0);
    void clearRoutes(SS7Layer3* network, bool ok);
    void reroute(const SS7Layer3* network);
    void rerouteCheck(const Time& when);
    void rerouteFlush();
    bool setRouteSpecificState(SS7PointCode::Type type, unsigned int packedPC,
        unsigned int srcPC, SS7Route::State state, const SS7Layer3* changer = 0);
    inline bool setRouteSpecificState(SS7PointCode::Type type, const SS7PointCode& dest,
        const SS7PointCode&src, SS7Route::State state, const SS7Layer3* changer = 0)
        { return setRouteSpecificState(type,dest.pack(type),src.pack(type),state,changer); }
    void sendRouteTest();
    int routeMSU(const SS7MSU& msu, const SS7Label& label, SS7Layer3* network, int sls, SS7Route::State states);
    void buildView(SS7PointCode::Type type, ObjList& view, SS7Layer3* network);
    void buildViews();
    void printStats();
    Mutex m_statsMutex;
    SignallingTimer m_trafficOk;
    SignallingTimer m_trafficSent;
    SignallingTimer m_routeTest;
    bool m_testRestricted;
    bool m_transferSilent;
    bool m_checkRoutes;
    bool m_autoAllowed;
    bool m_sendUnavail;
    bool m_sendProhibited;
    unsigned long m_rxMsu;
    unsigned long m_txMsu;
    unsigned long m_fwdMsu;
    unsigned long m_failMsu;
    unsigned long m_congestions;
    SS7Management* m_mngmt;
};

class YSIG_API SS7M2PA : public SS7Layer2, public SIGTRAN
{
    YCLASS(SS7M2PA,SS7Layer2)
public:
    enum m2paState {
        Alignment = 1,
        ProvingNormal = 2,
        ProvingEmergency = 3,
        Ready = 4,
        ProcessorOutage = 5,
        ProcessorRecovered = 6,
        Busy = 7,
        BusyEnded = 8,
        OutOfService = 9,
    };
 
    enum msgType {
        UserData = 1,
        LinkStatus = 2
    };
 
    enum sctpState {
        Idle,
        Associating,
        Established
    };
 
    enum M2PAOperations {
        Pause        = SS7Layer2::Pause,
        // start link operation, align if it needs to
        Resume       = SS7Layer2::Resume,
        // start link, force realignment
        Align        = SS7Layer2::Align,
        // get operational status
        Status       = SS7Layer2::Status,
        // restart transport layer
        TransRestart = 0x500
    };

    SS7M2PA(const NamedList& params);

    ~SS7M2PA();

    virtual bool initialize(const NamedList* config);

    virtual bool control(NamedList& params);

    virtual bool control(M2PAOperations oper, NamedList* params = 0);

    virtual bool control(SS7Layer2::Operation oper, NamedList* params = 0)
        { return control((M2PAOperations)oper,params); }

    virtual unsigned int status() const;

    virtual bool transmitMSU(const SS7MSU& msu);

    virtual void notifyLayer(SignallingInterface::Notification status);

    virtual void recoverMSU(int sequence);

    bool decodeSeq(const DataBlock& data, u_int8_t msgType);

    void abortAlignment(const char* info = 0);

    void transmitLS(int streamId = 0);

    void setHeader(DataBlock& data);

    bool processLinkStatus(DataBlock& data, int streamId);

    bool processSLinkStatus(DataBlock& data, int streamId);

    void sendAck();

    bool removeFrame(u_int32_t bsn);

    bool nextBsn(u_int32_t bsn) const;

    static inline u_int32_t increment(u_int32_t& nr)
        { return (nr == 0xffffff) ? (nr = 0) : nr++; }

    static inline u_int32_t getNext(u_int32_t nr)
        { return (nr == 0xffffff) ? 0 : nr + 1; }
 
protected:

    virtual void timerTick(const Time& when);

    virtual bool aligned() const;

    virtual bool operational() const;

    virtual bool processMSG(unsigned char msgVersion, unsigned char msgClass,
        unsigned char msgType, const DataBlock& msg, int streamId);

    void startAlignment(bool emergency = false);

     void retransData();
 
     virtual void destroyed();
private:
    void dumpMsg(u_int8_t version, u_int8_t mClass, u_int8_t type,
        const DataBlock& data, int stream, bool send);
    void setLocalStatus(unsigned int status);
    void setRemoteStatus(unsigned int status);
    u_int32_t m_seqNr;
    u_int32_t m_needToAck;
    u_int32_t m_lastAck;
    u_int32_t m_confCounter;
    u_int32_t m_maxUnack;
    u_int32_t m_maxQueueSize;
    unsigned int m_localStatus;
    unsigned int m_state;
    unsigned int m_remoteStatus;
    unsigned int m_transportState;
    unsigned int m_connFailCounter;
    unsigned int m_connFailThreshold;
    Mutex m_mutex;
    ObjList m_ackList;
    SignallingTimer m_t1;
    SignallingTimer m_t2;
    SignallingTimer m_t3;
    SignallingTimer m_t4;
    SignallingTimer m_ackTimer;
    SignallingTimer m_confTimer;
    SignallingTimer m_oosTimer;
    SignallingTimer m_waitOosTimer;
    SignallingTimer m_connFailTimer;
    bool m_autostart;
    bool m_sequenced;
    bool m_dumpMsg;
};

class YSIG_API SS7M2UAClient : public SIGAdaptClient
{
    YCLASS(SS7M2UAClient,SIGAdaptClient)
public:
    inline SS7M2UAClient(const NamedList& params)
        : SIGAdaptClient(params.safe("SS7M2UAClient"),&params,2,2904)
        { }
    virtual bool processMSG(unsigned char msgVersion, unsigned char msgClass,
        unsigned char msgType, const DataBlock& msg, int streamId);
};

class YSIG_API SS7M2UA : public SS7Layer2, public SIGAdaptUser
{
    friend class SS7M2UAClient;
    YCLASS(SS7M2UA,SS7Layer2)
public:
    SS7M2UA(const NamedList& params);

    virtual bool initialize(const NamedList* config);

    virtual bool control(Operation oper, NamedList* params = 0);

    virtual unsigned int status() const;

    virtual bool transmitMSU(const SS7MSU& msu);

    virtual void recoverMSU(int sequence);

    virtual bool operational() const;

    virtual int getSequence();

    virtual void activeChange(bool active);

    inline int32_t iid() const
        { return m_iid; }
 
protected:
    enum LinkState {
        LinkDown,
        LinkReq,
        LinkReqEmg,
        LinkUp,
        LinkUpEmg,
    };

    virtual void timerTick(const Time& when);
 
    SS7M2UAClient* client() const
        { return static_cast<SS7M2UAClient*>(adaptation()); }
    virtual bool processMGMT(unsigned char msgType, const DataBlock& msg, int streamId);
    virtual bool processMAUP(unsigned char msgType, const DataBlock& msg, int streamId);
    void postRetrieve();
    SignallingTimer m_retrieve;
    int32_t m_iid;
    int m_linkState;
    bool m_rpo;
    bool m_longSeq;
};

class YSIG_API SS7M3UA : public SS7Layer3, public SIGAdaptUser
{
    YCLASS(SS7M3UA,SS7Layer3)
};

class YSIG_API SS7MTP2 : public SS7Layer2, public SignallingReceiver, public SignallingDumpable, public Mutex
{
    YCLASS2(SS7MTP2,SS7Layer2,SignallingReceiver)
public:
    enum ErrorCorrection {
        Basic,       // retransmits only based on sequence numbers
        Preventive,  // continuously retransmit unacknowledged packets
        Adaptive,    // switch to using preventive retransmission dynamically
    };

    SS7MTP2(const NamedList& params, unsigned int status = OutOfService);

    virtual ~SS7MTP2();

    virtual bool initialize(const NamedList* config);

    virtual bool transmitMSU(const SS7MSU& msu);

    virtual void recoverMSU(int sequence);

    virtual unsigned int status() const;

    virtual bool aligned() const;

    virtual bool operational() const;

    virtual bool control(Operation oper, NamedList* params = 0);

    virtual bool notify(SignallingInterface::Notification event);
 
protected:
    virtual void destroyed()
    {
        SS7Layer2::attach(0);
        TelEngine::destruct(SignallingReceiver::attach(0));
        SignallingComponent::destroyed();
    }

    virtual void timerTick(const Time& when);

    virtual bool receivedPacket(const DataBlock& packet);

    virtual void processFISU();

    virtual void processLSSU(unsigned int status);

    bool transmitLSSU(unsigned int status);

    inline bool transmitLSSU()
        { return transmitLSSU(m_lStatus); }

    bool transmitFISU();

    void startAlignment(bool emergency = false);

    void abortAlignment(bool retry = true);

    bool startProving();
 
private:
    virtual bool control(NamedList& params)
        { return SignallingDumpable::control(params,this) || SS7Layer2::control(params); }
    void unqueueAck(unsigned char bsn);
    bool txPacket(const DataBlock& packet, bool repeat, SignallingInterface::PacketType type = SignallingInterface::Unknown);
    void setLocalStatus(unsigned int status);
    void setRemoteStatus(unsigned int status);
    // sent but yet unacknowledged packets
    ObjList m_queue;
    // data link status (alignment) - desired, local and remote
    unsigned int m_status, m_lStatus, m_rStatus;
    // various interval period end
    u_int64_t m_interval;
    // time when resending packets
    u_int64_t m_resend;
    // time when aborting resending packets
    u_int64_t m_abort;
    // time when need to transmit next FISU/LSSU
    u_int64_t m_fillTime;
    // remote congestion indicator
    bool m_congestion;
    // backward and forward sequence numbers
    unsigned char m_bsn, m_fsn;
    // backward and forward indicator bits
    bool m_bib, m_fib;
    // last forward sequence number we sent a retransmission request
    unsigned char m_lastFsn;
    // last received backward sequence number
    unsigned char m_lastBsn;
    // last received backward indicator bit
    bool m_lastBib;
    // count of errors
    unsigned int m_errors;
    // maximum accepted errors
    unsigned int m_maxErrors;
    // packet resend interval
    unsigned int m_resendMs;
    // packet resend abort interval
    unsigned int m_abortMs;
    // FISU/LSSU soft resend interval
    unsigned int m_fillIntervalMs;
    // fill link with end-to-end FISU/LSSU
    bool m_fillLink;
    // automatically align on resume
    bool m_autostart;
    // flush MSUs after aligning
    bool m_flushMsus;
};

class YSIG_API SS7MTP3 : public SS7Layer3, public SS7L2User, public SignallingDumpable, public Mutex
{
    YCLASS(SS7MTP3,SS7Layer3)
public:
    enum Operation {
        // take linkset out of service
        Pause   = 0x100,
        // start linkset operation
        Resume  = 0x200,
        // force a MTP restart procedure
        Restart = 0x300,
        // get operational status
        Status  = 0x400,
    };

    SS7MTP3(const NamedList& params);

    virtual ~SS7MTP3();

    virtual bool initialize(const NamedList* config);

    virtual int transmitMSU(const SS7MSU& msu, const SS7Label& label, int sls = -1);

    virtual bool operational(int sls = -1) const;

    virtual int inhibited(int sls) const;

    virtual bool inhibit(int sls, int setFlags, int clrFlags = 0);

    virtual unsigned int congestion(int sls);

    virtual int getSequence(int sls) const;

    virtual void recoverMSU(int sls, int sequence);

    virtual bool control(Operation oper, NamedList* params = 0);

    virtual void attach(SS7Layer2* link);

    virtual void detach(SS7Layer2* link);

    virtual bool control(NamedList& params);

    virtual bool allowedTo(SS7PointCode::Type type, unsigned int packedPC) const;

    inline unsigned int linksTotal() const
        { return m_total; }

    inline unsigned int linksChecked() const
        { return m_checked; }

    inline unsigned int linksActive() const
        { return m_active; }

    inline const ObjList* links() const
        { return &m_links; }
 
protected:
    virtual void destroyed();

    virtual void timerTick(const Time& when);

    virtual void linkChecked(int sls, bool remote);

    virtual bool responder() const
        { return !m_inhibit; }

    virtual bool receivedMSU(const SS7MSU& msu, SS7Layer2* link, int sls);

    virtual bool recoveredMSU(const SS7MSU& msu, SS7Layer2* link, int sls);

    virtual void notify(SS7Layer2* link);

    unsigned int countLinks();
 
private:
    ObjList m_links;
    // total links in linkset
    unsigned int m_total;
    // checked links in linkset
    unsigned int m_checked;
    // currently active links
    unsigned int m_active;
    // SLS to SLC shift
    bool m_slcShift;
    // inhibited flag
    bool m_inhibit;
    // warn if all links are down
    bool m_warnDown;
    // check the links before placing them in service
    bool m_checklinks;
    // realign links that don't respond to test messages anymore
    bool m_forcealign;
    // maintenance check intervals (Q.707)
    u_int64_t m_checkT1;
    u_int64_t m_checkT2;
    // list of allowed point codes seen from this network
    unsigned int* m_allowed[YSS7_PCTYPE_COUNT];
};

class YSIG_API SS7MsgSNM : public SignallingMessage
{
public:
    enum Type {
        Unknown = 0,
        COO  = 0x11, // Changeover Order signal
        ECO  = 0x12, // Emergency Changeover Order signal
        RCT  = 0x13, // Route Set Congestion Test signal
        TFP  = 0x14, // Transfer Prohibited signal
        RST  = 0x15, // Route Set Test for prohibited destination
        RSP  = RST,  // Route Set Test for prohibited destination (ANSI)
        LIN  = 0x16, // Link Inhibit signal
        TRA  = 0x17, // Traffic Restart Allowed signal
        DLC  = 0x18, // Data Link Connection Order signal
        UPU  = 0x1a, // User Part Unavailable signal
        COA  = 0x21, // Changeover Acknowledgment signal
        ECA  = 0x22, // Emergency Changeover Acknowledgment signal
        TFC  = 0x23, // Transfer Controlled signal
        TCP  = 0x24, // Transfer Cluster Prohibited
        TFPA = TCP,  // Transfer Prohibited Acknowledgment (Yellow Book only)
        RSR  = 0x25, // Route Set Test for prohibited destination (national use)
        LUN  = 0x26, // Link Uninhibit signal
        TRW  = 0x27, // Traffic Restart Waiting (ANSI only)
        CSS  = 0x28, // Connection Successful signal
        XCO  = 0x31, // Extended Changeover Order signal
        TFR  = 0x34, // Transfer Restricted signal (national use)
        RCP  = 0x35, // Route Set Test for cluster-prohibited
        LIA  = 0x36, // Link Inhibit Acknowledgment signal
        CNS  = 0x38, // Connection Not Successful signal
        XCA  = 0x41, // Extended Changeover Acknowledgment signal
        TCR  = 0x44, // Transfer Cluster Restricted signal (ANSI only)
        RCR  = 0x45, // Route Set Test for cluster-restricted (ANSI only)
        LUA  = 0x46, // Link Uninhibit Acknowledgment signal
        CNP  = 0x48, // Connection Not Possible signal
        CBD  = 0x51, // Changeback Declaration signal
        TFA  = 0x54, // Transfer Allowed signal
        LID  = 0x56, // Link Inhibit Denied signal
        CBA  = 0x61, // Changeback Acknowledgment signal
        TCA  = 0x64, // Transfer Cluster Allowed
        TFAA = TCA,  // Transfer Allowed Acknowledgment (Yellow Book only)
        LFU  = 0x66, // Link Forced Uninhibit signal
        LLT  = 0x76, // Link Local Inhibit Test signal
        LLI  = LLT,  // Link Local Inhibit Test signal (ANSI)
        LRT  = 0x86, // Link Remote Inhibit Test signal
        LRI  = LRT,  // Link Remote Inhibit Test signal (ANSI)
    };

    enum Group {
        CHM = 0x01,  // Changeover and changeback
        ECM = 0x02,  // Emergency changeover
        FCM = 0x03,  // Transfer controlled and signalling route set congestion
        TFM = 0x04,  // Transfer prohibited/allowed/restricted
        RSM = 0x05,  // Signalling route/set/test
        MIM = 0x06,  // Management inhibit
        TRM = 0x07,  // Traffic restart allowed
        DLM = 0x08,  // Signalling data/link/connection
        UFC = 0x0a,  // User part flow control
    };

    SS7MsgSNM(unsigned char type);

    inline unsigned char type() const
        { return m_type; }

    inline unsigned char group() const
        { return m_type & 0x0f; }

    void toString(String& dest, const SS7Label& label, bool params) const;

    static SS7MsgSNM* parse(SS7Management* receiver, unsigned char type,
        SS7PointCode::Type pcType,
        const unsigned char* buf, unsigned int len);

    static const TokenDict* names();

    static inline const char* lookup(Type type, const char* defvalue = 0)
        { return TelEngine::lookup(type,names(),defvalue); }

    static inline Type lookup(const char* name, Type defvalue = Unknown)
        { return static_cast<Type>(TelEngine::lookup(name,names(),defvalue)); }
 
private:
    unsigned char m_type;
};

class YSIG_API SS7MsgMTN
{
public:
    enum Type {
        Unknown = 0,
        SLTM = 0x11, // Signalling Link Test Message
        SLTA = 0x21, // Signalling Link Test Acknowledgment
    };
 
    static const TokenDict* names();

    static inline const char* lookup(Type type, const char* defvalue = 0)
        { return TelEngine::lookup(type,names(),defvalue); }

    static inline Type lookup(const char* name, Type defvalue = Unknown)
        { return static_cast<Type>(TelEngine::lookup(name,names(),defvalue)); }
};

class YSIG_API SS7MsgISUP : public SignallingMessage
{
    YCLASS(SS7MsgISUP,SignallingMessage)
    friend class SS7ISUPCall;
public:
    enum Type {
        Unknown = 0,
        IAM  = 0x01, // Initial Address Message
        SAM  = 0x02, // Subsequent Address Message
        INR  = 0x03, // Information Request (national use)
        INF  = 0x04, // Information (national use)
        COT  = 0x05, // Continuity
        ACM  = 0x06, // Address Complete Message
        CON  = 0x07, // Connect
        FOT  = 0x08, // Forward Transfer
        ANM  = 0x09, // Answer Message
        REL  = 0x0c, // Release Request
        SUS  = 0x0d, // Suspend
        RES  = 0x0e, // Resume
        RLC  = 0x10, // Release Complete
        CCR  = 0x11, // Continuity Check Request
        RSC  = 0x12, // Reset Circuit
        BLK  = 0x13, // Blocking
        UBL  = 0x14, // Unblocking
        BLA  = 0x15, // Blocking Acknowledgement
        UBA  = 0x16, // Unblocking Acknowledgement
        GRS  = 0x17, // Circuit Group Reset
        CGB  = 0x18, // Circuit Group Blocking
        CGU  = 0x19, // Circuit Group Unblocking
        CGA  = 0x1a, // Circuit Group Blocking Acknowledgement
        CGBA = CGA,
        CUA  = 0x1b, // Circuit Group Unblocking Acknowledgement
        CMR  = 0x1c, // Call Modification Request (ANSI only)
        CMC  = 0x1d, // Call Modification Completed (ANSI only)
        CMRJ = 0x1e, // Call Modification Rejected (ANSI only)
        FACR = 0x1f, // Facility Request
        FAA  = 0x20, // Facility Accepted
        FRJ  = 0x21, // Facility Reject
        FAD  = 0x22, // Facility Deactivated (ANSI only)
        FAI  = 0x23, // Facility Information (ANSI only)
        LPA  = 0x24, // Loopback Acknowledgement (national use)
        CSVR = 0x25, // CUG Selection and Validation Request (ANSI only)
        CSVS = 0x26, // CUG Selection and Validation Response (ANSI only)
        DRS  = 0x27, // Delayed Release (ANSI only)
        PAM  = 0x28, // Pass Along Message (national use)
        GRA  = 0x29, // Circuit Group Reset Acknowledgement
        CQM  = 0x2a, // Circuit Group Query (national use)
        CQR  = 0x2b, // Circuit Group Query Response (national use)
        CPR  = 0x2c, // Call Progress
        CPG  = CPR,
        USR  = 0x2d, // User-to-User Information
        UEC  = 0x2e, // Unequipped CIC (national use)
        UCIC = UEC,
        CNF  = 0x2f, // Confusion
        OLM  = 0x30, // Overload Message (national use)
        CRG  = 0x31, // Charge Information (national use and format, ITU only)
        NRM  = 0x32, // Network Resource Management
        FAC  = 0x33, // Facility (national use)
        UPT  = 0x34, // User Part Test
        UPA  = 0x35, // User Part Available
        IDR  = 0x36, // Identification Request (ITU only)
        IRS  = 0x37, // Identification Response (ITU only)
        SGM  = 0x38, // Segmentation
        LOP  = 0x40, // Loop Prevention
        APM  = 0x41, // Application Transport
        PRI  = 0x42, // Pre-Release Information
        SDN  = 0x43, // Subsequent Directory Number (national use)
        CRA  = 0xe9, // Circuit Reservation Acknowledgement (ANSI only)
        CRM  = 0xea, // Circuit Reservation (ANSI only)
        CVR  = 0xeb, // Circuit Validation Response (ANSI only)
        CVT  = 0xec, // Circuit Validation Test (ANSI only)
        EXM  = 0xed, // Exit Message (ANSI only)
        // Dummy, used for various purposes
        CtrlSave = 256, // control, save circuits
        CtrlCicEvent,   // control, generate circuit events, debug only
    };

    enum Parameters {
        EndOfParameters                = 0,
        CallReference                  = 0x01,
        TransmissionMediumRequirement  = 0x02,
        AccessTransport                = 0x03,
        CalledPartyNumber              = 0x04,
        SubsequentNumber               = 0x05,
        NatureOfConnectionIndicators   = 0x06,
        ForwardCallIndicators          = 0x07,
        OptionalForwardCallIndicators  = 0x08,
        CallingPartyCategory           = 0x09,
        CallingPartyNumber             = 0x0a,
        RedirectingNumber              = 0x0b,
        RedirectionNumber              = 0x0c,
        ConnectionRequest              = 0x0d,
        InformationRequestIndicators   = 0x0e,
        InformationIndicators          = 0x0f,
        ContinuityIndicators           = 0x10,
        BackwardCallIndicators         = 0x11,
        CauseIndicators                = 0x12,
        RedirectionInformation         = 0x13,
        GroupSupervisionTypeIndicator  = 0x15,
        RangeAndStatus                 = 0x16,
        CallModificationIndicators     = 0x17, // ANSI only
        FacilityIndicator              = 0x18,
        FacilityInformationIndicators  = 0x19, // ANSI only
        CUG_InterlockCode              = 0x1a,
        Index                          = 0x1b, // ANSI only
        CUG_CheckResponseIndicators    = 0x1c, // ANSI only
        UserServiceInformation         = 0x1d,
        SignallingPointCode            = 0x1e,
        UserToUserInformation          = 0x20,
        ConnectedNumber                = 0x21,
        SuspendResumeIndicators        = 0x22,
        TransitNetworkSelection        = 0x23,
        EventInformation               = 0x24,
        CircuitAssignmentMap           = 0x25, // ANSI only
        CircuitStateIndicator          = 0x26,
        AutomaticCongestionLevel       = 0x27,
        OriginalCalledNumber           = 0x28,
        OptionalBackwardCallIndicators = 0x29,
        UserToUserIndicators           = 0x2a,
        OriginationISCPointCode        = 0x2b, // ITU only
        GenericNotification            = 0x2c, // ITU only
        CallHistoryInformation         = 0x2d, // ITU only
        AccessDeliveryInformation      = 0x2e, // ITU only
        NetworkSpecificFacilities      = 0x2f, // ITU only
        UserServiceInformationPrime    = 0x30,
        PropagationDelayCounter        = 0x31, // ITU only
        RemoteOperations               = 0x32,
        ServiceActivation              = 0x33,
        UserTeleserviceInformation     = 0x34, // ITU only
        TransmissionMediumUsed         = 0x35,
        CallDiversionInformation       = 0x36, // ITU only
        EchoControlInformation         = 0x37, // ITU only
        MessageCompatInformation       = 0x38, // ITU only
        ParameterCompatInformation     = 0x39, // ITU only
        MLPP_Precedence                = 0x3a, // ITU name
        Precedence                     = MLPP_Precedence, // ANSI name
        MCID_RequestIndicator          = 0x3b, // ITU only
        MCID_ResponseIndicator         = 0x3c, // ITU only
        HopCounter                     = 0x3d,
        TransMediumRequirementPrime    = 0x3e, // ITU only
        LocationNumber                 = 0x3f, // ITU only
        RedirectionNumberRestriction   = 0x40, // ITU only
        FreephoneIndicators            = 0x41, // ITU only
        GenericReference               = 0x42, // ITU only
        CCSScallIndication             = 0x4b,
        ForwardGVNS                    = 0x4c,
        BackwardGVNS                   = 0x4d,
        RedirectCapability             = 0x4e, // National use
        CalledINNumber                 = 0x6f,
        UID_ActionIndicators           = 0x74,
        UID_CapabilityIndicators       = 0x75,
        RedirectCounter                = 0x77, // National use
        ApplicationTransport           = 0x78,
        CCNRpossibleIndicator          = 0x7a,
        PivotRoutingIndicators         = 0x7c,
        CalledDirectoryNumber          = 0x7d, // National use
        OriginalCalledINNumber         = 0x7f,
        CallingGeodeticLocation        = 0x81,
        HTR_Information                = 0x82,
        NetworkRoutingNumber           = 0x84, // National use
        QueryOnReleaseCapability       = 0x85, // Network option
        PivotStatus                    = 0x86, // National use
        PivotCounter                   = 0x87,
        PivotRoutingForwardInformation = 0x88,
        PivotRoutingBackInformation    = 0x89,
        RedirectStatus                 = 0x8a, // National use
        RedirectForwardInformation     = 0x8b, // National use
        RedirectBackwardInformation    = 0x8c, // National use
        NumberPortabilityInformation   = 0x8d, // Network option
        GenericNumber                  = 0xc0, // ITU name
        GenericAddress                 = GenericNumber, // ANSI name
        GenericDigits                  = 0xc1,
        OperatorServicesInformation    = 0xc2, // ANSI only
        Egress                         = 0xc3, // ANSI only
        Jurisdiction                   = 0xc4, // ANSI only
        CarrierIdentification          = 0xc5, // ANSI only
        BusinessGroup                  = 0xc6, // ANSI only
        GenericName                    = 0xc7, // ANSI only
        NotificationIndicator          = 0xe1, // ANSI only
        TransactionRequest             = 0xe3, // ANSI only
        CircuitGroupCharactIndicator   = 0xe5, // ANSI only
        CircuitValidationRespIndicator = 0xe6, // ANSI only
        OutgoingTrunkGroupNumber       = 0xe7, // ANSI only
        CircuitIdentificationName      = 0xe8, // ANSI only
        CommonLanguage                 = 0xe9, // ANSI only
        OriginatingLineInformation     = 0xea, // ANSI only
        ChargeNumber                   = 0xeb, // ANSI only
        ServiceCodeIndicator           = 0xec, // ANSI only
        SpecialProcessingRequest       = 0xed, // ANSI only
        CarrierSelectionInformation    = 0xee, // ANSI only
        NetworkTransport               = 0xef, // ANSI only
        NationalForwardCallIndicatorsLinkByLink = 0xf4, // UK-ISUP
        NationalInformationIndicators           = 0xf5, // UK-ISUP
        NationalInformationRequestIndicators    = 0xf6, // UK-ISUP
        CalledSubscribersTerminatingFacilMarks  = 0xf7, // UK-ISUP
        CallingSubscribersOriginatingFacilMarks = 0xf8, // UK-ISUP
        CallingSubscribersBasicServiceMarks     = 0xf9, // UK-ISUP
        CalledSubscribersBasicServiceMarks      = 0xfa, // UK-ISUP
        PartialCLI                              = 0xfb, // UK-ISUP
        LastDivertingLineIdentity               = 0xfc, // UK-ISUP
        PresentationNumber                      = 0xfd, // UK-ISUP
        NationalForwardCallIndicators           = 0xfe, // UK-ISUP
    };

    inline SS7MsgISUP(Type type, unsigned int cic)
        : SignallingMessage(lookup(type,"Unknown")), m_type(type), m_cic(cic)
        { }

    virtual ~SS7MsgISUP()
        { }

    inline Type type() const
        { return m_type; }

    inline unsigned int cic() const
        { return m_cic; }

    void toString(String& dest, const SS7Label& label, bool params,
        const void* raw = 0, unsigned int rawLen = 0) const;

    static const TokenDict* names();

    static inline const char* lookup(Type type, const char* defvalue = 0)
        { return TelEngine::lookup(type,names(),defvalue); }

    static inline Type lookup(const char* name, Type defvalue = Unknown)
        { return static_cast<Type>(TelEngine::lookup(name,names(),defvalue)); }
 
private:
    Type m_type;                         // Message type
    unsigned int m_cic;                  // Source/destination Circuit Identification Code
};

class YSIG_API SS7Management : public SS7Layer4, public Mutex
{
    YCLASS(SS7Management,SS7Layer4)
public:
    SS7Management(const NamedList& params, unsigned char sio = SS7MSU::SNM|SS7MSU::National);
 
protected:
    virtual HandledMSU receivedMSU(const SS7MSU& msu, const SS7Label& label, SS7Layer3* network, int sls);

    bool inhibit(const SS7Label& link, int setFlags, int clrFlags = 0);

    bool inhibited(const SS7Label& link, int flags);

    void recover(const SS7Label& link, int sequence);

    virtual void notify(SS7Layer3* link, int sls);

    virtual bool control(NamedList& params);

    virtual void timerTick(const Time& when);
 
private:
    bool postpone(SS7MSU* msu, const SS7Label& label, int txSls,
        u_int64_t interval, u_int64_t global = 0, bool force = false, const Time& when = Time());
    bool timeout(const SS7MSU& msu, const SS7Label& label, int txSls, bool final);
    bool timeout(SignallingMessageTimer& timer, bool final);
    SignallingMessageTimerList m_pending;
    bool m_changeMsgs;
    bool m_changeSets;
    bool m_neighbours;
};

class YSIG_API SS7Testing : public SS7Layer4, public Mutex
{
    YCLASS(SS7Testing,SS7Layer4)
public:
    inline SS7Testing(const NamedList& params, unsigned char sio = SS7MSU::MTP_T|SS7MSU::National)
        : SignallingComponent(params.safe("SS7Testing"),&params,"ss7-test"),
          SS7Layer4(sio,&params),
          Mutex(true,"SS7Testing"),
          m_timer(0), m_exp(0), m_seq(0), m_len(16), m_sharing(false)
        { }

    virtual bool initialize(const NamedList* config);

    virtual bool control(NamedList& params);
 
protected:
    virtual HandledMSU receivedMSU(const SS7MSU& msu, const SS7Label& label, SS7Layer3* network, int sls);

    virtual void notify(SS7Layer3* link, int sls);

    virtual void timerTick(const Time& when);
 
private:
    bool sendTraffic();
    void setParams(const NamedList& params, bool setSeq = false);
    SignallingTimer m_timer;
    SS7Label m_lbl;
    u_int32_t m_exp;
    u_int32_t m_seq;
    u_int16_t m_len;
    bool m_sharing;
};

class YSIG_API SS7ISUPCall : public SignallingCall
{
    friend class SS7ISUP;
public:
    enum State {
        // NOTE: Keep the order of state values: the code relies on it
        Null      = 0,                   // No message exchanged
        Testing   = 1,                   // IAM but waiting for continuity check
        Setup     = 2,                   // IAM (initial address)
        Accepted  = 3,                   // ACM (address complete)
        Ringing   = 4,                   // CPM (call progress)
        Answered  = 5,                   // ANM (answer)
        Releasing = 6,                   // REL (release)
        Released  = 7                    // Call released, no message or events allowed
    };

    virtual ~SS7ISUPCall();

    inline State state() const
        { return m_state; }

    inline bool earlyState() const
        { return m_state <= Setup && !m_testCall; }

    inline const String& cicRange() const
        { return m_cicRange; }

    inline unsigned int id() const
        { return m_circuit ? m_circuit->code() : 0; }

    virtual SignallingEvent* getEvent(const Time& when);

    virtual bool sendEvent(SignallingEvent* event);

    inline void setTerminate(bool gracefully, const char* reason = 0,
        const char* diagnostic = 0, const char* location = 0)
    {
        Lock lock(this);
        m_terminate = true;
        m_gracefully = gracefully;
        setReason(reason,0,diagnostic,location);
    }

    virtual void* getObject(const String& name) const;
 
protected:
    SS7ISUPCall(SS7ISUP* controller, SignallingCircuit* cic,
        const SS7PointCode& local, const SS7PointCode& remote, bool outgoing,
        int sls = -1, const char* range = 0, bool testCall = false);

    SignallingEvent* releaseComplete(bool final, SS7MsgISUP* msg = 0, const char* reason = 0,
        bool timeout = false);

    bool canReplaceCircuit();

    bool replaceCircuit(SignallingCircuit* circuit, SS7MsgISUP* msg = 0);

    void stopWaitSegment(bool discard);
 
private:
    // Initialize/set IAM message parameters
    // @param msg Valid ISUP message
    // @param outgoing Message direction: true for outgoing
    // @param sigMsg Valid signalling message with parameters if outgoing
    bool copyParamIAM(SS7MsgISUP* msg, bool outgoing = false, SignallingMessage* sigMsg = 0);
    // If already releasing, set termination flag. Otherwise, send REL (Release) message
    // Set m_lastEvent if event is 0 (the method is called internally)
    // @param event Event with the parameters. 0 if release is started on some timeout
    // @param msg Received message to put in release event
    // @return Generated release event if any
    SignallingEvent* release(SignallingEvent* event = 0, SS7MsgISUP* msg = 0);
    // Set termination reason from message or parameter
    void setReason(const char* reason, SignallingMessage* msg, const char* diagnostic = 0,
        const char* location = 0);
    // Accept send/receive messages in current state based on call direction
    bool validMsgState(bool send, SS7MsgISUP::Type type, bool hasBkwCallInd = false);
    // Connect the reserved circuit. Return false if it fails. Return true if this call is a signalling only one
    bool connectCircuit(const char* special = 0);
    // Transmit the IAM message. Start IAM timer if not started
    bool transmitIAM();
    // Transmit SAM digits
    bool transmitSAM(const char* extra = 0);
    // (Re)transmit REL. Create and populate message if needed. Remember sls
    bool transmitREL(const NamedList* params = 0);
    // Check if the circuit needs continuity testing
    bool needsTesting(const SS7MsgISUP* msg);
    // Stop waiting for a SGM (Segmentation) message. Copy parameters to the pending segmented message if sgm is valid.
    // Change call state and set m_lastEvent
    // @param sgm Optional received SGM message with parameters to be added to the pending segmented message
    // @param timeout True if waiting timer timed out. Ignored if sgm is non null
    // @return m_lastEvent
    SignallingEvent* processSegmented(SS7MsgISUP* sgm = 0, bool timeout = false);
    // Transmit message. Set routing label's link if not already set
    inline bool transmitMessage(SS7MsgISUP* msg);
    // Get the ISUP call controller
    inline SS7ISUP* isup() const;
    // Set overlapped flag. Output a debug message
    void setOverlapped(bool on, bool numberComplete = true);
 
    State m_state;                       // Call state
    bool m_testCall;                     // Test only call
    SignallingCircuit* m_circuit;        // Circuit reserved for this call
    String m_cicRange;                   // The range used to re(alloc) a circuit
    SS7Label m_label;                    // The routing label for this call
    bool m_terminate;                    // Termination flag
    bool m_gracefully;                   // Terminate gracefully: send RLC
    bool m_circuitChanged;               // Circuit change flag
    bool m_circuitTesting;               // The circuit is tested for continuity
    bool m_inbandAvailable;              // Inband data is available
    int m_replaceCounter;                // Circuit replace counter
    String m_format;                     // Data format used by the circuit
    String m_reason;                     // Termination reason
    String m_diagnostic;                 // Termination diagnostic
    String m_location;                   // Termination location
    SS7MsgISUP* m_iamMsg;                // Message with the call parameters for outgoing calls
    SS7MsgISUP* m_sgmMsg;                // Pending received message with segmentation flag set
    SS7MsgISUP* m_relMsg;                // Release message preserved for retransmissions
    // Overlapped
    String m_samDigits;                  // SAM digits
    unsigned int m_sentSamDigits;        // The number of sent SAM digits
    // Timers
    SignallingTimer m_relTimer;          // Send release
    SignallingTimer m_iamTimer;          // Send initial address
    SignallingTimer m_sgmRecvTimer;      // Receive segmented message
    SignallingTimer m_contTimer;         // Continuity timer
    SignallingTimer m_anmTimer;          // T9 ACM -> ANM timer
};

class YSIG_API SS7ISUP : public SignallingCallControl, public SS7Layer4
{
    YCLASS(SS7ISUP,SS7Layer4)
    friend class SS7ISUPCall;
public:
    enum {
        SlsAuto    = -1,
        SlsLatest  = -2,
        SlsCircuit = -3,
        SlsDefault = -4
    };
 
    enum ChargeProcess {
        Confusion,
        Ignore,
        Raw,
        Parsed
    };

    SS7ISUP(const NamedList& params, unsigned char sio = SS7MSU::ISUP|SS7MSU::National);

    virtual ~SS7ISUP();

    virtual bool initialize(const NamedList* config);

    virtual const char* statusName() const;

    virtual void attach(SS7Layer3* network);

    unsigned int cicLen() const
        { return m_cicLen; }

    const String& format() const
        { return m_format; }

    inline bool ignoreUnknownAddrSignals() const
        { return m_ignoreUnkDigits; }

    bool setPointCode(SS7PointCode* pc, bool def);

    unsigned int setPointCode(const NamedList& params);

    SS7PointCode* hasPointCode(const SS7PointCode& pc);

    inline bool handlesRemotePC(const SS7PointCode& pc) const
        { return !m_remotePoint || (pc == *m_remotePoint); }

    inline void setLabel(SS7Label& label, const SS7PointCode& opc, const SS7PointCode& dpc,
        unsigned char sls = 255)
        { label.assign(m_type,dpc,opc,sls); }

    inline void setDebug(bool printMsg, bool extendedDebug)
        { m_extendedDebug = ((m_printMsg = printMsg) && extendedDebug); }

    virtual SS7MSU* createMSU(SS7MsgISUP::Type type, unsigned char ssf,
        const SS7Label& label, unsigned int cic, const NamedList* params = 0) const;

    virtual SignallingCall* call(SignallingMessage* msg, String& reason);

    int transmitMessage(SS7MsgISUP* msg, const SS7Label& label, bool recvLbl, int sls = SlsDefault);

    virtual void cleanup(const char* reason = "net-out-of-order");

    virtual bool control(NamedList& params);

    bool decodeMessage(NamedList& msg, SS7MsgISUP::Type msgType, SS7PointCode::Type pcType,
        const unsigned char* paramPtr, unsigned int paramLen);

    bool encodeMessage(DataBlock& buf, SS7MsgISUP::Type msgType, SS7PointCode::Type pcType,
        const NamedList& params, unsigned int* cic = 0);

    bool processParamCompat(const NamedList& list, unsigned int cic, bool* callReleased = 0);

    inline ChargeProcess getChargeProcessType() const
        { return m_chargeProcessType; }
 
protected:
    virtual void destroyed();

    virtual void timerTick(const Time& when);

    virtual void notify(SS7Layer3* link, int sls);

    SS7MSU* buildMSU(SS7MsgISUP::Type type, unsigned char sio,
        const SS7Label& label, unsigned int cic, const NamedList* params) const;

    virtual HandledMSU receivedMSU(const SS7MSU& msu, const SS7Label& label, SS7Layer3* network, int sls);

    virtual bool processMSU(SS7MsgISUP::Type type, unsigned int cic,
        const unsigned char* paramPtr, unsigned int paramLen,
        const SS7Label& label, SS7Layer3* network, int sls);

    virtual void receivedUPU(SS7PointCode::Type type, const SS7PointCode node,
        SS7MSU::Services part, unsigned char cause, const SS7Label& label, int sls);

    virtual SignallingEvent* processCircuitEvent(SignallingCircuitEvent*& event,
        SignallingCall* call = 0);

    bool startCircuitReset(SignallingCircuit*& cic, const String& timer);

    unsigned int m_cicLen;
 
private:
    // Process a received message that should be processed by a call
    // @param msg The received message
    // @param label The routing label of the received message
    // @param sls Signalling Link the message was received from
    void processCallMsg(SS7MsgISUP* msg, const SS7Label& label, int sls);
    // Process a received message that should be processed by this call controller
    // @param msg The received message
    // @param label The routing label of the received message
    // @param sls Signalling Link the message was received from
    void processControllerMsg(SS7MsgISUP* msg, const SS7Label& label, int sls);
    // Replace a call's circuit if checkCall is true
    // Clear lock flags of the circuit. Release currently reseting circuit if the code match
    // Return false if the given circuit doesn't exist
    bool resetCircuit(unsigned int cic, bool remote, bool checkCall);
    // Block/unblock a circuit side (local or remote)
    // Return false if the given circuit doesn't exist
    bool blockCircuit(unsigned int cic, bool block, bool remote, bool hwFail,
        bool changed, bool changedState, bool resetLocking = false);
    // Find a call by its circuit identification code
    // This method is not thread safe
    SS7ISUPCall* findCall(unsigned int cic);
    // Find a call by its circuit identification code
    // This method is thread safe
    inline void findCall(unsigned int cic, RefPointer<SS7ISUPCall>& call) {
            Lock mylock(this);
            call = findCall(cic);
        }
    // Encode a raw message
    SS7MSU* encodeRawMessage(SS7MsgISUP::Type type, unsigned char sio,
        const SS7Label& label, unsigned int cic, const String& param) const;
    // Send blocking/unblocking messages.
    // Restart the re-check timer if there is any (un)lockable, not sent cic
    // Return false if no request was sent
    bool sendLocalLock(const Time& when = Time());
    // Fill label from local/remote point codes
    // This method is thread safe
    // Return a true if local and remote point codes are valid
    bool setLabel(SS7Label& label, unsigned int cic);
    // Retrieve a pending message
    SignallingMessageTimer* findPendingMessage(SS7MsgISUP::Type type, unsigned int cic,
        bool remove = false);
    // Retrieve a pending message with given parameter
    SignallingMessageTimer* findPendingMessage(SS7MsgISUP::Type type, unsigned int cic,
        const String& param, const String& value, bool remove = false);
    // Transmit a list of messages. Return true if at least 1 message was sent
    bool transmitMessages(ObjList& list);
    // Handle circuit(s) (un)block command
    bool handleCicBlockCommand(const NamedList& p, bool block);
    // Handle remote circuit(s) (un)block command
    bool handleCicBlockRemoteCommand(const NamedList& p, unsigned int* cics,
        unsigned int count, bool block);
    // Handle circuit(s) event generation command
    bool handleCicEventCommand(const NamedList& p);
    // Try to start single circuit (un)blocking. Set a pending operation on success
    // @param force True to ignore resetting/(un)blocking flags of the circuit
    // Return built message to be sent on success
    SS7MsgISUP* buildCicBlock(SignallingCircuit* cic, bool block, bool force = false);
    // Replace circuit for outgoing calls in Setup state
    // Send REL/RSC before repeat attempt
    void replaceCircuit(unsigned int cic, const String& map, bool rel = true);
    // Handle circuit hw-fail block
    // Replace cics for outgoing calls. Terminate incoming
    void cicHwBlocked(unsigned int cic, const String& map);
 
    SS7PointCode::Type m_type;           // Point code type of this call controller
    ObjList m_pointCodes;                // Point codes serviced by this call controller
    SS7PointCode* m_defPoint;            // Default point code for outgoing calls
    SS7PointCode* m_remotePoint;         // Default remote point code for outgoing calls and maintenance
    unsigned char m_sls;                 // Last known valid SLS
    bool m_earlyAcm;                     // Accept progress/ringing in early ACM
    bool m_inn;                          // Routing to internal network number flag
    int m_defaultSls;                    // Default SLS to use in outbound calls
    unsigned int m_maxCalledDigits;      // Maximum digits allowed in Called Number in IAM
    String m_numPlan;                    // Numbering plan
    String m_numType;                    // Number type
    String m_numPresentation;            // Number presentation
    String m_numScreening;               // Number screening
    String m_callerCat;                  // Caller party category
    String m_format;                     // Default format
    String m_continuity;                 // Continuity test type
    bool m_confirmCCR;                   // Send LPA in response to CCR
    bool m_dropOnUnknown;                // Drop call in early state on unknown message
    bool m_ignoreGRSSingle;              // Ignore (drop) GRS with range 0 (1 circuit affected)
    bool m_ignoreCGBSingle;              // Ignore (drop) CGB with range 0 (1 circuit in map)
    bool m_ignoreCGUSingle;              // Ignore (drop) CGU with range 0 (1 circuit in map)
    bool m_duplicateCGB;                 // Send duplicate CGB messages (ANSI)
    bool m_ignoreUnkDigits;              // Check if the message parser should ignore unknown digits encoding
    bool m_l3LinkUp;                     // Flag indicating the availability of a Layer3 data link
    ChargeProcess m_chargeProcessType;   // Indicates the way that charge message should be processed
    u_int64_t m_t1Interval;              // Q.764 T1 timer interval
    u_int64_t m_t5Interval;              // Q.764 T5 timer interval
    u_int64_t m_t7Interval;              // Q.764 T7 timer interval
    u_int64_t m_t9Interval;              // Q.764 T9 AMM/CON recv timer interval
    u_int64_t m_t12Interval;             // Q.764 T12 BLK timer interval
    u_int64_t m_t13Interval;             // Q.764 T13 BLK global timer interval
    u_int64_t m_t14Interval;             // Q.764 T14 UBL timer interval
    u_int64_t m_t15Interval;             // Q.764 T15 UBL global timer interval
    u_int64_t m_t16Interval;             // Q.764 T16 RSC timer interval
    u_int64_t m_t17Interval;             // Q.764 T17 timer interval
    u_int64_t m_t18Interval;             // Q.764 T18 CGB timer interval
    u_int64_t m_t19Interval;             // Q.764 T19 CGB global timer interval
    u_int64_t m_t20Interval;             // Q.764 T20 CGU timer interval
    u_int64_t m_t21Interval;             // Q.764 T21 CGU global timer interval
    u_int64_t m_t27Interval;             // Q.764 T27 Reset after Cont. Check failure
    u_int64_t m_t34Interval;             // Q.764 T34 Segmentation receive timout
    SignallingMessageTimerList m_pending;// Pending messages (RSC ...)
    // Remote User Part test
    SignallingTimer m_uptTimer;          // Timer for UPT
    bool m_userPartAvail;                // Flag indicating the remote User Part availability
    SS7MsgISUP::Type m_uptMessage;       // Message used, may not be always UPT
    unsigned int m_uptCicCode;           // The circuit code sent with UPT
    int m_cicWarnLevel;                  // Wrong CIC warn level
    int m_replaceCounter;                // Circuit replace counter
    // Circuit reset
    SignallingTimer m_rscTimer;          // RSC message or idle timeout
    SignallingCircuit* m_rscCic;         // Circuit currently beeing reset
    u_int32_t m_rscInterval;             // Saved reset interval
    u_int32_t m_rscSpeedup;              // Circuits left for speedup
    // Blocking/unblocking circuits
    SignallingTimer m_lockTimer;         // Timer used to re-check local lock
    bool m_lockGroup;                    // Allow sending requests for a group
    // Debug flags
    bool m_printMsg;                     // Print messages to output
    bool m_extendedDebug;                // Extended debug flag
};

class YSIG_API SS7BICC : public SS7ISUP
{
    YCLASS(SS7BICC,SS7ISUP)
public:
    SS7BICC(const NamedList& params, unsigned char sio = SS7MSU::BICC|SS7MSU::National);

    virtual ~SS7BICC();
 
protected:
    virtual HandledMSU receivedMSU(const SS7MSU& msu, const SS7Label& label, SS7Layer3* network, int sls);
};

class YSIG_API SS7TUP : public SignallingCallControl, public SS7Layer4
{
public:
    SS7TUP(const NamedList& params, unsigned char sif = SS7MSU::TUP);

    virtual ~SS7TUP();
};

 
class YSIG_API SCCPManagement : public SignallingComponent , public Mutex
{
    friend class SS7SCCP;
    friend class SccpLocalSubsystem; // Local Broadcast
    YCLASS(SCCPManagement,SignallingComponent)
public:
    enum MsgType {
        SSA = 0x01,  // Subsystem-allowed
        SSP = 0x02,  // Subsystem-prohibited
        SST = 0x03,  // Subsystem-status-test
        SOR = 0x04,  // Subsystem-out-of-service-request
        SOG = 0x05,  // Subsystem-out-of-service-grant
        SSC = 0x06,  // SCCP/Subsystem-congested      (ITU  only)
        SBR = 0xfd,  // Subsystem-backup-routing      (ANSI only)
        SNR = 0xfe,  // Subsystem-normal-routing      (ANSI only)
        SRT = 0xff   // Subsystem-routing-status-test (ANSI only)
    };
 
    enum LocalBroadcast {
        UserOutOfService,
        UserInService,
        PCInaccessible,         // Signalling Point Inaccessible
        PCAccessible,           // Signalling Point Accessible
        SccpRemoteInaccessible,
        SccpRemoteAccessible,
        PCCongested,           // Signalling Point Congested
        SubsystemStatus        // Request send by sccp management to find if a ssn is available
    };
 
    enum SccpStates {
        Allowed = SS7Route::Allowed,
        Prohibited = SS7Route::Prohibited,
        Unknown = SS7Route::Unknown,
        WaitForGrant,
        IgnoreTests
    };

    SCCPManagement(const NamedList& params, SS7PointCode::Type type);

    virtual ~SCCPManagement();

    virtual bool initialize(const NamedList* config);

    virtual bool processMessage(SS7MsgSCCP* message);

    void attach(SS7SCCP* sccp);

    virtual void pointcodeStatus(SS7Layer3* link, bool operational);

    virtual void routeStatus(SS7PointCode::Type type, const SS7PointCode& node, SS7Route::State state);

    virtual void notify(SCCP::Type type, NamedList& params);

    virtual void routeFailure(SS7MsgSCCP* msg);

    virtual void subsystemFailure(SS7MsgSCCP* msg, const SS7Label& label);

    virtual void sccpUnavailable(const SS7PointCode& pointcode, unsigned char cause);

    void subsystemsStatus(String& dest,bool extended = true);

    void routeStatus(String& dest,bool extended = false);

    virtual void notifyConcerned(MsgType msg, unsigned char ssn, int smi);

    static const TokenDict* broadcastType();

    virtual void updateTables(SccpRemote* rsccp, SccpSubsystem* ssn = 0);

    virtual void printMessage(String& dest, MsgType type, const NamedList& params);

    static const char* stateName(SCCPManagement::SccpStates state)
        { return lookup(state,s_states); }
protected:

    virtual void timerTick(const Time& when);
 
    inline SS7SCCP* sccp()
        { return m_sccp; }
 
    ObjList m_remoteSccp;
    ObjList m_statusTest;
    ObjList m_localSubsystems;
    ObjList m_concerned;
    SS7PointCode::Type m_pcType;

    inline u_int32_t getTestTimeout()
        { return m_testTimeout; }

    bool managementMessage(SCCP::Type type, NamedList& params);

    SccpLocalSubsystem* getLocalSubsystem(unsigned char ssn);

    SccpRemote* getRemoteSccp(int pointcode);

    virtual bool sendMessage(SCCPManagement::MsgType msgType, const NamedList& params) = 0;

    virtual void stopSst(SccpRemote* remoteSccp, SccpSubsystem* rSubsystem = 0, SccpSubsystem* less = 0);

    inline void stopSSTs()
        { Lock lock(this); m_statusTest.clear(); }

    virtual void startSst(SccpRemote* remoteSccp, SccpSubsystem* rSubsystem);

    void mtpEndRestart();

    void localBroadcast(SCCP::Type type, int pointcode, int sps, int rss = -1,
            int rl = -1, int ssn = -1, int ss = -1);

    bool sendSST(SccpRemote* remote, SccpSubsystem* sub);

    bool handleMessage(int msgType, unsigned char ssn, unsigned char smi, NamedList& params);

    virtual void manageSccpRemoteStatus(SccpRemote* rsccp, SS7Route::State newState)
        { }

    inline bool printMessagess()
        { return m_printMessages; }

    void handleCoordinateChanged(unsigned char ssn, int smi, const NamedList& params);

    void handleSog(unsigned char ssn, int pointcode);

    virtual void handleSubsystemStatus(SccpSubsystem* subsystem, bool allowed, SccpRemote* remote, int smi)
        { }

    inline u_int32_t getCoordTimeout()
        { return m_coordTimeout; }

    inline u_int32_t getIgnoreTestsInterval()
        { return m_ignoreStatusTestsInterval; }
private:
    // Helper method to fill broadcast param list
    void putValue(NamedList& params,int val,const char* name, bool dict = false);
 
    SS7SCCP* m_sccp;
    NamedList m_unknownSubsystems;
    unsigned int m_subsystemFailure;    // Counter used in status to inform about the total number of packets received for a unknown ssn
    unsigned int m_routeFailure;
    u_int32_t m_testTimeout;
    u_int32_t m_coordTimeout;
    u_int32_t m_ignoreStatusTestsInterval;
    bool m_autoAppend;
    bool m_printMessages;
    static const TokenDict s_broadcastType[];
    static const TokenDict s_states[];
};
 
class YSIG_API SS7MsgSCCP : public SignallingMessage
{
    YCLASS(SS7MsgSCCP,SignallingMessage)
public:
    enum Type {
        Unknown = 0,
        CR     = 0x01, // Connection request
        CC     = 0x02, // Connection confirm
        CREF   = 0x03, // Connection refused
        RLSD   = 0x04, // Released
        RLC    = 0x05, // Release complete
        DT1    = 0x06, // Data form 1
        DT2    = 0x07, // Data form 2
        AK     = 0x08, // Data acknowledgement
        UDT    = 0x09, // Unitdata
        UDTS   = 0x0a, // Unitdata service
        ED     = 0x0b, // Expedited data
        EA     = 0x0c, // Expedited data acknowledgement
        RSR    = 0x0d, // Reset request
        RSC    = 0x0e, // Reset confirmation
        ERR    = 0x0f, // Protocol data unit error
        IT     = 0x10, // Inactivity test
        XUDT   = 0x11, // Extended unitdata
        XUDTS  = 0x12, // Extended unitdata service
        LUDT   = 0x13, // Long unitdata
        LUDTS  = 0x14, // Long unitdata service
    };
 
    enum Parameters {
        EndOfParameters                = 0,
        DestinationLocalReference      = 0x01,
        SourceLocalReference           = 0x02,
        CalledPartyAddress             = 0x03,
        CallingPartyAddress            = 0x04,
        ProtocolClass                  = 0x05,
        Segmenting                     = 0x06,
        ReceiveSequenceNumber          = 0x07,
        Sequencing                     = 0x08,
        Credit                         = 0x09,
        ReleaseCause                   = 0x0a,
        ReturnCause                    = 0x0b,
        ResetCause                     = 0x0c,
        ErrorCause                     = 0x0d,
        RefusalCause                   = 0x0e,
        Data                           = 0x0f,
        Segmentation                   = 0x10,
        HopCounter                     = 0x11,
        Importance                     = 0x12, // ITU only
        LongData                       = 0x13,
        MessageTypeInterworking        = 0xf8, // ANSI only
        INS                            = 0xf9, // ANSI only
        ISNI                           = 0xfa, // ANSI only
    };

    inline SS7MsgSCCP(Type type)
        : SignallingMessage(lookup(type,"Unknown")), m_type(type), m_data(0)
        { }

    virtual ~SS7MsgSCCP();

    inline Type type() const
        { return m_type; }

    inline void updateType(Type type)
        { m_type = type; params().assign(lookup(type,"Unknown")); }

    inline bool isLongDataMessage() const
        { return m_type == LUDT || m_type == LUDTS; }

    inline bool canBeUDT() const
        { return !(params().getParam(YSTRING("Importance")) ||
                    params().getParam(YSTRING("HopCounter"))); }

    void toString(String& dest, const SS7Label& label, bool params,
        const void* raw = 0, unsigned int rawLen = 0) const;

    static const TokenDict* names();

    static inline const char* lookup(Type type, const char* defvalue = 0)
        { return TelEngine::lookup(type,names(),defvalue); }

    static inline Type lookup(const char* name, Type defvalue = Unknown)
        { return static_cast<Type>(TelEngine::lookup(name,names(),defvalue)); }

    inline void setData(DataBlock* data)
        { m_data = data; }

    inline void removeData()
        { m_data = 0; }

    inline DataBlock* getData()
        { return m_data; }

    inline DataBlock* extractData()
        {
            DataBlock* data = m_data;
            m_data = 0;
            return data;
        }
 
private:
    Type m_type;                         // Message type
    DataBlock* m_data;                   // Message data NOTE: The message never owns the data
};
 
class YSIG_API SS7MsgSccpReassemble : public SS7MsgSCCP
{
    YCLASS(SS7MsgSccpReassemble,SignallingMessage)
public:
    enum Return {
        Rejected,
        Accepted,
        Error,
        Finished,
    };
    SS7MsgSccpReassemble(SS7MsgSCCP* msg, const SS7Label& label, unsigned int timeToLive);

    virtual ~SS7MsgSccpReassemble();

    bool canProcess(const SS7MsgSCCP* msg, const SS7Label& label);

    Return appendSegment(SS7MsgSCCP* msg, const SS7Label& label);

    inline bool timeout()
        { return m_timeout > 0 ? Time::msecNow() > m_timeout : false; }

    inline bool haveAllSegments()
        { return m_remainingSegments == 0; }
private:
    SS7Label m_label;
    NamedList m_callingPartyAddress;
    u_int32_t m_segmentationLocalReference;
    u_int64_t m_timeout;
    unsigned char m_remainingSegments;
    unsigned int m_firstSgmDataLen;
};
 
class YSIG_API SccpSubsystem : public RefObject
{
    YCLASS(SccpSubsystem,RefObject);
public:
    inline SccpSubsystem(int ssn, SCCPManagement::SccpStates state = SCCPManagement::Allowed, unsigned char smi = 0)
        : m_ssn(ssn), m_smi(smi), m_state(state)
        { }
 
    virtual ~SccpSubsystem()
        { }

    inline unsigned char getSSN()
        { return m_ssn; }

    inline SCCPManagement::SccpStates getState()
        { return m_state; }

    inline void setState(SCCPManagement::SccpStates state)
        { m_state = state; }

    inline unsigned char getSmi()
        { return m_smi; }

    void dump(String& dest)
        {
            dest << "Subsystem: " << m_ssn << " , smi: " << m_smi;
            dest << ", state: " << SCCPManagement::stateName(m_state) << " ";
        }
private:
    unsigned char m_ssn;
    unsigned char m_smi;
    SCCPManagement::SccpStates m_state;
};
 
class YSIG_API RemoteBackupSubsystem : public GenObject
{
    YCLASS(RemoteBackupSubsystem,GenObject);
public:

    RemoteBackupSubsystem(unsigned char ssn, int pointcode, bool wfg = false)
        : m_ssn(ssn), m_pointcode(pointcode), m_waitForGrant(wfg)
        { }
 
    virtual ~RemoteBackupSubsystem()
        { }

    inline bool equals(unsigned char ssn, int pointcode)
        { return m_pointcode == pointcode && m_ssn == ssn; }

    inline void permisionGranted()
        { m_waitForGrant = false; }

    inline bool waitingForGrant()
        { return m_waitForGrant; }
 
private:
    unsigned char m_ssn;
    int m_pointcode;
    bool m_waitForGrant;
};
 
class YSIG_API SccpLocalSubsystem : public RefObject, public Mutex
{
    YCLASS(SccpLocalSubsystem,RefObject);
public:
    SccpLocalSubsystem(unsigned char ssn, u_int64_t coordInterval, u_int64_t istInterval, unsigned char smi = 0);

    virtual ~SccpLocalSubsystem();

    inline unsigned char getSSN()
        { return m_ssn; }

    inline void setState(SCCPManagement::SccpStates newState)
        { m_state = newState; }

    inline SCCPManagement::SccpStates getState()
        { return m_state; }

    inline void startCoord()
        { m_coordTimer.start(); }

    inline bool ignoreTests()
        { return m_ignoreTestsTimer.started(); }

    void setIgnoreTests(bool ignore);

    bool timeout();

    void manageTimeout(SCCPManagement* mgm);

    inline void stopCoordTimer()
        { m_coordTimer.stop(); }

    inline unsigned char getSmi()
        { return m_smi; }

    void dump(String& dest);

    bool receivedSOG(unsigned char ssn, int pointcode);

    inline void resetTimers()
        { m_coordTimer.stop(); m_ignoreTestsTimer.stop(); }

    inline void clearBackups()
        {
            Lock lock(this);
            m_backups.clear();
        }

    inline void appendBackup(RemoteBackupSubsystem* backup)
        {
            Lock lock(this);
            m_backups.append(backup);
        }
private:
    unsigned char m_ssn;
    unsigned char m_smi;
    SCCPManagement::SccpStates m_state;
    SignallingTimer m_coordTimer;
    SignallingTimer m_ignoreTestsTimer;
    ObjList m_backups;
    bool m_receivedAll;
};

class YSIG_API SccpRemote : public RefObject, public Mutex
{
    YCLASS(SccpRemote,RefObject);
public:
    SccpRemote(SS7PointCode::Type pcType);

    SccpRemote(unsigned int pointcode, SS7PointCode::Type pcType);

    virtual ~SccpRemote();

    bool initialize(const String& params);

    inline SCCPManagement::SccpStates getState()
        { return m_state; }

    SccpSubsystem* getSubsystem(int ssn);

    void setState(SCCPManagement::SccpStates state);

    inline const SS7PointCode& getPointCode()
        { return m_pointcode; }

    inline int getPackedPointcode()
        { return m_pointcode.pack(m_pointcodeType); }

    inline const char* getPointCodeType()
        { return SS7PointCode::lookup(m_pointcodeType); }

    void dump(String& dest, bool extended = false);

    bool changeSubsystemState(int ssn,SCCPManagement::SccpStates newState);

    inline ObjList& getSubsystems()
        { return m_subsystems; }

    inline void setCongestion(unsigned int cl)
        { m_congestionLevel = cl; }

    inline void resetCongestion()
        { m_congestionLevel = 0; }

    inline unsigned int getCongestion()
        { return m_congestionLevel; }
private:
    SS7PointCode m_pointcode;
    SS7PointCode::Type m_pointcodeType;
    ObjList m_subsystems;
    SCCPManagement::SccpStates m_state;
    unsigned int m_congestionLevel;
};
 
class YSIG_API SS7AnsiSccpManagement : public SCCPManagement
{
    YCLASS(SS7AnsiSccpManagement,SCCPManagement)
public:

    inline SS7AnsiSccpManagement(const NamedList& params)
        : SCCPManagement(params,SS7PointCode::ANSI)
        { }
 
    virtual ~SS7AnsiSccpManagement();

    virtual bool processMessage(SS7MsgSCCP* message);

    virtual bool sendMessage(SCCPManagement::MsgType msgType, const NamedList& params);

    virtual void manageSccpRemoteStatus(SccpRemote* rsccp, SS7Route::State newState);

    virtual void handleSubsystemStatus(SccpSubsystem* subsystem, bool allowed, SccpRemote* remote, int smi);

    bool handleMessage(int msgType, NamedList& params);
};
 
class YSIG_API SS7ItuSccpManagement : public SCCPManagement
{
    YCLASS(SS7ItuSccpManagement,SCCPManagement)
public:

    SS7ItuSccpManagement(const NamedList& params);

    virtual ~SS7ItuSccpManagement()
        { }

    virtual bool processMessage(SS7MsgSCCP* message);

    virtual bool sendMessage(MsgType msgType, const NamedList& params);

    virtual void manageSccpRemoteStatus(SccpRemote* rsccp, SS7Route::State newState);

    bool handleMessage(int msgType, NamedList& params);

    virtual void handleSubsystemStatus(SccpSubsystem* subsystem, bool allowed, SccpRemote* remote, int smi);
 
};

class SS7SCCPDataSegment : public GenObject
{
    YCLASS(SS7SCCPDataSegment,GenObject)
public:
    inline SS7SCCPDataSegment(unsigned int index, unsigned int length)
        : m_length(length), m_index(index)
        {}

    virtual ~SS7SCCPDataSegment()
        {}

    inline void fillSegment(DataBlock& temp, const DataBlock& orig)
        { temp.assign(orig.data(m_index,m_length),m_length,false); }
 
private:
    unsigned int m_length;
    unsigned int m_index;
};

class YSIG_API SS7SCCP : public SS7Layer4, public SCCP, public Mutex
{
    YCLASS(SS7SCCP,SCCP)
    friend class SCCPManagement;
public:
    enum ReturnCauses {
        NoTranslationAddressNature         = 0x00,
        NoTranslationSpecificAddress       = 0x01,
        SubsystemCongestion                = 0x02,
        SubsystemFailure                   = 0x03,
        UnequippedUser                     = 0x04,
        MtpFailure                         = 0x05,
        NetworkCongestion                  = 0x06,
        Unqualified                        = 0x07,
        ErrorInMessageTransport            = 0x08,
        ErrorInLocalProcessing             = 0x09,
        DestinationCanNotPerformReassembly = 0x0a,
        SccpFailure                        = 0x0b,
        HopCounterViolation                = 0x0c,
        SegmentationNotSupported           = 0x0d,
        SegmentationFailure                = 0x0e,
        // ANSI only
        MessageChangeFailure               = 0xf7,
        InvalidINSRoutingRequest           = 0xf8,
        InvalidISNIRoutingRequest          = 0xf9,
        UnauthorizedMessage                = 0xfa,
        MessageIncompatibility             = 0xfb,
        NotSupportedISNIRouting            = 0xfc,
        RedundantISNIConstrainedRouting    = 0xfd,
        ISNIIdentificationFailed           = 0xfe,
    };
 
    enum Control {
        Status                    = 0x01,
        FullStatus                = 0x02,
        EnableExtendedMonitoring  = 0x03,
        DisableExtendedMonitoring = 0x04,
        EnablePrintMsg            = 0x05,
        DisablePrintMsg           = 0x06,
    };
     SS7SCCP(const NamedList& config);

     ~SS7SCCP();

    virtual bool initialize(const NamedList* config);

    virtual void attach(SS7Layer3* network);

    int transmitMessage(SS7MsgSCCP* msg, bool local = false);

     virtual bool managementStatus(Type type, NamedList& params);

    virtual int sendMessage(DataBlock& data, const NamedList& params);

    virtual HandledMSU receivedMSU(const SS7MSU& msu, const SS7Label& label, SS7Layer3* network, int sls);

    virtual void receivedUPU(SS7PointCode::Type type, const SS7PointCode node,
        SS7MSU::Services part, unsigned char cause, const SS7Label& label, int sls);
 
    virtual bool control(NamedList& params);

    int segmentMessage(SS7MsgSCCP* origMsg, const SS7Label& label, bool local);

     inline const bool ITU() const
        { return m_type == SS7PointCode::ITU; }

    inline bool ignoreUnknownAddrSignals() const
        { return m_ignoreUnkDigits; }

    virtual void notify(SS7Layer3* link, int sls);

    virtual void routeStatusChanged(SS7PointCode::Type type, const SS7PointCode& node, SS7Route::State state);
    inline unsigned int messagesSend()
        { return m_totalSent; }

    inline unsigned int messagesReceived()
        { return m_totalReceived; }

    inline unsigned int errors()
        { return m_errors; }

    inline unsigned int translations()
        { return m_totalGTTranslations; }

    inline const SS7PointCode* getLocalPointCode() const
        { return m_localPointCode; }

     inline SS7PointCode::Type getLocalPointCodeType()
        { return m_type; }

    inline int getPackedPointCode()
        { return m_localPointCode ? m_localPointCode->pack(m_type) : 0; }

    inline bool isLayer3Up()
        { return m_layer3Up; }
protected:

    virtual void  destroyed();

    inline bool extendedMonitoring()
        { return m_extendedMonitoring; }

    virtual void timerTick(const Time& when);

    SS7MsgSccpReassemble::Return reassembleSegment(SS7MsgSCCP* segment, const SS7Label& label, SS7MsgSCCP*& msg);

    virtual bool isEndpoint()
        { return m_endpoint; }

    int routeLocal(SS7MsgSCCP* msg);
private:
    // Helper method to calculate sccp address length
    unsigned int getAddressLength(const NamedList& params, const String& prefix);
    // Helper method used to ajust HopCounter and Importance parameters
    void ajustMessageParams(NamedList& params, SS7MsgSCCP::Type type);
    // Obtain maximum data length for a UDT, XUDT and LUDT message
    void getMaxDataLen(const SS7MsgSCCP* msg, const SS7Label& label,
            unsigned int& udtLength, unsigned int& xudtLength, unsigned int& ludtLength);
    // Helper method to obtain data segments
    // NOTE The list must be destroyed
    ObjList* getDataSegments(unsigned int dataLength, unsigned int maxSegmentSize);
    // Helper method to print a SCCP message
    void printMessage(const SS7MSU* msu, const SS7MsgSCCP* msg, const SS7Label& label);
    // Helper method used to extract the pointcode from Calling/Called party address.
    // Also will call GT translate if there is no pointcode in called party address
    int getPointCode(SS7MsgSCCP* msg, const String& prefix, const char* pCode, bool translate);
    // Transmit a SCCP message
    int sendSCCPMessage(SS7MsgSCCP* sccpMsg,int dpc,int opc, bool local);
    // Helper method used to verify if the message is a connectionless data message
    inline bool isSCLCMessage(int msgType)
        { return msgType == SS7MsgSCCP::UDT || msgType == SS7MsgSCCP::XUDT || msgType == SS7MsgSCCP::LUDT; }
    // Helper method used to verify if the message is a connectionless service message
    inline bool isSCLCSMessage(int msgType)
        { return msgType == SS7MsgSCCP::UDTS || msgType == SS7MsgSCCP::XUDTS || msgType == SS7MsgSCCP::LUDTS; }
    bool isSCOCMsg(int msgType);
 
    bool fillLabelAndReason(String& dest, const SS7Label& label,const SS7MsgSCCP* msg);
    inline bool unknownPointCodeType()
        { return m_type != SS7PointCode::ITU && m_type != SS7PointCode::ANSI && m_type != SS7PointCode::ANSI8; }
    // Helper method used to verify if th importance level is in standard range
    int checkImportanceLevel(int msgType,int initialImportance);
    // Helper method used to verify if the optional parameters present in message are declared in standards
    void checkSCLCOptParams(SS7MsgSCCP* msg);
    // Helper method used to monitor service messages
    void archiveMessage(SS7MsgSCCP* msg);
    // Helper method used to dump service messages and error codes status
    void dumpArchive(String& msg, bool extended);
 
    bool processMSU(SS7MsgSCCP::Type type, const unsigned char* paramPtr,
            unsigned int paramLen, const SS7Label& label, SS7Layer3* network, int sls);
 
    bool decodeMessage(SS7MsgSCCP* msg, SS7PointCode::Type pcType,
            const unsigned char* paramPtr, unsigned int paramLen);
 
    void returnMessage(SS7MsgSCCP* message, int error);
 
    static void switchAddresses(const NamedList& source, NamedList& dest);
    // Helper method to dump sccp status
    void printStatus(bool extended);
    void setNetworkUp(bool operational);
 
    SS7MSU* buildMSU(SS7MsgSCCP* msg, const SS7Label& label, bool checkLength = true) const;
    bool routeSCLCMessage(SS7MsgSCCP*& msg, const SS7Label& label);
    // Member data
    SS7PointCode::Type m_type;           // Point code type of this SCCP
    SS7PointCode* m_localPointCode;      // Local point code
    SCCPManagement* m_management;        // SCCP management
    ObjList m_reassembleList;            // List of sccp messages that are waiting to be reassembled
    u_int8_t m_hopCounter;               // Hop counter value
    NamedList m_msgReturnStatus;         // List with message return statistics
    u_int32_t m_segTimeout;              // Time in milliseconds for segmentation timeout
    bool m_ignoreUnkDigits;              // Check if GT digit parser of should ignore unknown digits encoding
    bool m_layer3Up;                     // Flag used to verify if the network is operational
    unsigned int m_maxUdtLength;         // The maximum length of data packet transported in a UDT message
    u_int32_t m_totalSent;               // Counter of the total number of SCCP messages sent
    u_int32_t m_totalReceived;           // The number of incoming sccp messages
    u_int32_t m_errors;                  // Counter of the number of messages that failed to be delivered
    u_int32_t m_totalGTTranslations;     // The number of GT translations made
    u_int32_t m_gttFailed;               // Number of global title that failed to be translated
    bool m_extendedMonitoring;           // Flag used to check if the monitoring is normal or extended
    const char* m_mgmName;               // The name of the sccp management section from ysigchan.conf
    // Debug flags
    bool m_printMsg;                     // Print messages to output
    bool m_extendedDebug;                // Extended debug flag
    bool m_endpoint;                     // Flag used to force message processing if the message have a ssn
};

class YSIG_API SS7SUA : public SIGAdaptUser, public SCCP
{
};

class YSIG_API SS7TCAPMessage : public GenObject
{
public:
    inline SS7TCAPMessage(NamedList& params, DataBlock& data, bool notice = false)
        : m_msgParams(params), m_msgData(data), m_notice(notice)
        {}

    inline NamedList& msgParams()
        { return m_msgParams; }

    inline DataBlock& msgData()
        { return m_msgData; }

    inline bool& isNotice()
        { return m_notice; }
 
private:
    NamedList m_msgParams;
    DataBlock m_msgData;
    bool m_notice;
};

class YSIG_API SS7TCAP : public SCCPUser
{
    YCLASS(SS7TCAP,SCCPUser)
public:
    enum TCAPType {
        UnknownTCAP,
        ITUTCAP,
        ANSITCAP,
    };

    enum TCAPUserCompActions {
        TC_Invoke         = 1,        // ITU-T Invoke primitive, ANSI InvokeLast - Request/Indication
        TC_ResultLast     = 2,        // ITU-T & ANSI ResultLast primitive - Request/Indication
        TC_U_Error        = 3,        // ITU-T & ANSI ReturnError primitive - Request/Indication
        TC_U_Reject       = 4,        // ITU-T & ANSI Reject primitive - Request/Indication, TC-user rejected the component
        TC_R_Reject       = 5,        // ITU-T & ANSI Reject primitive - Indication, Remote TC-user rejected the component
        TC_L_Reject       = 6,        // ITU-T & ANSI Reject primitive - Indication, local Component Sublayer rejected the component
        TC_InvokeNotLast  = 7,        // ANSI InvokeNotLast primitive - Request/Indication
        TC_ResultNotLast  = 8,        // ITU-T & ANSI ResultNotLast primitive - Request/Indication
        TC_L_Cancel       = 9,        // Local Cancel primitive - Indication, inform TC-user that an operation has timed out
        TC_U_Cancel       = 10,       // User Cancel primitive - Request, TC-user request cancellation of an operation
        TC_TimerReset     = 11,       // Timer Reset - Indication, allow TC-user to refresh an operation timer
    };

    enum TCAPUserTransActions {
        TC_Unknown         = 0,
        TC_Unidirectional  = 1,          // ITU-T & ANSI - Request/Indication, request Unidirectional message
        TC_Begin,                   // ITU-T - Request/Indication, begin a dialogue
        TC_QueryWithPerm,           // ANSI - Request/Indication, begin a dialogue with permission to end it
        TC_QueryWithoutPerm,        // ANSI - Request/Indication, begin a dialogue without permission to end it
        TC_Continue,                // ITU-T - Request/Indication, continue a dialogue
        TC_ConversationWithPerm,    // ANSI - Request/Indication, continue a dialogue with permission
        TC_ConversationWithoutPerm, // ANSI - Request/Indication, continue a dialogue without permission
        TC_End,                     // ITU-T -Request/Indication, end a dialogue
        TC_Response,                // ANSI - Request/Indication, end a dialogue
        TC_U_Abort,                 // ITU-T & ANSI - Request/Indication, abort a dialogue per user's request
        TC_P_Abort,                 // ITU-T & ANSI - Indication, notify the abort of a dialogue because of a protocol error
        TC_Notice,                  // ITU-T & ANSI - Indication, notify the TC-user that the network was unable to provide the requested service
    };

    enum TCAPComponentOperationClass {
        SuccessOrFailureReport    = 1,
        FailureOnlyReport         = 2,
        SuccessOnlyReport         = 3,
        NoReport                  = 4,
    };

    enum TCAPCounter {
        IncomingMsgs,
        OutgoingMsgs,
        DiscardedMsgs,
        NormalMsgs,
        AbnormalMsgs,
    };

    SS7TCAP(const NamedList& params);

    virtual ~SS7TCAP();

    virtual bool initialize(const NamedList* config);

    virtual bool sendData(DataBlock& data, NamedList& params);

    virtual HandledMSU receivedData(DataBlock& data, NamedList& params);

    virtual HandledMSU notifyData(DataBlock& data, NamedList& params);

    bool managementNotify(SCCP::Type type, NamedList& params);

    void attach(TCAPUser* user);

    void detach(TCAPUser* user);

    virtual SS7TCAPError userRequest(NamedList& requestParams);

    virtual HandledMSU processSCCPData(SS7TCAPMessage* sccpData);

    inline TCAPType tcapType()
        { return m_tcapType; }

    inline void setTCAPType(TCAPType type)
        { m_tcapType = type; }

    virtual void enqueue(SS7TCAPMessage* msg);

    virtual SS7TCAPMessage* dequeue();

    virtual const String allocTransactionID();

    void allocTransactionID(String& str);

    static const TokenDict s_tcapVersion[];

    static const TokenDict s_compPrimitives[];

    static const TokenDict s_transPrimitives[];

    static const TokenDict s_compOperClasses[];

    virtual SS7TCAPTransaction* buildTransaction(SS7TCAP::TCAPUserTransActions type, const String& transactID, NamedList& params,
        bool initLocal = true) = 0;

    SS7TCAPTransaction* getTransaction(const String& tid);

    void removeTransaction(SS7TCAPTransaction* tr);

    virtual void timerTick(const Time& when);

    virtual bool sendToUser(NamedList& params);

    virtual void buildSCCPData(NamedList& params, SS7TCAPTransaction* tr);

    virtual void status(NamedList& status);

    virtual void userStatus(NamedList& status);

    virtual HandledMSU handleError(SS7TCAPError& error, NamedList& params, DataBlock& data, SS7TCAPTransaction* tr = 0);

    virtual void updateUserStatus(TCAPUser* user, SCCPManagement::LocalBroadcast status, NamedList& params);

    inline void incCounter(TCAPCounter counterType)
    {
        switch (counterType) {
            case IncomingMsgs:
                m_recvMsgs++;
                break;
            case OutgoingMsgs:
                m_sentMsgs++;
                break;
            case DiscardedMsgs:
                m_discardMsgs++;
                break;
            case NormalMsgs:
                m_normalMsgs++;
                break;
            case AbnormalMsgs:
                m_abnormalMsgs++;
                break;
            default:
                break;
        }
    }

    inline unsigned int count(TCAPCounter counterType)
    {
        switch (counterType) {
            case IncomingMsgs:
                return m_recvMsgs;
            case OutgoingMsgs:
                return m_sentMsgs;
            case DiscardedMsgs:
                return m_discardMsgs;
            case NormalMsgs:
                return m_normalMsgs;
            case AbnormalMsgs:
                return m_abnormalMsgs;
            default:
                break;
        }
        return 0;
    }

    static inline const char* lookupTransaction(int tr)
        { return lookup(tr,s_transPrimitives,"Unknown"); }

    static inline int lookupTransaction(const char* tr)
        { return lookup(tr,s_transPrimitives,TC_Unknown); }

    static inline const char* lookupComponent(int comp)
        { return lookup(comp,s_compPrimitives,"Unknown"); }

    static inline int lookupComponent(const char* comp)
        { return lookup(comp,s_compPrimitives,TC_Unknown); }
 
protected:
    virtual SS7TCAPError decodeTransactionPart(NamedList& params, DataBlock& data) = 0;
    virtual void encodeTransactionPart(NamedList& params, DataBlock& data) = 0;
    bool sendSCCPNotify(NamedList& params);
    // list of TCAP users attached to this TCAP instance
    ObjList m_users;
    Mutex m_usersMtx;
 
    // list of messages received from sublayer, waiting to be processed
    ObjList m_inQueue;
    Mutex m_inQueueMtx;
 
    unsigned int m_SSN;
    unsigned int m_defaultRemoteSSN;
    unsigned int m_defaultHopCounter;
    SS7PointCode m_defaultRemotePC;
    SS7PointCode::Type m_remoteTypePC;
    u_int64_t m_trTimeout;
 
    // list of current TCAP transactions
    Mutex m_transactionsMtx;
    ObjList m_transactions;
    // type of TCAP
    TCAPType m_tcapType;
 
    // counter for allocating transaction IDs
    u_int32_t m_idsPool;
 
    // counters
    unsigned int m_recvMsgs;
    unsigned int m_sentMsgs;
    unsigned int m_discardMsgs;
    unsigned int m_normalMsgs;
    unsigned int m_abnormalMsgs;
 
    // Subsystem Status
    SCCPManagement::LocalBroadcast m_ssnStatus;
};
 
class YSIG_API SS7TCAPError
{
public:
    enum ErrorType {
        // P-AbortCause TransactionProblems
        Transact_UnrecognizedPackageType,     // named after the ANSI specification, equivalent to ITU-T UnrecongnizedMessageType P-AbortCause
        Transact_IncorrectTransactionPortion, // <==> ITU-T incorrectTrasactionPortion P-AbortCause
        Transact_BadlyStructuredTransaction,  // <==> ITU-T badlyFormattedTransactionPortion P-AbortCause
        Transact_UnassignedTransactionID,
        Transact_PermissionToReleaseProblem,  // HANDLING NOT DEFINED
        Transact_ResourceUnavailable,         // <==> ITU-T resourceLimitation P-AbortCause
 
        // P-AbortCause DialogProblem
        Dialog_UnrecognizedDialoguePortionID, // ANSI only
        Dialog_BadlyStructuredDialoguePortion,// ANSI only
        Dialog_MissingDialoguePortion,        // ANSI only
        Dialog_InconsistentDialoguePortion,   // ANSI only
        Dialog_Abnormal,                      // ITU only, indication only
 
        // GeneralProblem
        General_UnrecognizedComponentType,   // named after the ANSI specification, equivalent to ITU-T UnrecognizedComponent General Problem
        General_IncorrectComponentPortion,   // ANSI specification, equivalent to ITU-T MistypedComponent General Problem
        General_BadlyStructuredCompPortion,  // ANSI specification, equivalent to ITU-T BadlyStructuredComponent General Problem
        General_IncorrectComponentCoding,    // ANSI specification, no ITU-T equivalent
 
        // InvokeProblem
        Invoke_DuplicateInvokeID,           // ANSI & ITU-T specification
        Invoke_UnrecognizedOperationCode,   // ANSI specification, equivalent to ITU-T UnrecognizedOperation Invoke Problem
        Invoke_IncorrectParameter,          // ANSI specification, equivalent to ITU-T MistypedParameter Invoke Problem
        Invoke_UnrecognizedCorrelationID,   // ANSI specification, equivalent to ITU-T UnrecognizedLinkedID Invoke Problem
        Invoke_ResourceLimitation,          // ITU-T only
        Invoke_InitiatingRelease,           // ITU-T only
        Invoke_LinkedResponseUnexpected,    // ITU-T only
        Invoke_UnexpectedLinkedOperation,   // ITU-T only
 
        // ReturnResult
        Result_UnrecognizedInvokeID,        // ITU-T only
        Result_UnrecognisedCorrelationID,   // ANSI only
        Result_UnexpectedReturnResult,      // ANSI specification, equivalent to ITU-T ReturnResultUnexpected Result Problem
        Result_IncorrectParameter,          // ANSI specification, equivalent to ITU-T MistypedParameter Result Problem
 
        // ReturnError
        Error_UnrecognizedInvokeID,        // ITU-T only
        Error_UnrecognisedCorrelationID,   // ANSI only
        Error_UnexpectedReturnError,       // ANSI only
        Error_UnrecognisedError,           // ANSI & ITU-T
        Error_UnexpectedError,             // ANSI & ITU-T
        Error_IncorrectParameter,          // ANSI specification, equivalent to ITU-T MistypedParameter Return Error Problem
 
        Discard,
        NoError,
    };

    SS7TCAPError(SS7TCAP::TCAPType tcapType);

    SS7TCAPError(SS7TCAP::TCAPType tcapType, ErrorType error);

    ~SS7TCAPError();

    inline ErrorType error()
        { return m_error; }

    inline void setError(ErrorType error)
        { m_error = error; }

    const String errorName();

    u_int16_t errorCode();

    static int errorFromCode(SS7TCAP::TCAPType tcapType, u_int16_t code);

    static u_int16_t codeFromError(SS7TCAP::TCAPType tcapType, int err);

    static const TokenDict s_errorTypes[];
 
private:
    SS7TCAP::TCAPType m_tcapType;
    ErrorType m_error;
};

class YSIG_API SS7TCAPTransaction : public RefObject, public Mutex
{
public:
    enum TransactionState {
        Idle                      = 0,
        PackageSent               = 1,
        PackageReceived           = 2,
        Active                    = 3,
    };
 
    enum TransactionTransmit {
        NoTransmit       = 0,
        PendingTransmit  = 256,
        Transmitted      = 521,
    };

    SS7TCAPTransaction(SS7TCAP* tcap, SS7TCAP::TCAPUserTransActions type, const String& transactID, NamedList& params,
        u_int64_t timeout, bool initLocal = true);

    ~SS7TCAPTransaction();

    virtual SS7TCAPError handleData(NamedList& params, DataBlock& data) = 0;

    virtual SS7TCAPError update(SS7TCAP::TCAPUserTransActions type, NamedList& params, bool updateByUser = true) = 0;

    virtual SS7TCAPError handleDialogPortion(NamedList& params,bool byUser = true) = 0;

    virtual SS7TCAPError buildComponentError(SS7TCAPError& error, NamedList& params, DataBlock& data);

    virtual SS7TCAPError handleComponents(NamedList& params, bool updateByUser = true);

    virtual void requestComponents(NamedList& params, DataBlock& data);

    virtual void transactionData(NamedList& params);

    virtual void requestContent(NamedList& params, DataBlock& data) = 0;

    virtual void checkComponents();

    inline void setTransactionType(SS7TCAP::TCAPUserTransActions type)
        { Lock l(this); m_type = type; }

    inline SS7TCAP::TCAPUserTransActions transactionType()
        { return m_type; }

    inline void setState(TransactionState state)
    {
        Lock l(this);
        m_state = state;
        // changing state automatically triggers a change in transmission state (except for Idle)
        if (state != Idle)
            m_transmit = PendingTransmit;
    }

    inline TransactionState transactionState()
        { return m_state; }

    void setTransmitState(TransactionTransmit state);

    inline TransactionTransmit transmitState()
        { return m_transmit; }

    inline SS7TCAP* tcap()
        { return m_tcap; }

    const String& toString() const
        { return m_localID; }

    inline void setUserName(const String& name)
        { m_userName = name; }

    const String& userName()
        { return m_userName; }

    inline bool basicEnd()
        { return m_basicEnd; }

    void addSCCPAddressing(NamedList& fillParams, bool local);

    inline bool endNow()
        { return m_endNow; }

    inline void endNow(bool endNow)
        { m_endNow = endNow; }

    inline bool timedOut()
        { return m_timeout.timeout(); }

    SS7TCAPComponent* findComponent(const String& id);

    virtual void updateToEnd();

    virtual void updateState(bool byUser = true) = 0;

    virtual void abnormalDialogInfo(NamedList& params);

    virtual SS7TCAPError decodeDialogPortion(NamedList& params, DataBlock& data) = 0;

    virtual void encodeDialogPortion(NamedList& params, DataBlock& data) = 0;

    virtual SS7TCAPError decodeComponents(NamedList& params, DataBlock& data) = 0;

    virtual void encodeComponents(NamedList& params, DataBlock& data) = 0;
 
protected:
    SS7TCAP* m_tcap;
    SS7TCAP::TCAPType m_tcapType;
    String m_userName;
    String m_localID;
    String m_remoteID;
    SS7TCAP::TCAPUserTransActions m_type;
    TransactionState m_state;
    TransactionTransmit m_transmit;
 
    ObjList m_components;
 
    NamedList m_localSCCPAddr;
    NamedList m_remoteSCCPAddr;
 
    bool m_basicEnd; // basic or prearranged end (specified by user when sending a Response)
    bool m_endNow; // delete immediately after sending
    SignallingTimer m_timeout;
};

class YSIG_API SS7TCAPComponent : public GenObject
{
public:
    enum TCAPComponentState {
        Idle,
        OperationPending,
        OperationSent,
        WaitForReject,
    };

    SS7TCAPComponent(SS7TCAP::TCAPType type, SS7TCAPTransaction* trans, NamedList& params, unsigned int index);

    virtual ~SS7TCAPComponent();

    virtual void update(NamedList& params, unsigned int index);

    virtual void fill(unsigned int index, NamedList& fillIn);

    static SS7TCAPComponent* componentFromNamedList(SS7TCAP::TCAPType type, SS7TCAPTransaction* tr, NamedList& params, unsigned int index);

    void setTransaction(SS7TCAPTransaction* transact);

    SS7TCAPTransaction* transaction();

    inline void setType(SS7TCAP::TCAPUserCompActions type)
        { m_type = type; }

    inline SS7TCAP::TCAPUserCompActions type()
        { return m_type; }

    virtual void setInvokeID(String invokeID)
        { m_id = invokeID; }

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

    virtual const String&  correlationID() const
        { return m_corrID; }

    inline bool timedOut()
        { return m_opTimer.timeout(); }

    void setState(TCAPComponentState state);

    inline TCAPComponentState state()
        { return m_state; }

    void resetTimer(NamedList& params, unsigned int index);

    SS7TCAP::TCAPComponentOperationClass operationClass()
        { return m_opClass; }

    static const TokenDict s_compStates[];
 
private:
    SS7TCAPTransaction* m_transact;
    SS7TCAP::TCAPUserCompActions m_type;
    TCAPComponentState m_state;
    String m_id;
    String m_corrID;
    String m_opCode;
    String m_opType;
    SS7TCAP::TCAPComponentOperationClass m_opClass;
    SignallingTimer m_opTimer;
    SS7TCAPError m_error;
};

class YSIG_API SS7TCAPANSI : virtual public SS7TCAP
{
    YCLASS(SS7TCAPANSI,SS7TCAP)
public:
    enum TCAPTags {
        TransactionIDTag    = 0xc7,
        PCauseTag           = 0xd7,
        UserAbortPTag       = 0xd8 , // Primitive
        UserAbortCTag       = 0xf8,  // Constructor
    };
 
    enum TCAPDialogTags {
        DialogPortionTag         = 0xf9,
        ProtocolVersionTag       = 0xda,
        IntApplicationContextTag = 0xdb,
        OIDApplicationContextTag = 0xdc,
        UserInformationTag       = 0xfd,
        IntSecurityContextTag    = 0x80,
        OIDSecurityContextTag    = 0x81,
        ConfidentialityTag       = 0xa2,
    };
 
    enum UserInfoTags {
        DirectReferenceTag       = 0x06,
        DataDescriptorTag        = 0x07,
        ExternalTag              = 0x28,
        SingleASNTypePEncTag     = 0x80, // Primitive Single-ASN1-Type-Encoding
        SingleASNTypeCEncTag     = 0xa0, // Constructor Single-ASN1-Type-Encoding
        OctetAlignEncTag         = 0x81,
        ArbitraryEncTag          = 0x82,
    };
 
    enum ConfidentialityTags {
        IntConfidentialContextTag    = 0x80,
        OIDConfidentialContextTag    = 0x81,
    };
 
    enum TCAPComponentTags {
        ComponentPortionTag  = 0xe8,
        ComponentsIDsTag     = 0xcf,
        OperationNationalTag = 0xd0,
        OperationPrivateTag  = 0xd1,
        ErrorNationalTag     = 0xd3,
        ErrorPrivateTag      = 0xd4,
        ProblemCodeTag       = 0xd5,
        ParameterSetTag      = 0xf2,
        ParameterSeqTag      = 0x30,
    };

    SS7TCAPANSI(const NamedList& params);

    ~SS7TCAPANSI();

    virtual SS7TCAPTransaction* buildTransaction(SS7TCAP::TCAPUserTransActions type, const String& transactID, NamedList& params,
        bool initLocal = true);
 
private:
    SS7TCAPError decodeTransactionPart(NamedList& params, DataBlock& data);
    void encodeTransactionPart(NamedList& params, DataBlock& data);
};

class YSIG_API SS7TCAPTransactionANSI : public SS7TCAPTransaction
{
public:
    enum TCAPANSIComponentType {
        CompUnknown         = 0x0,
        Local               = 0x1,
        InvokeLast          = 0xe9,
        ReturnResultLast    = 0xea,
        ReturnError         = 0xeb,
        Reject              = 0xec,
        InvokeNotLast       = 0xed,
        ReturnResultNotLast = 0xee,
    };
 
    enum ANSITransactionType {
        Unknown                         = 0x0,
        Unidirectional                  = 0xe1,
        QueryWithPermission             = 0xe2,
        QueryWithoutPermission          = 0xe3,
        Response                        = 0xe4,
        ConversationWithPermission      = 0xe5,
        ConversationWithoutPermission   = 0xe6,
        Abort                           = 0xf6,
    };

    SS7TCAPTransactionANSI(SS7TCAP* tcap, SS7TCAP::TCAPUserTransActions type, const String& transactID, NamedList& params,
        u_int64_t timeout, bool initLocal = true);

    ~SS7TCAPTransactionANSI();

    virtual SS7TCAPError handleData(NamedList& params, DataBlock& data);

    virtual SS7TCAPError update(SS7TCAP::TCAPUserTransActions type, NamedList& params, bool updateByUser = true);

    virtual SS7TCAPError handleDialogPortion(NamedList& params, bool byUser = true);

    static void encodePAbort(SS7TCAPTransaction* tr, NamedList& params, DataBlock& data);

    static SS7TCAPError decodePAbort(SS7TCAPTransaction* tr, NamedList& params, DataBlock& data);

    virtual void updateToEnd();

    virtual void updateState(bool byUser);

    virtual void requestContent(NamedList& params, DataBlock& data);

    static const TokenDict s_ansiTransactTypes[];
 
private:
    SS7TCAPError decodeDialogPortion(NamedList& params, DataBlock& data);
    void encodeDialogPortion(NamedList& params, DataBlock& data);
    SS7TCAPError decodeComponents(NamedList& params, DataBlock& data);
    void encodeComponents(NamedList& params, DataBlock& data);
 
    SS7TCAP::TCAPUserTransActions m_prevType;
};

class YSIG_API SS7TCAPITU : virtual public SS7TCAP
{
    YCLASS(SS7TCAPITU,SS7TCAP)
public:
    enum TCAPTags {
        OriginatingIDTag    = 0x48,
        DestinationIDTag    = 0x49,
        PCauseTag           = 0x4a,
    };
 
    enum TCAPDialogTags {
        DialogPortionTag         = 0x6b,
        ProtocolVersionTag       = 0x80,
        ApplicationContextTag    = 0xa1,
        UserInformationTag       = 0xbe,
    };
 
    enum UserInfoTags {
        DirectReferenceTag       = 0x06,
        DataDescriptorTag        = 0x07,
        ExternalTag              = 0x28,
        SingleASNTypePEncTag     = 0x80, // Primitive Single-ASN1-Type-Encoding
        SingleASNTypeCEncTag     = 0xa0, // Constructor Single-ASN1-Type-Encoding
        OctetAlignEncTag         = 0x81,
        ArbitraryEncTag          = 0x82,
    };
 
    enum TCAPComponentTags {
        ComponentPortionTag  = 0x6c,
        LocalTag             = 0x02,
        LinkedIDTag          = 0x80,
        GlobalTag            = 0x06,
        ParameterSeqTag      = 0x30,
        ParameterSetTag      = 0x31,
    };

    SS7TCAPITU(const NamedList& params);

    ~SS7TCAPITU();

    virtual SS7TCAPTransaction* buildTransaction(SS7TCAP::TCAPUserTransActions type, const String& transactID, NamedList& params,
        bool initLocal = true);
 
private:
    SS7TCAPError decodeTransactionPart(NamedList& params, DataBlock& data);
    void encodeTransactionPart(NamedList& params, DataBlock& data);
};

class YSIG_API SS7TCAPTransactionITU : public SS7TCAPTransaction
{
public:
    enum ITUComponentType {
        CompUnknown         = 0x0,
        Local               = 0x1,
        Invoke              = 0xa1,
        ReturnResultLast    = 0xa2,
        ReturnError         = 0xa3,
        Reject              = 0xa4,
        ReturnResultNotLast = 0xa7,
    };
 
    enum ITUTransactionType {
        Unknown                         = 0x0,
        Unidirectional                  = 0x61,
        Begin                           = 0x62,
        End                             = 0x64,
        Continue                        = 0x65,
        Abort                           = 0x67,
    };
 
    enum ITUDialogTags {
        AARQDialogTag               = 0x60,
        AAREDialogTag               = 0x61,
        ABRTDialogTag               = 0x64,
        ResultDiagnosticUserTag     = 0xa1,
        ResultDiagnosticProviderTag = 0xa2,
        ResultTag                   = 0xa2,
        ResultDiagnosticTag         = 0xa3,
    };
 
    enum ITUDialogValues {
        ResultAccepted                     = 0,
        ResultRejected                     = 1,
        DiagnosticUserNull                 = 0x10,
        DiagnosticUserNoReason             = 0x11,
        DiagnosticUserAppCtxtNotSupported  = 0x12,
        DiagnosticProviderNull             = 0x20,
        DiagnosticProviderNoReason         = 0x21,
        DiagnosticProviderNoCommonDialog   = 0x22,
        AbortSourceUser                    = 0x30,
        AbortSourceProvider                = 0x31,
    };

    SS7TCAPTransactionITU(SS7TCAP* tcap, SS7TCAP::TCAPUserTransActions type, const String& transactID, NamedList& params,
        u_int64_t timeout, bool initLocal = true);

    ~SS7TCAPTransactionITU();

    virtual SS7TCAPError handleData(NamedList& params, DataBlock& data);

    virtual SS7TCAPError update(SS7TCAP::TCAPUserTransActions type, NamedList& params, bool updateByUser = true);

    virtual SS7TCAPError handleDialogPortion(NamedList& params, bool byUser = true);

    static void encodePAbort(SS7TCAPTransaction* tr, NamedList& params, DataBlock& data);

    static SS7TCAPError decodePAbort(SS7TCAPTransaction* tr, NamedList& params, DataBlock& data);

    virtual void updateToEnd();

    inline bool dialogPresent()
        { return !(m_appCtxt.null()); }

    bool testForDialog(DataBlock& data);

    void encodeDialogPortion(NamedList& params, DataBlock& data);

    SS7TCAPError decodeDialogPortion(NamedList& params, DataBlock& data);

    void updateState(bool byUser = false);

    virtual void requestContent(NamedList& params, DataBlock& data);

    virtual void abnormalDialogInfo(NamedList& params);

    static const TokenDict s_dialogPDUs[];

    static const TokenDict s_resultPDUValues[];
 
private:
    SS7TCAPError decodeComponents(NamedList& params, DataBlock& data);
    void encodeComponents(NamedList& params, DataBlock& data);
 
    String m_appCtxt;
};
 
// The following classes are ISDN, not SS7, but they use the same signalling
//  interfaces so they will remain here

class YSIG_API ISDNLayer2 : virtual public SignallingComponent
{
    YCLASS(ISDNLayer2,SignallingComponent)
    friend class ISDNQ921Management;
public:
    enum State {
        Released,                        // Multiple frame acknowledged not allowed
        WaitEstablish,                   // Wating to establish 'multiple frame acknowledged' mode
        Established,                     // Multiple frame acknowledged allowed
        WaitRelease,                     // Wating to release 'multiple frame acknowledged' mode
    };

    virtual ~ISDNLayer2();

    inline ISDNLayer3* layer3() const
        { return m_layer3; }

    inline State state() const
        { return m_state; }

    inline bool network() const
        { return m_network; }

    inline bool detectType() const
        { return m_detectType; }

    inline u_int8_t localSapi() const
        { return m_sapi; }

    inline u_int8_t localTei() const
        { return m_tei; }

    inline u_int32_t maxUserData() const
        { return m_maxUserData; }

    inline bool teiAssigned() const
        { return m_teiAssigned; }

    inline bool autoRestart() const
        { return m_autoRestart; }

    unsigned int upTime() const
        { return m_lastUp ? (Time::secNow() - m_lastUp) : 0; }

    virtual bool multipleFrame(u_int8_t tei, bool establish, bool force)
        { return false; }

    virtual bool sendData(const DataBlock& data, u_int8_t tei, bool ack)
        { return false; }

    virtual void cleanup() = 0;

    virtual void attach(ISDNLayer3* layer3);

    static inline const char* stateName(State s)
        { return lookup((int)s,m_states); }
 
protected:
    ISDNLayer2(const NamedList& params, const char* name = 0, u_int8_t tei = 0);

    inline Mutex& l2Mutex()
        { return m_layerMutex; }

    void multipleFrameEstablished(u_int8_t tei, bool confirm, bool timeout);

    void multipleFrameReleased(u_int8_t tei, bool confirm, bool timeout);

    void dataLinkState(u_int8_t tei, bool cmd, bool value);

    void idleTimeout();

    void receiveData(const DataBlock& data, u_int8_t tei);

    void teiAssigned(bool status);

    void changeState(State newState, const char* reason = 0);

    bool changeType();

    inline void autoRestart(bool restart)
        { m_autoRestart = restart; }

    inline void setRi(u_int16_t ri)
        { m_ri = ri; }

    ISDNFrame* parsePacket(const DataBlock& packet);
 
private:
    ISDNLayer3* m_layer3;                // The attached Layer 3 interface
    Mutex m_layerMutex;                  // Layer 2 operations mutex
    Mutex m_layer3Mutex;                 // Control m_layer3 operations
    State m_state;                       // Layer's state
    bool m_network;                      // Network/CPE type of the interface
    bool m_detectType;                   // Detect interface type
    u_int8_t m_sapi;                     // SAPI value
    u_int8_t m_tei;                      // TEI value
    u_int16_t m_ri;                      // Reference number
    u_int32_t m_lastUp;                  // Time when the interface got up
    bool m_checked;                      // Flag to indicate if the layer was checked
    bool m_teiAssigned;                  // The TEI status
    bool m_autoRestart;                  // True to restart when released
    u_int32_t m_maxUserData;             // Maximum length of user data transported trough this layer
    unsigned int m_teiRefNumber;         // The Reference Number (Ri) carried by a TEI management frame
    static const TokenDict m_states[];   // Keep the string associated with each state
};

class YSIG_API ISDNLayer3 : virtual public SignallingComponent
{
    YCLASS(ISDNLayer3,SignallingComponent)
public:
    virtual void multipleFrameEstablished(u_int8_t tei, bool confirm, bool timeout, ISDNLayer2* layer2)
        { }

    virtual void multipleFrameReleased(u_int8_t tei, bool confirm, bool timeout, ISDNLayer2* layer2)
        { }

    virtual void dataLinkState(u_int8_t tei, bool cmd, bool value, ISDNLayer2* layer2)
        { }

    virtual void idleTimeout(ISDNLayer2* layer2)
        { }

    virtual void receiveData(const DataBlock& data, u_int8_t tei, ISDNLayer2* layer2) = 0;

    virtual ISDNLayer2* attach(ISDNLayer2* layer2)
        { return 0; }
 
protected:
    inline ISDNLayer3(const char* name = 0)
        : SignallingComponent(name),
          m_layerMutex(true,"ISDNLayer3::layer")
        { }

    inline Mutex& l3Mutex()
        { return m_layerMutex; }
 
private:
    Mutex m_layerMutex;                  // Layer 3 operations mutex
};

class YSIG_API ISDNFrame : public RefObject
{
    friend class ISDNQ921;
    friend class ISDNQ921Management;
public:
    enum Type {
        DISC = 1,                        // disconnect (command)
        DM = 2,                          // disconnected (response)
        FRMR = 3,                        // frame reject (response)
        I = 4,                           // information transfer (response)
        REJ = 5,                         // reject (command/response)
        RNR = 6,                         // receive not ready (command/response)
        RR = 7,                          // receive ready (command/response)
        SABME = 8,                       // set asynchronous balanced mode extended (command)
        UA = 9,                          // unnumbered acknoledgement (response)
        UI = 10,                         // unnumbered information (command)
        XID = 11,                        // exchange identification (command/response)
        // Note: Keep all errors greater then Invalid: The code relies on it
        Invalid = 100,
        ErrUnknownCR = 101,              // Error: Unknown command/response. Set by parser
        ErrHdrLength = 102,              // Error: Invalid header length. Set by parser
        ErrDataLength = 103,             // Error: Information field too long
        ErrRxSeqNo = 104,                // Error: Invalid receive sequence number
        ErrTxSeqNo = 105,                // Error: Invalid send sequence number
        ErrInvalidEA = 106,              // Error: Invalid 'extended address' bit(s). Set by parser
        ErrInvalidAddress = 107,         // Error: Invalid SAPI/TEI
        ErrUnsupported = 108,            // Error: Unsupported command. E.g. XID
        ErrInvalidCR = 109,              // Error: Invalid command/response flag
    };

    enum TeiManagement {
        TeiReq       = 1,                // TEI request (user to network)
        TeiAssigned  = 2,                // TEI assigned (network to user)
        TeiDenied    = 3,                // TEI denied (network to user)
        TeiCheckReq  = 4,                // TEI check request (network to user)
        TeiCheckRsp  = 5,                // TEI check response (user to network)
        TeiRemove    = 6,                // TEI remove (network to user)
        TeiVerify    = 7                 // TEI verify (user to network)
    };

    enum Category {
        Data,                            // I, UI
        Supervisory,                     // RR, RNR, REJ
        Unnumbered,                      // SABME, DISC, UA DM, FRMR XID
        Error
    };

    virtual ~ISDNFrame();

    inline Type type() const
        { return m_type; }

    inline Type error() const
        { return m_error; }

    inline Category category() const
        { return m_category; }

    inline bool command() const
        { return m_command; }

    inline u_int8_t sapi() const
        { return m_sapi; }

    inline u_int8_t tei() const
        { return m_tei; }

    inline bool poll() const
        { return m_poll; }

    inline u_int8_t ns() const
        { return m_ns; }

    inline u_int8_t nr() const
        { return m_nr; }

    inline u_int8_t headerLength() const
        { return m_headerLength; }

    inline u_int32_t dataLength() const
        { return m_dataLength; }

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

    inline bool sent() const
        { return m_sent; }

    inline void sent(bool value)
        { m_sent = value; }

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

    void update(u_int8_t* ns = 0, u_int8_t* nr = 0);

    inline void getData(DataBlock& dest) const
        { dest.assign((u_int8_t*)m_buffer.data() + m_headerLength,m_dataLength); }

    void toString(String& dest, bool extendedDebug) const;

    bool checkTeiManagement() const;

    static u_int16_t getRi(const DataBlock& data);

    inline static u_int8_t getType(const DataBlock& data)
        { return static_cast<u_int8_t>(data.at(3,0)); }

    inline static u_int8_t getAi(const DataBlock& data)
        { return static_cast<u_int8_t>(data.at(4,0) >> 1); }
 

    static ISDNFrame* parse(const DataBlock& data, ISDNLayer2* receiver);

    static bool buildTeiManagement(DataBlock& data, u_int8_t type, u_int16_t ri,
        u_int8_t ai);

    static inline bool commandBit(bool network)
        { return network; }

    static inline bool responseBit(bool network)
        { return !network; }

    static inline bool isCommand(u_int8_t cr, bool sentByNetwork)
        { return cr ? sentByNetwork : !sentByNetwork; }

    static inline const char* typeName(Type type)
        { return lookup(type,s_types,"Invalid frame"); }

    static const TokenDict s_types[];
 
protected:
    ISDNFrame(Type type = Invalid);

    ISDNFrame(Type type, bool command, bool senderNetwork,
        u_int8_t sapi, u_int8_t tei, bool pf, u_int8_t nr = 0);

    ISDNFrame(bool ack, bool senderNetwork, u_int8_t sapi, u_int8_t tei,
        bool pf, const DataBlock& data);
 
private:
    Type m_type;                         // Frame type
    Type m_error;                        // Frame error type
    Category m_category;                 // Frame category
    // Address
    bool m_command;                      // Command/Response frame
    bool m_senderNetwork;                // True if the sender of this frame is the network side of the data link
    u_int8_t m_sapi;                     // SAPI value
    u_int8_t m_tei;                      // TEI value
    // Control
    bool m_poll;                         // Poll/Final flag
    u_int8_t m_ns;                       // N(S) value (when applicable): transmitter send sequence number
    u_int8_t m_nr;                       // N(R) value (when applicable): transmitter receive sequence number
    // Data
    u_int8_t m_headerLength;             // Header length
    u_int32_t m_dataLength;              // Data length
    DataBlock m_buffer;                  // Whole frame: header + data + FCS (frame check sequence = 2 bytes)
    // Outgoing frames only
    bool m_sent;                         // True if already sent
};

class YSIG_API ISDNQ921 : public ISDNLayer2, public SignallingReceiver, public SignallingDumpable
{
    YCLASS2(ISDNQ921,ISDNLayer2,SignallingReceiver)
    friend class ISDNQ921Management;
public:
    ISDNQ921(const NamedList& params, const char* name = 0, ISDNQ921Management* mgmt = 0, u_int8_t tei = 0);

    virtual ~ISDNQ921();

    virtual bool initialize(const NamedList* config);

    inline u_int64_t dataTimeout() const
        { return m_retransTimer.interval() * m_n200.maxVal(); }

    virtual bool multipleFrame(u_int8_t tei, bool establish, bool force);

    virtual bool sendData(const DataBlock& data, u_int8_t tei, bool ack);

    inline bool sendSabme()
        { return sendUFrame(ISDNFrame::SABME,true,true); }

    virtual void cleanup();

    inline void setDebug(bool printFrames, bool extendedDebug)
        { m_extendedDebug = ((m_printFrames = printFrames) && extendedDebug); }
 
protected:
    virtual void destroyed()
    {
        ISDNLayer2::attach((ISDNLayer3*)0);
        TelEngine::destruct(SignallingReceiver::attach(0));
        SignallingComponent::destroyed();
    }

    virtual void timerTick(const Time& when);

    virtual bool receivedPacket(const DataBlock& packet);

    bool receivedFrame(ISDNFrame* frame);

    virtual bool notify(SignallingInterface::Notification event);

    void reset();
 
private:
    virtual bool control(NamedList& params)
        { return SignallingDumpable::control(params,this); }
    // Acknoledge outgoing frames
    // @param frame The acknoledging frame
    bool ackOutgoingFrames(const ISDNFrame* frame);
    // Process a received I/UI frame
    // @param ack True for I frame, false for UI frame
    // @return True to send data to Layer 3
    bool processDataFrame(const ISDNFrame* frame, bool ack);
    // Process a received S frame
    // @return True to exit from timer recovery state
    bool processSFrame(const ISDNFrame* frame);
    // Process a received U frame
    // @param newState The new state if true is returned
    // @param confirmation True if the new state is Established or Released and
    //  this is a confirmation
    // @return True to change state
    bool processUFrame(const ISDNFrame* frame, State& newState,
        bool& confirmation);
    // Accept frame according to Q.921 5.8.5
    // Update counters.
    // If not accepted the frame is rejected or dropped
    // reject is set to true if the frame is rejected
    bool acceptFrame(ISDNFrame* frame, bool& reject);
    // Update rejected frames counter. Print message. Send FRMR (frame reject)
    void rejectFrame(const ISDNFrame* frame, const char* reason = 0);
    // Update dropped frames counter. Print message
    void dropFrame(const ISDNFrame* frame, const char* reason = 0);
    // Send S frames other then UI frames
    bool sendUFrame(ISDNFrame::Type type, bool command, bool pf,
        bool retrans = false);
    // Send U frames
    bool sendSFrame(ISDNFrame::Type type, bool command, bool pf);
    // Send a frame to remote peer
    // @param frame Frame to send
    // @return False if the operation failed
    bool sendFrame(const ISDNFrame* frame);
    // Send pending outgoing I frames
    // @param retrans: True   Send all transmission window
    //                 False  Send only the unsent frames in transmission window
    // @return True if a transmission took place
    bool sendOutgoingData(bool retrans = false);
    // Start/Stop T200. Stop/Start T203
    // If start is false reset N200 (retransmission counter)
    // @param start True to start. False to stop
    // @param t203 Start/don't start T203. Ignored if start is false
    // @param time Current time if known
    void timer(bool start, bool t203, u_int64_t time = 0);
 
    ISDNQ921Management* m_management;    // TEI management component
    // State variables
    bool m_remoteBusy;                   // Remote peer is busy: don't send any I frames
    bool m_timerRecovery;                // T200 expired
    bool m_rejectSent;                   // True if we've sent a REJ frame
    bool m_pendingDMSabme;               // True if we have a pending SABME on DM received
    bool m_lastPFBit;                    // Last P/F bit sent with an I or S frame
    u_int8_t m_vs;                       // Sequence number of the next transmitted I frame
    u_int8_t m_va;                       // Last ack'd I frame by remote peer
    u_int8_t m_vr;                       // Expected I frame sequence number
    // Timers and counters
    SignallingTimer m_retransTimer;      // T200: Retransmission interval
    SignallingTimer m_idleTimer;         // T203: Channel idle interval
    SignallingCounter m_window;          // Maximum/current number of pending outgoing I frames
    SignallingCounter m_n200;            // Maximum/current retransmission counter
    // Data
    ObjList m_outFrames;                 // Outgoing I frames queue
    // Statistics
    u_int32_t m_txFrames;                // The number of frames accepted by layer 1 to be transmitted
    u_int32_t m_txFailFrames;            // The number of frames not accepted by layer 1 to be transmitted
    u_int32_t m_rxFrames;                // The number of successfully parsed frames
    u_int32_t m_rxRejectedFrames;        // The number of rejected frames. Doesn't include dropped frames
    u_int32_t m_rxDroppedFrames;         // The number of dropped frames. Doesn't include rejected frames
    u_int32_t m_hwErrors;                // The number of hardware notifications
    // Debug flags
    bool m_printFrames;                  // Print frames to output
    bool m_extendedDebug;                // Extended debug flag
    // Flags used to avoid repetitive errors
    bool m_errorSend;                    // Send error
    bool m_errorReceive;                 // Receive error
};

class YSIG_API ISDNQ921Management : public ISDNLayer2, public ISDNLayer3, public SignallingReceiver, public SignallingDumpable
{
    YCLASS3(ISDNQ921Management,ISDNLayer2,ISDNLayer3,SignallingReceiver)
public:
    ISDNQ921Management(const NamedList& params, const char* name = 0, bool net = true);

    virtual ~ISDNQ921Management();

    virtual bool initialize(const NamedList* config);

    virtual void engine(SignallingEngine* eng);

    virtual bool multipleFrame(u_int8_t tei, bool establish, bool force);

    virtual bool sendData(const DataBlock& data, u_int8_t tei, bool ack);

    bool sendFrame(const ISDNFrame* frame, const ISDNQ921* q921 = 0);
 

    virtual void cleanup();

    virtual void multipleFrameEstablished(u_int8_t tei, bool confirm, bool timeout, ISDNLayer2* layer2);

    virtual void multipleFrameReleased(u_int8_t tei, bool confirm, bool timeout, ISDNLayer2* layer2);

    virtual void dataLinkState(u_int8_t tei, bool cmd, bool value, ISDNLayer2* layer2);

    virtual void receiveData(const DataBlock& data, u_int8_t tei, ISDNLayer2* layer2);
 
protected:
    virtual void timerTick(const Time& when);

    virtual bool receivedPacket(const DataBlock& packet);

    virtual bool notify(SignallingInterface::Notification event);

    bool processTeiManagement(ISDNFrame* frame);

    bool sendTeiManagement(ISDNFrame::TeiManagement type, u_int16_t ri, u_int8_t ai, u_int8_t tei = 127, bool pf = false);

    void processTeiRequest(u_int16_t ri, u_int8_t ai, bool pf);

    void processTeiRemove(u_int8_t ai);

    void processTeiCheckRequest(u_int8_t ai, bool pf);

    void processTeiCheckResponse(u_int16_t ri, u_int8_t ai);

    void processTeiAssigned(u_int16_t ri, u_int8_t ai);

    void processTeiDenied(u_int16_t ri);

    void processTeiVerify(u_int8_t ai, bool pf);

    void sendTeiReq(u_int8_t tei);

    void sendTeiRemove();
 
private:
    ISDNQ921* m_layer2[127];             // The list of Layer 2 objects attached to this Layer 3
    SignallingTimer m_teiManTimer;       // T202
    SignallingTimer m_teiTimer;          // T201
};

class YSIG_API ISDNQ921Passive : public ISDNLayer2, public SignallingReceiver, public SignallingDumpable
{
    YCLASS2(ISDNQ921Passive,ISDNLayer2,SignallingReceiver)
public:
    ISDNQ921Passive(const NamedList& params, const char* name = 0);

    virtual ~ISDNQ921Passive();

    virtual void cleanup();

    virtual bool initialize(const NamedList* config);

    inline void setDebug(bool printFrames, bool extendedDebug)
        { m_extendedDebug = ((m_printFrames = printFrames) && extendedDebug); }
 
protected:
    virtual void destroyed()
    {
        ISDNLayer2::attach(0);
        TelEngine::destruct(SignallingReceiver::attach(0));
        SignallingComponent::destroyed();
    }

    virtual void timerTick(const Time& when);

    virtual bool receivedPacket(const DataBlock& packet);

    virtual bool notify(SignallingInterface::Notification event);
 
private:
    virtual bool control(NamedList& params)
        { return SignallingDumpable::control(params,this); }
    // Filter received frames. Accept only frames that would generate a notification to the upper layer:
    // UI/I, and Valid SABME/DISC/UA/DM
    // On success, if frame is not a data one, prepare cmd and value to notify layer 3
    bool acceptFrame(ISDNFrame* frame, bool& cmd, bool& value);
    // Show debug message. Count dropped frames
    bool dropFrame(const ISDNFrame* frame, const char* reason = 0);
 
    bool m_checkLinkSide;                // Check if this is the correct side of the data link
    SignallingTimer m_idleTimer;         // Channel idle interval
    u_int8_t m_lastFrame;                // Transmitter send number of the last received frame
    u_int32_t m_rxFrames;                // The number of successfully parsed frames
    u_int32_t m_rxDroppedFrames;         // The number of dropped frames. Doesn't include rejected frames
    u_int32_t m_hwErrors;                // The number of hardware notifications
    bool m_printFrames;                  // Print frames to output
    bool m_extendedDebug;                // Extended debug flag
    bool m_errorReceive;                 // Receive error
};

class YSIG_API ISDNIUAClient : public SIGAdaptClient
{
    YCLASS(ISDNIUAClient,SIGAdaptClient)
public:
    inline ISDNIUAClient(const NamedList& params)
        : SIGAdaptClient(params.safe("ISDNIUAClient"),&params,1,9900)
        { }
 
    virtual bool processMSG(unsigned char msgVersion, unsigned char msgClass,
        unsigned char msgType, const DataBlock& msg, int streamId);
};

class YSIG_API ISDNIUA : public ISDNLayer2, public SIGAdaptUser
{
    friend class ISDNIUAClient;
    YCLASS(ISDNIUA,ISDNLayer2)
public:
    ISDNIUA(const NamedList& params, const char* name = 0, u_int8_t tei = 0);

    virtual ~ISDNIUA();

    virtual bool initialize(const NamedList* config);

    virtual bool multipleFrame(u_int8_t tei, bool establish, bool force);

    virtual bool sendData(const DataBlock& data, u_int8_t tei, bool ack);

    virtual void cleanup();

    virtual void activeChange(bool active);

    inline int32_t iid() const
        { return m_iid; }
 
protected:
    ISDNIUAClient* client() const
        { return static_cast<ISDNIUAClient*>(adaptation()); }
    virtual bool processMGMT(unsigned char msgType, const DataBlock& msg, int streamId);
    virtual bool processQPTM(unsigned char msgType, const DataBlock& msg, int streamId);
    int32_t m_iid;
};

class YSIG_API ISDNQ931IE : public NamedList
{
    friend class ISDNQ931Message;
public:
    enum Type {
        // Fixed (1 byte) length information element
        Shift = 0x90,                    // Shift
        MoreData = 0xa0,                 // More data
        SendComplete = 0xa1,             // Sending complete
        Congestion = 0xb0,               // Congestion level
        Repeat = 0xd0,                   // Repeat indicator
        // Variable length information element
        Segmented = 0x00,                // Segmented message
        BearerCaps = 0x04,               // Bearer capability
        Cause = 0x08,                    // Cause
        CallIdentity = 0x10,             // Call identity
        CallState = 0x14,                // Call state
        ChannelID = 0x18,                // Channel identification
        Progress = 0x1e,                 // Progress indicator
        NetFacility = 0x20,              // Network-specific facilities
        Notification = 0x27,             // Notification indicator
        Display = 0x28,                  // Display
        DateTime = 0x29,                 // Date/time
        Keypad = 0x2c,                   // Keypad facility
        Signal = 0x34,                   // Signal
        ConnectedNo = 0x4c,              // Connected number (Q.951)
        CallingNo = 0x6c,                // Calling party number
        CallingSubAddr = 0x6d,           // Calling party subaddress
        CalledNo = 0x70,                 // Called party number
        CalledSubAddr = 0x71,            // Called party subaddress
        NetTransit = 0x78,               // Transit network selection
        Restart = 0x79,                  // Restart indicator
        LoLayerCompat = 0x7c,            // Low layer compatibility
        HiLayerCompat = 0x7d,            // High layer compatibility
        // Not used
        UserUser = 0x7e,                 // User-user
        Escape = 0x7f,                   // Escape for extension
    };

    ISDNQ931IE(u_int16_t type);

    virtual ~ISDNQ931IE();

    inline u_int8_t type() const
        { return (u_int8_t)m_type; }

    inline void addParamPrefix(const char* name, const char* value)
        { addParam(*this+"."+name,value); }

    void toString(String& dest, bool extendedDebug, const char* before = 0);

    static inline const char* typeName(int type, const char* defVal = 0)
        { return lookup(type,s_type,defVal); }

    static const TokenDict s_type[];

    DataBlock m_buffer;
 
private:
    u_int16_t m_type;                    // IE type
};

class YSIG_API ISDNQ931Message : public SignallingMessage
{
public:
    enum Type {
        Alerting = 0x01,                 // ALERTING
        Proceeding = 0x02,               // CALL PROCEEDING
        Connect = 0x07,                  // CONNECT
        ConnectAck = 0x0f,               // CONNECT ACK
        Progress = 0x03,                 // PROGRESS
        Setup = 0x05,                    // SETUP
        SetupAck = 0x0d,                 // SETUP ACK
        Resume = 0x26,                   // RESUME
        ResumeAck = 0x2e,                // RESUME ACK
        ResumeRej = 0x22,                // RESUME REJECT
        Suspend = 0x25,                  // SUSPEND
        SuspendAck = 0x2d,               // SUSPEND ACK
        SuspendRej = 0x21,               // SUSPEND REJECT
        UserInfo = 0x20,                 // USER INFO
        Disconnect = 0x45,               // DISCONNECT
        Release = 0x4d,                  // RELEASE
        ReleaseComplete = 0x5a,          // RELEASE COMPLETE
        Restart = 0x46,                  // RESTART
        RestartAck = 0x4e,               // RESTART ACK
        Segment = 0x60,                  // SEGMENT
        CongestionCtrl = 0x79,           // CONGESTION CONTROL
        Info = 0x7b,                     // INFORMATION
        Notify = 0x6e,                   // NOTIFY
        Status = 0x7d,                   // STATUS
        StatusEnquiry = 0x75,            // STATUS ENQUIRY
    };

    ISDNQ931Message(Type type, bool initiator, u_int32_t callRef, u_int8_t callRefLen);

    ISDNQ931Message(Type type);

    ISDNQ931Message(Type type, ISDNQ931Call* call);

    virtual ~ISDNQ931Message();

    inline Type type() const
        { return m_type; }

    inline bool initiator() const
        { return m_initiator; }

    inline u_int32_t callRef() const
        { return m_callRef; }

    inline u_int8_t callRefLen() const
        { return m_callRefLen; }

    inline bool dummyCallRef() const
        { return m_dummy; }

    inline bool unknownMandatory() const
        { return m_unkMandatory; }

    inline void setUnknownMandatory()
        { m_unkMandatory = true; }

    inline ObjList* ieList()
        { return &m_ie; }

    ISDNQ931IE* getIE(ISDNQ931IE::Type type, ISDNQ931IE* base = 0);

    ISDNQ931IE* removeIE(ISDNQ931IE::Type type, ISDNQ931IE* base = 0);

    inline const char* getIEValue(ISDNQ931IE::Type type, const char* param,
        const char* defVal = 0)
    {
        ISDNQ931IE* ie = getIE(type);
        return (ie ? ie->getValue(param?param:ie->c_str(),defVal) : defVal);
    }

    inline ISDNQ931IE* appendIEValue(ISDNQ931IE::Type type, const char* param,
        const char* value)
    {
        ISDNQ931IE* ie = new ISDNQ931IE(type);
        ie->addParam(param?param:ie->c_str(),value);
        appendSafe(ie);
        return ie;
    }

    inline bool append(ISDNQ931IE* ie)
        { return 0 != m_ie.append(ie); }

    bool appendSafe(ISDNQ931IE* ie);

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

    virtual void* getObject(const String& name) const;

    u_int8_t encode(ISDNQ931ParserData& parserData, ObjList& dest);

    static ISDNQ931Message* parse(ISDNQ931ParserData& parserData,
        const DataBlock& buffer, DataBlock* segData);

    static inline const char* typeName(int t)
        { return lookup(t,s_type,"Unknown"); }

    static const TokenDict s_type[];

    DataBlock m_buffer;
 
private:
    Type m_type;                         // Message type
    bool m_initiator;                    // The call initiator flag: True: this is the initiator
    u_int32_t m_callRef;                 // The call reference
    u_int8_t m_callRefLen;               // The call reference length
    bool m_unkMandatory;                 // True if this message contains unknown mandatory IE(s)
    bool m_dummy;                        // True if this message has a dummy call reference
    ObjList m_ie;                        // IE list
};

class YSIG_API ISDNQ931IEData
{
    friend class ISDNQ931Call;
    friend class ISDNQ931CallMonitor;
    friend class ISDNQ931;
    friend class ISDNQ931Monitor;
private:
    // Constructor
    ISDNQ931IEData(bool bri = false);
    // Process received IEs
    // If add is true, append an IE to the message
    // If add is false, extract data from message. Set data to default values if IE is missing
    // @return False if the IE is missing when decoding or the IE wasn't added
    bool processBearerCaps(ISDNQ931Message* msg, bool add, ISDNQ931ParserData* data = 0);
    bool processCause(ISDNQ931Message* msg, bool add, ISDNQ931ParserData* data = 0);
    bool processDisplay(ISDNQ931Message* msg, bool add, ISDNQ931ParserData* data = 0);
    bool processKeypad(ISDNQ931Message* msg, bool add, ISDNQ931ParserData* data = 0);
    bool processChannelID(ISDNQ931Message* msg, bool add, ISDNQ931ParserData* data = 0);
    bool processProgress(ISDNQ931Message* msg, bool add, ISDNQ931ParserData* data = 0);
    bool processRestart(ISDNQ931Message* msg, bool add, ISDNQ931ParserData* data = 0);
    bool processNotification(ISDNQ931Message* msg, bool add, ISDNQ931ParserData* data = 0);
    bool processCalledNo(ISDNQ931Message* msg, bool add, ISDNQ931ParserData* data = 0);
    bool processCallingNo(ISDNQ931Message* msg, bool add, ISDNQ931ParserData* data = 0);
 
    // IE parameters
    String m_display;                    // Display: The data
    String m_callerNo;                   // CallingNo: Number
    String m_callerType;                 // CallingNo: Number type
    String m_callerPlan;                 // CallingNo: Number plan
    String m_callerPres;                 // CallingNo: Number presentation
    String m_callerScreening;            // CallingNo: Number screening
    String m_calledNo;                   // CalledNo: Number
    String m_calledType;                 // CalledNo: Number type
    String m_calledPlan;                 // CalledNo: Number plan
    String m_transferCapability;         // BearerCaps: Transfer capability
    String m_transferMode;               // BearerCaps: Transfer mode
    String m_transferRate;               // BearerCaps: Transfer rate
    String m_format;                     // BearerCaps: Layer 1 protocol
    String m_reason;                     // Cause
    String m_keypad;                     // Keypad: 'keypad' parameter
    String m_progress;                   // Progress: Progress description
    String m_notification;               // Notify: Notification indicator
    bool m_bri;                          // ChannelID: BRI interface flag
    bool m_channelMandatory;             // ChannelID: Indicated channel is mandatory/preferred
    bool m_channelByNumber;              // ChannelID: m_channels contains a channel list or a slot map
    String m_channelType;                // ChannelID: Channel type
    String m_channelSelect;              // ChannelID: Channel select
    String m_channels;                   // ChannelID: Channel list or slot map
    String m_restart;                    // Restart: The class of restarting circuits
};

class YSIG_API ISDNQ931State
{
public:
    enum State {
        // Common state
        Null                    = 0x00,  // Null
        // Call states
        CallInitiated           = 0x01,  // Call initiated: sent SETUP
        OverlapSend             = 0x02,  // Overlap sending
        OutgoingProceeding      = 0x03,  // Outgoing call proceeding: received valid CALL PROCEEDING
        CallDelivered           = 0x04,  // Call delivered: received valid ALERTING
        CallPresent             = 0x06,  // Call present: received valid SETUP or recover from STATUS
        CallReceived            = 0x07,  // Call received: sent ALERTING or recover from STATUS
        ConnectReq              = 0x08,  // Connect request: sent/received valid CONNECT or recover from STATUS
        IncomingProceeding      = 0x09,  // Incoming call proceeding: sent CALL PROCEEDING or recover from STATUS
        Active                  = 0x0a,  // Active: sent/received valid CONNECT ACK
        DisconnectReq           = 0x0b,  // Disconnect request: sent DISCONNECT
        DisconnectIndication    = 0x0c,  // Disconnect indication: received valid DISCONNECT
        SuspendReq              = 0x0f,  // Suspend request
        ResumeReq               = 0x11,  // Resume reques
        ReleaseReq              = 0x13,  // Release request: sent/received valid RELEASE
        CallAbort               = 0x16,  // Call abort: received STATUS in Null state with remote not in Null state
        OverlapRecv             = 0x19,  // Overlap receiving
        // Call controller states
        RestartReq              = 0x3d,  // Restart request
        Restart                 = 0x3e,  // Restart
    };

   inline ISDNQ931State() : m_state(Null)
        { }

    inline State state() const
        { return m_state; }

    static const char* stateName(u_int8_t s)
        { return lookup(s,s_states,0); }

    static const TokenDict s_states[];
 
protected:
    bool checkStateRecv(int type, bool* retrans);

    bool checkStateSend(int type);

    State m_state;
 
};

class YSIG_API ISDNQ931Call : public ISDNQ931State, public SignallingCall
{
    friend class ISDNQ931;
public:
    virtual ~ISDNQ931Call();

    inline u_int32_t callRef() const
        { return m_callRef; }

    inline u_int32_t callRefLen() const
        { return m_callRefLen; }

    inline u_int8_t callTei() const
        { return m_tei; }

    inline SignallingCircuit* circuit()
        { return m_circuit; }

    void setTerminate(bool destroy, const char* reason);

    virtual bool sendEvent(SignallingEvent* event);

    virtual SignallingEvent* getEvent(const Time& when);

    void dataLinkState(bool up);

    virtual void* getObject(const String& name) const;
 
protected:
    ISDNQ931Call(ISDNQ931* controller, bool outgoing, u_int32_t callRef,
        u_int8_t callRefLen, u_int8_t tei = 0);

    SignallingEvent* releaseComplete(const char* reason = 0, const char* diag = 0);

    SignallingEvent* getCircuitEvent(const Time& when);
 
private:
    // Reserve and connect a circuit. Change the reserved one if it must to
    bool reserveCircuit();
    // Process call when terminate flag is set. Check timeout
    // @param msg Optional message extracted from queue
    SignallingEvent* processTerminate(ISDNQ931Message* msg = 0);
    // Check timer(s)
    SignallingEvent* checkTimeout(u_int64_t time);
    // Check received messages for valid state
    // True to send status if not accepted
    bool checkMsgRecv(ISDNQ931Message* msg, bool status);
    // Process received messages
    // @param msg Valid ISDNQ931Message pointer
    SignallingEvent* processMsgAlerting(ISDNQ931Message* msg);
    SignallingEvent* processMsgCallProceeding(ISDNQ931Message* msg);
    SignallingEvent* processMsgConnect(ISDNQ931Message* msg);
    SignallingEvent* processMsgConnectAck(ISDNQ931Message* msg);
    SignallingEvent* processMsgDisconnect(ISDNQ931Message* msg);
    SignallingEvent* processMsgInfo(ISDNQ931Message* msg);
    SignallingEvent* processMsgNotify(ISDNQ931Message* msg);
    SignallingEvent* processMsgProgress(ISDNQ931Message* msg);
    SignallingEvent* processMsgRelease(ISDNQ931Message* msg);
    SignallingEvent* processMsgSetup(ISDNQ931Message* msg);
    SignallingEvent* processMsgSetupAck(ISDNQ931Message* msg);
    SignallingEvent* processMsgStatus(ISDNQ931Message* msg);
    SignallingEvent* processMsgStatusEnquiry(ISDNQ931Message* msg);
    // Send message
    // @param msg Pointer to SignallingMessage with parameters
    bool sendAlerting(SignallingMessage* sigMsg);
    bool sendCallProceeding(SignallingMessage* sigMsg);
    bool sendConnect(SignallingMessage* sigMsg);
    bool sendConnectAck(SignallingMessage* sigMsg);
    bool sendDisconnect(SignallingMessage* sigMsg);
    bool sendInfo(SignallingMessage* sigMsg);
    bool sendProgress(SignallingMessage* sigMsg);
    bool sendRelease(const char* reason = 0, SignallingMessage* sigMsg = 0);
    bool sendReleaseComplete(const char* reason = 0, const char* diag = 0, u_int8_t tei = 0);
    bool sendSetup(SignallingMessage* sigMsg);
    bool sendSuspendRej(const char* reason = 0, SignallingMessage* sigMsg = 0);
    bool sendSetupAck();
    // Errors on processing received messages
    // Missing mandatory IE
    // @param release True to send release complete and generate a release event
    SignallingEvent* errorNoIE(ISDNQ931Message* msg, ISDNQ931IE::Type type, bool release);
    SignallingEvent* errorWrongIE(ISDNQ931Message* msg, ISDNQ931IE::Type type, bool release);
    // Change call state
    void changeState(State newState);
    // Remove the call from controller's list
    void removeFromController();
    // Get the Q931 call controller
    inline ISDNQ931* q931();
 
    // Call data
    u_int32_t m_callRef;                 // Call reference
    u_int32_t m_callRefLen;              // Call reference length
    u_int8_t m_tei;                      // TEI used for the call
    SignallingCircuit* m_circuit;        // Circuit reserved for this call
    bool m_circuitChange;                // True if circuit changed
    bool m_channelIDSent;                // Incoming calls: ChannelID IE already sent
    bool m_rspBearerCaps;                // Incoming calls: Send BearerCaps IE in the first response
    bool m_inbandAvailable;              // Inband data is available
    bool m_net;                          // Flag indicating call is sent by a NT
    ISDNQ931IEData m_data;               // Data to process IEs
    ObjList m_inMsg;                     // Incoming message queue
    bool m_broadcast[127];               // TEIs that answered to PTMP SETUP
    // Timers
    SignallingTimer m_discTimer;         // T305: sending DISCONNECT
    SignallingTimer m_relTimer;          // T308: sending RELEASE
    SignallingTimer m_conTimer;          // T313: sending CONNECT
    SignallingTimer m_overlapSendTimer;  // T302 for overlapped sending
    SignallingTimer m_overlapRecvTimer;  // T304
    SignallingTimer m_retransSetupTimer; // T302 for setup retransmission (PTMP)
    // Termination
    bool m_terminate;                    // Terminate flag: send RELEASE
    bool m_destroy;                      // Destroy flag: call releaseComplete()
    bool m_destroyed;                    // Call destroyed flag
};

class YSIG_API ISDNQ931CallMonitor : public ISDNQ931State, public SignallingCall
{
    friend class ISDNQ931Monitor;
public:
    virtual ~ISDNQ931CallMonitor();

    inline bool netInit() const
        { return m_netInit; }

    virtual SignallingEvent* getEvent(const Time& when);

    void setTerminate(const char* reason);

    virtual void* getObject(const String& name) const;
 
protected:
    ISDNQ931CallMonitor(ISDNQ931Monitor* controller, u_int32_t callRef, bool netInit);

    SignallingEvent* releaseComplete(const char* reason = 0);
 
private:
    // Get an event from one of the reserved circuits
    SignallingEvent* getCircuitEvent(const Time& when);
    // Process received setup message
    SignallingEvent* processMsgSetup(ISDNQ931Message* msg);
    // Process received responses to setup message (Proceeding, Alerting, Connect)
    SignallingEvent* processMsgResponse(ISDNQ931Message* msg);
    // Process termination messages (Disconnect, Release, Release Complete)
    SignallingEvent* processMsgTerminate(ISDNQ931Message* msg);
    // Process INFORMATION messages to get tones
    SignallingEvent* processMsgInfo(ISDNQ931Message* msg);
    // Reserve/release the circuits
    bool reserveCircuit();
    void releaseCircuit();
    // Connect the caller's or called's circuit
    bool connectCircuit(bool caller);
    // Change call state
    void changeState(State newState);
    // Remove the call from controller's list
    void removeFromController();
    // Get the Q931Monitor call controller
    inline ISDNQ931Monitor* q931();
 
    u_int32_t m_callRef;                 // Call reference
    SignallingCircuit* m_callerCircuit;  // Circuit reserved for caller
    SignallingCircuit* m_calledCircuit;  // Circuit reserved for called
    SignallingCircuit* m_eventCircuit;   // Last circuit that generated an event
    bool m_netInit;                      // The call initiator is from the network side of the link
    bool m_circuitChange;                // True if circuit changed
    ISDNQ931IEData m_data;               // Data to process IEs
    bool m_terminate;                    // Terminate flag
    String m_terminator;                 // The name of the entity that terminated the call
    ObjList m_inMsg;                     // Incoming messages queue
};

class YSIG_API ISDNQ931ParserData
{
public:
    ISDNQ931ParserData(const NamedList& params, DebugEnabler* dbg = 0);

    inline bool flag(int mask) const
        { return (0 != (m_flags & mask)); }
 
    DebugEnabler* m_dbg;                 // The debug enabler used for output
    u_int32_t m_maxMsgLen;               // Maximum length of outgoing messages (or message segments)
    int m_flags;                         // The current behaviour flags
    int m_flagsOrig;                     // The original behaviour flags
    u_int8_t m_maxDisplay;               // Max Display IE size
    bool m_allowSegment;                 // True if message segmentation is allowed
    u_int8_t m_maxSegments;              // Maximum allowed segments for outgoing messages
    bool m_extendedDebug;                // True to fill message/IE buffer
};

class YSIG_API ISDNQ931 : public SignallingCallControl, public SignallingDumpable, public ISDNLayer3
{
    YCLASS(ISDNQ931,ISDNLayer3)
    friend class ISDNQ931Call;
public:
    enum BehaviourFlags {
        // Append the progress indicator 'non-isdn-source' if present when
        // sending SETUP. If this flag is not set, the indicator will be
        // removed from the message
        SendNonIsdnSource = 0x00000001,
        // Ignore (don't send) the progress indicator 'non-isdn-destination'
        // if present when sending SETUP ACKNOWLEDGE or CONNECT
        IgnoreNonIsdnDest = 0x00000002,
        // Always set presentation='allowed' and screening='network-provided'
        // for Calling Party Number IE
        ForcePresNetProv = 0x00000004,
        // Translate '3.1khz-audio' transfer capability code 0x10 to/from 0x08
        Translate31kAudio = 0x00000008,
        // Send only transfer mode and rate when sending the Bearer Capability IE
        // with transfer capability 'udi' or 'rdi' (unrestricted/restricted
        // digital information)
        URDITransferCapsOnly = 0x00000010,
        // Don't send Layer 1 capabilities (data format) with the
        // Bearer Capability IE when in circuit switch mode
        NoLayer1Caps = 0x00000020,
        // Don't parse incoming IEs found after a temporary (non-locking) shift
        IgnoreNonLockedIE = 0x00000040,
        // Don't send the Display IE
        // This flag is internally set for EuroIsdnE1 type when the call
        // controller is the CPE side of the link
        NoDisplayIE = 0x00000080,
        // Don't append a charset byte 0xb1 before Display data
        NoDisplayCharset = 0x00000100,
        // Send a Sending Complete IE even if no overlap dialing
        ForceSendComplete = 0x00000200,
        // Don't change call state to Active instead of ConnectRequest after
        // sending CONNECT. This flag is internally set when the call
        // controller is the CPE side of the data link
        NoActiveOnConnect = 0x00000400,
        // Check the validity of the notification indicator when sending a NOTIFY message
        CheckNotifyInd = 0x00000800,
        // Request an outbound PRI channel to be exclusive
        ChannelExclusive = 0x00001000,
    };

    enum SwitchType {
        Unknown      = 0,
        // Standard Euro ISDN (CTR4, ETSI 300-102)
        EuroIsdnE1   = ForceSendComplete|CheckNotifyInd|NoDisplayCharset|URDITransferCapsOnly,
        // T1 Euro ISDN variant (ETSI 300-102)
        EuroIsdnT1   = ForceSendComplete|CheckNotifyInd,
        // National ISDN
        NationalIsdn = SendNonIsdnSource,
        // DMS 100
        Dms100       = ForcePresNetProv|IgnoreNonIsdnDest,
        // Lucent 5E
        Lucent5e     = IgnoreNonLockedIE,
        // AT&T 4ESS
        Att4ess      = ForcePresNetProv|IgnoreNonLockedIE|Translate31kAudio|NoLayer1Caps,
        // QSIG Switch
        QSIG         = NoActiveOnConnect|NoDisplayIE|NoDisplayCharset
    };

    ISDNQ931(const NamedList& params, const char* name = 0);

    virtual ~ISDNQ931();

    virtual bool initialize(const NamedList* config);

    virtual const char* statusName() const;

    inline const ISDNLayer2* layer2() const
        { return m_q921; }

    inline bool primaryRate() const
        { return m_primaryRate; }

    inline bool network() const
        { return m_q921 ? m_q921->network() : m_networkHint; }

    inline bool transferModeCircuit() const
        { return m_transferModeCircuit; }

    inline ISDNQ931ParserData& parserData()
        { return m_parserData; }

    inline const String& numPlan() const
        { return m_numPlan; }

    inline const String& numType() const
        { return m_numType; }

    inline const String& numPresentation() const
        { return m_numPresentation; }

    inline const String& numScreening() const
        { return m_numScreening; }

    inline const String& format() const
        { return m_format; }

    bool sendMessage(ISDNQ931Message* msg, u_int8_t tei, String* reason = 0);

    virtual void multipleFrameEstablished(u_int8_t tei, bool confirm, bool timeout, ISDNLayer2* layer2);

    virtual void multipleFrameReleased(u_int8_t tei, bool confirm, bool timeout, ISDNLayer2* layer2);

    virtual void receiveData(const DataBlock& data, u_int8_t tei, ISDNLayer2* layer2);

    virtual ISDNLayer2* attach(ISDNLayer2* q921);

    SignallingCall* call(SignallingMessage* msg, String& reason);

    bool restart(const char* circuits);

    inline bool sendStatus(ISDNQ931Call* call, const char* cause, u_int8_t tei = 0,
        const char* display = 0, const char* diagnostic = 0)
    {
        return call && sendStatus(cause,call->callRefLen(),call->callRef(),tei,
            call->outgoing(),call->state(),display,diagnostic);
    }

    inline bool sendRelease(ISDNQ931Call* call, bool release, const char* cause, u_int8_t tei = 0,
        const char* diag = 0, const char* display = 0, const char* signal = 0)
    {
        return call && sendRelease(release,call->callRefLen(),call->callRef(),tei,
            call->outgoing(),cause,diag,display,signal);
    }

    virtual void cleanup(const char* reason = "offline");

    void setInterval(SignallingTimer& timer, int id);

    void manageTimeout();

    inline void setDebug(bool printMsg, bool extendedDebug)
        { m_parserData.m_extendedDebug = m_extendedDebug =
            ((m_printMsg = printMsg) && extendedDebug); }

    static const TokenDict s_flags[];

    static const TokenDict s_swType[];
 
protected:
    virtual void destroyed()
    {
        TelEngine::destruct(attach(0));
        TelEngine::destruct(SignallingCallControl::attach(0));
        ISDNLayer3::destroyed();
    }

    virtual void timerTick(const Time& when);

    ISDNQ931Call* findCall(u_int32_t callRef, bool outgoing, u_int8_t tei = 0);

    ISDNQ931Call* findCall(unsigned int circuit);

    void terminateCalls(ObjList* list, const char* reason);

    bool acceptNewCall(bool outgoing, String& reason);

    ISDNQ931Message* getMsg(const DataBlock& data);

    ISDNQ931Message* endReceiveSegment(const char* reason = 0);

    void processGlobalMsg(ISDNQ931Message* msg, u_int8_t tei = 0);

    void processMsgRestart(ISDNQ931Message* msg, u_int8_t tei = 0);

    void processInvalidMsg(ISDNQ931Message* msg, u_int8_t tei = 0);

    void sendRestart(u_int64_t time = Time::msecNow(), bool retrans = false);

    void endRestart(bool restart, u_int64_t time, bool timeout = false);

    bool sendStatus(const char* cause, u_int8_t callRefLen, u_int32_t callRef = 0,
        u_int8_t tei = 0, bool initiator = false, ISDNQ931Call::State state = ISDNQ931Call::Null,
        const char* display = 0, const char* diagnostic = 0);

    bool sendRelease(bool release, u_int8_t callRefLen, u_int32_t callRef, u_int8_t tei,
        bool initiator, const char* cause = 0, const char* diag = 0,
        const char* display = 0, const char* signal = 0);
 
private:
    virtual bool control(NamedList& params)
        { return SignallingDumpable::control(params,this); }
    bool q921Up() const;                 // Check if layer 2 may be up
    ISDNLayer2* m_q921;                  // The attached layer 2
    bool m_q921Up;                       // Layer 2 state
    // Protocol data
    bool m_networkHint;                  // NET / CPE hint, layer 2 is authoritative
    bool m_primaryRate;                  // Primary/base rate support
    bool m_transferModeCircuit;          // Circuit switch/packet mode transfer
    u_int32_t m_callRef;                 // Current available call reference for outgoing calls
    u_int8_t m_callRefLen;               // Call reference length
    u_int32_t m_callRefMask;             // Call reference mask
    ISDNQ931ParserData m_parserData;     // Parser settings
    ISDNQ931IEData m_data;               // Process IEs
    // Timers & counters
    SignallingTimer m_l2DownTimer;       // T309: Layer 2 is down timeout
    SignallingTimer m_recvSgmTimer;      // T314: Receive segment timeout
    SignallingTimer m_syncCicTimer;      // T316: Restart individual circuit timeout
    SignallingCounter m_syncCicCounter;  // RESTART retransmission counter
    SignallingTimer m_callDiscTimer;     // Q931 call value (see ISDQ931Call)
    SignallingTimer m_callRelTimer;      // Q931 call value (see ISDQ931Call)
    SignallingTimer m_callConTimer;      // Q931 call value (see ISDQ931Call)
    // Default values
    String m_numPlan;                    // Numbering plan
    String m_numType;                    // Number type
    String m_numPresentation;            // Number presentation
    String m_numScreening;               // Number screening
    String m_format;                     // Data format
    String m_cpeNumber;                  // The number of the BRI CPE
    // Restart data
    SignallingCircuit* m_restartCic;     // Currently restarting circuit
    unsigned int m_lastRestart;          // Last restarted circuit's code
    SignallingTimer m_syncGroupTimer;    // Restarting circuit group interval
    // Message segmentation data
    DataBlock m_segmentData;             // Message segments buffer
    ISDNQ931Message* m_segmented;        // Segmented message
    u_int8_t m_remaining;                // Remaining segments
    // Debug
    bool m_printMsg;                     // True to print messages to output
    bool m_extendedDebug;                // Extended debug flag
    // Flags used to print error messages
    bool m_flagQ921Down;                 // Layer 2 is down period timed out
    bool m_flagQ921Invalid;              // Refusing to send message when Layer 2 is missing or down
};

class YSIG_API ISDNQ931Monitor : public SignallingCallControl, public ISDNLayer3
{
    YCLASS(ISDNQ931Monitor,ISDNLayer3)
    friend class ISDNQ931CallMonitor;
public:
    ISDNQ931Monitor(const NamedList& params, const char* name = 0);

    virtual ~ISDNQ931Monitor();

    virtual bool initialize(const NamedList* config);

    virtual const char* statusName() const;

    virtual void dataLinkState(u_int8_t tei, bool cmd, bool value, ISDNLayer2* layer2);

    virtual void idleTimeout(ISDNLayer2* layer2);

    virtual void receiveData(const DataBlock& data, u_int8_t tei, ISDNLayer2* layer2);

    virtual ISDNQ921Passive* attach(ISDNQ921Passive* q921, bool net);

    virtual SignallingCircuitGroup* attach(SignallingCircuitGroup* circuits, bool net);

    inline ISDNQ921Passive* circuits(bool net) const
        { return net ? m_q921Net : m_q921Cpe; }

    inline void setDebug(bool printMsg, bool extendedDebug)
        { m_parserData.m_extendedDebug = m_extendedDebug =
            ((m_printMsg = printMsg) && extendedDebug); }

    virtual void cleanup(const char* reason = "offline")
        { terminateMonitor(0,reason); }

    void terminateMonitor(ISDNQ931CallMonitor* mon, const char* reason);
 
protected:
    virtual void destroyed()
    {
        TelEngine::destruct(SignallingCallControl::attach(0));
        TelEngine::destruct(attach((ISDNQ921Passive*)0,true));
        TelEngine::destruct(attach((ISDNQ921Passive*)0,false));
        attach((SignallingCircuitGroup*)0,true);
        attach((SignallingCircuitGroup*)0,false);
        ISDNLayer3::destroyed();
    }

    virtual void timerTick(const Time& when);

    bool reserveCircuit(unsigned int code, bool netInit,
        SignallingCircuit** caller, SignallingCircuit** called);

    bool releaseCircuit(SignallingCircuit* circuit);

    void processMsgRestart(ISDNQ931Message* msg);
 
private:
    // Find a call monitor by call reference or reserved circuit
    // @return Referenced call monitor pointer or 0 if not found
    ISDNQ931CallMonitor* findMonitor(unsigned int value, bool byCallRef);
    // Drop some messages. Return true if the message should be dropped
    bool dropMessage(const ISDNQ931Message* msg);
 
    ISDNQ921Passive* m_q921Net;          // Net side of the link
    ISDNQ921Passive* m_q921Cpe;          // CPE side of the link
    SignallingCircuitGroup* m_cicNet;    // Circuit group for the net side of the link
    SignallingCircuitGroup* m_cicCpe;    // Circuit group for the cpe side of the link
    ISDNQ931ParserData m_parserData;     // Parser settings
    ISDNQ931IEData m_data;               // Process IEs
    // Debug
    bool m_printMsg;                     // True to print messages to output
    bool m_extendedDebug;                // Extended debug flag
};
 
}
 
#endif /* __YATESIG_H */
 
/* vi: set ts=8 sw=4 sts=4 noet: */