yatertp.h

 
#ifndef __YATERTP_H
#define __YATERTP_H
 
#include <yateclass.h>
 
#ifdef _WINDOWS
 
#ifdef LIBYRTP_EXPORTS
#define YRTP_API __declspec(dllexport)
#else
#ifndef LIBYRTP_STATIC
#define YRTP_API __declspec(dllimport)
#endif
#endif
 
#endif /* _WINDOWS */
 
#ifndef YRTP_API
#define YRTP_API
#endif

namespace TelEngine {
 
class RTPGroup;
class RTPTransport;
class RTPSession;
class RTPSender;
class RTPReceiver;
class RTPSecure;

class YRTP_API RTPDebug
{
public:
    inline RTPDebug(DebugEnabler* dbg, const char* traceId)
        : m_dbg(dbg), m_traceId(traceId)
        {}

    RTPDebug(RTPSession* session);

    inline DebugEnabler* dbg() const
        { return m_dbg; }

    inline const String& dbgTraceId() const
        { return m_traceId; }
 
protected:
    inline void setDebug(DebugEnabler* dbg, const char* traceId) {
            m_dbg = dbg;
            if (!m_traceId)
                m_traceId = traceId;
        }
 
    DebugEnabler* m_dbg;
    String m_traceId;
};

class YRTP_API RTPProcessor : public GenObject, public RTPDebug
{
    friend class UDPSession;
    friend class UDPTLSession;
    friend class RTPGroup;
    friend class RTPTransport;
    friend class RTPSender;
    friend class RTPReceiver;
 
public:
    RTPProcessor(DebugEnabler* dbg = 0, const char* traceId = 0);

    virtual ~RTPProcessor();

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

    virtual void rtpData(const void* data, int len);

    virtual void rtcpData(const void* data, int len);

    virtual void getStats(String& stats) const;

    virtual inline void incWrongSrc()
        {  }

    inline unsigned int wrongSrc()
        { return m_wrongSrc; }
 
protected:
    void group(RTPGroup* newgrp);

    virtual void timerTick(const Time& when) = 0;
 
    unsigned int m_wrongSrc;
 
private:
    RTPGroup* m_group;
};

class YRTP_API RTPGroup : public GenObject, public Mutex, public Thread
{
    friend class RTPProcessor;
 
public:
    RTPGroup(int msec = 0, Priority prio = Normal, const String& affinity = String::empty());

    virtual ~RTPGroup();

    virtual void cleanup();

    virtual void run();

    static void setMinSleep(int msec);

    void join(RTPProcessor* proc);

    void part(RTPProcessor* proc);
 
private:
    ObjList m_processors;
    bool m_listChanged;
    unsigned long m_sleep;
};

class YRTP_API RTPTransport : public RTPProcessor
{
public:
    enum Activation {
        Inactive,
        Bound,
        Active
    };

    enum Type {
        Unknown,
        RTP,
        UDPTL
    };

    RTPTransport(Type type = RTP, DebugEnabler* dbg = 0, const char* traceId = 0);

    virtual ~RTPTransport();

    virtual void destruct();

    void setProcessor(RTPProcessor* processor = 0);

    void setMonitor(RTPProcessor* monitor = 0);

    inline const SocketAddr& localAddr() const
        { return m_localAddr; }

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

    bool localAddr(SocketAddr& addr, bool rtcp = true);

    bool remoteAddr(SocketAddr& addr, bool sniff = false);

    bool setBuffer(int bufLen = 4096);

    inline bool setTOS(int tos)
        { return m_rtpSock.setTOS(tos); }

    inline Socket* rtpSock()
        { return &m_rtpSock; }

    inline Socket* rtcpSock()
        { return &m_rtcpSock; }

    bool drillHole();
 
protected:
    virtual void timerTick(const Time& when);

    virtual void rtpData(const void* data, int len);

