jni/ccrtp-1.8.0-android/src/rtppkt.cpp - jami-client-android - Gitiles

 // Copyright (C) 1999-2005 Open Source Telecom Corporation.
 // Copyright (C) 2006-2010 David Sugar, Tycho Softworks.
 //
 // 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.
 //

 /**
  * @file rtppkt.cpp
  * @short StaticPayloadFormat, DynamicPayloadFormat, RTPPacket,
  * OutgoingRTPPkt and IncomingRTPPkt classes implementation.
  **/

 #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
 }

 void RTPPacket::reComputePayLength(bool padding)
 {
     // If payloadsize was computed without padding set then re-compute
     // payloadSize after the padding bit was set and set padding flag
     // in RTP header - option for SRTP
     if (padding) {
         size_t len = 0;
         getHeader()->padding = 1;
         len -= buffer[payloadSize - 1];
         payloadSize = (uint32)(payloadSize - len);
     }
 }

 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

 /** EMACS **
  * Local variables:
  * mode: c++
  * c-basic-offset: 4
  * End:
  */
	// Copyright (C) 1999-2005 Open Source Telecom Corporation.
	// Copyright (C) 2006-2010 David Sugar, Tycho Softworks.
	//
	// 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.
	//

	/**
	* @file rtppkt.cpp
	* @short StaticPayloadFormat, DynamicPayloadFormat, RTPPacket,
	* OutgoingRTPPkt and IncomingRTPPkt classes implementation.
	**/

	#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
	}

	void RTPPacket::reComputePayLength(bool padding)
	{
	// If payloadsize was computed without padding set then re-compute
	// payloadSize after the padding bit was set and set padding flag
	// in RTP header - option for SRTP
	if (padding) {
	size_t len = 0;
	getHeader()->padding = 1;
	len -= buffer[payloadSize - 1];
	payloadSize = (uint32)(payloadSize - len);
	}
	}

	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

	/ EMACS
	* Local variables:
	* mode: c++
	* c-basic-offset: 4
	* End:
	*/