rtppkt.cpp

Go to the documentation of this file.

// Copyright (C) 1999-2007 Open Source Telecom Corporation.
//
// 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.
//

#include "private.h"
#include <ccrtp/rtppkt.h>
#include <ccrtp/CryptoContext.h>

#ifdef  CCXX_NAMESPACES
namespace ost {
#endif

// Default to 8Khz when no value is specified.
const uint32 PayloadFormat::defaultRTPClockRate = 8000;

//uint32 PayloadFormat::staticRates[lastStaticPayloadType]
uint32 StaticPayloadFormat::staticAudioTypesRates[] = {
        // audio types:
        8000,    //  0 - sptPCMU
        0,       //  1 - reserved
        8000,    //  2 - sptG726_32
        8000,    //  3 - sptGSM
        8000,    //  4 - sptG723
        8000,    //  5 - sptDVI4_8000
        16000,   //  6 - sptDVI4_16000
        8000,    //  7 - sptLPC
        8000,    //  8 - sptPCMA
        8000,    //  9 - sptG722
        44100,   // 10 - sptL16_DUAL
        44100,   // 11 - sptL16_MONO
        8000,    // 12 - sptQCELP
        0,       // 13 - reserved
        90000,   // 14 - sptMPA
        8000,    // 15 - sptG728
        11015,   // 16 - sptDVI4_11025
        22050,   // 17 - sptDVI4_22050
        8000     // 18 - sptG729
/*      0,       // reserved
        0,       // unassigned
        0,       // unassigned
        0,       // unassigned
        0        // unassigned
*/
        // All video types have 90000 hz RTP clock rate.
        // If sometime in the future a static video payload type is
        // defined with a different RTP clock rate (quite
        // unprobable). This table and/or the StaticPayloadType
        // constructor must be changed.
};

StaticPayloadFormat::StaticPayloadFormat(StaticPayloadType type)
{
        setPayloadType( (type <= lastStaticPayloadType)? type : 0);
        if ( type <= sptG729 ) {
                // audio static type
                setRTPClockRate(staticAudioTypesRates[type]);
        } else {
                // video static type
                setRTPClockRate(90000);
        }
}

DynamicPayloadFormat::DynamicPayloadFormat(PayloadType type, uint32 rate)
{
        PayloadFormat::setPayloadType(type);
        setRTPClockRate(rate);
}

// constructor commonly used for incoming packets
RTPPacket::RTPPacket(const unsigned char* const block, size_t len,
                     bool duplicate):
        total((uint32)len),
        duplicated(duplicate)
{

        const RTPFixedHeader* const header =
                reinterpret_cast<const RTPFixedHeader*>(block);
        hdrSize = sizeof(RTPFixedHeader) + (header->cc << 2);
        if ( header->extension ){
                RTPHeaderExt *ext = (RTPHeaderExt *)(block + hdrSize);
                hdrSize += sizeof(uint32) + (ntohs(ext->length) * 4);
        }
        if ( header->padding )
                len -= block[len - 1];
        payloadSize = (uint32)(len - hdrSize);

        if ( duplicate ) {
                buffer = new unsigned char[len];
                setbuffer(block,len,0);
        } else {
                buffer = const_cast<unsigned char*>(block);
        }
}

// constructor commonly used for outgoing packets
RTPPacket::RTPPacket(size_t hdrlen, size_t plen, uint8 paddinglen, CryptoContext* pcc ) :
        payloadSize((uint32)plen),
        buffer(NULL),
        hdrSize((uint32)hdrlen),
        duplicated(false)
{
        total = (uint32)(hdrlen + payloadSize);
        // compute if there must be padding
        uint8 padding = 0;
        if ( 0 != paddinglen ) {
                padding = paddinglen - (total % paddinglen);
                total += padding;
        }
        srtpLength = 0;
        srtpDataOffset = 0;
        if (pcc != NULL) {
                // compute additional memory for SRTP data
                srtpLength = pcc->getTagLength() + pcc->getMkiLength();
                srtpDataOffset = total; // SRTP data go behind header plus payload plus padding
        }

        // now we know the actual total length of the packet, get  some memory
        // but take SRTP data into account. Don't change total because some RTP
        // functions rely on the fact that total is the overall size (without
        // the SRTP data)
        buffer = new unsigned char[total + srtpLength];
        *(reinterpret_cast<uint32*>(getHeader())) = 0;
        getHeader()->version = CCRTP_VERSION;
        if ( 0 != padding ) {
                memset(buffer + total - padding,0,padding - 1);
                buffer[total - 1] = padding;
                getHeader()->padding = 1;
        } else {
                getHeader()->padding = 0;
        }
}

void
RTPPacket::endPacket()
{
#ifdef  CCXX_EXCEPTIONS
        try {
#endif
                delete [] buffer;
#ifdef  CCXX_EXCEPTIONS
        } catch (...) { };
#endif
}

OutgoingRTPPkt::OutgoingRTPPkt(
        const uint32* const csrcs, uint16 numcsrc,
        const unsigned char* const hdrext, uint32 hdrextlen,
        const unsigned char* const data, size_t datalen,
        uint8 paddinglen, CryptoContext* pcc) :
        RTPPacket((getSizeOfFixedHeader() + sizeof(uint32) * numcsrc
                  + hdrextlen),datalen,paddinglen, pcc)
{
        uint32 pointer = (uint32)getSizeOfFixedHeader();
        // add CSCR identifiers (putting them in network order).
        setCSRCArray(csrcs,numcsrc);
        pointer += numcsrc * sizeof(uint32);

        // add header extension.
        setbuffer(hdrext,hdrextlen,pointer);
        setExtension(hdrextlen > 0);
        pointer += hdrextlen;

        // add data.
        setbuffer(data,datalen,pointer);
}

OutgoingRTPPkt::OutgoingRTPPkt(
        const uint32* const csrcs, uint16 numcsrc,
        const unsigned char* data, size_t datalen,
        uint8 paddinglen, CryptoContext* pcc) :
        RTPPacket((getSizeOfFixedHeader() + sizeof(uint32) *numcsrc),datalen,
                  paddinglen, pcc)
{
        uint32 pointer = (uint32)getSizeOfFixedHeader();
        // add CSCR identifiers (putting them in network order).
        setCSRCArray(csrcs,numcsrc);
        pointer += numcsrc * sizeof(uint32);

        // not needed, as the RTPPacket constructor sets by default
        // the whole fixed header to 0.
        // getHeader()->extension = 0;

        // add data.
        setbuffer(data,datalen,pointer);
}

OutgoingRTPPkt::OutgoingRTPPkt(const unsigned char* data, size_t datalen,
                               uint8 paddinglen, CryptoContext* pcc) :
        RTPPacket(getSizeOfFixedHeader(),datalen,paddinglen, pcc)
{
        // not needed, as the RTPPacket constructor sets by default
        // the whole fixed header to 0.
        //getHeader()->cc = 0;
        //getHeader()->extension = 0;

        setbuffer(data,datalen,getSizeOfFixedHeader());
}

void
OutgoingRTPPkt::setCSRCArray(const uint32* const csrcs, uint16 numcsrc)
{
        setbuffer(csrcs, numcsrc * sizeof(uint32),getSizeOfFixedHeader());
        uint32* csrc = const_cast<uint32*>(getCSRCs());
        for ( int i = 0; i < numcsrc; i++ )
                csrc[i] = htonl(csrc[i]);
        getHeader()->cc = numcsrc;
}

void
OutgoingRTPPkt::protect(uint32 ssrc, CryptoContext* pcc)
{
        /* Encrypt the packet */
        uint64 index = ((uint64)pcc->getRoc() << 16) | (uint64)getSeqNum();

        pcc->srtpEncrypt(this, index, ssrc);

        // NO MKI support yet - here we assume MKI is zero. To build in MKI
        // take MKI length into account when storing the authentication tag.

        /* Compute MAC */
        pcc->srtpAuthenticate(this, pcc->getRoc(),
                                   const_cast<uint8*>(getRawPacket()+srtpDataOffset) );
        /* Update the ROC if necessary */
        if (getSeqNum() == 0xFFFF ) {
                pcc->setRoc(pcc->getRoc() + 1);
        }
}

// These masks are valid regardless of endianness.
const uint16 IncomingRTPPkt::RTP_INVALID_PT_MASK = (0x7e);
const uint16 IncomingRTPPkt::RTP_INVALID_PT_VALUE = (0x48);

IncomingRTPPkt::IncomingRTPPkt(const unsigned char* const block, size_t len) :
        RTPPacket(block,len)
{
        // first, perform validity check:
        // 1) check protocol version
        // 2) it is not an SR nor an RR
        // 3) consistent length field value (taking CC value and P and
        //    X bits into account)
        if ( getProtocolVersion() != CCRTP_VERSION
             ||
             (getPayloadType() & RTP_INVALID_PT_MASK) == RTP_INVALID_PT_VALUE) {
            /*
             ||
             getPayloadSize() <= 0 ) {
            */
                headerValid = false;
                return;
        }
        headerValid = true;
        cachedTimestamp = getRawTimestamp();
        cachedSeqNum = ntohs(getHeader()->sequence);
        cachedSSRC = ntohl(getHeader()->sources[0]);
}

int32
IncomingRTPPkt::unprotect(CryptoContext* pcc)
{
        if (pcc == NULL) {
                return true;
        }

        /*
         * This is the setting of the packet data when we come to this
         * point:
         *
         * total:       complete length of received data
         * buffer:      points to data as received from network
         * hdrSize:     length of header including header extension
         * payloadSize: length of data excluding hdrSize and padding
         *
         * Because this is an SRTP packet we need to adjust some values here.
         * The SRTP MKI and authentication data is always at the end of a
         * packet. Thus compute the position of this data.
         */

        uint32 srtpDataIndex = total - (pcc->getTagLength() + pcc->getMkiLength());

        // now adjust total because some RTP functions rely on the fact that
        // total is the full length of data without SRTP data.
        total -= pcc->getTagLength() + pcc->getMkiLength();

        // recompute payloadSize by subtracting SRTP data
        payloadSize -= pcc->getTagLength() + pcc->getMkiLength();

        // unused??
        // const uint8* mki = getRawPacket() + srtpDataIndex;
        const uint8* tag = getRawPacket() + srtpDataIndex + pcc->getMkiLength();

        /* Replay control */
        if (!pcc->checkReplay(cachedSeqNum)) {
                return -2;
        }
        /* Guess the index */
        uint64 guessedIndex = pcc->guessIndex(cachedSeqNum);

        uint32 guessedRoc = guessedIndex >> 16;
        uint8* mac = new uint8[pcc->getTagLength()];

        pcc->srtpAuthenticate(this, guessedRoc, mac);
        if (memcmp(tag, mac, pcc->getTagLength()) != 0) {
            delete[] mac;
            return -1;
        }
        delete[] mac;

        /* Decrypt the content */
        pcc->srtpEncrypt( this, guessedIndex, cachedSSRC );

        /* Update the Crypto-context */
        pcc->update(cachedSeqNum);

        return 1;
}

#ifdef  CCXX_NAMESPACES
}
#endif

---

© sourcejam.com 2005-2008