    virtual void rtcpData(const void* data, int len);
 
private:
    bool sendData(Socket& sock, const SocketAddr& to, const void* data, int len,
        const char* what, bool& flag);
    Type m_type;
    RTPProcessor* m_processor;
    RTPProcessor* m_monitor;
    Socket m_rtpSock;
    Socket m_rtcpSock;
    SocketAddr m_localAddr;
    SocketAddr m_remoteAddr;
    SocketAddr m_remoteRTCP;
    SocketAddr m_remotePref;
    SocketAddr m_rxAddrRTP;
    SocketAddr m_rxAddrRTCP;
    bool m_autoRemote;
    bool m_warnSendErrorRtp;
    bool m_warnSendErrorRtcp;
};

class YRTP_API RTPDejitter : public RTPProcessor
{
public:
    RTPDejitter(RTPReceiver* receiver, unsigned int mindelay, unsigned int maxdelay,
        DebugEnabler* dbg = 0, const char* traceId = 0);

    virtual ~RTPDejitter();

    virtual bool rtpRecv(bool marker, int payload, unsigned int timestamp,
        const void* data, int len);

    void clear();
 
protected:
    virtual void timerTick(const Time& when);
 
private:
    ObjList m_packets;
    RTPReceiver* m_receiver;
    unsigned int m_minDelay;
    unsigned int m_maxDelay;
    unsigned int m_headStamp;
    unsigned int m_tailStamp;
    u_int64_t m_headTime;
    u_int64_t m_sampRate;
    unsigned char m_fastRate;
};

class YRTP_API RTPBaseIO: public RTPDebug
{
    friend class RTPSession;
    friend class RTPSecure;
public:
    inline RTPBaseIO(RTPSession* session = 0)
        : RTPDebug(session),
          m_session(session), m_secure(0),
          m_ssrcInit(true), m_ssrc(0), m_ts(0),
          m_seq(0), m_rollover(0), m_secLen(0), m_mkiLen(0),
          m_evTs(0), m_evNum(-1), m_evVol(-1), m_evSeq(0),
          m_ioPackets(), m_ioOctets(0), m_tsLast(0),
          m_debugDataLevel(0), m_debugData(false), m_debugEvent(false),
          m_dataType(-1), m_eventType(-1), m_silenceType(-1)
        { }

    virtual ~RTPBaseIO();

    inline int dataPayload() const
        { return m_dataType; }

    bool dataPayload(int type);

    inline int eventPayload() const
        { return m_eventType; }

    bool eventPayload(int type);

    inline int silencePayload() const
        { return m_silenceType; }

    bool silencePayload(int type);

    unsigned int ssrcInit();

    inline void reset()
        { m_ssrcInit = true; }

    inline unsigned int ssrc() const
        { return m_ssrcInit ? 0 : m_ssrc; }

    inline void ssrc(unsigned int src)
        { m_ssrc = src; m_ssrcInit = false; }

    inline u_int16_t seq() const
        { return m_seq; }

    inline u_int32_t rollover() const
        { return m_rollover; }

    inline u_int64_t fullSeq() const
        { return m_seq | (((u_int64_t)m_rollover) << 16); }

    inline u_int32_t ioPackets() const
        { return m_ioPackets; }

    inline u_int32_t ioOctets() const
        { return m_ioOctets; }

    inline unsigned int tsLast() const
        { return m_ts + m_tsLast; }

    inline RTPSession* session() const
        { return m_session; }

    inline RTPSecure* security() const
        { return m_secure; }

    void security(RTPSecure* secure);

    void initDebugData(bool recv, const NamedList& params);
 
protected:
    virtual void timerTick(const Time& when) = 0;

    inline void secLength(u_int32_t len, u_int32_t key = 0)
        { m_secLen = len; m_mkiLen = key; }
 
