rtppkt.h

Go to the documentation of this file.

// Copyright (C) 2002 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 General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
//
// 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>

#ifdef CCXX_NAMESPACES
namespace ost {
#endif

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     __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 __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

#ifdef  CCXX_NAMESPACES
}
#endif

#endif  // ndef CCXX_RTP_RTPPKT_H_