--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/rtp/srtpstack/tsrc/ut_srtpstack/src/UT_CSRTPStreamIn.cpp Tue Feb 02 01:03:15 2010 +0200
@@ -0,0 +1,1123 @@
+/*
+* 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:
+*
+*/
+
+
+
+
+// CLASS HEADER
+#include "UT_CSRTPStreamIn.h"
+#include "srtputils.h"
+
+// CONSTANTS
+const TInt KRtpVersion = 2; // Current protocol version
+const TUint KMinRtpHeaderLen( 12 );
+const TUint16 KTestSeqNr17 = 17171;
+const TUint16 KTestSeqNr18 = 17172;
+const TInt KLength = 50;
+
+// 80 bit key, test 1
+_LIT8(KTestPayload160Bits, "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
+
+// 80 bit key, test 1
+//_LIT8(KTestMKI128Bits, "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB");
+_LIT8(KTestMKI128Bits, "ABCDEF1234567890ABCDEF1234567890");
+
+// 80 bit key, test 1
+_LIT8(KTestAuthTag80Bits, "CCCCCCCCCCCCCCCCCCCC");
+
+
+_LIT8(KRFC3711_TestMasterKey128bits, "E1F97A0D3E018BE0D64FA32C06DE4139");
+_LIT8(KRFC3711_TestMasterSalt112bits, "0EC675AD498AFEEBB6960B3AABE6");
+_LIT8(KRFC3711_SessionEncrKey128bits, "C61E7A93744F39EE10734AFE3FF7A087");
+_LIT8(KRFC3711_SessionSaltKey128bits, "30CBBC08863D8C85D49DB34A9AE1");
+_LIT8(KRFC3711_SessionAuthKey128bits, "CEBE321F6FF7716B6FD4AB49AF256A156D38BAA4");
+
+_LIT8(KRFC3711_RtcpEncrKey128bits, "4C1AA45A81F73D61C800BBB00FBB1EAA");
+_LIT8(KRFC3711_RtcpSaltKey128bits, "9581C7AD87B3E530BF3E4454A8B3");
+_LIT8(KRFC3711_RtcpAuthKey128bits, "8D54534FEB49AE8E7993A6BD0B844FC323A93DFD");
+
+_LIT8(KDecryptedPayload, "2EDE3286C6E33E68C6BB93350620A1245EC0004F");
+
+_LIT8(KTestM_without_ROC, "123456789ABCDE");
+_LIT8(KRefM_with_ROC, "123456789ABCDEFFFFFFFF");
+
+_LIT8(KTestAuthTag, "D07919ABC9F235CB4516");
+_LIT8(KDummyRTCPPacket, "dummyrtcp");
+_LIT8(KRTCPPacket, "80C90001DEADBEEF9E30159059A23363F0FBDB62DC85AF52875C944495C5B00280000001ABCDEF1234567890ABCDEF1234567890DFC98F01DE16DA30F20D");
+
+_LIT8(KSRTCPPacket2, "80C90001DEADBEEF2BC095F51495D87D35B816BE569A6A1BA6989D5A20B541D680000002ABCDEF1234567890ABCDEF12345678905140BA93E8CDAC0C89D5");
+
+
+// EXTERNAL INCLUDES
+#include <digia/eunit/eunitmacros.h>
+#include "srtpcryptohandlersrtp.h"
+#include "srtpcryptohandlersrtcp.h"
+#include "srtpmastersalt.h"
+#include "srtpmasterkey.h"
+#include "srtpstreamin.h"
+#include "srtpsession.h"
+#include "srtputils.h"
+
+
+
+// INTERNAL INCLUDES
+#include "srtpstreamin.h"
+
+// CONSTRUCTION
+UT_CSRTPStreamIn* UT_CSRTPStreamIn::NewL()
+ {
+ UT_CSRTPStreamIn* self = UT_CSRTPStreamIn::NewLC();
+ CleanupStack::Pop();
+
+ return self;
+ }
+
+UT_CSRTPStreamIn* UT_CSRTPStreamIn::NewLC()
+ {
+ UT_CSRTPStreamIn* self = new( ELeave ) UT_CSRTPStreamIn();
+ CleanupStack::PushL( self );
+
+ self->ConstructL();
+
+ return self;
+ }
+
+// Destructor (virtual by CBase)
+UT_CSRTPStreamIn::~UT_CSRTPStreamIn()
+ {
+ }
+
+// Default constructor
+UT_CSRTPStreamIn::UT_CSRTPStreamIn()
+ {
+ }
+
+UT_CSRTPStreamIn::TPayloadDetails::TPayloadDetails() :
+ seqNr(),
+// ssrc(),
+ padding(0),
+ numCSRC(0),
+ fHeaderExtension(EFalse),
+ payloadLen(0),
+ payloadData(NULL),
+ MKILen(0),
+ MKIData(NULL),
+ authTagLen(0),
+ authTagData(NULL)
+ {
+ }
+
+void UT_CSRTPStreamIn::SRTPMasterKeyStaleEvent(const CSRTPStream& /*aStream*/ )
+ {
+ }
+void UT_CSRTPStreamIn::SRTPMasterKeyStaleEvent(const CSRTPSession& /*aSession*/ )
+ {
+ }
+
+// Second phase construct
+void UT_CSRTPStreamIn::ConstructL()
+ {
+ // The ConstructL from the base class CEUnitTestSuiteClass must be called.
+ // It generates the test case table.
+ CEUnitTestSuiteClass::ConstructL();
+ }
+
+// METHODS
+
+
+void UT_CSRTPStreamIn::Hex(HBufC8& aString)
+{
+ TPtr8 ptr=aString.Des();
+ TInt length = aString.Length();
+ if (aString.Length()%2)
+ {
+ ptr.SetLength(0);
+ return;
+ }
+ TInt i;
+ for (i=0;i<aString.Length();i+=2)
+ {
+ TUint8 tmp;
+ tmp=(TUint8)(aString[i]-(aString[i]>'9'?('A'-10):'0'));
+ tmp*=16;
+ tmp|=(TUint8)(aString[i+1]-(aString[i+1]>'9'?('A'-10):'0'));
+ ptr[i/2]=tmp;
+ }
+ ptr.SetLength(aString.Length()/2);
+
+}
+
+// ---------------------------------------------------------------------------
+// UT_CSRTPStreamIn::BuildSrtpPacketL()
+//
+// ---------------------------------------------------------------------------
+//
+HBufC8* UT_CSRTPStreamIn::BuildPacketL(TBool aSrtp, TPayloadDetails& details)
+ {
+ TUint packetSize = KMinRtpHeaderLen + details.payloadLen;
+ TUint payloadStartOffset = KMinRtpHeaderLen;
+ TUint8 padCount = 0;
+
+ packetSize += details.numCSRC*4;
+ payloadStartOffset += details.numCSRC*4;
+
+ if (details.fHeaderExtension)
+ {
+ packetSize += 4;
+ payloadStartOffset += 4;
+ }
+
+ if (details.padding)
+ {
+ padCount = 3;
+ }
+
+ packetSize += padCount;
+
+ if (aSrtp)
+ {
+ packetSize += details.MKILen;
+ packetSize += details.authTagLen;
+ }
+
+
+ HBufC8* packet = HBufC8::NewMaxL(packetSize);
+ TUint8* dataP = const_cast<TUint8*>( packet->Des().Ptr() );
+ TUint8* ptr = dataP;
+ Mem::FillZ( ptr, packetSize);
+
+ // padding (1 bit)
+ ptr[0] |= static_cast<TUint8>( details.padding << 5 );
+
+ // header extension (1 bit)
+ if ( details.fHeaderExtension )
+ {
+ ptr[0] |= ( 1 << 4 );
+ }
+
+ if (details.numCSRC)
+ {
+ // CC
+ ptr[0] |= details.numCSRC;
+ }
+
+ //sequence number
+ ptr+=2;
+ TSRTPUtils::Write16( ptr, details.seqNr );
+
+ //ssrc
+ /*
+ ptr+=6;
+ if (details.ssrc)
+ {
+ Mem::Copy( ptr, details.ssrc, 4 );
+ }
+ */
+ //payload
+ ptr = dataP + payloadStartOffset;
+ if (details.payloadData)
+ {
+ Mem::Copy( ptr, details.payloadData, details.payloadLen );
+ }
+
+ if (aSrtp)
+ {
+ //MKI
+ ptr = dataP + payloadStartOffset + details.payloadLen + padCount;
+ if (details.MKILen > 0)
+ {
+ Mem::Copy( ptr, details.MKIData, details.MKILen );
+ }
+ ptr = dataP + payloadStartOffset + details.payloadLen + padCount + details.MKILen;
+ if (details.authTagLen==14)
+ {
+ details.authTagLen=10;
+ TSRTPUtils::Write32( ptr,0);
+ ptr+=4;
+ }
+ //auth tag
+
+ if (details.authTagLen > 0)
+ {
+ Mem::Copy( ptr, details.authTagData, details.authTagLen );
+ }
+ }
+
+ return packet;
+ }
+
+
+
+void UT_CSRTPStreamIn::SetupL( )
+ {
+
+ iDecryptedPayload = HBufC8::NewL(KDecryptedPayload().Length());
+ *iDecryptedPayload = KDecryptedPayload;
+ Hex(*iDecryptedPayload);
+ iDecryptedPayload->Des().SetLength(20);
+
+ iRFC3711_SessionEncrKey128bits = HBufC8::NewL(KRFC3711_SessionEncrKey128bits().Length());
+ *iRFC3711_SessionEncrKey128bits = KRFC3711_SessionEncrKey128bits;
+ Hex(*iRFC3711_SessionEncrKey128bits);
+
+ iRFC3711_SessionSaltKey128bits = HBufC8::NewL(KRFC3711_SessionSaltKey128bits().Length());
+ *iRFC3711_SessionSaltKey128bits = KRFC3711_SessionSaltKey128bits;
+ Hex(*iRFC3711_SessionSaltKey128bits);
+
+ iRFC3711_SessionAuthKey128bits = HBufC8::NewL(KRFC3711_SessionAuthKey128bits().Length());
+ *iRFC3711_SessionAuthKey128bits = KRFC3711_SessionAuthKey128bits;
+ Hex(*iRFC3711_SessionAuthKey128bits);
+
+ iRFC3711_RtcpEncrKey128bits = HBufC8::NewL(KRFC3711_RtcpEncrKey128bits().Length());
+ *iRFC3711_RtcpEncrKey128bits = KRFC3711_RtcpEncrKey128bits;
+ Hex(*iRFC3711_RtcpEncrKey128bits);
+
+ iRFC3711_RtcpSaltKey128bits = HBufC8::NewL(KRFC3711_RtcpSaltKey128bits().Length());
+ *iRFC3711_RtcpSaltKey128bits = KRFC3711_RtcpSaltKey128bits;
+ Hex(*iRFC3711_RtcpSaltKey128bits);
+
+ iRFC3711_RtcpAuthKey128bits = HBufC8::NewL(KRFC3711_RtcpAuthKey128bits().Length());
+ *iRFC3711_RtcpAuthKey128bits = KRFC3711_RtcpAuthKey128bits;
+ Hex(*iRFC3711_RtcpAuthKey128bits);
+
+
+
+ iTestPayload160Bits = HBufC8::NewL(KTestPayload160Bits().Length());
+ *iTestPayload160Bits = KTestPayload160Bits;
+ Hex(*iTestPayload160Bits);
+
+
+ // our test MKI is 16 bit long:
+ // ABCDEF1234567890ABCDEF1234567890
+
+ HBufC8* masterKey = HBufC8::NewL(KRFC3711_TestMasterKey128bits().Length());
+ CleanupStack::PushL( masterKey );
+ *masterKey = KRFC3711_TestMasterKey128bits;
+
+
+
+ HBufC8* masterSalt =HBufC8::NewL(KRFC3711_TestMasterSalt112bits().Length());
+ CleanupStack::PushL( masterSalt);
+ *masterSalt = KRFC3711_TestMasterSalt112bits;
+
+
+ HBufC8* mki =HBufC8::NewL(KTestMKI128Bits().Length());
+ CleanupStack::PushL( mki);
+ *mki = KTestMKI128Bits;
+ Hex(*mki);
+
+ iMasterKey = CSRTPMasterKey::NewL( *masterKey, *mki );
+ iMasterSalt = CSRTPMasterSalt::NewL( *masterSalt );
+
+
+ TSrtpCryptoParams params;
+ iContext = CSRTPCryptoContext::NewL(iMasterKey, iMasterSalt, params );
+ CleanupStack::PopAndDestroy( mki );
+ CleanupStack::PopAndDestroy( masterSalt );
+ CleanupStack::PopAndDestroy( masterKey );
+ iDestination.Input(_L("127.0.0.1"));
+
+
+
+ iSRTPSession = CSRTPSession::NewL( iDestination, iContext, *this );
+ iStreamIn = CSRTPStreamIn::NewL(*iSRTPSession, (TUint)1);
+ iStreamInLateBD = CSRTPStreamIn::NewL(*iSRTPSession);
+ iCryptoHandlerSRTP = iStreamIn->iHandlerRTP;
+ iCryptoHandlerSRTCP =iStreamIn->iHandlerRTCP;
+ iCryptoHandlerSRTP2 = iStreamInLateBD->iHandlerRTP;
+ iCryptoHandlerSRTCP2 =iStreamInLateBD->iHandlerRTCP;
+ }
+
+
+void UT_CSRTPStreamIn::Teardown( )
+ {
+ delete iDecryptedPayload;
+ delete iTestPayload160Bits;
+
+
+ delete iStreamIn;
+ delete iStreamInLateBD;
+ delete iSRTPSession;
+
+
+ delete iRFC3711_SessionEncrKey128bits;
+ delete iRFC3711_SessionSaltKey128bits;
+ delete iRFC3711_SessionAuthKey128bits;
+ delete iRFC3711_RtcpEncrKey128bits;
+ delete iRFC3711_RtcpSaltKey128bits;
+ delete iRFC3711_RtcpAuthKey128bits;
+ }
+
+void UT_CSRTPStreamIn::UT_CSRTPStreamIn_NewL_1L( )
+ {
+ CSRTPStreamIn* tempStreamIn = CSRTPStreamIn::NewL(*iSRTPSession, (TUint)1);
+ EUNIT_ASSERT(tempStreamIn->SSRC()== 1);
+ delete tempStreamIn;
+ }
+
+void UT_CSRTPStreamIn::UT_CSRTPStreamIn_NewL_2L( )
+ {
+ HBufC8* masterKey = HBufC8::NewL(KRFC3711_TestMasterKey128bits().Length());
+ CleanupStack::PushL( masterKey );
+ *masterKey = KRFC3711_TestMasterKey128bits;
+
+
+ HBufC8* masterSalt =HBufC8::NewL(KRFC3711_TestMasterSalt112bits().Length());
+ CleanupStack::PushL( masterSalt);
+ *masterSalt = KRFC3711_TestMasterSalt112bits;
+
+
+ HBufC8* mki =HBufC8::NewL(KTestMKI128Bits().Length());
+ CleanupStack::PushL( mki);
+ *mki = KRFC3711_TestMasterSalt112bits;
+ Hex(*mki);
+ TSrtpCryptoParams params;
+ CSRTPMasterKey* masterkey = CSRTPMasterKey::NewLC( *masterKey, *mki );
+ CSRTPMasterSalt* mastersalt = CSRTPMasterSalt::NewLC( *masterSalt );
+ CSRTPCryptoContext* context = CSRTPCryptoContext::NewL(masterkey, mastersalt, params );
+ CleanupStack::Pop( mastersalt );
+ CleanupStack::Pop( masterkey );
+ CleanupStack::PopAndDestroy( mki );
+ CleanupStack::PopAndDestroy( masterSalt );
+ CleanupStack::PopAndDestroy( masterKey );
+ CleanupStack::PushL( context );
+ CSRTPSession* srtpSession = CSRTPSession::NewL( iDestination, context, *this );
+ CleanupStack::Pop( context );
+ CleanupStack::PushL( srtpSession );
+ CSRTPStreamIn* tempStreamIn =CSRTPStreamIn::NewL( *srtpSession,
+ (TUint)1,
+ *this );
+ EUNIT_ASSERT(tempStreamIn->SSRC()== 1);
+ delete tempStreamIn;
+ CleanupStack::PopAndDestroy( srtpSession );
+ }
+
+void UT_CSRTPStreamIn::UT_CSRTPStreamIn_NewL_3L( )
+ {
+ HBufC8* masterKey = HBufC8::NewL(KRFC3711_TestMasterKey128bits().Length());
+ CleanupStack::PushL( masterKey );
+ *masterKey = KRFC3711_TestMasterKey128bits;
+
+
+ HBufC8* masterSalt =HBufC8::NewL(KRFC3711_TestMasterSalt112bits().Length());
+ CleanupStack::PushL( masterSalt);
+ *masterSalt = KRFC3711_TestMasterSalt112bits;
+
+
+ HBufC8* mki =HBufC8::NewL(KTestMKI128Bits().Length());
+ CleanupStack::PushL( mki);
+ *mki = KRFC3711_TestMasterSalt112bits;
+ Hex(*mki);
+ TSrtpCryptoParams params;
+ CSRTPMasterKey* masterkey = CSRTPMasterKey::NewLC( *masterKey, *mki );
+ CSRTPMasterSalt* mastersalt = CSRTPMasterSalt::NewLC( *masterSalt );
+ CSRTPCryptoContext* context = CSRTPCryptoContext::NewL(masterkey, mastersalt, params );
+
+ CleanupStack::Pop( mastersalt );
+ CleanupStack::Pop( masterkey );
+ CleanupStack::PopAndDestroy( mki );
+ CleanupStack::PopAndDestroy( masterSalt );
+ CleanupStack::PopAndDestroy( masterKey );
+ CleanupStack::PushL( context );
+ CSRTPSession* srtpSession = CSRTPSession::NewL( iDestination, context, *this );
+ CleanupStack::Pop( context );
+ CleanupStack::PushL( srtpSession );
+ CSRTPStreamIn* tempStreamIn =CSRTPStreamIn::NewL( *srtpSession);
+
+ EUNIT_ASSERT(tempStreamIn->GetCryptoContext().Valid()==ETrue);
+ delete tempStreamIn;
+ CleanupStack::PopAndDestroy( srtpSession );
+ }
+void UT_CSRTPStreamIn::UT_CSRTPStreamIn_NewL_4L( )
+ {
+ HBufC8* masterKey = HBufC8::NewL(KRFC3711_TestMasterKey128bits().Length());
+ CleanupStack::PushL( masterKey );
+ *masterKey = KRFC3711_TestMasterKey128bits;
+
+
+ HBufC8* masterSalt =HBufC8::NewL(KRFC3711_TestMasterSalt112bits().Length());
+ CleanupStack::PushL( masterSalt);
+ *masterSalt = KRFC3711_TestMasterSalt112bits;
+
+
+ HBufC8* mki =HBufC8::NewL(KTestMKI128Bits().Length());
+ CleanupStack::PushL( mki);
+ *mki = KRFC3711_TestMasterSalt112bits;
+ Hex(*mki);
+ TSrtpCryptoParams params;
+ CSRTPMasterKey* masterkey = CSRTPMasterKey::NewLC( *masterKey, *mki );
+ CSRTPMasterSalt* mastersalt = CSRTPMasterSalt::NewLC( *masterSalt );
+ CSRTPCryptoContext* context = CSRTPCryptoContext::NewL(masterkey, mastersalt, params );
+
+ CleanupStack::Pop( mastersalt );
+ CleanupStack::Pop( masterkey );
+ CleanupStack::PopAndDestroy( mki );
+ CleanupStack::PopAndDestroy( masterSalt );
+ CleanupStack::PopAndDestroy( masterKey );
+ CleanupStack::PushL( context );
+ CSRTPSession* srtpSession = CSRTPSession::NewL( iDestination, context, *this );
+ CleanupStack::Pop( context );
+ CleanupStack::PushL( srtpSession );
+ CSRTPStreamIn* tempStreamIn =CSRTPStreamIn::NewL( *srtpSession, *this );
+
+ EUNIT_ASSERT(tempStreamIn->GetCryptoContext().Valid()==ETrue);
+ delete tempStreamIn;
+ CleanupStack::PopAndDestroy( srtpSession );
+ }
+
+void UT_CSRTPStreamIn::UT_CSRTPStreamIn_NewL_5L( )
+ {
+ HBufC8* masterKey = HBufC8::NewL(KRFC3711_TestMasterKey128bits().Length());
+ CleanupStack::PushL( masterKey );
+ *masterKey = KRFC3711_TestMasterKey128bits;
+
+
+ HBufC8* masterSalt =HBufC8::NewL(KRFC3711_TestMasterSalt112bits().Length());
+ CleanupStack::PushL( masterSalt);
+ *masterSalt = KRFC3711_TestMasterSalt112bits;
+
+
+ HBufC8* mki =HBufC8::NewL(KTestMKI128Bits().Length());
+ CleanupStack::PushL( mki);
+ *mki = KRFC3711_TestMasterSalt112bits;
+ Hex(*mki);
+ TSrtpCryptoParams params;
+ CSRTPMasterKey* masterkey = CSRTPMasterKey::NewLC( *masterKey, *mki );
+ CSRTPMasterSalt* mastersalt = CSRTPMasterSalt::NewLC( *masterSalt );
+ CSRTPCryptoContext* context = CSRTPCryptoContext::NewL(masterkey, mastersalt, params );
+
+ CleanupStack::Pop( mastersalt );
+ CleanupStack::Pop( masterkey );
+ CleanupStack::PopAndDestroy( mki );
+ CleanupStack::PopAndDestroy( masterSalt );
+ CleanupStack::PopAndDestroy( masterKey );
+ CleanupStack::PushL( context );
+ CSRTPSession* srtpSession = CSRTPSession::NewL( iDestination);
+ CleanupStack::PushL( srtpSession );
+ CSRTPStreamIn* tempStreamIn =CSRTPStreamIn::NewL( *srtpSession, context, *this );
+ CleanupStack::Pop( srtpSession );
+ CleanupStack::Pop( context );
+
+
+ EUNIT_ASSERT(tempStreamIn->GetCryptoContext().Valid()==ETrue);
+ delete tempStreamIn;
+ delete srtpSession;
+ }
+
+void UT_CSRTPStreamIn::UT_CSRTPStreamIn_SetCryptoInL( )
+ {
+ HBufC8* masterKey = HBufC8::NewL(KRFC3711_TestMasterKey128bits().Length());
+ CleanupStack::PushL( masterKey );
+ *masterKey = KRFC3711_TestMasterKey128bits;
+
+
+ HBufC8* masterSalt =HBufC8::NewL(KRFC3711_TestMasterSalt112bits().Length());
+ CleanupStack::PushL( masterSalt);
+ *masterSalt = KRFC3711_TestMasterSalt112bits;
+
+
+ HBufC8* mki =HBufC8::NewL(KTestMKI128Bits().Length());
+ CleanupStack::PushL( mki);
+ *mki = KRFC3711_TestMasterSalt112bits;
+ Hex(*mki);
+ TSrtpCryptoParams params;
+ CSRTPMasterKey* masterkey = CSRTPMasterKey::NewLC( *masterKey, *mki );
+ CSRTPMasterSalt* mastersalt = CSRTPMasterSalt::NewLC( *masterSalt );
+ CSRTPCryptoContext* context = CSRTPCryptoContext::NewL(masterkey, mastersalt, params );
+
+ CleanupStack::Pop( mastersalt );
+ CleanupStack::Pop( masterkey );
+ CleanupStack::PopAndDestroy( mki );
+ CleanupStack::PopAndDestroy( masterSalt );
+ CleanupStack::PopAndDestroy( masterKey );
+ CleanupStack::PushL( context );
+ CSRTPSession* srtpSession = CSRTPSession::NewL( iDestination);
+ CleanupStack::PushL( srtpSession );
+ CSRTPStreamIn* tempStreamIn =CSRTPStreamIn::NewL( *srtpSession, *this );
+ CleanupStack::PushL( tempStreamIn );
+ CSRTPCryptoContext* context2 =NULL;
+ CSRTPCryptoContext* context3 =context;
+ EUNIT_ASSERT_SPECIFIC_LEAVE(tempStreamIn->SetCryptoInL(context2), KErrArgument);
+ tempStreamIn->SetCryptoInL(context);
+ CleanupStack::Pop( tempStreamIn );
+ CleanupStack::Pop( srtpSession );
+ CleanupStack::Pop( context );
+ CleanupStack::PushL( srtpSession );
+ CleanupStack::PushL( tempStreamIn );
+ EUNIT_ASSERT(tempStreamIn->GetCryptoContext().Valid()==ETrue);
+ //iRekey is True
+ tempStreamIn->iRekey=ETrue;
+ tempStreamIn->SetCryptoInL(context);
+
+ //with ssrc
+ tempStreamIn->SetSSRC(1);
+ tempStreamIn->SetCryptoInL(context3);
+
+ CleanupStack::PopAndDestroy( tempStreamIn );
+ CleanupStack::PopAndDestroy( srtpSession );
+ }
+
+void UT_CSRTPStreamIn::UT_CSRTPStreamIn_UnprotectSrtpLL( )
+ {
+
+ TInt authTagLenInBytes = (iContext->CryptoParams().iSrtpAuthTagLen)/8;
+
+ TBuf8<32> payload;
+ TBuf8<32> authTag;
+ TInt ssrc = 500;
+
+
+ for (TInt i=0; i<20; i++)
+ {
+ payload.Append(0xAA);
+ }
+
+ payload.SetLength(20);
+
+ authTag.Append(0x6F);
+ authTag.Append(0x35);
+ authTag.Append(0x39);
+ authTag.Append(0x16);
+ authTag.Append(0x8C);
+ authTag.Append(0xBB);
+ authTag.Append(0xAD);
+ authTag.Append(0xF5);
+ authTag.Append(0xFD);
+ authTag.Append(0x4B);
+
+ HBufC8* mki =HBufC8::NewL(KTestMKI128Bits().Length());
+ CleanupStack::PushL( mki);
+ *mki = KTestMKI128Bits;
+ Hex(*mki);
+ TInt mkiLength = mki->Length();
+
+ const TUint8* payloadPtr = payload.PtrZ();
+ const TUint8* mkiPtr =mki->Ptr();// mki->Des().PtrZ();
+ const TUint8* authTagPtr = authTag.PtrZ();
+ const TUint8* decryptedPayloadPtr = iDecryptedPayload->Des().PtrZ();
+
+ TPayloadDetails details;
+
+ details.seqNr = KTestSeqNr17;
+// details.ssrc = ssrcPtr;
+ details.padding = 0;
+ details.numCSRC = 0;
+ details.fHeaderExtension = EFalse;
+ details.payloadLen = 20;
+ details.payloadData = payloadPtr;
+ details.MKILen = mkiLength;
+ details.MKIData = mkiPtr;
+ details.authTagLen = authTagLenInBytes;
+ details.authTagData = authTagPtr;
+
+
+ HBufC8* srtpPacket = BuildPacketL(ETrue, details);
+ CleanupStack::PushL(srtpPacket);
+
+ details.payloadData = decryptedPayloadPtr;
+
+ HBufC8* refRtpPacket = BuildPacketL(EFalse, details);
+ CleanupStack::PushL(refRtpPacket);
+
+
+ HBufC8* rtpPacket = iStreamIn->UnprotectSrtpL(*srtpPacket);
+ CleanupStack::PushL(rtpPacket);
+
+ EUNIT_ASSERT( iCryptoHandlerSRTP->iSessionEncrKey->Compare(
+ *iRFC3711_SessionEncrKey128bits) == 0);
+ EUNIT_ASSERT( iCryptoHandlerSRTP->iSessionSaltKey->Compare(
+ *iRFC3711_SessionSaltKey128bits) == 0);
+ EUNIT_ASSERT( iCryptoHandlerSRTP->iSessionAuthKey->Compare(
+ *iRFC3711_SessionAuthKey128bits) == 0);
+ EUNIT_ASSERT( refRtpPacket->Compare(*rtpPacket) == 0);
+
+ EUNIT_ASSERT(iStreamIn->iCurrentRTPState==
+ MSRTPStreamInContext::ESRTPStreamInNormal);
+ CleanupStack::Pop(3);
+ delete rtpPacket;
+ delete refRtpPacket;
+ delete srtpPacket;
+ CleanupStack::PopAndDestroy(mki);
+
+ }
+
+void UT_CSRTPStreamIn::UT_CSRTPStreamIn_UnprotectSrtpL2L( )
+ {
+ //Test Late Binding state
+ TInt authTagLenInBytes = iContext->CryptoParams().iSrtpAuthTagLen/8;
+
+ TBuf8<32> payload;
+ TBuf8<32> authTag;
+ TInt ssrc = 500;
+
+ for (TInt i=0; i<20; i++)
+ {
+ payload.Append(0xAA);
+ }
+
+ payload.SetLength(20);
+
+ authTag.Append(0x6F);
+ authTag.Append(0x35);
+ authTag.Append(0x39);
+ authTag.Append(0x16);
+ authTag.Append(0x8C);
+ authTag.Append(0xBB);
+ authTag.Append(0xAD);
+ authTag.Append(0xF5);
+ authTag.Append(0xFD);
+ authTag.Append(0x4B);
+
+ HBufC8* mki =HBufC8::NewL(KTestMKI128Bits().Length());
+ CleanupStack::PushL( mki);
+ *mki = KTestMKI128Bits;
+ Hex(*mki);
+ TInt mkiLength = mki->Length();
+
+ const TUint8* payloadPtr = payload.PtrZ();
+ const TUint8* mkiPtr =mki->Ptr();// mki->Des().PtrZ();
+ const TUint8* authTagPtr = authTag.PtrZ();
+ const TUint8* decryptedPayloadPtr = iDecryptedPayload->Des().PtrZ();
+
+ TPayloadDetails details;
+
+ details.seqNr = KTestSeqNr17;
+ details.padding = 0;
+ details.numCSRC = 0;
+ details.fHeaderExtension = EFalse;
+ details.payloadLen = 20;
+ details.payloadData = payloadPtr;
+ details.MKILen = mkiLength;
+ details.MKIData = mkiPtr;
+ details.authTagLen = authTagLenInBytes;
+ details.authTagData = authTagPtr;
+
+
+ HBufC8* srtpPacket = BuildPacketL(ETrue, details);
+ CleanupStack::PushL(srtpPacket);
+
+ details.payloadData = decryptedPayloadPtr;
+
+ HBufC8* refRtpPacket = BuildPacketL(EFalse, details);
+ CleanupStack::PushL(refRtpPacket);
+
+
+ HBufC8* rtpPacket = iStreamInLateBD->UnprotectSrtpL(*srtpPacket);
+ CleanupStack::PushL(rtpPacket);
+
+ EUNIT_ASSERT( iCryptoHandlerSRTP2->iSessionEncrKey->Compare(
+ *iRFC3711_SessionEncrKey128bits) == 0);
+ EUNIT_ASSERT( iCryptoHandlerSRTP2->iSessionSaltKey->Compare(
+ *iRFC3711_SessionSaltKey128bits) == 0);
+ EUNIT_ASSERT( iCryptoHandlerSRTP2->iSessionAuthKey->Compare(
+ *iRFC3711_SessionAuthKey128bits) == 0);
+
+ EUNIT_ASSERT(iStreamInLateBD->iCurrentRTPState==
+ MSRTPStreamInContext::ESRTPStreamInNormal);
+ CleanupStack::Pop(3);
+ delete rtpPacket;
+ delete refRtpPacket;
+ delete srtpPacket;
+ CleanupStack::PopAndDestroy(mki);
+ }
+
+void UT_CSRTPStreamIn::UT_CSRTPStreamIn_UnprotectSrtpL3L( )
+ {
+ //Test RCC mode
+ HBufC8* masterKey = HBufC8::NewL(KRFC3711_TestMasterKey128bits().Length());
+ CleanupStack::PushL( masterKey );
+ *masterKey = KRFC3711_TestMasterKey128bits;
+
+
+ HBufC8* masterSalt =HBufC8::NewL(KRFC3711_TestMasterSalt112bits().Length());
+ CleanupStack::PushL( masterSalt);
+ *masterSalt = KRFC3711_TestMasterSalt112bits;
+
+
+ HBufC8* mki1 =HBufC8::NewL(KTestMKI128Bits().Length());
+ CleanupStack::PushL( mki1);
+ *mki1 = KTestMKI128Bits;
+ Hex(*mki1);
+ TSrtpCryptoParams params;
+ params.iSrtpAuthAlg=EAuthRCCm1;
+ params.iSrtpAuthTagLen=112;
+ CSRTPMasterKey* masterkey = CSRTPMasterKey::NewLC( *masterKey, *mki1 );
+ CSRTPMasterSalt* mastersalt = CSRTPMasterSalt::NewLC( *masterSalt );
+ CSRTPCryptoContext* context = CSRTPCryptoContext::NewL(masterkey, mastersalt, params );
+
+ CleanupStack::Pop( mastersalt );
+ CleanupStack::Pop( masterkey );
+ CleanupStack::PopAndDestroy( mki1 );
+ CleanupStack::PopAndDestroy( masterSalt );
+ CleanupStack::PopAndDestroy( masterKey );
+ CleanupStack::PushL( context );
+ //update context
+ iStreamIn->SetCryptoInL(context);
+ CleanupStack::Pop( context );
+ iStreamIn->SetROC(0);
+
+ TInt authTagLenInBytes = (iContext->CryptoParams().iSrtpAuthTagLen)/8;
+
+ TBuf8<32> payload;
+ TBuf8<32> authTag;
+ TInt ssrc = 500;
+
+ for (TInt i=0; i<20; i++)
+ {
+ payload.Append(0xAA);
+ }
+
+ payload.SetLength(20);
+
+ authTag.Append(0x6F);
+ authTag.Append(0x35);
+ authTag.Append(0x39);
+ authTag.Append(0x16);
+ authTag.Append(0x8C);
+ authTag.Append(0xBB);
+ authTag.Append(0xAD);
+ authTag.Append(0xF5);
+ authTag.Append(0xFD);
+ authTag.Append(0x4B);
+
+ HBufC8* mki =HBufC8::NewL(KTestMKI128Bits().Length());
+ CleanupStack::PushL( mki);
+ *mki = KTestMKI128Bits;
+ Hex(*mki);
+ TInt mkiLength = mki->Length();
+
+ const TUint8* payloadPtr = payload.PtrZ();
+ const TUint8* mkiPtr =mki->Ptr();
+ const TUint8* authTagPtr = authTag.PtrZ();
+ const TUint8* decryptedPayloadPtr = iDecryptedPayload->Des().PtrZ();
+
+ TPayloadDetails details;
+
+ details.seqNr = KTestSeqNr17;
+ details.padding = 0;
+ details.numCSRC = 0;
+ details.fHeaderExtension = EFalse;
+ details.payloadLen = 20;
+ details.payloadData = payloadPtr;
+ details.MKILen = mkiLength;
+ details.MKIData = mkiPtr;
+ details.authTagLen = authTagLenInBytes+4;
+ details.authTagData = authTagPtr;
+
+
+ HBufC8* srtpPacket = BuildPacketL(ETrue, details);
+ CleanupStack::PushL(srtpPacket);
+
+ details.payloadData = decryptedPayloadPtr;
+
+ HBufC8* refRtpPacket = BuildPacketL(EFalse, details);
+ CleanupStack::PushL(refRtpPacket);
+
+
+ HBufC8* rtpPacket = iStreamIn->UnprotectSrtpL(*srtpPacket);
+ CleanupStack::PushL(rtpPacket);
+
+ EUNIT_ASSERT( iCryptoHandlerSRTP->iSessionEncrKey->Compare(
+ *iRFC3711_SessionEncrKey128bits) == 0);
+ EUNIT_ASSERT( iCryptoHandlerSRTP->iSessionSaltKey->Compare(
+ *iRFC3711_SessionSaltKey128bits) == 0);
+ EUNIT_ASSERT( iCryptoHandlerSRTP->iSessionAuthKey->Compare(
+ *iRFC3711_SessionAuthKey128bits) == 0);
+ EUNIT_ASSERT( refRtpPacket->Compare(*rtpPacket) == 0);
+
+ EUNIT_ASSERT(iStreamIn->iCurrentRTPState==
+ MSRTPStreamInContext::ESRTPStreamInNormal);
+ CleanupStack::Pop(3);
+ delete rtpPacket;
+ delete refRtpPacket;
+ delete srtpPacket;
+ CleanupStack::PopAndDestroy(mki);
+ }
+
+
+void UT_CSRTPStreamIn::UT_CSRTPStreamIn_UnprotectSrtcpLL( )
+ {
+ HBufC8* encSrtcpPacket =HBufC8::NewLC(KRTCPPacket().Length());
+ *encSrtcpPacket=KRTCPPacket;
+ Hex(*encSrtcpPacket);
+ TInt len= KRTCPPacket().Length();
+ encSrtcpPacket->Des().SetLength(len/2);
+
+ HBufC8* rtcpPacket =iStreamIn->UnprotectSrtcpL(*encSrtcpPacket);
+ CleanupStack::PopAndDestroy(encSrtcpPacket);
+ CleanupStack::PushL(rtcpPacket);
+ EUNIT_ASSERT( iCryptoHandlerSRTCP->iSessionEncrKey->Compare(
+ *iRFC3711_RtcpEncrKey128bits) == 0);
+ EUNIT_ASSERT( iCryptoHandlerSRTCP->iSessionSaltKey->Compare(
+ *iRFC3711_RtcpSaltKey128bits) == 0);
+ EUNIT_ASSERT( iCryptoHandlerSRTCP->iSessionAuthKey->Compare(
+ *iRFC3711_RtcpAuthKey128bits) == 0);
+ EUNIT_ASSERT(iStreamIn->iCurrentRTCPState==
+ MSRTPStreamInContext::ESRTPStreamInNormal);
+ CleanupStack::PopAndDestroy(rtcpPacket);
+
+ }
+
+void UT_CSRTPStreamIn::UT_CSRTPStreamIn_UnprotectSrtcpL2L( )
+ {
+ HBufC8* encSrtcpPacket =HBufC8::NewLC(KRTCPPacket().Length());
+ *encSrtcpPacket=KRTCPPacket;
+ Hex(*encSrtcpPacket);
+ TInt len= KRTCPPacket().Length();
+ encSrtcpPacket->Des().SetLength(len/2);
+
+ HBufC8* rtcpPacket =iStreamInLateBD->UnprotectSrtcpL(*encSrtcpPacket);
+ CleanupStack::PopAndDestroy(encSrtcpPacket);
+ CleanupStack::PushL(rtcpPacket);
+ EUNIT_ASSERT( iCryptoHandlerSRTCP2->iSessionEncrKey->Compare(
+ *iRFC3711_RtcpEncrKey128bits) == 0);
+ EUNIT_ASSERT( iCryptoHandlerSRTCP2->iSessionSaltKey->Compare(
+ *iRFC3711_RtcpSaltKey128bits) == 0);
+ EUNIT_ASSERT( iCryptoHandlerSRTCP2->iSessionAuthKey->Compare(
+ *iRFC3711_RtcpAuthKey128bits) == 0);
+ EUNIT_ASSERT(iStreamInLateBD->iCurrentRTCPState==
+ MSRTPStreamInContext::ESRTPStreamInNormal);
+ CleanupStack::PopAndDestroy(rtcpPacket);
+
+ }
+void UT_CSRTPStreamIn::UT_CSRTPStreamIn_StateTestsL()
+ {
+ EUNIT_ASSERT(iStreamIn->iCurrentRTPState==
+ MSRTPStreamInContext::ESRTPStreamInUninitialized);
+ UT_CSRTPStreamIn_UnprotectSrtpLL( );
+ EUNIT_ASSERT(iStreamIn->iCurrentRTPState==
+ MSRTPStreamInContext::ESRTPStreamInNormal);
+ EUNIT_ASSERT(iStreamIn->iCurrentRTCPState==
+ MSRTPStreamInContext::ESRTPStreamInUninitialized);
+
+ UT_CSRTPStreamIn_UnprotectSrtcpLL( );
+ EUNIT_ASSERT(iStreamIn->iCurrentRTPState==
+ MSRTPStreamInContext::ESRTPStreamInNormal);
+ //UT_CSRTPStreamIn_UnprotectSrtpLL( );
+ //change sequence number
+
+ TInt authTagLenInBytes = iContext->CryptoParams().iSrtpAuthTagLen/8;
+
+ TBuf8<32> payload;
+ TBuf8<32> authTag;
+ TInt ssrc = 500;
+// TUint8* ssrcPtr = static_cast<TUint8 *>(&ssrc);
+
+
+ for (TInt i=0; i<20; i++)
+ {
+ payload.Append(0xAA);
+ }
+
+ payload.SetLength(20);
+ //898C05B99F51A602AEF8495A2987EB45A0FB5995
+ authTag.Append(0x89);
+ authTag.Append(0x8C);
+ authTag.Append(0x05);
+ authTag.Append(0xB9);
+ authTag.Append(0x9F);
+ authTag.Append(0x51);
+ authTag.Append(0xA6);
+ authTag.Append(0x02);
+ authTag.Append(0xAE);
+ authTag.Append(0xF8);
+
+ HBufC8* mki =HBufC8::NewL(KTestMKI128Bits().Length());
+ CleanupStack::PushL( mki);
+ *mki = KTestMKI128Bits;
+ Hex(*mki);
+ TInt mkiLength = mki->Length();
+
+ const TUint8* payloadPtr = payload.PtrZ();
+ const TUint8* mkiPtr =mki->Ptr();// mki->Des().PtrZ();
+ const TUint8* authTagPtr = authTag.PtrZ();
+ const TUint8* decryptedPayloadPtr = iDecryptedPayload->Des().PtrZ();
+
+ TPayloadDetails details;
+
+ details.seqNr = KTestSeqNr18;
+// details.ssrc = ssrcPtr;
+ details.padding = 0;
+ details.numCSRC = 0;
+ details.fHeaderExtension = EFalse;
+ details.payloadLen = 20;
+ details.payloadData = payloadPtr;
+ details.MKILen = mkiLength;
+ details.MKIData = mkiPtr;
+ details.authTagLen = authTagLenInBytes;
+ details.authTagData = authTagPtr;
+
+
+ HBufC8* srtpPacket = BuildPacketL(ETrue, details);
+ CleanupStack::PushL(srtpPacket);
+
+ details.payloadData = decryptedPayloadPtr;
+
+ HBufC8* refRtpPacket = BuildPacketL(EFalse, details);
+ CleanupStack::PushL(refRtpPacket);
+
+
+ HBufC8* rtpPacket = iStreamIn->UnprotectSrtpL(*srtpPacket);
+ CleanupStack::PushL(rtpPacket);
+
+ EUNIT_ASSERT( iCryptoHandlerSRTP->iSessionEncrKey->Compare(
+ *iRFC3711_SessionEncrKey128bits) == 0);
+ EUNIT_ASSERT( iCryptoHandlerSRTP->iSessionSaltKey->Compare(
+ *iRFC3711_SessionSaltKey128bits) == 0);
+ EUNIT_ASSERT( iCryptoHandlerSRTP->iSessionAuthKey->Compare(
+ *iRFC3711_SessionAuthKey128bits) == 0);
+
+
+ EUNIT_ASSERT(iStreamIn->iCurrentRTPState==
+ MSRTPStreamInContext::ESRTPStreamInNormal);
+ CleanupStack::Pop(3);
+ delete rtpPacket;
+ delete refRtpPacket;
+ delete srtpPacket;
+ CleanupStack::PopAndDestroy(mki);
+ EUNIT_ASSERT(iStreamIn->iCurrentRTCPState==
+ MSRTPStreamInContext::ESRTPStreamInNormal);
+ }
+
+void UT_CSRTPStreamIn::UT_CSRTPStreamIn_StateTests2L()
+ {
+ EUNIT_ASSERT(iStreamIn->iCurrentRTPState==
+ MSRTPStreamInContext::ESRTPStreamInUninitialized);
+
+
+ UT_CSRTPStreamIn_UnprotectSrtpLL( );
+
+ EUNIT_ASSERT(iStreamIn->iCurrentRTPState==
+ MSRTPStreamInContext::ESRTPStreamInNormal);
+ EUNIT_ASSERT(iStreamIn->iCurrentRTCPState==
+ MSRTPStreamInContext::ESRTPStreamInUninitialized);
+
+ UT_CSRTPStreamIn_UnprotectSrtcpLL( );
+ EUNIT_ASSERT(iStreamIn->iCurrentRTCPState==
+ MSRTPStreamInContext::ESRTPStreamInNormal);
+
+ HBufC8* encSrtcpPacket =HBufC8::NewLC(KSRTCPPacket2().Length());
+ *encSrtcpPacket=KSRTCPPacket2();
+ Hex(*encSrtcpPacket);
+ TInt len= KSRTCPPacket2().Length();
+ encSrtcpPacket->Des().SetLength(len/2);
+ //The following will leave because of the authentication tag will not match
+ HBufC8* rtcpPacket =iStreamIn->UnprotectSrtcpL(*encSrtcpPacket);
+ CleanupStack::PopAndDestroy(encSrtcpPacket);
+ CleanupStack::PushL(rtcpPacket);
+
+ CleanupStack::PopAndDestroy(rtcpPacket);
+ EUNIT_ASSERT(iStreamIn->iCurrentRTCPState==
+ MSRTPStreamInContext::ESRTPStreamInNormal);
+ }
+// TEST TABLE
+
+EUNIT_BEGIN_TEST_TABLE(
+ UT_CSRTPStreamIn,
+ "CSRTPStreamIn",
+ "UNIT" )
+
+EUNIT_TEST(
+ "NewL1 - test ",
+ "CSRTPStreamIn",
+ "NewL1",
+ "FUNCTIONALITY",
+ SetupL, UT_CSRTPStreamIn_NewL_1L, Teardown)
+
+EUNIT_TEST(
+ "NewL2 - test ",
+ "CSRTPStreamIn",
+ "NewL2",
+ "FUNCTIONALITY",
+ SetupL, UT_CSRTPStreamIn_NewL_2L, Teardown)
+
+EUNIT_TEST(
+ "NewL3 - test ",
+ "CSRTPStreamIn",
+ "NewL3",
+ "FUNCTIONALITY",
+ SetupL, UT_CSRTPStreamIn_NewL_3L, Teardown)
+
+EUNIT_TEST(
+ "NewL4 - test ",
+ "CSRTPStreamIn",
+ "NewL4",
+ "FUNCTIONALITY",
+ SetupL, UT_CSRTPStreamIn_NewL_4L, Teardown)
+
+EUNIT_TEST(
+ "NewL5 - test ",
+ "CSRTPStreamIn",
+ "NewL5",
+ "FUNCTIONALITY",
+ SetupL, UT_CSRTPStreamIn_NewL_5L, Teardown)
+EUNIT_TEST(
+ "UnprotectSrtpL - test ",
+ "CSRTPStreamIn",
+ "UnprotectSrtpL",
+ "FUNCTIONALITY",
+ SetupL, UT_CSRTPStreamIn_UnprotectSrtpLL, Teardown)
+
+EUNIT_TEST(
+ "UnprotectSrtcpL - test ",
+ "CSRTPStreamIn",
+ "UnprotectSrtcpL",
+ "FUNCTIONALITY",
+ SetupL, UT_CSRTPStreamIn_UnprotectSrtcpLL, Teardown)
+
+EUNIT_TEST(
+ "UnprotectSrtpLateBD - test ",
+ "CSRTPStreamIn",
+ "UnprotectSrtpL Late Binding",
+ "FUNCTIONALITY",
+ SetupL, UT_CSRTPStreamIn_UnprotectSrtpL2L, Teardown)
+
+EUNIT_TEST(
+ "UnprotectSrtpL3L-RCC mode",
+ "CSRTPStreamIn",
+ "UnprotectSrtpL RCC",
+ "FUNCTIONALITY",
+ SetupL, UT_CSRTPStreamIn_UnprotectSrtpL3L, Teardown)
+
+EUNIT_TEST(
+ "UnprotectSrtcpLateBind - test ",
+ "CSRTPStreamIn",
+ "UnprotectSrtcpL Late Binding",
+ "FUNCTIONALITY",
+ SetupL, UT_CSRTPStreamIn_UnprotectSrtcpL2L, Teardown)
+EUNIT_TEST(
+ "State Tests ",
+ "CSRTPStreamIn",
+ "State Tests for SRTP and SRTCP",
+ "FUNCTIONALITY",
+ SetupL, UT_CSRTPStreamIn_StateTestsL, Teardown)
+EUNIT_TEST(
+ "State Tests2 ",
+ "CSRTPStreamIn",
+ "State Tests for SRTP and SRTCP Noraml State",
+ "FUNCTIONALITY",
+ SetupL, UT_CSRTPStreamIn_StateTests2L, Teardown)
+
+EUNIT_TEST(
+ "SetCryptoIn",
+ "CSRTPStreamIn",
+ "SetCryptoIn",
+ "FUNCTIONALITY",
+ SetupL, UT_CSRTPStreamIn_SetCryptoInL, Teardown)
+EUNIT_END_TEST_TABLE
+
+// END OF FILE