    RTPSession* m_session;
    RTPSecure* m_secure;
    bool m_ssrcInit;
    u_int32_t m_ssrc;
    u_int32_t m_ts;
    u_int16_t m_seq;
    u_int32_t m_rollover;
    u_int16_t m_secLen;
    u_int16_t m_mkiLen;
    u_int32_t m_evTs;
    int m_evNum;
    int m_evVol;
    unsigned int m_evSeq;
    u_int32_t m_ioPackets;
    u_int32_t m_ioOctets;
    unsigned int m_tsLast;
    // Debug data
    int m_debugDataLevel;
    bool m_debugData;
    bool m_debugEvent;
 
private:
    int m_dataType;
    int m_eventType;
    int m_silenceType;
};

class YRTP_API RTPReceiver : public RTPBaseIO
{
    friend class RTPSession;
    friend class RTPDejitter;
public:
    inline RTPReceiver(RTPSession* session = 0)
        : RTPBaseIO(session),
          m_ioLostPkt(0), m_dejitter(0),
          m_seqSync(0), m_seqCount(0), m_warn(true), m_warnSeq(1),
          m_seqLost(0), m_wrongSSRC(0), m_syncLost(0)
        { }

    virtual ~RTPReceiver();

    inline u_int32_t ioPacketsLost() const
        { return m_ioLostPkt; }
 

    void setDejitter(RTPDejitter* dejitter);

    inline void setDejitter(unsigned int mindelay, unsigned int maxdelay)
        { setDejitter(new RTPDejitter(this,mindelay,maxdelay,dbg(),m_traceId)); }

    virtual bool rtpRecv(bool marker, int payload, unsigned int timestamp,
        const void* data, int len);

    virtual bool rtpRecvData(bool marker, unsigned int timestamp,
        const void* data, int len);

    virtual bool rtpRecvEvent(int event, char key, int duration,
        int volume, unsigned int timestamp);

    virtual void rtpNewPayload(int payload, unsigned int timestamp);

    virtual void rtpNewSSRC(u_int32_t newSsrc, bool marker);

    virtual void stats(NamedList& stat) const;
 
protected:
    virtual void timerTick(const Time& when);

    virtual bool rtpDecipher(unsigned char* data, int len, const void* secData, u_int32_t ssrc, u_int64_t seq);

    virtual bool rtpCheckIntegrity(const unsigned char* data, int len, const void* authData, u_int32_t ssrc, u_int64_t seq);
 
    u_int32_t m_ioLostPkt;
 
private:
    void rtpData(const void* data, int len);
    void rtcpData(const void* data, int len);
    bool decodeEvent(bool marker, unsigned int timestamp, const void* data, int len);
    bool decodeSilence(bool marker, unsigned int timestamp, const void* data, int len);
    void finishEvent(unsigned int timestamp);
    bool pushEvent(int event, int duration, int volume, unsigned int timestamp);
    RTPDejitter* m_dejitter;
    u_int16_t m_seqSync;
    u_int16_t m_seqCount;
    bool m_warn;
    int m_warnSeq;                       // Warn on invalid sequence (1: DebugWarn, -1: DebugInfo)
    unsigned int m_seqLost;
    unsigned int m_wrongSSRC;
    unsigned int m_syncLost;
};

class YRTP_API RTPSender : public RTPBaseIO
{
public:
    RTPSender(RTPSession* session = 0, bool randomTs = true);

    virtual ~RTPSender()
        { }

    bool rtpSend(bool marker, int payload, unsigned int timestamp,
        const void* data, int len);

    bool rtpSendData(bool marker, unsigned int timestamp,
        const void* data, int len);

    bool rtpSendEvent(int event, int duration, int volume = 0, unsigned int timestamp = 0);

    bool rtpSendKey(char key, int duration, int volume = 0, unsigned int timestamp = 0);
 

    inline int padding() const
        { return m_padding; }

    bool padding(int chunk);

    virtual void stats(NamedList& stat) const;
 
protected:
    virtual void timerTick(const Time& when);

    virtual void rtpEncipher(unsigned char* data, int len);

    virtual void rtpAddIntegrity(const unsigned char* data, int len, unsigned char* authData);
 
 
private:
    int m_evTime;
    unsigned char m_padding;
    DataBlock m_buffer;
    bool sendEventData(unsigned int timestamp);
};

class YRTP_API UDPSession : public RTPProcessor
{
public:
    virtual ~UDPSession();

    virtual RTPTransport* createTransport();

    bool initTransport();

    bool initGroup(int msec = 0, Thread::Priority prio = Thread::Normal, const String& affinity = String::empty());

