yatemgcp.h

 
#ifndef __YATEMGCP_H
#define __YATEMGCP_H
 
#include <yateclass.h>
#include <yatemime.h>
 
#ifdef _WINDOWS
 
#ifdef LIBYMGCP_EXPORTS
#define YMGCP_API __declspec(dllexport)
#else
#ifndef LIBYMGCP_STATIC
#define YMGCP_API __declspec(dllimport)
#endif
#endif
 
#endif /* _WINDOWS */
 
#ifndef YMGCP_API
#define YMGCP_API
#endif

namespace TelEngine {
 
class MGCPMessage;
class MGCPTransaction;
class MGCPEpInfo;
class MGCPEndpoint;
class MGCPEvent;
class MGCPEngine;

class YMGCP_API MGCPMessage : public RefObject
{
    friend class MGCPTransaction;
public:
    MGCPMessage(MGCPEngine* engine, const char* name, const char* ep, const char* ver = "MGCP 1.0");

    MGCPMessage(MGCPTransaction* trans, unsigned int code, const char* comment = 0);

    virtual ~MGCPMessage();

    inline bool valid() const
        { return m_valid; }

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

    inline int code() const
        { return m_code; }

    inline const String& version() const
        { return m_version; }

    inline const String& comment() const
        { return m_comment; }

    inline bool isCommand() const
        { return code() < 0; }

    inline bool isResponse() const
        { return 100 <= code(); }

    inline bool isAck() const
        { return 0 <= code() && code() <= 99; }

    inline unsigned int transactionId() const
        { return m_transaction; }

    inline const String& endpointId() const
        { return m_endpoint; }

    void toString(String& dest) const;

    static bool parse(MGCPEngine* engine, ObjList& dest,
        const unsigned char* buffer, unsigned int len,
        const char* sdpType = "application/sdp");

    NamedList params;

    ObjList sdp;
 
protected:
    MGCPMessage(MGCPEngine* engine, const char* name, int code,
        unsigned int transId, const char* epId, const char* ver);
 
private:
    MGCPMessage() : params("") {}        // Avoid using default constructor
    // Decode the message line
    static MGCPMessage* decodeMessage(const char* line, unsigned int len, unsigned int& trans,
        String& error, MGCPEngine* engine);
    // Decode message parameters. Return true if found a line containing a dot
    static bool decodeParams(const unsigned char* buffer, unsigned int len,
        unsigned int& crt, MGCPMessage* msg, String& error, MGCPEngine* engine);
 
    String m_name;                       // Command or string representation of response code
    bool m_valid;                        // False if this message is invalid
    int m_code;                          // Response code or -1 if this is a command
    unsigned int m_transaction;          // The id of the transaction this message belongs to
    String m_endpoint;                   // The id of the endpoint issuing this message
    String m_version;                    // The protocol version
    String m_comment;                    // The comment attached to a response message
};

class YMGCP_API MGCPTransaction : public RefObject, public Mutex
{
    friend class MGCPEngine;             // Process a received message
    friend class MGCPEvent;              // Access to event termination notification
public:
    enum State {
        Invalid      = 0,                // This is an invalid transaction (constructor failed)
        Initiated    = 1,                // An initial command message was sent/received
        Trying       = 2,                // Sent or received a provisional response to the initial message
        Responded    = 3,                // Sent or received a final response to the initial message
        Ack          = 4,                // Response was ack'd
        Destroying   = 5,                // Waiting to be removed from the engine
    };

    MGCPTransaction(MGCPEngine* engine, MGCPMessage* msg, bool outgoing,
        const SocketAddr& address, bool engineProcess = true);

    virtual ~MGCPTransaction();

    inline State state() const
        { return m_state; }

    inline unsigned int id() const
        { return m_id; }

    inline bool outgoing() const
        { return m_outgoing; }

    inline const String& ep() const
        { return m_endpoint; }

    const SocketAddr& addr() const
        { return m_address; }

    inline MGCPEngine* engine()
        { return m_engine; }

    inline const MGCPMessage* initial() const
        { return m_cmd; }

    inline const MGCPMessage* msgProvisional() const
        { return m_provisional; }

    inline const MGCPMessage* msgResponse() const
        { return m_response; }

    inline const MGCPMessage* msgAck() const
        { return m_ack; }

    inline bool timeout() const
        { return m_timeout; }

    inline void ackRequest(bool request)
        { m_ackRequest = request; }

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

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

    inline void setEngineProcess()
        { m_engineProcess = true; }

    MGCPEvent* getEvent(u_int64_t time = Time());

    bool sendProvisional(int code = 100, const char* comment = 0);

    inline bool setResponse(int code, const char* comment = 0)
        { return setResponse(new MGCPMessage(this,code,comment)); }

    bool setResponse(int code, const NamedList* params, MimeSdpBody* sdp1 = 0,
        MimeSdpBody* sdp2 = 0);

