void UT_CMceStateError::SetupL( ) { CMCETls::OpenL(); //TMceIds ids; iIds.iProfileID = 1; iIds.iManagerType = KMceCSSIPSession; iIds.iDialogType = KMceDlgTypeInvite; iServerCore = CMceServerCore::NewL(); iStorage = CMCETls::Storage(); CDesC8ArrayFlat* params = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity ); CleanupStack::PushL( params ); params->AppendL( _L8("User <user2@host>") ); params->AppendL( _L8("User <user@host>") ); CMceMsgTextArray* msgParams = new (ELeave) CMceMsgTextArray( *params ); CleanupStack::PushL( msgParams ); iStorage->StoreL( iIds, *msgParams ); CleanupStack::PopAndDestroy( msgParams ); CleanupStack::PopAndDestroy( params ); iSession = CMceCsSession::NewL(*iServerCore); iSession->CreateSubSessionL(iIds, RMessage2()); iSipSession = static_cast<CMceSipSession*>((iSession->Implementation().SubSessions())[0]); iSipSession->NextState( KMceStateError ); iState = static_cast<CMceStateError*>(&iSipSession->CurrentState()); }
// --------------------------------------------------------------------------- // UT_CMCENatUseCases::SetupL // --------------------------------------------------------------------------- void UT_CMCENatUseCases::SetupL() { CMCETls::OpenL(); SdpCodecStringPool::OpenL(); iIds.iAppUID = 10; iIds.iProfileID = 1; iIds.iManagerType = KMceCSSIPSession; iIds.iDialogType = KMceDlgTypeInvite; iServerCore = CMceServerCore::NewL(); iStorage = CMCETls::Storage(); iNatSessionId = 3; iServerCore->Manager().MediaManager().NatPluginManager().iEnabled = ETrue; CDesC8ArrayFlat* params = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity ); CleanupStack::PushL( params ); params->AppendL( _L8("") ); params->AppendL( _L8("*****@*****.**") ); CMceMsgTextArray* msgParams = new (ELeave) CMceMsgTextArray( *params ); CleanupStack::PushL( msgParams ); iStorage->StoreL( iIds, *msgParams ); CleanupStack::PopAndDestroy( msgParams ); CleanupStack::PopAndDestroy( params ); iSession = CMceCsSession::NewL( *iServerCore ); iSession->SetClientUidL( iIds, RMessage2() ); iSession->CreateSubSessionL( iIds, RMessage2() ); iNatSipSession = static_cast<CMceNatSipSession*>( (iSession->Implementation().SubSessions())[0] ); }
// ---------------------------------------------------------------------------- // CMceInReferTest::RespondTest3L // ---------------------------------------------------------------------------- // void CMceInReferTest::RespondTest3L() { EUNIT_ASSERT( iManager->Events().Count() == 0 ); MCE_INCOMING_REFER( iManager ); EUNIT_ASSERT( iManager->Events().Count() == 1 ); EUNIT_ASSERT( iManager->Refers().Count() == 1 ); iInRefer = static_cast<CMceInRefer*>( iManager->Refers()[0] ); EUNIT_ASSERT( iInRefer->IsInRefer() ); EUNIT_ASSERT( iInRefer->Type() == CMceRefer::ENoSuppression ); EUNIT_ASSERT( iInRefer->State() == CMceRefer::EIdle ); CDesC8ArrayFlat* headers = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity ); CleanupStack::PushL( headers ); headers->AppendL( KMceHeader1 ); headers->AppendL( KMceHeader2 ); iInEvent = iInRefer->RespondL(_L8("NOT_FINE"), 444, headers ); CleanupStack::Pop( headers ); EUNIT_ASSERT( !iInEvent ); EUNIT_ASSERT( iInRefer->State() == CMceRefer::ETerminated ); EUNIT_ASSERT( iStorage->iIDS.iSessionID == iInRefer->Id() ); iInEvent = static_cast<CMceInEvent*>( iManager->Events()[0] ); MCE_SES_RECEIVE( iInEvent, KErrCompletion ); iInEvent = NULL; }
void UT_CMceStateOffering::SetupL( ) { CMCETls::OpenL(); SdpCodecStringPool::OpenL(); //TMceIds ids; iIds.iProfileID = 1; iIds.iManagerType = KMceCSSIPSession; iIds.iDialogType = KMceDlgTypeInvite; iServerCore = CMceServerCore::NewL(); iStorage = CMCETls::Storage(); CDesC8ArrayFlat* params = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity ); CleanupStack::PushL( params ); params->AppendL( _L8("User <user2@host>") ); params->AppendL( _L8("User <user@host>") ); CMceMsgTextArray* msgParams = new (ELeave) CMceMsgTextArray( *params ); CleanupStack::PushL( msgParams ); iStorage->StoreL( iIds, *msgParams ); CleanupStack::PopAndDestroy( msgParams ); CleanupStack::PopAndDestroy( params ); iSession = CMceCsSession::NewL(*iServerCore); iSession->CreateSubSessionL(iIds, RMessage2()); iSipSession = static_cast<CMceSipSession*>((iSession->Implementation().SubSessions())[0]); CSIPClientTransaction* transaction = MCETestHelper::ClientTransactionLC( SipStrConsts::EInvite, KMceSipOK, SipStrConsts::EPhraseOk, ETrue ); iSipSession->SetPendingTransactionL( transaction ); CleanupStack::Pop( transaction ); iSipSession->iResponse = transaction; iSipSession->iBody = CMceComSession::NewL( CMceComSession::EOutSession ); imServer = new (ELeave) CMceServerStub(); iManager = CMceMediaManager::NewL( *imServer ); iSdpSession = CMceSdpSession::NewL( *iSipSession->iBody, *iManager ); iSipSession->NextState( KMceStateOffering ); iState = static_cast<CMceStateOffering*>(&iSipSession->CurrentState()); iSipSession->iOffer = CSdpDocument::NewL(); }
void UT_CMceStateOffering::Setup2L( ) { CMCETls::OpenL(); SdpCodecStringPool::OpenL(); //TMceIds ids; iIds.iProfileID = 1; iIds.iManagerType = KMceCSSIPSession; iIds.iDialogType = KMceDlgTypeInvite; iServerCore = CMceServerCore::NewL(); iStorage = CMCETls::Storage(); CDesC8ArrayFlat* params = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity ); CleanupStack::PushL( params ); params->AppendL( _L8("User <user2@host>") ); params->AppendL( _L8("User <user@host>") ); CMceMsgTextArray* msgParams = new (ELeave) CMceMsgTextArray( *params ); CleanupStack::PushL( msgParams ); iStorage->StoreL( iIds, *msgParams ); CleanupStack::PopAndDestroy( msgParams ); CleanupStack::PopAndDestroy( params ); iSession = CMceCsSession::NewL(*iServerCore); iSession->CreateSubSessionL(iIds, RMessage2()); iSipSession = static_cast<CMceSipSession*>((iSession->Implementation().SubSessions())[0]); iSipSession->SetBodyL(); MCETestHelper::RequestL( iSipSession, SipStrConsts::EUpdate, ETrue, EFalse ); MCE_SET_STATES( iSipSession /*session*/, CMceSession::EOffering /*clientState*/, KMceStateOffering /*serverState*/ ); iState = static_cast<CMceStateOffering*>(&iSipSession->CurrentState()); HBufC8* token = KMediaToken().AllocL(); iSipSession->SetMediaAuthorizationToken( token ); }
void UT_CMceStateServerEstablishing::SetupL( ) { CMCETls::OpenL(); SdpCodecStringPool::OpenL(); //TMceIds ids; iIds.iProfileID = 1; iIds.iManagerType = KMceCSSIPSession; iIds.iDialogType = KMceDlgTypeInvite; iServerCore = CMceServerCore::NewL(); iStorage = CMCETls::Storage(); CDesC8ArrayFlat* params = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity ); CleanupStack::PushL( params ); params->AppendL( _L8("User <user2@host>") ); params->AppendL( _L8("User <user@host>") ); CMceMsgTextArray* msgParams = new (ELeave) CMceMsgTextArray( *params ); CleanupStack::PushL( msgParams ); iStorage->StoreL( iIds, *msgParams ); CleanupStack::PopAndDestroy( msgParams ); CleanupStack::PopAndDestroy( params ); iSession = CMceCsSession::NewL(*iServerCore); iSession->CreateSubSessionL(iIds, RMessage2()); iSipSession = static_cast<CMceSipSession*>((iSession->Implementation().SubSessions())[0]); // incoming request CSIPServerTransaction* invite = MCETestHelper::ServerTransactionL( SipStrConsts::EInvite ); CleanupStack::PushL( invite ); iSipSession->iPendingReceivedRequests.AppendL( invite ); CleanupStack::Pop( invite ); iSipSession->NextState( KMceStateServerEstablishing ); iState = static_cast<CMceStateServerEstablishing*>(&iSipSession->CurrentState()); }
TInt CSocketEngine::GetCookieArray(const TDesC8& aData,CDesC8ArrayFlat& aCookies){ _LIT8(KSC,"Set-Cookie:"); TInt cnt=0; TPtrC8 r; TPtrC8 ptr(aData); TInt pos=ptr.FindF(KSC); while(pos>=0&&(pos+KSC().Length())<ptr.Length()){ ptr.Set(ptr.Mid(pos+KSC().Length())); pos=ptr.FindF(_L8("\n")); if(pos>0){ r.Set(ptr.Left(pos)); aCookies.AppendL(r); cnt++; } pos=ptr.FindF(KSC); } return cnt; }
QStringList S60FormatSupported::supportedPlayMimeTypesL() { RArray<TUid> mediaIds; //search for both audio and video RMMFControllerImplInfoArray iControllers; m_controllerparam = CMMFControllerPluginSelectionParameters::NewL(); m_playformatparam = CMMFFormatSelectionParameters::NewL(); mediaIds.Append(KUidMediaTypeAudio); mediaIds.Append(KUidMediaTypeVideo); m_controllerparam->SetMediaIdsL(mediaIds, CMMFPluginSelectionParameters::EAllowOtherMediaIds); m_controllerparam->SetRequiredPlayFormatSupportL(*m_playformatparam); m_controllerparam->ListImplementationsL(iControllers); CDesC8ArrayFlat* controllerArray = new (ELeave) CDesC8ArrayFlat(1); for (TInt i = 0; i < iControllers.Count(); i++) { for (TInt j = 0; j < (iControllers[i]->PlayFormats()).Count(); j++) { const CDesC8Array& iarr = (iControllers[i]->PlayFormats()[j]->SupportedMimeTypes()); TInt count = iarr.Count(); for (TInt k = 0; k < count; k++) { TPtrC8 ptr = iarr.MdcaPoint(k); HBufC8* n = HBufC8::NewL(ptr.Length()); TPtr8 ptr1 = n->Des(); ptr1.Copy((TUint8*) ptr.Ptr(), ptr.Length()); controllerArray->AppendL(ptr1); } } } // converting CDesC8Array to QStringList for (TInt x = 0; x < controllerArray->Count(); x++) { m_supportedplaymime.append(QString::fromUtf8( (const char*) (controllerArray->MdcaPoint(x).Ptr()), controllerArray->MdcaPoint(x).Length())); } // populating the list with only audio and controller mime types QStringList tempaudio = m_supportedplaymime.filter(QString("audio")); QStringList tempvideo = m_supportedplaymime.filter(QString("video")); m_supportedplaymime.clear(); m_supportedplaymime = tempaudio + tempvideo; mediaIds.Close(); delete controllerArray; iControllers.ResetAndDestroy(); return m_supportedplaymime; }
void CSdlAppUi::StartTestL(TInt aCmd) { //TInt flags = CSDL::EDrawModeGdi | CSDL::EEnableFocusStop // | CSDL::EMainThread;// | CSDL::EAutoOrientation; TInt flags = 0; //flags |= CSDL::EDrawModeDSB | CSDL::EDrawModeDSBDoubleBuffer; flags |= CSDL::EDrawModeGdi; // Don't draw when in background. //flags |= CSDL::EEnableFocusStop; flags |= CSDL::EAutoOrientation; // This should be on by default anyway flags |= CSDL::EMainThread; //Create CommandLine Arguments and read it. CDesC8ArrayFlat *arr = new (ELeave) CDesC8ArrayFlat(1); CleanupStack::PushL(arr); CCommandLineArguments* args = CCommandLineArguments::NewLC(); // The real args we are interested in start at the 2nd arg for (TInt i = 1; i < args->Count(); i++) { TBuf8<256> arg; arg.Copy(args->Arg(i)); arr->AppendL(arg); //TPtrC argumentPrt(args->Arg(i)); //console->Printf(_L("Arg %d == %S\n"), i, &argumentPrt); } iSdl = CSDL::NewL(flags); iSdl->SetContainerWindowL(iSDLWin->GetWindow(), iEikonEnv->WsSession(), *iEikonEnv->ScreenDevice()); iSdl->CallMainL(iWait->iStatus, *arr, flags, 0x14000); iWait->Start(); arr->Reset(); CleanupStack::PopAndDestroy(2); // command line and arr }
void CCalAlarmAttachTest::TestCopyEntryWithAlarmContentL() { test.Printf(_L("Test copying entry but delete the original one\n")); _LIT8(KUidEntryOriginal, "EntryOriginalUid"); CCalAlarm* alarm = StoreEntryWithAlarmContentLC(KUidEntryOriginal()); CleanupStack::PopAndDestroy(alarm); RPointerArray<CCalEntry> entries; CleanupResetAndDestroyPushL(entries); iTestLib->SynCGetEntryViewL().FetchL(KUidEntryOriginal(), entries); // Copy the entry from the original one _LIT8(KUidEntryCopy, "EntryCopyUid"); HBufC8* guid1 = KUidEntryCopy().AllocLC(); CCalEntry* copiedEntry = CCalEntry::NewL(CCalEntry::EEvent, guid1, CCalEntry::EMethodNone,0); CleanupStack::Pop(guid1); CleanupStack::PushL(copiedEntry); copiedEntry->CopyFromL(*entries[0],CCalEntry::EDontCopyId);//restore the alarmaction entries.ResetAndDestroy(); entries.AppendL(copiedEntry); CleanupStack::Pop(copiedEntry); //delete the original entry that will delete the alarm and its content CDesC8ArrayFlat* guidArray = new(ELeave)CDesC8ArrayFlat(1); CleanupStack::PushL(guidArray); guidArray->AppendL(KUidEntryOriginal()); iTestLib->SynCGetEntryViewL().DeleteL(*guidArray); CleanupStack::PopAndDestroy(guidArray); //Store the copied entry and access its alarm content TestAlarmL(copiedEntry, KContent(), KMimeType()); TInt entriesStored = 0; iTestLib->SynCGetEntryViewL().StoreL(entries, entriesStored); entries.ResetAndDestroy(); iTestLib->SynCGetEntryViewL().FetchL(KUidEntryCopy(), entries); TestAlarmL(entries[0], KContent(), KMimeType()); CleanupStack::PopAndDestroy(&entries); }
/** * INPUT: * Headers: - * Parameters: AuthenticationMechanism, SecurityParams* * IDs: - * * OUTPUT: * Parameters: - * IDs: - */ void TCmdSetSecurityParams::ExecuteL() { // -- Setup --------------------------------------------------------------- // Get mandatory AuthenticationMechanism TPtrC8 mechanism = ExtractTextL( KParamAuthenticationMechanism ); // Create a string array for the parameter values CDesC8ArrayFlat* secParams = new( ELeave ) CDesC8ArrayFlat( KTcGranularity ); CleanupStack::PushL( secParams ); // Get optional security parameters structure CTcStructure* structure = FindStructureL( KParamSecurityParams, EFalse ); if( structure ) { TInt count = structure->Count(); for( TInt i = 0; i < count; i++ ) { // Each item is read from the structure const CTcNameValue& tv = structure->Item( i ); // ..and appended to the array formatted as "<name><tab><value>" TBuf8< KMaxSecurityParamLength > entry; entry.Append( tv.Name() ); entry.Append( KTab ); entry.Append( tv.Value() ); secParams->AppendL( entry ); } } // -- Execution ----------------------------------------------------------- // CSIPSecurity* security = CSIPSecurity::NewLC( iContext.SIP() ); // security->SetParamsL( mechanism, *secParams ); // CleanupStack::PopAndDestroy( security ); CleanupStack::PopAndDestroy( secParams ); // -- Response creation --------------------------------------------------- }
/** * Delete entries by uid list */ void CTestCalInterimApiModifier::DeleteEntriesByUidListL() { CDesC8ArrayFlat* deleteGuidArray = new(ELeave) CDesC8ArrayFlat(4); CleanupStack::PushL(deleteGuidArray); const TInt KUidCount(iModifier->iEntryArray.Count()); for (TInt j(0); j < KUidCount; ++j) { if(iModifier->iEntryArray[j]->RecurrenceIdL().TimeUtcL() == Time::NullTTime()) { // Deleting a Parent entry deletes all the associated child entries // Hence bypasing all child entries deleteGuidArray->AppendL(iModifier->iEntryArray[j]->UidL()); } } TRAPD(err, iEntryView->DeleteL(*deleteGuidArray)); CleanupStack::PopAndDestroy(deleteGuidArray); if((err != KErrNone)) { iTestStep->ERR_PRINTF2(KErrDeleteOperation,err); iTestStep->SetTestStepResult(EFail); } }
// ----------------------------------------------------------------------------- // CMceOutRefer::ConstructL // ----------------------------------------------------------------------------- // void CMceOutRefer::ConstructL( const TDesC8& aRecipient, const TDesC8& aReferTo, TType aType, HBufC8* aOriginator ) { CDesC8ArrayFlat* params = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity ); CleanupStack::PushL( params ); params->AppendL( aReferTo ); if ( iDialogId == KMceNotAssigned ) { params->AppendL( aRecipient ); if ( aOriginator ) { params->AppendL( *aOriginator ); } else { params->AppendL( KNullDesC8 ); } } if ( aType == ENoSuppression ) { HBufC8* originator = NULL; if ( aOriginator ) { originator = ( *aOriginator ).AllocL(); } CleanupStack::PushL( originator ); iOwnedEvent = CMceOutEvent::NewL( iManager, iProfileId, aRecipient, KReferEventHeader, 0, originator, iDialogId, KMceDlgTypeRefer, params ); CleanupStack::Pop( originator ); CleanupStack::Pop( params ); } HBufC8* recipient = aRecipient.AllocLC(); HBufC8* referTo = aReferTo.AllocLC(); if ( aType == ENoSuppression ) { CMceRefer::ConstructL( recipient, referTo, aOriginator, NULL ); CleanupStack::Pop( referTo ); CleanupStack::Pop( recipient ); } else { CMceRefer::ConstructL( recipient, referTo, aOriginator, params ); CleanupStack::Pop( referTo ); CleanupStack::Pop( recipient ); CleanupStack::Pop( params ); } }
// ---------------------------------------------------------------------------- // CMceOutSessionTest::EstablishTestL // ---------------------------------------------------------------------------- // void CMceSecureOutSessionTest::EstablishTestL() { MCE_CREATE_PROFILE; EUNIT_ASSERT( iStorage->iSessionId == 0 ); iSecureOutSession = CMceSecureOutSession::NewL( *iManager, *profile, KMceRecipient ); EUNIT_ASSERT( iManager->Sessions().Count() == 1 ); EUNIT_ASSERT( iSecureOutSession->Recipient().Compare( KMceRecipient ) == 0 ); EUNIT_ASSERT( iSecureOutSession->Id() == 1 ); EUNIT_ASSERT( iStorage->iSessionId == 1 ); iSecureOutSession->EstablishL(); EUNIT_ASSERT( iSecureOutSession->State() == CMceSession::EOffering ); EUNIT_ASSERT( iSecureOutSession->Id() == 1 ); CMceMsgObject<CMceComSession>* sentSessionMsg = new (ELeave) CMceMsgObject<CMceComSession>(); CleanupStack::PushL( sentSessionMsg ); sentSessionMsg->DecodeL( *(iStorage->iContext) ); sentSessionMsg->PushL(); CMceComSession* sentSession = sentSessionMsg->iObject; EUNIT_ASSERT( sentSession->iType == CMceComSession::EOutSession ); EUNIT_ASSERT( sentSession->iState == CMceSession::EIdle ); EUNIT_ASSERT( sentSession->iID == iStorage->iIDS.iSessionID ); EUNIT_ASSERT( sentSession->Streams().Count() == 0 ); sentSessionMsg->Pop(); delete sentSession; CleanupStack::PopAndDestroy( sentSessionMsg ); EUNIT_ASSERT( iSecureOutSession->State() == CMceSession::EOffering ); EUNIT_ASSERT( iSecureOutSession->Id() == 1 ); TRAPD( notReady, iSecureOutSession->EstablishL() ); MCE_TEST_HANDLE_ALLOC_FAILURE( notReady ) EUNIT_ASSERT( notReady == KErrNotReady ); MCE_TEST_DELETE( iSecureOutSession ); EUNIT_ASSERT( iManager->Sessions().Count() == 0 ); //detailed iStorage->Reset(); iSecureOutSession = CMceSecureOutSession::NewL( *iManager, *profile, KMceRecipient ); EUNIT_ASSERT( iManager->Sessions().Count() == 1 ); EUNIT_ASSERT( iSecureOutSession->Recipient().Compare( KMceRecipient ) == 0 ); for ( int i=0;i<2;i++ ) { CMceAudioStream* outStream = CMceAudioStream::NewL(); CleanupStack::PushL( outStream ); CMceAudioStream* inStream = CMceAudioStream::NewL(); CleanupStack::PushL( inStream ); outStream->AddSinkL( CMceRtpSink::NewLC() ); CleanupStack::Pop(); outStream->SetSourceL( CMceMicSource::NewLC() ); CleanupStack::Pop(); CDesC8ArrayFlat* sdp = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity ); CleanupStack::PushL( sdp ); sdp->AppendL( KMceMedialine1 ); sdp->AppendL( KMceMedialine2 ); outStream->SetMediaAttributeLinesL( sdp ); CleanupStack::Pop( sdp ); inStream->SetSourceL( CMceRtpSource::NewLC() ); CleanupStack::Pop(); inStream->AddSinkL( CMceSpeakerSink::NewLC() ); CleanupStack::Pop(); sdp = 0; sdp = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity ); CleanupStack::PushL( sdp ); sdp->AppendL( KMceMedialine1 ); sdp->AppendL( KMceMedialine2 ); inStream->SetMediaAttributeLinesL( sdp ); CleanupStack::Pop( sdp ); outStream->BindL( inStream ); CleanupStack::Pop( inStream ); iSecureOutSession->AddStreamL( outStream ); CleanupStack::Pop( outStream ); // Try to add same stream again TRAPD( err, iSecureOutSession->AddStreamL( outStream ) ); MCE_TEST_HANDLE_ALLOC_FAILURE( err ) EUNIT_ASSERT_EQUALS( KErrArgument, err ); } static_cast<CMceAudioStream*>( iSecureOutSession->Streams()[1])->BindL( NULL ); CDesC8ArrayFlat* headers = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity ); CleanupStack::PushL( headers ); headers->AppendL( KMceHeader1 ); headers->AppendL( KMceHeader2 ); HBufC8* contentType = KMceContentType().AllocLC(); HBufC8* body = KMceMessageBody().AllocLC(); // Leaving cases // content type, no content TRAPD( err, iSecureOutSession->EstablishL( KMceTestTimeout, headers, contentType, NULL ) ); MCE_TEST_HANDLE_ALLOC_FAILURE( err ) EUNIT_ASSERT( err == KErrArgument ); EUNIT_ASSERT( iSecureOutSession->State() == CMceSession::EIdle ); // no content type, content TRAPD( err2, iSecureOutSession->EstablishL( KMceTestTimeout, headers, NULL, body ) ); MCE_TEST_HANDLE_ALLOC_FAILURE( err2 ) EUNIT_ASSERT( err2 == KErrArgument ); EUNIT_ASSERT( iSecureOutSession->State() == CMceSession::EIdle ); // no headers, no content type, no content, content headers TRAPD( err3, iSecureOutSession->EstablishL( KMceTestTimeout, NULL, NULL, NULL, headers ) ); MCE_TEST_HANDLE_ALLOC_FAILURE( err3 ) EUNIT_ASSERT( err3 == KErrArgument ); EUNIT_ASSERT( iSecureOutSession->State() == CMceSession::EIdle ); iSecureOutSession->EstablishL( KMceTestTimeout, headers, contentType, body ); EUNIT_ASSERT( iSecureOutSession->State() == CMceSession::EOffering ); CleanupStack::Pop( body ); CleanupStack::Pop( contentType ); CleanupStack::Pop( headers ); EUNIT_ASSERT( iStorage->iContent->Compare( KMceMessageBody ) == 0 ); sentSessionMsg = new (ELeave) CMceMsgObject<CMceComSession>(); CleanupStack::PushL( sentSessionMsg ); sentSessionMsg->DecodeL( *(iStorage->iContext) ); sentSessionMsg->PushL(); sentSession = sentSessionMsg->iObject; EUNIT_ASSERT( sentSession->iType == CMceComSession::EOutSession ); EUNIT_ASSERT( sentSession->iState == CMceSession::EIdle ); EUNIT_ASSERT( sentSession->iID == iStorage->iIDS.iSessionID ); EUNIT_ASSERT( sentSession->iSIPContentType->Compare( KMceContentType ) == 0 ); EUNIT_ASSERT( sentSession->iSIPHeaders->Count() == 2 ); EUNIT_ASSERT( sentSession->iSIPHeaders->MdcaPoint( 0 ).Compare( KMceHeader1 ) == 0 ); EUNIT_ASSERT( sentSession->iSIPHeaders->MdcaPoint( 1 ).Compare( KMceHeader2 ) == 0 ); EUNIT_ASSERT( sentSession->Streams().Count() == 2 ); EUNIT_ASSERT( sentSession->Streams()[0]->iLocalMediaSDPLines->MdcaPoint( 0 ).Compare( KMceMedialine1 ) == 0 ); EUNIT_ASSERT( sentSession->Streams()[0]->iLocalMediaSDPLines->MdcaPoint( 1 ).Compare( KMceMedialine2 ) == 0 ); EUNIT_ASSERT( static_cast<CMceComAudioStream*>( sentSession->Streams()[0])->BoundStream() ); EUNIT_ASSERT( static_cast<CMceComAudioStream*>( sentSession->Streams()[0])->BoundStreamL().iLocalMediaSDPLines->MdcaPoint( 0 ).Compare( KMceMedialine1 ) == 0 ); EUNIT_ASSERT( static_cast<CMceComAudioStream*>( sentSession->Streams()[0])->BoundStreamL().iLocalMediaSDPLines->MdcaPoint( 1 ).Compare( KMceMedialine2 ) == 0 ); EUNIT_ASSERT( !static_cast<CMceComAudioStream*>( sentSession->Streams()[1])->BoundStream() ); TRAPD( notReady2, iSecureOutSession->EstablishL( KMceTestTimeout, NULL, NULL, NULL) ); MCE_TEST_HANDLE_ALLOC_FAILURE( notReady2 ) EUNIT_ASSERT( notReady2 == KErrNotReady ); sentSessionMsg->Pop(); delete sentSession; CleanupStack::PopAndDestroy( sentSessionMsg ); EUNIT_ASSERT( iSecureOutSession->State() == CMceSession::EOffering ); MCE_DELETE_PROFILE; }
/** * INPUT: * Headers: - * Parameters: ProfileType*, ProfileAOR* * IDs: RegistryId * * OUTPUT: * Parameters: - * IDs: ProfileIdList */ void TCmdGetProfiles::ExecuteL() { // -- Setup --------------------------------------------------------------- // Get selected registry CTcSIPProfileContainer& container = SelectProfileL(); // Type TcLog::WriteFormat( _L8("-- Get optional structure \"ProfileType\"") ); CTcStructure* structure = FindStructureL( KParamProfileType, EFalse ); TSIPProfileTypeInfo typeInfo; if( structure ) { TcLog::Write( KLogOk ); TcLog::WriteFormat( _L8("-- Get mandatory structure item \"ProfileName\"") ); typeInfo.iSIPProfileName = structure->ItemL( KParamProfileName )->Value(); TcLog::Write( KLogOk ); TcLog::WriteFormat( _L8("-- Get mandatory structure item \"Class\"") ); typeInfo.iSIPProfileClass = ProfileTypeClassL( structure ); TcLog::Write( KLogOk ); } else { TcLog::Write( KLogNotFound ); } // Get profile AOR, or KNullDesC8 TPtrC8 aor = ExtractTextL( KParamProfileAOR, EFalse ); // -- Execution ----------------------------------------------------------- RPointerArray< CSIPProfile > profileArray; CleanupResetAndDestroyPushL( profileArray ); // See if Type was given if( structure ) { container.ManagedProfileRegistry().ProfilesL( typeInfo, profileArray ); } else if( aor != KNullDesC8 ) { container.ManagedProfileRegistry().ProfilesL( aor, profileArray ); } else { User::Leave( KTcErrMandatoryParameterNotFound ); } // -- Response creation --------------------------------------------------- // Crete response only if some profiles exist TInt count = profileArray.Count(); if ( count > 0 ) { CDesC8ArrayFlat* array = new ( ELeave ) CDesC8ArrayFlat( count ); CleanupStack::PushL( array ); for( TInt i = 0; i < count; i++ ) { // Register object CSIPProfile* profile = profileArray[ i ]; // Create a name out of the profile id TBuf8< KTcMaxIntConversion > idName; TUint32 profileId( 0 ); User::LeaveIfError( profile->GetParameter( KSIPProfileId, profileId ) ); idName.AppendNum( (TInt)profileId ); // ..and add it to the ProfileIdList array array->AppendL( idName ); } AddArrayResponseL( KParamProfileProfileIdist, *array ); CleanupStack::PopAndDestroy(); // array } CleanupStack::PopAndDestroy(); // profileArray }
// ---------------------------------------------------------------------------- // CMceInReferTest::TerminateTestL // ---------------------------------------------------------------------------- // void CMceInReferTest::TerminateTestL() { EUNIT_ASSERT( iManager->Events().Count() == 0 ); MCE_INCOMING_REFER( iManager ); EUNIT_ASSERT( iManager->Events().Count() == 1 ); EUNIT_ASSERT( iManager->Refers().Count() == 1 ); iInRefer = static_cast<CMceInRefer*>( iManager->Refers()[0] ); EUNIT_ASSERT( iInRefer->IsInRefer() ); EUNIT_ASSERT( iInRefer->Type() == CMceRefer::ENoSuppression ); EUNIT_ASSERT( iInRefer->State() == CMceRefer::EIdle ); //simple accept iInEvent = iInRefer->AcceptL(); EUNIT_ASSERT( iInRefer->State() == CMceRefer::EPending ); EUNIT_ASSERT( iStorage->iIDS.iSessionID == iInRefer->Id() ); //simple accept TRAPD(err,iInRefer->AcceptL()); MCE_TEST_HANDLE_ALLOC_FAILURE( err ) EUNIT_ASSERT( err == KErrNotReady ); MCE_SESSION_STATECHANGE( iInEvent, CMceEvent::EActive, KMceNotAssigned ); HBufC8* sipfrag = KContentSIPFragType().AllocLC(); HBufC8* messageOK = KContentMsgOK().AllocLC(); iInEvent->TerminateL( NULL, sipfrag, messageOK ); CleanupStack::Pop( messageOK ); CleanupStack::Pop( sipfrag ); //This is needed otherwise it will leave as KErrNotReady when trys to delete event iInEvent->iState = CMceEvent::ETerminated ; //terminate with headers MCE_SESSION_STATECHANGE( iInEvent, CMceEvent::EActive, KMceNotAssigned ); EUNIT_ASSERT( iInEvent->State() == CMceEvent::EActive ); CDesC8ArrayFlat* headers = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity ); CleanupStack::PushL( headers ); headers->AppendL( KMceHeader1 ); headers->AppendL( KMceHeader2 ); iInEvent->TerminateL(headers); CleanupStack::Pop(headers); //terminate with subscription state headers MCE_SESSION_STATECHANGE( iInEvent, CMceEvent::EActive, KMceNotAssigned ); EUNIT_ASSERT( iInEvent->State() == CMceEvent::EActive ); CDesC8ArrayFlat* headers2 = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity ); CleanupStack::PushL( headers2 ); headers->AppendL( KMceSubscriptionStateHeader3 ); headers->AppendL( KMceHeader2 ); iInEvent->TerminateL( headers2 ); CleanupStack::Pop( headers2 ); // Leaving cases // content type, no content MCE_SESSION_STATECHANGE( iInEvent, CMceEvent::EActive, KMceNotAssigned ); EUNIT_ASSERT( iInEvent->State() == CMceEvent::EActive ); HBufC8* contentType = KMceEventHeader().AllocLC(); HBufC8* content = KMceEventHeader().AllocLC(); TRAPD( err1, iInEvent->TerminateL( NULL, contentType, NULL ) ); MCE_TEST_HANDLE_ALLOC_FAILURE( err ) EUNIT_ASSERT( err1 == KErrArgument ); EUNIT_ASSERT( iInEvent->State() == CMceEvent::EActive ); // no content type content TRAPD( err2, iInEvent->TerminateL( NULL, NULL, content) ); MCE_TEST_HANDLE_ALLOC_FAILURE( err2 ) EUNIT_ASSERT( err2 == KErrArgument ); EUNIT_ASSERT( iInEvent->State() == CMceEvent::EActive ); iInEvent->TerminateL(0, contentType, content); CleanupStack::Pop( content ); CleanupStack::Pop( contentType ); }
// ----------------------------------------------------------------------------- // MceSip::UserHeadersToTextArrayL // ----------------------------------------------------------------------------- // CDesC8Array* MceSip::UserHeadersToTextArrayL( CSIPTransactionBase& aTransaction, const CSIPDialog& aDialog ) { CDesC8ArrayFlat* headers = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity ); CleanupStack::PushL( headers ); HBufC8* head = NULL; const CSIPHeaderBase* callid = NULL; const CSIPHeaderBase* cseq = NULL; const CSIPFromHeader* from = NULL; const CSIPToHeader* to = NULL; const CSIPMessageElements* elements = ToMessageElements( aTransaction ); if ( aTransaction.IsSIPClientTransaction() ) { const CSIPResponseElements* responseElements = static_cast<CSIPClientTransaction&>( aTransaction ). ResponseElements(); cseq = responseElements ? responseElements->CSeqHeader() : NULL; from = responseElements ? responseElements->FromHeader() : NULL; to = responseElements ? responseElements->ToHeader() : NULL; } else { const CSIPRequestElements* requestElements = static_cast<CSIPServerTransaction&>( aTransaction ). RequestElements(); from = requestElements ? requestElements->FromHeader() : NULL; to = requestElements ? requestElements->ToHeader() : NULL; } from = !from ? &aDialog.FromHeader() : from; to = !to ? &aDialog.ToHeader() : to; head = from->ToTextLC(); headers->AppendL( *head ); CleanupStack::PopAndDestroy( head ); head = to->ToTextLC(); headers->AppendL( *head ); CleanupStack::PopAndDestroy( head ); if ( cseq ) { head = cseq->ToTextLC(); headers->AppendL( *head ); CleanupStack::PopAndDestroy( head ); } TRAPD( error, callid = &aDialog.CallIdL() ); if ( error == KErrNone ) { head = callid->ToTextLC(); headers->AppendL( *head ); CleanupStack::PopAndDestroy( head ); } if ( elements ) { const RPointerArray<CSIPHeaderBase>& sipHeaders = elements->UserHeaders(); for ( TInt i=0; i < sipHeaders.Count(); i++ ) { CSIPHeaderBase* anotherhead = sipHeaders[ i ]; head = anotherhead->ToTextLC(); headers->AppendL( *head ); CleanupStack::PopAndDestroy( head ); } } CleanupStack::Pop( headers ); return headers; }
// ----------------------------------------------------------------------------- // CSTSUserAuth::DecodeL // Decrypts raw data to this instance // (other items were commented in a header). // ----------------------------------------------------------------------------- void CSTSUserAuth::DecodeL(const TDesC8& aRawData) { CArrayPtr<TASN1DecGeneric>* itemsData = DecodeSequenceLC(ETrue, // must be sequence aRawData, KSTSMinNumberOfSubModules); // we would not get this far if there was atleast two element TInt pos = 0; // decoding authentication id (octet string) TASN1DecOctetString authId; HBufC8* tmp = authId.DecodeDERL(*itemsData->At(pos++)); delete iAuthId; iAuthId = tmp; // decoding user authentication method (choice) // we need: apduPinEntry [0]APDUPinEntry TASN1DecGeneric taggedEntryDec(*itemsData->At(pos++)); taggedEntryDec.InitL(); if (taggedEntryDec.Tag() == KSTSAPDUPinEntryTag) { // set information that apduHeaders used iType = EAPDUPinEntry; // decoding apduPinEntry TASN1DecGeneric decGen(taggedEntryDec.GetContentDER()); TRAPD(err, decGen.InitL()); // it there is some optional headers inside APDUPINEntry if (!err) { CleanupStack::PopAndDestroy(itemsData); itemsData = DecodeSequenceLC(EFalse, taggedEntryDec.Encoding()); TInt numOfHeaders = itemsData->Count(); if (numOfHeaders) { CDesC8ArrayFlat* tmpArray = new(ELeave) CDesC8ArrayFlat(numOfHeaders); CleanupStack::PushL(tmpArray); TUint currentTag = 0; TInt itemsLeft = numOfHeaders; // decode all pinheaders(octet string) in loop for (TInt i = 0; i < numOfHeaders; i++) { TBool ready = EFalse; TASN1DecGeneric decGenApduHeader(*itemsData->At(i)); // we must check tags in order 0 to ... while (!ready && (currentTag <= (TUint)(itemsLeft + currentTag))) { // add found header to correct place in buffer if (decGenApduHeader.Tag() == currentTag) { TASN1DecGeneric decGenApduHeaderDER( itemsData->At(i)->Encoding()); decGenApduHeaderDER.InitL(); TASN1DecOctetString apduHeader; HBufC8* headerBuf = apduHeader.DecodeDERL( decGenApduHeaderDER); CleanupStack::PushL(headerBuf); tmpArray->AppendL(headerBuf->Des()); CleanupStack::PopAndDestroy(headerBuf); ready = ETrue; itemsLeft--; } // there was no header for this tag, so add empty else { tmpArray->AppendL(KNullDesC8()); } currentTag++; } } delete iApduPinHeaders; iApduPinHeaders = tmpArray; // compress to get rid of possible unneccessary slots iApduPinHeaders->Compress(); CleanupStack::Pop(tmpArray); } } } else { iType = EOther; // we won't need others at all } CleanupStack::PopAndDestroy(itemsData); }