    inline bool remoteAddr(SocketAddr& addr, bool sniff = false)
        { return m_transport && m_transport->remoteAddr(addr,sniff); }

    inline bool setBuffer(int bufLen = 4096)
        { return m_transport && m_transport->setBuffer(bufLen); }

    inline bool setTOS(int tos)
        { return m_transport && m_transport->setTOS(tos); }

    inline Socket* rtpSock()
        { return m_transport ? m_transport->rtpSock() : 0; }

    inline bool drillHole()
        { return m_transport && m_transport->drillHole(); }

    void setTimeout(int interval);

    inline RTPTransport* transport() const
        { return m_transport; }

    virtual void transport(RTPTransport* trans);
 
protected:
    UDPSession(DebugEnabler* dbg = 0, const char* traceId = 0);

    virtual void timeout(bool initial);
 
    RTPTransport* m_transport;
    u_int64_t m_timeoutTime;
    u_int64_t m_timeoutInterval;
};

class YRTP_API RTPSession : public UDPSession, public Mutex
{
public:
    enum Direction {
        FullStop = 0,
        RecvOnly = 1,
        SendOnly = 2,
        SendRecv = 3
    };

    RTPSession(DebugEnabler* dbg = 0, const char* traceId = 0);

    virtual ~RTPSession();

    virtual void getStats(String& stats) const;

    virtual void rtpData(const void* data, int len);

    virtual void rtcpData(const void* data, int len);

    virtual bool rtpRecvData(bool marker, unsigned int timestamp,
        const void* data, int len);

    virtual bool rtpRecvEvent(int event, char key, int duration,
        int volume, unsigned int timestamp);

    virtual void rtpNewPayload(int payload, unsigned int timestamp);

    virtual void rtpNewSSRC(u_int32_t newSsrc, bool marker);

    virtual RTPSender* createSender();

    virtual RTPReceiver* createReceiver();

    virtual Cipher* createCipher(const String& name, Cipher::Direction dir);

    virtual bool checkCipher(const String& name);

    inline bool rtpSend(bool marker, int payload, unsigned int timestamp,
        const void* data, int len)
        { Lock lck(this); return m_send && m_send->rtpSend(marker,payload,timestamp,data,len); }

    inline bool rtpSendData(bool marker, unsigned int timestamp,
        const void* data, int len)
        { Lock lck(this); return m_send && m_send->rtpSendData(marker,timestamp,data,len); }

    inline bool rtpSendEvent(int event, int duration, int volume = 0, unsigned int timestamp = 0)
        { Lock lck(this); return m_send && m_send->rtpSendEvent(event,duration,volume,timestamp); }

    inline bool rtpSendKey(char key, int duration, int volume = 0, unsigned int timestamp = 0)
        { Lock lck(this); return m_send && m_send->rtpSendKey(key,duration,volume,timestamp); }

    inline u_int32_t ioPacketsLost() const
        { return m_recv ? m_recv->ioPacketsLost() : 0; }

    inline int padding() const
        { return m_send ? m_send->padding() : 0; }

    inline bool padding(int chunk)
        { return m_send && m_send->padding(chunk); }

    inline void setDejitter(unsigned int mindelay = 20, unsigned int maxdelay = 50)
        { if (m_recv) m_recv->setDejitter(mindelay,maxdelay); }

    virtual void transport(RTPTransport* trans);

    inline RTPSender* sender() const
        { return m_send; }

    void sender(RTPSender* send);

    inline RTPReceiver* receiver() const
        { return m_recv; }

    void receiver(RTPReceiver* recv);

    inline Direction direction() const
        { return m_direction; }

    bool direction(Direction dir);

    inline bool addDirection(Direction dir)
        { return direction((Direction)(m_direction | dir)); }

    inline bool delDirection(Direction dir)
        { return direction((Direction)(m_direction & ~dir)); }

    bool dataPayload(int type);

    bool eventPayload(int type);

    bool silencePayload(int type);

    inline bool localAddr(SocketAddr& addr, bool rtcp = true)
        { Lock lck(this); return m_transport && m_transport->localAddr(addr,rtcp); }

    inline RTPSecure* security() const
        { return m_send ? m_send->security() : m_secure; }