    bool setResponse(MGCPMessage* msg);
 
protected:
    virtual void destroyed();

    void processMessage(MGCPMessage* msg);

    MGCPEvent* checkTimeout(u_int64_t time);

    void eventTerminated(MGCPEvent* event);

    void changeState(State newState);

    void setProvisional(int code = 100);

    void send(MGCPMessage* msg);
 
private:
    MGCPTransaction() {}                 // Avoid using default constructor
    // Check if received any final response. Create an event. Init timeout.
    // Send a response ACK if requested by the response
    MGCPEvent* checkResponse(u_int64_t time);
    // Init timeout for retransmission or transaction termination
    void initTimeout(u_int64_t time, bool extra);
    // Remove from engine. Create event. Deref the transaction
    MGCPEvent* terminate();
 
    State m_state;                       // Current state
    unsigned int m_id;                   // Transaction id
    bool m_outgoing;                     // Transaction direction
    SocketAddr m_address;                // Remote andpoint's address
    MGCPEngine* m_engine;                // The engine owning this transaction
    MGCPMessage* m_cmd;                  // The command that created this transaction
    MGCPMessage* m_provisional;          // The provisional response to the command that created this transaction
    MGCPMessage* m_response;             // The response to the command that created this transaction
    MGCPMessage* m_ack;                  // The response aknowledgement message sent or received
    MGCPEvent* m_lastEvent;              // The last generated event
    String m_endpoint;                   // The endpoint owning this transaction
    u_int64_t m_nextRetrans;             // Retransission or destroy time
    unsigned int m_crtRetransInterval;   // Current retransmission interval
    unsigned int m_retransCount;         // Remainig number of retransmissions
    bool m_timeout;                      // Transaction timeout flag
    bool m_ackRequest;                   // Remote is requested to send ACK
    void* m_private;                     // Data used by this transaction's user
    String m_debug;                      // String used to identify the transaction in debug messages
    bool m_engineProcess;                // Process transaction (getEvent) from engine processor
};

class YMGCP_API MGCPEndpointId
{
public:
    inline MGCPEndpointId()
        : m_port(0)
        {}

    inline MGCPEndpointId(const String& src)
        : m_port(0)
        { set(src); }

    inline MGCPEndpointId(const MGCPEndpointId& value)
        : m_id(value.id()), m_endpoint(value.user()),
          m_host(value.host()), m_port(value.port())
        { }

    inline MGCPEndpointId(const char* endpoint, const char* host, int port, bool addPort = true)
        : m_port(0)
        { set(endpoint,host,port,addPort); }

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

    inline const String& user() const
        { return m_endpoint; }

    inline const String& host() const
        { return m_host; }

    inline int port() const
        { return m_port; }

    inline void port(int newPort, bool addPort = true)
        { set(m_endpoint,m_host,newPort,addPort); }

    void set(const char* endpoint, const char* host, int port, bool addPort = true);

    inline void set(const String& src) {
            URI uri(src);
            set(uri.getUser(),uri.getHost(),uri.getPort());
        }

    inline bool valid() const {
            return m_endpoint && m_endpoint.length() < 256 &&
                m_host && m_host.length() < 256;
        }
 
private:
    String m_id;                         // The complete id
    String m_endpoint;                   // The endpoint's name inside the host
    String m_host;                       // Host of this endpoint
    int m_port;                          // Port used by this endpoint
};

class YMGCP_API MGCPEpInfo : public MGCPEndpointId, public GenObject
{
public:
    inline MGCPEpInfo(const char* endpoint, const char* host, int port, bool addPort = true)
        : MGCPEndpointId(endpoint,host,port,addPort),
          m_address(AF_INET), m_resolve(true) {
            m_address.port(port);
        }

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

    inline const SocketAddr& address() const
        { return m_address; }

    const SocketAddr& address();

    inline void address(const SocketAddr& addr)
        { m_resolve = false; m_address = addr; }

    String alias;
 
private:
    SocketAddr m_address;
    bool m_resolve;
};

class YMGCP_API MGCPEndpoint : public RefObject, public MGCPEndpointId, public Mutex
{
public:
    MGCPEndpoint(MGCPEngine* engine, const char* user, const char* host, int port, bool addPort = true);

    virtual ~MGCPEndpoint();

    virtual const String& toString() const
        { return MGCPEndpointId::id(); }

    inline MGCPEngine* engine()
        { return m_engine; }

    MGCPEpInfo* append(const char* endpoint, const char* host, int port = 0);

    inline void clear()
        { lock(); m_remote.clear(); unlock(); }

    MGCPEpInfo* find(const String& epId);

    MGCPEpInfo* findAlias(const String& alias);

    MGCPEpInfo* peer();
 
private:
    MGCPEngine* m_engine;                // The engine owning this endpoint
    ObjList m_remote;                    // The remote endpoints
};

class YMGCP_API MGCPEvent
{
    friend class MGCPTransaction;
public:
    ~MGCPEvent();

