rtppkt.h

Go to the documentation of this file.

// Copyright (C) 2002-2015 Federico Montesino Pouzols <fedemp@altern.org>.
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with GNU ccRTP.  If not, see <http://www.gnu.org/licenses/>.
//
// As a special exception, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License.  This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
//
// This exception applies only to the code released under the name GNU
// ccRTP.  If you copy code from other releases into a copy of GNU
// ccRTP, as the General Public License permits, the exception does
// not apply to the code that you add in this way.  To avoid misleading
// anyone as to the status of such modified files, you must delete
// this exception notice from them.
//
// If you write modifications of your own for GNU ccRTP, it is your choice
// whether to permit this exception to apply to your modifications.
// If you do not wish that, delete this exception notice.
//

#ifndef CCXX_RTP_RTPPKT_H_
#define CCXX_RTP_RTPPKT_H_

#include <ccrtp/base.h>
#include <ccrtp/formats.h>
#include <ccrtp/CryptoContext.h>

NAMESPACE_COMMONCPP

class CryptoContext;

class  __EXPORT RTPPacket
{
private:
    struct RTPFixedHeader;
    struct RTPHeaderExt;

public:
    RTPPacket(const unsigned char* const block, size_t len,
          bool duplicate = false);

        RTPPacket(size_t hdrlen, size_t plen, uint8 paddinglen, CryptoContext* pcc= NULL);

    inline uint32
    getHeaderSize() const
    { return hdrSize; }

    inline const uint8* const
    getPayload() const
    { return (uint8*)(buffer + getHeaderSize()); }

    inline uint32
    getPayloadSize() const
    { return payloadSize; }

    inline PayloadType
    getPayloadType() const
    { return static_cast<PayloadType>(getHeader()->payload); }

    inline uint16
    getSeqNum() const
    { return cachedSeqNum; }

    inline uint32
    getTimestamp() const
    { return cachedTimestamp; }

    inline uint8
    getProtocolVersion() const
    { return getHeader()->version; }

    inline bool
    isPadded() const
    { return getHeader()->padding; }

    inline uint8
    getPaddingSize() const
    { return buffer[total - 1]; }

    inline bool
    isMarked() const
    { return getHeader()->marker; }

    inline bool
    isExtended() const
    { return getHeader()->extension; }

    inline uint16
    getCSRCsCount() const
    { return getHeader()->cc; }

    inline const uint32*
    getCSRCs() const
    { return static_cast<const uint32*>(&(getHeader()->sources[1])); }

    inline uint16
    getHdrExtUndefined() const
    { return (isExtended()? getHeaderExt()->undefined : 0); }

    inline uint32
    getHdrExtSize() const
    { return (isExtended()?
          (static_cast<uint32>(ntohs(getHeaderExt()->length)) << 2) :
          0); }

    inline const unsigned char*
    getHdrExtContent() const
    { return (isExtended() ?
          (reinterpret_cast<const unsigned char*>(getHeaderExt()) +
           sizeof(RTPHeaderExt)) :
          NULL); }

    inline const unsigned char* const
    getRawPacket() const
    { return buffer; }

    inline uint32
    getRawPacketSize() const
    { return total; }

        inline uint32
        getRawPacketSizeSrtp() const
        { return total + srtpLength; }

        inline size_t
    getSizeOfFixedHeader() const
    { return sizeof(RTPFixedHeader); }

    void reComputePayLength(bool padding);

protected:
    inline virtual ~RTPPacket()
    { endPacket(); }

    void
    endPacket();

    inline RTPFixedHeader*
    getHeader() const
    { return reinterpret_cast<RTPFixedHeader*>(buffer); }

    inline void
    setExtension(bool e)
    { getHeader()->extension = e; }

    inline const RTPHeaderExt*
    getHeaderExt() const
    {
         uint32 fixsize = sizeof(RTPFixedHeader) + (getHeader()->cc << 2);
     return (reinterpret_cast<RTPHeaderExt*>(buffer + fixsize));
    }

    inline uint32
    getRawTimestamp() const
    { return ntohl(getHeader()->timestamp); }

    inline void
    setbuffer(const void* src, size_t len, size_t pos)
    { memcpy(buffer + pos,src,len); }

    uint16 cachedSeqNum;
    uint32 cachedTimestamp;

        uint32 srtpDataOffset;

        int32 srtpLength;

        uint32 total;

        uint32 payloadSize;

private:
    unsigned char* buffer;
    uint32 hdrSize;
    bool duplicated;

#ifdef  CCXX_PACKED
#pragma pack(1)
#endif