    void security(RTPSecure* secure);

    void setReports(int interval);

    virtual void getStats(NamedList& stats) const;

    virtual void incWrongSrc();

    inline void setWarnSeq(bool on)
        { m_warnSeq = on ? 1 : -1; }

    inline void initDebugData(const NamedList& params) {
        if (m_recv)
                m_recv->initDebugData(true,params);
            if (m_send)
                m_send->initDebugData(false,params);
        }
 
protected:
    virtual void timerTick(const Time& when);

    void sendRtcpReport(const Time& when);

    void sendRtcpBye();
 
private:
    Direction m_direction;
    RTPSender* m_send;
    RTPReceiver* m_recv;
    RTPSecure* m_secure;
    u_int64_t m_reportTime;
    u_int64_t m_reportInterval;
    int m_warnSeq;                       // Warn on invalid sequence (1: DebugWarn, -1: DebugInfo)
};

class YRTP_API UDPTLSession : public UDPSession, public Mutex
{
public:
    ~UDPTLSession();

    inline bool localAddr(SocketAddr& addr)
        { Lock lck(this); return m_transport && m_transport->localAddr(addr,false); }

    inline u_int16_t maxLen() const
        { return m_maxLen; }

    inline u_int8_t maxSec() const
        { return m_maxSec; }

    virtual void rtpData(const void* data, int len);

    bool udptlSend(const void* data, int len, u_int16_t seq);
 
protected:
    UDPTLSession(u_int16_t maxLen = 250, u_int8_t maxSec = 2,
        DebugEnabler* dbg = 0, const char* traceId = 0);

    virtual void timerTick(const Time& when);

    virtual RTPTransport* createTransport();

    virtual void udptlRecv(const void* data, int len, u_int16_t seq, bool recovered) = 0;
 
private:
    void recoverSec(const unsigned char* data, int len, u_int16_t seq, int nSec);
    u_int16_t m_rxSeq;
    u_int16_t m_txSeq;
    u_int16_t m_maxLen;
    u_int8_t m_maxSec;
    bool m_warn;
    ObjList m_txQueue;
};

class YRTP_API RTPSecure : public GenObject, public RTPDebug
{
    friend class RTPReceiver;
    friend class RTPSender;
    friend class RTPSession;
public:
    RTPSecure(DebugEnabler* dbg = 0, const char* traceId = 0);

    RTPSecure(const String& suite, DebugEnabler* dbg = 0, const char* traceId = 0);

    RTPSecure(const RTPSecure& other);

    virtual ~RTPSecure();

    inline RTPBaseIO* owner() const
        { return m_owner; }

    void owner(RTPBaseIO* newOwner);

    inline Cipher* rtpCipher() const
        { return m_rtpCipher; }

    virtual bool supported(RTPSession* session = 0) const;

    virtual bool setup(const String& suite, const String& keyParams, const ObjList* paramList = 0);

    virtual bool create(String& suite, String& keyParams, bool buildMaster = true);
 
protected:
    virtual void init();

    virtual void rtpEncipher(unsigned char* data, int len);

    virtual void rtpAddIntegrity(const unsigned char* data, int len, unsigned char* authData);

    virtual bool rtpDecipher(unsigned char* data, int len, const void* secData, u_int32_t ssrc, u_int64_t seq);

    virtual bool rtpCheckIntegrity(const unsigned char* data, int len, const void* authData, u_int32_t ssrc, u_int64_t seq);

    bool deriveKey(Cipher& cipher, DataBlock& key, unsigned int len, unsigned char label, u_int64_t index = 0);
 
private:
    RTPBaseIO* m_owner;
    Cipher* m_rtpCipher;
    DataBlock m_masterKey;
    DataBlock m_masterSalt;
    DataBlock m_cipherKey;
    DataBlock m_cipherSalt;
    SHA1 m_authIpad;
    SHA1 m_authOpad;
    u_int32_t m_rtpAuthLen;
    bool m_rtpEncrypted;
};
 
}
 
#endif /* __YATERTP_H */
 
/* vi: set ts=8 sw=4 sts=4 noet: */