    inline MGCPTransaction* transaction()
        { return m_transaction; }

    inline MGCPMessage* message() const
        { return m_message; }
 
protected:
    MGCPEvent(MGCPTransaction* trans, MGCPMessage* msg = 0);
 
private:
    MGCPTransaction* m_transaction;      // The transaction that generated this event
    MGCPMessage* m_message;              // The message carried by this event, if any
};
 
class MGCPPrivateThread;

class YMGCP_API MGCPEngine : public DebugEnabler, public Mutex
{
    friend class MGCPPrivateThread;
    friend class MGCPTransaction;
public:
    MGCPEngine(bool gateway, const char* name = 0, const NamedList* params = 0);

    virtual ~MGCPEngine();

    inline bool gateway() const
        { return m_gateway; }

    inline const SocketAddr& address() const
        { return m_address; }

    inline unsigned int maxRecvPacket() const
        { return m_maxRecvPacket; }

    inline bool allowUnkCmd() const
        { return m_allowUnkCmd; }

    inline unsigned int retransInterval() const
        { return m_retransInterval; }

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

    inline u_int64_t extraTime() const
        { return m_extraTime; }

    inline bool parseParamToLower() const
        { return m_parseParamToLower; }

    inline bool provisional() const
        { return m_provisional; }

    inline bool ackRequest() const
        { return m_ackRequest; }

    inline void ackRequest(bool request)
        { m_ackRequest = request; }

    virtual void initialize(const NamedList& params);

    inline bool knownCommand(const String& cmd)
        { Lock lock(this); return (m_knownCommands.find(cmd) != 0); }

    void addCommand(const char* cmd);

    void attach(MGCPEndpoint* ep);

    void detach(MGCPEndpoint* ep, bool del = false, bool delTrans = false);

    MGCPEndpoint* findEp(MGCPEndpoint* ep);

    MGCPEndpoint* findEp(const String& epId);

    MGCPTransaction* findTrans(unsigned int id, bool outgoing);

    unsigned int getNextId();

    MGCPTransaction* sendCommand(MGCPMessage* cmd, const SocketAddr& address,
        bool engineProcess = true);

    bool receive(unsigned char* buffer, SocketAddr& addr);

    bool process(u_int64_t time = Time());

    bool processTransaction(MGCPTransaction* tr, u_int64_t time = Time());

    void runReceive(SocketAddr& addr);

    void runReceive();

    void runProcess();

    MGCPEvent* getEvent(u_int64_t time = Time());

    virtual bool processEvent(MGCPEvent* event);

    virtual bool processEvent(MGCPTransaction* trans, MGCPMessage* msg);

    void returnEvent(MGCPEvent* event);

    void cleanup(bool gracefully = true, const char* text = "Shutdown");

    static inline int defaultPort(bool gateway)
        { return gateway ? 2427 : 2727; }

    virtual void timeout(MGCPTransaction* tr)
        { }

    static TokenDict mgcp_commands[];

    static TokenDict mgcp_responses[];

    static TokenDict mgcp_reasons[];
 
protected:
    bool sendData(const String& msg, const SocketAddr& address);

    void appendTrans(MGCPTransaction* trans);

    void removeTrans(MGCPTransaction* trans, bool del);

    ObjList m_endpoints;

    ObjList m_transactions;

    ListIterator m_iterator;
 
private:
    // Append a private thread to the list
    void appendThread(MGCPPrivateThread* thread);
    // Remove private thread from the list without deleting it
    void removeThread(MGCPPrivateThread* thread);
    // Process ACK received with a message or response
    // Return a list of ack'd transactions or 0 if the parameter is incorrect
    unsigned int* decodeAck(const String& param, unsigned int & count);
 
    bool m_gateway;                      // True if this engine is an MGCP gateway, false if call agent
    bool m_initialized;                  // True if the engine was already initialized
    unsigned int m_nextId;               // Next outgoing transaction id
    Socket m_socket;                     // The socket used to send/receive data
    SocketAddr m_address;                // The IP address used by this engine
    unsigned int m_maxRecvPacket;        // The maximum length or received packets
    unsigned char* m_recvBuf;            // Receiving buffer
    bool m_allowUnkCmd;                  // Allow this engine to send/accept unknown commands
    unsigned int m_retransInterval;      // Message retransmission interval
    unsigned int m_retransCount;         // Maximum number of retransmissions for a message
    u_int64_t m_extraTime;               // Time to live after the transaction terminated gracefully
    bool m_parseParamToLower;            // Convert received messages' params to lower case
    bool m_provisional;                  // Send provisional responses flag
    bool m_ackRequest;                   // Remote is requested to send ACK
    ObjList m_knownCommands;             // The list of known commands
    ObjList m_threads;
};
 
}
 
#endif /* __YATEMGCP_H */
 
/* vi: set ts=8 sw=4 sts=4 noet: */