    struct RTPFixedHeader
    {
#if defined(__BYTE_ORDER) && __BYTE_ORDER == __BIG_ENDIAN
        unsigned char version:2;       
        unsigned char padding:1;       
        unsigned char extension:1;     
        unsigned char cc:4;            
        unsigned char marker:1;        
        unsigned char payload:7;       
#else
        unsigned char cc:4;            
        unsigned char extension:1;     
        unsigned char padding:1;       
        unsigned char version:2;       
        unsigned char payload:7;       
        unsigned char marker:1;        
#endif
        uint16 sequence;        
        uint32 timestamp;       
        uint32 sources[1];      
    };

public:
    struct RFC2833Payload
    {
#if defined(__BYTE_ORDER) && __BYTE_ORDER == __BIG_ENDIAN
            uint8 event : 8;
            bool ebit : 1;
            bool rbit : 1;
            uint8 vol : 6;
            uint16 duration : 16;
#else
            uint8 event : 8;
            uint8 vol : 6;
            bool rbit : 1;
            bool ebit : 1;
            uint16 duration : 16;
#endif
    };

private:
    struct RTPHeaderExt
    {
        uint16 undefined; 
        uint16 length;    
    };
#ifdef  CCXX_PACKED
#pragma pack()
#endif

    /* definitions for access to most common 2833 fields... */

public:
    inline struct RFC2833Payload *getRaw2833Payload(void)
        {return (struct RFC2833Payload *)getPayload();}

    inline uint16 get2833Duration(void)
        {return ntohs(getRaw2833Payload()->duration);}

    inline void set2833Duration(uint16 timestamp)
        {getRaw2833Payload()->duration = htons(timestamp);}
};

class __EXPORT OutgoingRTPPkt : public RTPPacket
{
public:
    OutgoingRTPPkt(const uint32* const csrcs, uint16 numcsrc,
               const unsigned char* const hdrext, uint32 hdrextlen,
               const unsigned char* const data, size_t datalen,
                       uint8 paddinglen= 0, CryptoContext* pcc= NULL);

    OutgoingRTPPkt(const uint32* const csrcs, uint16 numcsrc,
               const unsigned char* const data, size_t datalen,
                       uint8 paddinglen= 0, CryptoContext* pcc= NULL);

    OutgoingRTPPkt(const unsigned char* const data, size_t datalen,
                       uint8 paddinglen= 0, CryptoContext* pcc= NULL);

    ~OutgoingRTPPkt()
    { }

    inline void
    setPayloadType(PayloadType pt)
    { getHeader()->payload = pt; }

    inline void
    setSeqNum(uint16 seq)
    {
        cachedSeqNum = seq;
        getHeader()->sequence = htons(seq);
    }

    inline void
    setTimestamp(uint32 pts)
    {
        cachedTimestamp = pts;
        getHeader()->timestamp = htonl(pts);
    }

    inline void
    setSSRC(uint32 ssrc) const
    { getHeader()->sources[0] = htonl(ssrc); }

    inline void
    setSSRCNetwork(uint32 ssrc) const
    { getHeader()->sources[0] = ssrc; }

    inline void
    setMarker(bool mark)
    { getHeader()->marker = mark; }

        void protect(uint32 ssrc, CryptoContext* pcc);

    inline bool
    operator==(const OutgoingRTPPkt &p) const
    { return ( this->getSeqNum() == p.getSeqNum() ); }

    inline bool
    operator!=(const OutgoingRTPPkt &p) const
    { return ( this->getSeqNum() != p.getSeqNum() ); }

private:
    OutgoingRTPPkt(const OutgoingRTPPkt &o);

    OutgoingRTPPkt&
    operator=(const OutgoingRTPPkt &o);

    void setCSRCArray(const uint32* const csrcs, uint16 numcsrc);

};

class __EXPORT IncomingRTPPkt : public RTPPacket
{
public:
    IncomingRTPPkt(const unsigned char* block, size_t len);

    ~IncomingRTPPkt()
    { }

    inline bool
    isHeaderValid()
    { return headerValid; }

    inline uint32
    getSSRC() const
    { return cachedSSRC; }

        int32
        unprotect(CryptoContext* pcc);

    inline bool
    operator==(const IncomingRTPPkt &p) const
    { return ( (this->getSeqNum() == p.getSeqNum()) &&
           (this->getSSRC() == p.getSSRC()) ); }

    inline bool
    operator!=(const IncomingRTPPkt &p) const
    { return !( *this == p ); }

private:
    IncomingRTPPkt(const IncomingRTPPkt &ip);

    IncomingRTPPkt&
    operator=(const IncomingRTPPkt &ip);

    bool headerValid;
    uint32 cachedSSRC;
    // Masks for RTP header validation: types matching RTCP SR or
    // RR must be rejected to avoid accepting misaddressed RTCP
    // packets.
    static const uint16 RTP_INVALID_PT_MASK;
    static const uint16 RTP_INVALID_PT_VALUE;
};
 // rtppacket

END_NAMESPACE

#endif  // ndef CCXX_RTP_RTPPKT_H_