diff -r 000000000000 -r 307788aac0a8 rtp/srtpstack/src/srtpcryptohandlersrtcp.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/rtp/srtpstack/src/srtpcryptohandlersrtcp.cpp Tue Feb 02 01:03:15 2010 +0200 @@ -0,0 +1,667 @@ +/* +* Copyright (c) 2004 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: . +* +*/ + + + + +// INCLUDES +#include +#include +#include "srtpcryptohandler.h" +#include "srtpcryptohandlersrtcp.h" +#include "srtppacketrtcp.h" +#include "srtppacketsrtcp.h" +#include "msrtpcryptohandlercontext.h" + +#include "srtputils.h" +#include "srtpmasterkey.h" +#include "srtpmastersalt.h" +#include "msrtpkeyderivation.h" +#include "msrtpcipher.h" +#include "srtpstream.h" +#include "srtpcryptoparams.h" +#include "srtpcipher_aescm128.h" +#include "srtpcipher_null.h" +#include "srtpauthentication_hmac_sha1.h" +#include "srtpauthentication_null.h" +#include "srtpauthentication_rcc.h" + +// --------------------------------------------------------------------------- +// CSRTPCryptoHandlerSRTCP::CSRTPCryptoHandlerSRTCP +// --------------------------------------------------------------------------- +// +CSRTPCryptoHandlerSRTCP::CSRTPCryptoHandlerSRTCP( CSRTPStream& aStream) + : CSRTPCryptoHandler(aStream) + {} + +// --------------------------------------------------------------------------- +// Two-phased constructor. +// +// --------------------------------------------------------------------------- +// +CSRTPCryptoHandlerSRTCP* CSRTPCryptoHandlerSRTCP::NewL(CSRTPStream& aStream) + { + CSRTPCryptoHandlerSRTCP* self = CSRTPCryptoHandlerSRTCP::NewLC( aStream); + CleanupStack::Pop( self ); + return self; + } + + +// ----------------------------------------------------------------------------- +// CSRTPCryptoHandlerSRTCP::NewLC +// ----------------------------------------------------------------------------- +// +EXPORT_C CSRTPCryptoHandlerSRTCP* CSRTPCryptoHandlerSRTCP::NewLC( CSRTPStream& aStream) + { + CSRTPCryptoHandlerSRTCP* self = new( ELeave )CSRTPCryptoHandlerSRTCP( aStream); + CleanupStack::PushL( self ); + self->ConstructL(); + return self; + } + +// --------------------------------------------------------------------------- +// CSRTPCryptoHandlerSRTCP::~CSRTPCryptoHandlerSRTCP +// --------------------------------------------------------------------------- +// +CSRTPCryptoHandlerSRTCP::~CSRTPCryptoHandlerSRTCP( ) + { + + } + + +// --------------------------------------------------------------------------- +// CSRTPCryptoHandlerSRTCP::ConstructL() +// --------------------------------------------------------------------------- +// +void CSRTPCryptoHandlerSRTCP::ConstructL() + { + //construct the upper class + CSRTPCryptoHandler::ConstructL(); + SetEncAndAuthL(CryptoParams().iSrtcpEncAlg, + CryptoParams().iSrtcpAuthAlg); + iReplayPktIndex=0; + iReplayIndexDelta=0; + iSRTCPMasterKeyLifeTime = CryptoParams().iMasterKeysLifeTime; + + if ( !iSRTCPMasterKeyLifeTime || + iSRTCPMasterKeyLifeTime > KSRTCPMaterKeysLifeTime ) + { + iSRTCPMasterKeyLifeTime = KSRTCPMaterKeysLifeTime; + } + } + +// --------------------------------------------------------------------------- +// void CSRTPCryptoHandlerSRTCP::MasterKeysUpdated() +// --------------------------------------------------------------------------- +// +TBool CSRTPCryptoHandlerSRTCP::MasterKeysUpdated() + { + return iMasterDataUpdated; + + } + + +// --------------------------------------------------------------------------- +// void CSRTPCryptoHandlerSRTCP::CheckMasterKeyIdentifierL() +// --------------------------------------------------------------------------- +// +void CSRTPCryptoHandlerSRTCP::CheckMasterKeyIdentifierL() + { + // RFC 3711, section 3.4): + // verify that this packet uses the same MKI + // than we have in CryptoContext + if(Context().MasterKey().MKI()!= KNullDesC8) + { + if (Context().MasterKey().MKI().Length() > 0) + { + TPtrC8 mki = iCurrentPacket->MasterKeyIdentifier(); + if (Context().MasterKey().MKI().Compare(mki) != 0) + { + // we can not process this packet, since MKI does not match + User::Leave(KErrNotFound); + } + } + } + } +// --------------------------------------------------------------------------- +// void CSRTPCryptoHandlerSRTCP::AuthenticateL() +// --------------------------------------------------------------------------- +// +void CSRTPCryptoHandlerSRTCP::AuthenticateL() + { + SRTP_DEBUG_DETAIL( "CSRTPCryptoHandlerSRTCP::AuthenticateL() entry" ); + if ( CryptoParams().iSrtcpAuthAlg != EAuthNull && + iCurrentPacket->AuthenticationTag().Length()==0) + { + User::Leave(KErrNotFound); + } + + if (iCurrentPacket->AuthenticationTag().Length()>0) + { + // calculate auth tag from the authenticated area.. + HBufC8* calculatedAuthTag = CalculateAuthTagL(); + CleanupStack::PushL(calculatedAuthTag); + SRTP_DEBUG_DETAIL( "SRTCP HMAC caculated Authentication tag" ); + SRTP_DEBUG_PACKET( *calculatedAuthTag ); + + // finally, compare the two auth tags.. + if (iCurrentPacket->AuthenticationTag().Compare( + *calculatedAuthTag) != 0) + { + // authentication failed, since tags dont match + SRTP_DEBUG_DETAIL( "authenticate tag is not match to caculated one" ); + User::Leave(KErrNotFound); + } + + // then, lose the auth tag we just calculated + CleanupStack::PopAndDestroy(calculatedAuthTag); + + } + SRTP_DEBUG_DETAIL( "CSRTPCryptoHandlerSRTCP::AuthenticateL() exit" ); + } + +// --------------------------------------------------------------------------- +// CSRTPCryptoHandlerSRTCP::CountIV_And_TransformL() +// --------------------------------------------------------------------------- +// +HBufC8* CSRTPCryptoHandlerSRTCP::CountIV_And_TransformL() + { + /* + RTCP case is different. + */ + SRTP_DEBUG_DETAIL( "CSRTPCryptoHandlerSRTCP::CountIV_And_TransformL entry" ); + //IV is 128 bit value + TBuf8<16> iv; + // set IV to be 128 bit, 16 octets + iv.SetLength(16); + + // count the IV for decryption + //RFC 3711 4.1.1 + TInt ret = TSRTPUtils::CountIV(iv, *iSessionSaltKey, SSRC(), iSRTCPIndexEStripped); + + SRTP_DEBUG_TUINT_VALUE( "SRTCP in ssrc" , SSRC()); + + if (ret!=KErrNone) + { + User::Leave(ret); + } + SRTP_DEBUG_DETAIL( "CSRTPCryptoHandlerSRTCP::CountIV_And_TransformL exit" ); + + // Step 5, encryption (in RFC 3711, section 3.3): + return iCipher->TransformL( *iSessionEncrKey, + iv, iCurrentPacket->Payload() ); + } + +// --------------------------------------------------------------------------- +// CSRTPCryptoHandlerSRTCP::EncryptL() +// --------------------------------------------------------------------------- +// +HBufC8* CSRTPCryptoHandlerSRTCP::EncryptL() + { + SRTP_DEBUG_DETAIL( "CSRTPCryptoHandlerSRTCP::EncryptL() entry" ); + + HBufC8* encryptedPayload = CountIV_And_TransformL(); + CleanupStack::PushL(encryptedPayload); + + TUint8* encryptedPayloadPtr = const_cast(encryptedPayload->Des().Ptr()); + + HBufC8* srtpPacket = iCurrentPacket->CreateEncryptedPacketL(encryptedPayloadPtr); + CleanupStack::PushL(srtpPacket); + + TUint8* srtpPacketPtr = const_cast(srtpPacket->Des().Ptr()); + + //Step 6, Add E flag and SRTCP Index (RFC 3711 section 3.4) + AddEflagAndSrtcpIndex(srtpPacketPtr); + //Step 7, Add MKI (in RFC 3711, section 3.3): + AddMKIToPacket(srtpPacketPtr); + + //Step 8, Add authentication tag (in RFC 3711, section 3.3): + AddAuthTagToPacketL(srtpPacketPtr); + + + CleanupStack::Pop(srtpPacket); + SRTP_DEBUG_DETAIL( "Encrypted Payload" ); + SRTP_DEBUG_PACKET( *encryptedPayload ); + + CleanupStack::PopAndDestroy(encryptedPayload); + iNumPackets++; + + SRTP_DEBUG_DETAIL( "CSRTPCryptoHandlerSRTCP::EncryptL() exit" ); + + return srtpPacket; + } + +// --------------------------------------------------------------------------- +// CSRTPCryptoHandlerSRTCP::DecryptL() +// --------------------------------------------------------------------------- +// +HBufC8* CSRTPCryptoHandlerSRTCP::DecryptL() + { + SRTP_DEBUG_DETAIL( "CSRTPCryptoHandlerSRTCP::DecryptL() entry" ); + // Step 6, decryption (in RFC 3711, section 3.3): + HBufC8* decryptedPayload = CountIV_And_TransformL(); + CleanupStack::PushL(decryptedPayload); + + TUint8* decryptedPayloadPtr = const_cast(decryptedPayload->Des().Ptr()); + HBufC8* rtpPacket = iCurrentPacket->CreateDecryptedPacketL(decryptedPayloadPtr); + TUint8* rtpPacketPtr = const_cast(rtpPacket->Des().Ptr()); + SRTP_DEBUG_DETAIL( "SRTCP Decrypt Payload" ); + SRTP_DEBUG_PACKET( *decryptedPayload ); + + CleanupStack::PopAndDestroy(decryptedPayload); + + SRTP_DEBUG_DETAIL( "CSRTPCryptoHandlerSRTCP::DecryptL() exit" ); + + return rtpPacket; + } + +// --------------------------------------------------------------------------- +// CSRTPCryptoHandlerSRTCP::AddMKIToPacket +// +// --------------------------------------------------------------------------- +// +void CSRTPCryptoHandlerSRTCP::AddMKIToPacket(TUint8* aSrtpPacketPtr) + { + TUint8* ptr = aSrtpPacketPtr; + if( Context().MasterKey().MKI()!= KNullDesC8) + { + //Step 6, Add MKI (in RFC 3711, section 3.3): + if (Context().MasterKey().MKI().Length()>0 ) + { + ptr += iCurrentPacket->HeaderLength(); + ptr += iCurrentPacket->PayloadLength(); + ptr += KSRTCPPacketIndexLength4; + TUint8* mkiPtr = const_cast(Context().MasterKey().MKI().Ptr()); + Mem::Copy( ptr, mkiPtr, Context().MasterKey().MKI().Length()); + } + } + } +// --------------------------------------------------------------------------- +// CSRTPCryptoHandlerSRTCP::AddAuthTagToPacketL +// +// --------------------------------------------------------------------------- +// +void CSRTPCryptoHandlerSRTCP::AddAuthTagToPacketL(TUint8* aSrtpPacketPtr) + { + TUint8* ptr = aSrtpPacketPtr; + + //Step 7, Add authentication tag (in RFC 3711, section 3.3): + if ( CryptoParams().iSrtcpAuthTagLen>0) + { + ptr += iCurrentPacket->HeaderLength(); + ptr += iCurrentPacket->PayloadLength(); + ptr += KSRTCPPacketIndexLength4 ; /*srtcp index length*/ + if(Context().MasterKey().MKI()!= KNullDesC8) + { + ptr += Context().MasterKey().MKI().Length(); + } + //Copy the authenticatin portion only not with MKI key part + //RFC 3711 3.4 SRCP authentication portion including index + TInt len= iCurrentPacket->HeaderLength() + iCurrentPacket->PayloadLength() + + KSRTCPPacketIndexLength4 /*SRTCP index length*/; + HBufC8* authPortion = HBufC8::NewMaxLC(len); + TUint8* authptr = const_cast(authPortion->Des().Ptr()); + Mem::Copy( authptr, aSrtpPacketPtr, len); + authPortion->Des().SetLength(len); + + HBufC8* authTag = DoAuthenticationL(*authPortion, KNullDesC8); + + + CleanupStack::PopAndDestroy( authPortion ); + authPortion=NULL; + + + Mem::Copy( ptr, authTag->Ptr(), authTag->Length()); + delete authTag; + authTag=NULL; + } + } +// --------------------------------------------------------------------------- +// CSRTPCryptoHandlerSRTCP::CalculateAuthTagL() +// --------------------------------------------------------------------------- +// +HBufC8* CSRTPCryptoHandlerSRTCP::CalculateAuthTagL() + { + //RFC 3711 3.4 SRCP authentication portion including index + // that is, M = header + payload (Report block) + SRTCP indexp + + // calculate auth tag from the authenticated area.. + + TInt len= iCurrentPacket->HeaderLength() + + iCurrentPacket->PayloadLength() +4; /*SRTCP index length*/ + HBufC8* authPortion = iCurrentPacket->Get_Concatenated_MDataL(ETrue); + CleanupStack::PushL( authPortion ); + authPortion->Des().SetLength(len); + + HBufC8* calculatedAuthTag = DoAuthenticationL(*authPortion, KNullDesC8); + + // then, lose authPortion buffer + + CleanupStack::PopAndDestroy( authPortion ); + authPortion= NULL; + + return calculatedAuthTag; + } + +// --------------------------------------------------------------------------- +// CSRTPCryptoHandlerSRTCP::DoAuthenticationL +// +// --------------------------------------------------------------------------- +// +HBufC8* CSRTPCryptoHandlerSRTCP::DoAuthenticationL(const TDesC8& aAuthenticatedArea, + const TDesC8& aRoc) + { + // calculate auth tag from the authenticated area.. + TUint authtaglen= CryptoParams().iSrtcpAuthTagLen; + // Note that RCCm3 work as Auth Null so taglen does not matter to RTP/RTCP + if (aRoc.Length() && + (CryptoParams().iSrtcpAuthAlg == EAuthRCCm1 || + CryptoParams().iSrtcpAuthAlg == EAuthRCCm2 )) + { + authtaglen-= KSRTPAuthTagLength32 ; + } + if ((!aRoc.Length()) && + ( CryptoParams().iSrtcpAuthAlg != EAuthNull && + CryptoParams().iSrtcpAuthAlg != EAuthHMAC_SHA1)) + { + //This is for RTCP if using RCC mode because currently handler sharing + //the same context + authtaglen=KSRTPAuthTagDefaultLength; + } + return iAuthenticator->AuthenticateL(authtaglen, + *iSessionAuthKey, + aAuthenticatedArea, + aRoc); + } + +// --------------------------------------------------------------------------- +// void CSRTPCryptoHandlerSRTCP::InitializePlainPacketL() +// --------------------------------------------------------------------------- +// +void CSRTPCryptoHandlerSRTCP::InitializePlainPacketL(const TDesC8& aPacket) + { + if(iCurrentPacket) + delete iCurrentPacket;iCurrentPacket = NULL; + iCurrentPacket = CSRTPPacketRTCP::NewL(aPacket, *this); + } + +// --------------------------------------------------------------------------- +// void CSRTPCryptoHandlerSRTCP::InitializeEncryptedPacketL() +// --------------------------------------------------------------------------- +// +void CSRTPCryptoHandlerSRTCP::InitializeEncryptedPacketL(const TDesC8& aPacket) + { + if(iCurrentPacket) + delete iCurrentPacket;iCurrentPacket = NULL; + iCurrentPacket = CSRTPPacketSRTCP::NewL(aPacket, *this); + } + +// --------------------------------------------------------------------------- +// CSRTPCryptoHandlerSRTCP::DeriveSessionKeysL() +// --------------------------------------------------------------------------- +// +void CSRTPCryptoHandlerSRTCP::DeriveSessionKeysL() + { + SRTP_DEBUG_DETAIL( "CSRTPCryptoHandlerSRTCP::DeriveSessionKeysL() Entry" ); + + TBuf8<100> sessionKey_X; + DeleteSessionKeys(); + + TUint64 r = TSRTPUtils::Cnt_r(iSRTCPIndexEStripped, + CryptoParams().iSrtcpKeyDervRate); + + // session encryption key + //sessionKey_X.SetLength(Context()->MasterKey().EncrKeyLength()); + sessionKey_X.SetLength(100); + // session encryption key derivation : + sessionKey_X.FillZ(); + Count_X(r, KSRTCPEncryptionLabel, KSRTPIndexLength, sessionKey_X); + iSessionEncrKey = iKeyDeriver->PRF_128BitL(Context().MasterKey().EncrKeyLength(), + Context().MasterKey().MasterKey(), + sessionKey_X); + SRTP_DEBUG_DETAIL( "SRTCP iSessionEncrKey as CipherKey " ); + SRTP_DEBUG_PACKET( *iSessionEncrKey ); + + // session authentication key + sessionKey_X.FillZ(); + //sessionKey_X.SetLength(Context()->MasterKey().AuthKeyLength()); + Count_X(r, KSRTCPAuthenticationLabel, KSRTPIndexLength, sessionKey_X); + iSessionAuthKey = iKeyDeriver->PRF_128BitL(Context().MasterKey().AuthKeyLength(), + Context().MasterKey().MasterKey(), + sessionKey_X); + + SRTP_DEBUG_DETAIL( "SRTCP iSessionAuthKey" ); + SRTP_DEBUG_PACKET( *iSessionAuthKey); + + // session salt key + sessionKey_X.FillZ(); + //sessionKey_X.SetLength(Context()->MasterSalt().SaltLength()); + Count_X(r, KSRTCPSaltingLabel, KSRTPIndexLength, sessionKey_X); + iSessionSaltKey = iKeyDeriver->PRF_128BitL(Context().MasterSalt().SaltLength(), + Context().MasterKey().MasterKey(), + sessionKey_X); + SRTP_DEBUG_DETAIL( "SRTCP iSessionSaltKey" ); + SRTP_DEBUG_PACKET( *iSessionSaltKey ); + + + iMasterDataUpdated = EFalse; + SRTP_DEBUG_DETAIL( "CSRTPCryptoHandlerSRTCP::DeriveSessionKeysL() Exit" ); + + } + + +// --------------------------------------------------------------------------- +// CSRTPCryptoHandlerSRTCP::StripEBit() +// --------------------------------------------------------------------------- +// +void CSRTPCryptoHandlerSRTCP::StripEBit() + { + // strip the Ebit away + iSRTCPIndexEStripped = iSRTCPIndex ^ 0x80000000; + } + + +// --------------------------------------------------------------------------- +// void CSRTPCryptoHandlerSRTCP::ReplayProtectionL() +// --------------------------------------------------------------------------- +// +void CSRTPCryptoHandlerSRTCP::ReplayProtectionL() + { + if ( CryptoParams().iSrtcpReplayProtection) + { + TInt delta =0; + delta= iSRTCPIndexEStripped/*updated one*/ - iReplayPktIndex; //set as 0 + + //Index check + if ( CryptoParams().iSrtcpReplayProtection) + { + User::LeaveIfError (ReplayCheck(delta)); + } + //if the index is inside the replay window and index does not appear in rdb + //then Index add after authentication passed + iReplayIndexDelta= delta; + } + } + +// --------------------------------------------------------------------------- +// CSRTPCryptoHandlerSRTCP::CountSenderPacketIndex() +// --------------------------------------------------------------------------- +// +void CSRTPCryptoHandlerSRTCP::CountSenderPacketIndexL() + { + //Re-Key was needed earlier but key has not yet been updated + //iReKey is false + //Call it after each packet has been sent + //TReal modulus(0x10000000); + TReal twoexp31= 0x80000000; + + TReal srtcpindexincremented= iSRTCPIndexEStripped+1; + TReal result; + TInt32 intResult; + // count (ROC - 1) mod 2^31 + + TInt res = Math::Mod(result, srtcpindexincremented, twoexp31); + if (res!=KErrNone) + { + User::Leave(res); + } + + intResult = (TUint)result; + + iSRTCPIndexEStripped = intResult; + // E bit set to 1 indicates encrpted pacet 0 otherwise + iSRTCPIndex =0x00000000; + if (CryptoParams().iSrtcpEncAlg!=ENullAlg) + { + iSRTCPIndex =0x80000000; + } + + iSRTCPIndex = iSRTCPIndex + iSRTCPIndexEStripped; + iCurrentPacket->SetPacketIndex(iSRTCPIndex); + //Checking next Index if Keys needed to be renew + IndexReKeyCheckL(); + } + +// --------------------------------------------------------------------------- +// CSRTPCryptoHandlerSRTCP::ReceiverPacketIndexL() +// --------------------------------------------------------------------------- +// +void CSRTPCryptoHandlerSRTCP::ReceiverPacketIndexL() + { + if (iReKey) + { + //Re-Key was needed earlier but key has not yet been updated + User::Leave(KErrTooBig); + } + /* Can be done in the Replay protection + if (iCurrentPacket->PacketIndex()PacketIndex(); + //Strip EBit only when the encAlg is not NULL + if (CryptoParams().iSrtcpEncAlg!=ENullAlg) + StripEBit(); + IndexReKeyCheckL(); + } +// --------------------------------------------------------------------------- +// CSRTPCryptoHandlerSRTCP::InitialPacketIndex() +// --------------------------------------------------------------------------- +// +void CSRTPCryptoHandlerSRTCP::InitialPacketIndex() + { + //iSRTCPIndexEStripped=0x00; + iSRTCPIndex =0x80000000; + StripEBit(); + iSRTCPIndex = iSRTCPIndex + iSRTCPIndexEStripped; + iCurrentPacket->SetPacketIndex(iSRTCPIndex); + } + +// --------------------------------------------------------------------------- +// CSRTPCryptoHandlerSRTCP::AddEflagAndSrtcpIndex() +// --------------------------------------------------------------------------- +// +void CSRTPCryptoHandlerSRTCP::AddEflagAndSrtcpIndex(TUint8* aSrtcpPacketPtr) + { + //EBit set to 1 as hardcoded + + TUint8* ptr = aSrtcpPacketPtr; + + //Step 6, Add E flag and SRTCP Index (RFC 3711 section 3.4) + + ptr += iCurrentPacket->HeaderLength(); + ptr += iCurrentPacket->PayloadLength(); + //EBit set to 1 indicates encryted packet, otherwise set to 0 + if (CryptoParams().iSrtcpEncAlg!=ENullAlg ) + { + TSRTPUtils::Write32( ptr, iSRTCPIndex ); + } + else + { + TSRTPUtils::Write32( ptr, iSRTCPIndexEStripped); + } + + } +// --------------------------------------------------------------------------- +// CSRTPCryptoHandlerSRTCP::IndexReKeyCheck() +// --------------------------------------------------------------------------- +// +void CSRTPCryptoHandlerSRTCP::IndexReKeyCheckL() + { + TReal twoexp31= 0x80000000; + + TReal srtcpIndexIncremented= iSRTCPIndexEStripped+1; + TReal remainder; + + + + TInt res = Math::Mod(remainder, srtcpIndexIncremented, twoexp31); + if (res!=KErrNone) + { + User::Leave(res); + } + if (remainder == 0.0 && iSRTCPIndexEStripped != 0) + { + //RFC 3711 8.1 & 9.2 + iReKey = ETrue; + iStream.KeyExpired(); + //called incase the packets index is big in the begining + iStream.ReKeyNeeded(); + } + //should create function for checking.when value is bigger + TUint64 reKeyNumPacket = iNumPackets + KLeftNumOfPacketBeforeReKey; + // Re-key only call one time when there are 100 number packets left to send/recv + if ( ( reKeyNumPacket ) == iSRTCPMasterKeyLifeTime ) + { + iStream.ReKeyNeeded(); + } + //Key is really expired + if ( iNumPackets >= iSRTCPMasterKeyLifeTime ) + { + iReKey = ETrue; + iStream.KeyExpired(); + } + } + + // --------------------------------------------------------------------------- +// CSRTPCryptoHandlerSRTCP::AddReplayIndex() +// --------------------------------------------------------------------------- +// +void CSRTPCryptoHandlerSRTCP::AddReplayIndex() + { + if (CryptoParams().iSrtcpReplayProtection) + { + if (iReplayIndexDelta > 0) + { + /* shift forward by delta */ + iReplayPktIndex = iSRTCPIndexEStripped; + } + else + { + /* delta is in window, so flip bit in bitmask */ + /* mark as seen */ + TInt diff= -(iReplayIndexDelta); + iBitmap |= ((TUint64)1 << diff); + } + /* note that we need not consider the case that delta == 0 */ + } + //Add Number of packets received + iNumPackets++; + }