// -----------------------------------------------------------------------------
// CCMSEncapsulatedContentInfo::DecodeL
// Decrypts raw data to this instance
// -----------------------------------------------------------------------------
void CCMSEncapsulatedContentInfo::DecodeL( const TDesC8& aRawData )
{
CArrayPtr<TASN1DecGeneric>* itemsData = DecodeSequenceLC( aRawData,
KMinNumberOfSubModules,
KMaxNumberOfSubModules );
// we would not get this far if there is not atleast one
// decoding attribute type
TASN1DecObjectIdentifier decOid;
HBufC* oid = decOid.DecodeDERL( *itemsData->At( 0 ) );
delete iContentType;
iContentType = oid;
// decoding possible content
HBufC8* contDesc = NULL;
if( itemsData->Count() > 1 )
{
TASN1DecGeneric taggedContent( *itemsData->At( 1 ) );
if( taggedContent.Tag() != KContentTag )
{
User::Leave( KErrArgument );
}
TASN1DecOctetString content;
TInt pos = 0;
contDesc = content.DecodeDERL( taggedContent.GetContentDER(), pos );
}
delete iContent;
iContent = contDesc;
CleanupStack::PopAndDestroy( itemsData );
}
void COCSPResponseDecoder::DecodeBasicOCSPResponseL(const TDesC8& aEncoding)
{
CArrayPtr<TASN1DecGeneric>* items = DecodeSequenceLC(aEncoding, 3, 4);
// First, the ResponseData object
DecodeResponseDataL(items->At(0)->Encoding());
// Continue, with the AlgorithmIdentifier
iResponse->iSigningAlgorithm = CX509SigningAlgorithmIdentifier::NewL(items->At(1)->Encoding());
// Now move on to the signature
TASN1DecBitString encBS;
iResponse->iSignature = encBS.ExtractOctetStringL(*items->At(2));
// And finally, the certs (if they're there)
if (items->Count() == 4)
{
// Check explicit tag [0]
TASN1DecGeneric& certsDec = *items->At(3);
if (certsDec.Tag() != KCertificatesTag)
{
User::Leave(OCSP::EMalformedResponse);
}
// It's OK, so decode the response bytes object therein
DecodeCertificatesL(certsDec.GetContentDER());
}
CleanupStack::PopAndDestroy(items);
}
void COCSPResponseDecoder::DecodeOCSPResponseL(const TDesC8& aEncoding)
{
CArrayPtr<TASN1DecGeneric>* items = DecodeSequenceLC(aEncoding, 1, 2);
// Use integer decoding for enumerated
TASN1DecInteger decInt;
TInt status = decInt.DecodeDERShortL(*items->At(0));
if (status == ESuccessfulEncoding)
{
if (items->Count() != 2)
{
User::Leave(OCSP::EMalformedResponse);
}
// Check tag on second part is [0]
// We ignore any other parts in the sequence after that
TASN1DecGeneric& responseBytesDec = *items->At(1);
if (responseBytesDec.Tag() != KResponseBytesTag)
{
User::Leave(OCSP::EMalformedResponse);
}
// It's OK, so decode the response bytes object therein
DecodeResponseBytesL(responseBytesDec.GetContentDER());
}
else
{
if (items->Count() != 1)
{
User::Leave(KErrArgument);
}
switch (status)
{
case EMalformedRequestEncoding:
User::Leave(OCSP::EMalformedRequest);
case EInternalErrorEncoding:
User::Leave(OCSP::EServerInternalError);
break;
case ETryLaterEncoding:
User::Leave(OCSP::ETryLater);
break;
case ESigRequiredEncoding:
User::Leave(OCSP::ESignatureRequired);
break;
case EUnauthorisedEncoding:
User::Leave(OCSP::EClientUnauthorised);
break;
default:
User::Leave(OCSP::EMalformedResponse);
}
}
CleanupStack::PopAndDestroy(items);
}
void COCSPResponseDecoder::DecodeResponseExtensionL(const TDesC8& aEncoding)
{
CArrayPtr<TASN1DecGeneric>* items = DecodeSequenceLC(aEncoding, 2, 3);
// Get oid
TASN1DecGeneric& oid = *items->At(0);
if (oid.Tag() != EASN1ObjectIdentifier)
{
User::Leave(OCSP::EMalformedResponse);
}
TASN1DecObjectIdentifier oidDec;
HBufC* oidVal = oidDec.DecodeDERL(oid);
CleanupStack::PushL(oidVal);
TBool critical = EFalse; // Default value of critical flag
if (items->Count() == 3)
{
// The critical flag is specified - what does it say?
TASN1DecBoolean decBool;
critical = decBool.DecodeDERL(*items->At(1));
}
TASN1DecGeneric& extnVal = items->Count() == 3 ? *items->At(2) : *items->At(1);
if (extnVal.Tag() != EASN1OctetString)
{
User::Leave(OCSP::EMalformedResponse);
}
// Check oid to decide what to do
if (*oidVal == KOCSPOidNonce)
{
iResponse->iNonce.Set(extnVal.GetContentDER());
}
else if (*oidVal == KOCSPOidArchiveCutoff)
{
TASN1DecGeneralizedTime decGT;
TInt pos = 0;
iResponse->iArchiveCutoff = new (ELeave) TTime(decGT.DecodeDERL(extnVal.GetContentDER(), pos));
}
else if (critical)
{
// Didn't understand extension, and it was critical! Erk!
User::Leave(OCSP::EUnknownCriticalExtension);
}
CleanupStack::PopAndDestroy(2, items); // oidVal, items
}
// -----------------------------------------------------------------------------
// CCMSAuthenticatedData::DecodeAttributesL
// Decodes an array of attributes
// -----------------------------------------------------------------------------
CArrayPtrFlat< CCMSAttribute >* CCMSAuthenticatedData::DecodeAttributesL(
TASN1DecGeneric* aAttributesDec ) // generic decoder for the sequence
{
TASN1DecSequence sequenceDecoder;
CArrayPtr< TASN1DecGeneric >* attributes =
sequenceDecoder.DecodeDERLC( *aAttributesDec );
TInt attributeCount = attributes->Count();
if( attributeCount < 1 )
{
User::Leave( KErrArgument );
}
CArrayPtrFlat< CCMSAttribute >* retVal =
new( ELeave ) CArrayPtrFlat< CCMSAttribute >( attributeCount );
CleanupStack::PushL( retVal );
for( TInt i = 0; i < attributeCount; i++ )
{
CCMSAttribute* attribute = CCMSAttribute::NewLC();
attribute->DecodeL( attributes->At( i )->Encoding() );
retVal->AppendL( attribute );
// attribute is left in cleanup stack, as retVal has not been pushed
// with ResetAndDestroyPushL
}
CleanupStack::Pop( attributeCount ); // all attributes
CleanupStack::Pop( retVal );
CleanupStack::PopAndDestroy( attributes );
return retVal;
}
// -----------------------------------------------------------------------------
// CNSmlNotepadDatabase::ResetL
// -----------------------------------------------------------------------------
//
TInt CNSmlNotepadDatabase::ResetL()
{
_NOTEPAD_DBG_FILE("CNSmlNotepadDatabase::ResetL(): begin");
TInt err(KErrNone);
CArrayPtr<CNpdItem>* arrNpdItem = NULL;
// Fetch all the available notes from the db
arrNpdItem = FetchItemsLC();
// Delete the Notes
for( TInt count = 0; count < arrNpdItem->Count(); count++ )
{
CCalEntry* entryTobeDeleted(NULL);
entryTobeDeleted = iEntryView->FetchL( arrNpdItem->At(count)->Key() );
if(entryTobeDeleted)
{
CleanupStack::PushL(entryTobeDeleted);
iEntryView->DeleteL(*entryTobeDeleted);
CleanupStack::Pop(entryTobeDeleted);
}
delete entryTobeDeleted;
entryTobeDeleted = NULL;
}
CleanupStack::PopAndDestroy(arrNpdItem);
_NOTEPAD_DBG_FILE("CNSmlNotepadDatabase::ResetL(): begin");
return err;
}
// -----------------------------------------------------------------------------
// CSIPSettListSIPProfSetADestListItem::EditItemL
// Called before the pop-up list is shown. Updates it, if there was a
// non-matching destination UID at the start-up
// -----------------------------------------------------------------------------
//
void CSIPSettListSIPProfSetDestListItem::EditItemL(
TBool aCalledFromMenu )
{
__GSLOGSTRING("CSIPSettListSIPProfSetDestListItem::EditItemL" )
// Set backup value.
iBackupValue = iEnumValue;
if ( iEnumValue == KUnknownAPUID )
{
// destination was not found, create list for user to change the
// destination.
// The destination will be anyway changed; no matter does the user
// press Cancel or not..(Chosen destination will be the first one
// on the list, if user presses Cancel)
CArrayPtr<CAknEnumeratedText>* textArray = NULL;
CArrayPtr<HBufC>* nullTextArray = NULL;
InitializeListL( textArray, nullTextArray );
if ( textArray->Count() > KErrNone )
{
// There might be situation that no destinationss exist.
iEnumValue = textArray->At( KErrNone )->EnumerationValue();
}
SetEnumeratedTextArrays( textArray, nullTextArray );
HandleTextArrayUpdateL();
}
CAknEnumeratedTextPopupSettingItem::EditItemL( aCalledFromMenu );
}
// -----------------------------------------------------------------------------
// CCMSX509GeneralNames::DecodeL
// Decrypts raw data to this instance
// -----------------------------------------------------------------------------
void CCMSX509GeneralNames::DecodeL( const TDesC8& aRawData )
{
CArrayPtr< TASN1DecGeneric >* nameData =
DecodeSequenceLC( aRawData );
TInt nameCount = nameData->Count();
if( nameCount == 0 )
{
User::Leave( KErrArgument );
}
CArrayPtr< CCMSX509GeneralName >* names =
new( ELeave ) CArrayPtrFlat< CCMSX509GeneralName >( nameCount );
CleanupStack::PushL( names );
for( TInt i = 0; i < nameCount; i++ )
{
CCMSX509GeneralName* name = CCMSX509GeneralName::NewL( );
CleanupStack::PushL( name );
name->DecodeL( nameData->At( i )->Encoding() );
names->AppendL( name );
}
CleanupStack::Pop( nameCount ); // names
CleanupStack::Pop( names );
CleanupStack::PopAndDestroy( nameData );
if( iGeneralNames )
{
iGeneralNames->ResetAndDestroy();
delete iGeneralNames;
}
iGeneralNames = names;
}
TInt CJuikIconManagerImpl::FindEmptySlotL()
{
for ( TInt i = 0; i < iIconArray->Count(); i++ )
{
if ( iIconArray->At(i) == NULL )
return i;
}
return KErrNotFound;
}
void CEncapsulatedContentInfo::ConstructL(const TDesC8& aRawData)
{
const TInt minItems = 1; // Must have OID
const TInt maxItems = 2; // Must have data
CArrayPtr<TASN1DecGeneric>* contentInfo = PKCS7ASN1::DecodeSequenceLC(aRawData, minItems, maxItems);
//Decode Content Type
iContentType=(TCmsContentInfoType)(CmsUtils::DecodeContentTypeL(contentInfo->At(0)));
//Decode Content Data
if(contentInfo->Count() == 2)
{
iIsContentDataPresent=ETrue;
const TASN1DecGeneric* contentInfoAt1 = contentInfo->At(1);
//Decode [0] Explicit
if ( contentInfoAt1->Tag() == 0 || contentInfoAt1->Class() == EContextSpecific )
{
//Decode Wrapper Octet string
TASN1DecGeneric decGen(contentInfoAt1->GetContentDER());
decGen.InitL();
if(decGen.Tag() == EASN1OctetString && decGen.Class() == EUniversal)
{
iContentData.Set(decGen.GetContentDER());
}
else
{
//Wrapper is not an Octect String
User::Leave(KErrArgument);
}
}
else
{
//Not [0] Explicit
User::Leave(KErrArgument);
}
}
else
{
//No optional data
iContentData.Set(KNullDesC8());
}
CleanupStack::PopAndDestroy(contentInfo);
}
// ------------------------------------------------------------------------------------------------
// CNSmlDataModBase::MergeL
// Merges data from old item to new item.
// ------------------------------------------------------------------------------------------------
void CNSmlDataModBase::MergeL( TDes8& aNewItem, const TDesC8& aOldItem,TBool aFieldLevel )
{
TBool modified( EFalse );
CVersitParser* newItemParser = ChildCreateParserLC();
RDesReadStream newStream( aNewItem );
CleanupClosePushL( newStream );
newItemParser->InternalizeL( newStream );
CVersitParser* oldItemParser = ChildCreateParserLC();
RDesReadStream oldStream( aOldItem );
CleanupClosePushL( oldStream );
oldItemParser->InternalizeL( oldStream );
// Now we're ready to start analysis
CArrayPtr<CVersitParser>* newEntities = newItemParser->ArrayOfEntities( EFalse );
CArrayPtr<CVersitParser>* oldEntities = oldItemParser->ArrayOfEntities( ETrue );
if( newEntities && oldEntities )
{
CleanupPtrArrayPushL( oldEntities );
for( TInt i = 0; ( i < newEntities->Count() ) && ( i < oldEntities->Count() ); i++ )
{
MergeEntityL( newEntities->At( i ), oldEntities->At( i ), modified, aFieldLevel );
}
CleanupStack::PopAndDestroy(); // oldEntities
}
else
{
MergeEntityL( newItemParser, oldItemParser, modified, aFieldLevel );
}
// Only update if anything was modified in process
if ( modified )
{
aNewItem.Zero();
RDesWriteStream dws( aNewItem );
CleanupClosePushL( dws );
newItemParser->ExternalizeL( dws );
dws.CommitL();
CleanupStack::PopAndDestroy(); // dws
}
CleanupStack::PopAndDestroy( 4 ); // oldStream, oldItemParser, newStream, newItemParser
}
// -----------------------------------------------------------------------------
// CCMSOriginatorPublicKey::DecodeL
// Decrypts raw data to this instance
// -----------------------------------------------------------------------------
void CCMSOriginatorPublicKey::DecodeL( const TDesC8& aRawData )
{
TASN1DecGeneric decGen( aRawData );
decGen.InitL();
TASN1DecSequence decSeq;
CArrayPtr< TASN1DecGeneric >* itemsData =
decSeq.DecodeDERLC( decGen );
TInt count = itemsData->Count();
if( count != KNumberOfSubModules )
{
User::Leave( KErrArgument );
}
// we would not get this far if there is not 2 elements
// decoding algorithm identifier
CCMSX509AlgorithmIdentifier* algorithm =
CCMSX509AlgorithmIdentifier::NewL( );
CleanupStack::PushL( algorithm );
algorithm->DecodeL( itemsData->At( 0 )->Encoding() );
CleanupStack::Pop( algorithm );
delete iAlgorithm;
iAlgorithm = algorithm;
// decoding public key
TASN1DecGeneric gen( *itemsData->At( 1 ) );
gen.InitL();
// Symbian decoder can't handle zero length bit strings
if( gen.LengthDERContent() > 1 )
{
TASN1DecBitString bitStringDecoder;
HBufC8* tmp = bitStringDecoder.ExtractOctetStringL( gen );
delete iPublicKey;
iPublicKey = tmp;
}
else
{
HBufC8* tmp = KNullDesC8().AllocL();
delete iPublicKey;
iPublicKey = tmp;
}
CleanupStack::PopAndDestroy( itemsData );
}
void CDmAdEngine::CompleteCommandsL(CArrayPtr<CDmAdRtNode>& aRtNodes, TInt aStatus)
{
TRACE("CDmAdEngine::CompleteCommandsL");
for (TInt i=0; i < aRtNodes.Count(); i++)
{
CDmAdRtNode* rtNode = aRtNodes.At(i);
CompleteCommandsL(*rtNode, aStatus);
}
}
CArrayFix<TInt>& CJuikIconManagerImpl::ProviderIconIndexL(TInt aProviderId) const
{
CALLSTACKITEM_N(_CL("CJuikIconManagerImpl"), _CL("ProviderIconIndexL"));
AssertIndexL( *iProviderIconIndexes, aProviderId );
CArrayFix<TInt>* map = iProviderIconIndexes->At(aProviderId);
if ( map )
return *map;
else
Bug( _L("Trying to get removed provider") ).ErrorCode( MakeErrorCode( CONTEXT_UID_JAIKUUIKIT, KErrNotFound ) ).Raise();
return *map; // to please compiler
}
void COCSPResponseDecoder::DecodeResponsesL(const TDesC8& aEncoding)
{
CArrayPtr<TASN1DecGeneric>* items = DecodeSequenceLC(aEncoding);
TInt count = items->Count();
for (TInt index = 0; index < count; ++index)
{
DecodeSingleResponseL(items->At(index)->Encoding());
}
CleanupStack::PopAndDestroy(items);
}
//********************************************************************************************
void CVersitCardTest::CheckNumberOfSoundPropertiesL(const TDesC& aFileName, const CParserVCard& aParser, TInt aExpectedArrayElementCount, TInt aExpectedPropertyCount)
//
// Check that the number of SOUND sub-elements are as expected
//
{
TheTest.Printf(_L("%S\n"), &aFileName);
(void) aFileName;
//
TBool passedTest = EFalse;
CArrayPtr<CParserProperty>* properties = aParser.PropertyL(KVersitTokenSOUND, TUid::Uid(KVersitPropertyHBufCUid), EFalse);
TheTest(properties != NULL);
if (properties)
{
//
CleanupStack::PushL(properties);
const TInt count = properties->Count();
TheTest(count == aExpectedPropertyCount);
//
for(TInt i=0; i<count; i++)
{
const CParserProperty* property = properties->At(i);
// Check that the X-IRMC-N property parameter exists
const TBool foundParam = property->Param(KSoundExtensionPropertyParameterName) != NULL;
TheTest(foundParam);
// Check property value
TheTest(property->Value() != NULL);
CParserPropertyValueHBufC* propertyAsHBufC = static_cast<CParserPropertyValueHBufC*>(property->Value());
// Check property value as an array
CParserPropertyValueCDesCArray* valueAsArray = propertyAsHBufC->TreatAsArrayPropertyLC(*property);
TheTest(valueAsArray->Value() != NULL);
CDesCArray& array = *valueAsArray->Value();
//
const TInt arrayItemCount = array.Count();
TheTest(arrayItemCount == aExpectedArrayElementCount);
for(TInt j=0; j<arrayItemCount; j++)
{
const TPtrC pValue(array[j]);
TheTest.Printf(_L("%S\n"), &pValue);
}
TheTest.Printf(_L("\n"));
CleanupStack::PopAndDestroy(valueAsArray);
//
passedTest = ETrue;
}
CleanupStack::PopAndDestroy(properties);
}
TheTest(passedTest);
}
void COCSPResponseDecoder::DecodeResponseBytesL(const TDesC8& aEncoding)
{
CArrayPtr<TASN1DecGeneric>* items = DecodeSequenceLC(aEncoding, 2, 2);
TASN1DecObjectIdentifier decOid;
HBufC* oid = decOid.DecodeDERL(*items->At(0));
CleanupStack::PushL(oid);
if (*oid != KOCSPOidBasic)
{
User::Leave(OCSP::EUnknownResponseType);
}
TASN1DecGeneric& response = *items->At(1);
if (response.Tag() != EASN1OctetString)
{
User::Leave(OCSP::EMalformedResponse);
}
DecodeBasicOCSPResponseL(response.GetContentDER());
CleanupStack::PopAndDestroy(2, items); // oid, items
}
void CCmsContentInfo::ConstructL(const TDesC8& aRawData)
{
const TInt minItems = 2; // Must have OID
const TInt maxItems = 2; // Must have data
CArrayPtr<TASN1DecGeneric>* contentInfo = PKCS7ASN1::DecodeSequenceLC(aRawData, minItems, maxItems);
//Decode Content Type
iContentType=(TCmsContentInfoType)(CmsUtils::DecodeContentTypeL(contentInfo->At(0)));
//Decode Content Data
const TASN1DecGeneric* contentInfoAt1 = contentInfo->At(1);
if ( contentInfoAt1->Tag() == 0 || contentInfoAt1->Class() == EContextSpecific )
{
TASN1DecGeneric decGen(contentInfoAt1->GetContentDER());
decGen.InitL();
if (iContentType==EContentTypeData)
{
if (decGen.Tag()!=EASN1OctetString || decGen.Class()!=EUniversal)
{
User::Leave(KErrArgument);
}
else
{
iContentData.Set(decGen.GetContentDER());
}
}
else
{
iContentData.Set(decGen.Encoding());
}
}
else
{
User::Leave(KErrArgument);
}
CleanupStack::PopAndDestroy(contentInfo);
}
CArrayPtr<CGulIcon>* CJuikIconManagerImpl::GetProviderIconsL( TInt aProviderId )
{
CALLSTACKITEM_N(_CL("CJuikIconManagerImpl"), _CL("GetProviderIconsL"));
CArrayFix<TInt>& map = ProviderIconIndexL(aProviderId);
auto_ptr< CArrayPtr<CGulIcon> > result( new (ELeave) CArrayPtrFlat<CGulIcon>(map.Count()) );
for( TInt i=0; i < map.Count(); i++)
{
if ( map[i] >= 0 )
result->AppendL( iIconArray->At( map[i] ) );
else
result->AppendL( NULL );
}
return result.release();
}
void CmsUtils::DecodeDigestAlgorithmsL(RPointerArray<CX509AlgorithmIdentifier>& aDigestAlgorithms, const TDesC8& aRawData)
{
CArrayPtr<TASN1DecGeneric>* algsData = PKCS7ASN1::DecodeSequenceLC(aRawData);
TInt count = algsData->Count();
CX509AlgorithmIdentifier* alIdent;
for(TInt item = 0; item < count; item++)
{
alIdent = CX509AlgorithmIdentifier::NewLC(algsData->At(item)->Encoding());
aDigestAlgorithms.AppendL(alIdent);
CleanupStack::Pop(alIdent);
}
CleanupStack::PopAndDestroy(algsData);
}
// -----------------------------------------------------------------------------
// CSIPSettListSIPProfSetTypeListItem::EditItemL
// Called before the pop-up list is shown. Updates it, if there was a
// non-matching AP UID at the start-up
// -----------------------------------------------------------------------------
//
void CSIPSettListSIPProfSetTypeListItem::EditItemL(
TBool aCalledFromMenu )
{
__GSLOGSTRING("CSIPSettListSIPProfSetTypeListItem::EditItemL Start" )
CArrayPtr<CAknEnumeratedText>* array = EnumeratedTextArray();
TBool found = EFalse;
TInt i( 0 );
for ( i = 0; i < array->Count(); i++ )
{
if ( array->At( i )->EnumerationValue() == iEnumValue )
{
found = ETrue;
}
}
if ( !found && array->Count() > KErrNone )
{
iEnumValue = array->At( 0 )->EnumerationValue();
}
CAknEnumeratedTextPopupSettingItem::EditItemL( aCalledFromMenu );
__GSLOGSTRING("CSIPSettListSIPProfSetTypeListItem::EditItemL End" )
}
// ------------------------------------------------------------------------------------------------
// CNSmlDataModBase::StripL
// Strips data that is to be transmitted to the sync partner.
// ------------------------------------------------------------------------------------------------
void CNSmlDataModBase::StripL( TDes8& aItem )
{
_DBG_FILE("CNSmlDataModBase::StripL(): begin");
if ( !NeedsMerge() )
{
if ( iUsedRemoteMimeType == -1 )
{
User::Leave( KErrNotFound );
}
return;
}
TBool modified( EFalse );
CVersitParser* parser = ChildCreateParserLC();
RDesReadStream drs( aItem );
CleanupClosePushL( drs );
parser->InternalizeL( drs );
// Now we're ready to start analysis
CArrayPtr<CVersitParser>* entities = parser->ArrayOfEntities( EFalse );
if( entities )
{
for( TInt i = 0; i < entities->Count(); i++ )
{
StripEntityL( entities->At( i ), modified );
}
}
else
{
StripEntityL( parser, modified );
}
// Only update if anything was modified in process
if( modified )
{
aItem.Zero();
RDesWriteStream dws( aItem );
CleanupClosePushL( dws );
parser->ExternalizeL( dws );
dws.CommitL();
CleanupStack::PopAndDestroy(); // dws
}
CleanupStack::PopAndDestroy( 2 ); // drs, parser
_DBG_FILE("CNSmlDataModBase::StripL(): end");
}
// -----------------------------------------------------------------------------
// CPIMEventPropertyConverter::ConvertExDatePropertyL
// Inserts EXDATE proprety from a vEvent to a PIM Event Item as a repeat rule
// field
// -----------------------------------------------------------------------------
//
void CPIMEventPropertyConverter::ConvertExDatePropertyL(
const CPIMParserProperty& aProperty, // property to convert
CPIMEventItem& aItem) // item to insert the field to
{
JELOG2(EPim);
if (aProperty.Name().CompareF(KVersitTokenEXDATE) != 0)
{
// some unsupported multidate
return;
}
MPIMRepeatRuleData* repeatRule = aItem.GetRepeat();
CParserPropertyValueMultiDateTime* propertyValue =
static_cast<CParserPropertyValueMultiDateTime*>(aProperty.Value());
CArrayPtr<TVersitDateTime>* value = propertyValue->Value();
TInt valueCount = value->Count();
for (TInt i = 0; i < valueCount; i++)
{
TPIMDate date(value->At(i)->iDateTime);
repeatRule->AddExceptDateL(date);
}
}
// -----------------------------------------------------------------------------
// CCMSX509CertificateList::DecodeExtensionsL
// Decodes Extensions
// -----------------------------------------------------------------------------
CArrayPtrFlat<CX509CertExtension>* CCMSX509CertificateList::DecodeExtensionsL(
const TASN1DecGeneric* aExtensions )
{
CArrayPtr<TASN1DecGeneric>* extens =
DecodeSequenceLC( aExtensions->Encoding() );
TInt extensionCount = extens->Count();
CArrayPtrFlat< CX509CertExtension >* tmpExtensions =
new(ELeave)CArrayPtrFlat< CX509CertExtension >( KDefaultGranularity );
CleanupStack::PushL( tmpExtensions );
CleanupResetAndDestroyPushL( *tmpExtensions );
for( TInt j = 0; j < extensionCount; j++ )
{
CX509CertExtension* extension =
CX509CertExtension::NewLC( extens->At( j )->Encoding() );
tmpExtensions->AppendL( extension );
CleanupStack::Pop( extension );
}
CleanupStack::Pop( tmpExtensions ); // ResetAndDestroy
CleanupStack::Pop( tmpExtensions ); // normal cleanup
CleanupStack::PopAndDestroy( extens );
return tmpExtensions;
}
void CWapDgrmTestStep::_PrintL(CArrayPtr<CSmsMessage>& aSmsArray)
/**
* print an array of SMS messages to the console
*/
{
TInt Count = aSmsArray.Count();
TInt j = 1;
for (TInt i=0;i<Count;i++,j++)
{
// Ordinal
_Print(i);
_Print(_L8(": \n"));
CSmsMessage* Sms = aSmsArray.At(i);
_Print(*Sms);
// Print data
CSmsBufferBase& SmsBuffer = Sms->Buffer();
_PrintL(SmsBuffer);
}
}
// -----------------------------------------------------------------------------
// CSTSPath::DecodeL
// Decrypts raw data to this instance
// -----------------------------------------------------------------------------
void CSTSPath::DecodeL(const TDesC8& aRawData)
{
CArrayPtr<TASN1DecGeneric>* itemsData = DecodeSequenceLC(ETrue, //must be sequence
aRawData, KSTSMinNumberOfSubModules, KSTSMaxNumberOfSubModules);
// we would not get this far if there is not 1-3 elements
TInt pos = 0;
if (pos >= itemsData->Count())
{
User::Leave(KErrArgument);
}
//decoding Path (octet string)
TASN1DecOctetString path;
HBufC8* tmpPath = path.DecodeDERL(*itemsData->At(pos++));
delete iPath;
iPath = tmpPath;
//optional index and optional length are not needed
CleanupStack::PopAndDestroy(itemsData);
}
void CmsUtils::DecodeCertificatesL(RPointerArray<CCmsCertificateChoice>& aCertificates, const TDesC8& aRawData)
{
TASN1DecGeneric decGen(aRawData);
decGen.InitL();
TASN1DecSequence decSeq;
// have to do manual decoding of sequence because field is optional
CArrayPtr<TASN1DecGeneric>* items = NULL;
items = decSeq.DecodeDERLC(decGen);
TInt count = items->Count();
CCmsCertificateChoice* certificate;
for(TInt item = 0; item < count; item++)
{
certificate = CCmsCertificateChoice::NewL(items->At(item)->Encoding());
CleanupStack::PushL(certificate);
aCertificates.AppendL(certificate);
CleanupStack::Pop(certificate);
}
CleanupStack::PopAndDestroy(items);
}
void CDmAdEngine::SaveRtNodesL(void)
{
TRACE("CDmAdEngine::SaveRtNodesL");
CArrayPtr<CDmAdRtNode>* topLevelRtNodes;
BuildTopLevelRtNodesListLC(iRtNodes, topLevelRtNodes);
TInt countRtNodes;
countRtNodes = topLevelRtNodes->Count();
TInt i;
for (i=0; i < countRtNodes; i++)
{
CDmAdRtNode* rtNode = topLevelRtNodes->At(i);
CArrayPtr<CDmAdRtNode>* childRtNodes;
BuildChildRtNodesListLC(iRtNodes, rtNode->Uri(), childRtNodes);
TRAPD(err, iStoreApi->SaveTopLevelRtNodeL(*rtNode, *childRtNodes));
CompleteCommandsL(*rtNode, err);
CompleteCommandsL(*childRtNodes, err);
CleanupStack::PopAndDestroy(); //childRtNodes
}
CleanupStack::PopAndDestroy(); //topLevelRtNodes
//child rtNodes without top level RtNode
countRtNodes = iRtNodes->Count();
for (i=0; i < countRtNodes; i++)
{
CDmAdRtNode* rtNode = iRtNodes->At(i);
TInt err = KErrNone;
if (!rtNode->IsJustFetched())
{
TRAP(err, iStoreApi->SaveChildLevelRtNodeL(*rtNode));
}
CompleteCommandsL(*rtNode, err);
}
iRtNodes->ResetAndDestroy();
}
TInt CJuikIconManagerImpl::GetNewProviderIdL()
{
CALLSTACKITEM_N(_CL("CJuikIconManagerImpl"), _CL("GetNewProviderIdL"));
TInt providerIx = KErrNotFound;
for ( TInt i = 0; i < iProviderIconIndexes->Count(); i++)
{
if ( iProviderIconIndexes->At(i) == NULL )
{
providerIx = i;
break;
}
}
if ( providerIx == KErrNotFound )
{
iProviderIconIndexes->AppendL( new (ELeave) CArrayFixFlat<TInt>(3) );
return LastIndex( *iProviderIconIndexes );
}
else
{
(*iProviderIconIndexes)[providerIx] = new (ELeave) CArrayFixFlat<TInt>(3);
return providerIx;
}
}
// ------------------------------------------------------------------------------------------------
// CNSmlDataModBase::MergeEntityL
// Merges data from old entity to new entity.
// ------------------------------------------------------------------------------------------------
void CNSmlDataModBase::MergeEntityL( CVersitParser* aNewEntity, CVersitParser* aOldEntity, TBool& aModified, TBool aFieldLevel ) const
{
_DBG_FILE("CNSmlDataModBase::MergeEntityL(): begin");
// Remove all data that was not supposed to be supported by the partner but
// it was still sent to us.
StripAllNotOnPartnerListL( aNewEntity, aModified );
if( !aFieldLevel )
{
// Remove all properties from old item that are supported by remote server.
// If it is field level then old this is not done.
StripAllOnPartnerListL( aOldEntity, aModified, ETrue );
CArrayPtr<CParserProperty>* mergeProps = aOldEntity->ArrayOfProperties( ETrue );
if( mergeProps )
{
CleanupStack::PushL( mergeProps );
for( TInt i = 0; i < mergeProps->Count(); i++ )
{
aNewEntity->AddPropertyL( mergeProps->At( i ), ETrue );
}
CleanupStack::PopAndDestroy(); // mergeProps
}
}
else // Support for Field level merge
{
//Field level merge. Merge new item with old item. Properties of
//the old item are copied to new item if the new item entity does not
//contain certain property.
//------------------------------------------------------------------------
// Old New Merged
//------------------------------------------------------------------------
// BEGIN:VCARD -> BEGIN:VCARD = BEGIN:VCARD
// VERSION:2.1 -> VERSION:2.1 = VERSION:2.1
// N:Smith;John -> N:White;John = N:White;John
// ORG:Firm = ORG:Firm
// TITLE:Boss = TITLE:Boss
// -> TEL;CELL;VOICE:1234 = TEL;CELL;VOICE:1234
// END:VCARD -> END:VCARD = END:VCARD
CArrayPtr<CParserProperty>* newProps = aNewEntity->ArrayOfProperties( EFalse );
if( newProps )
{
CArrayPtr<CParserProperty>* oldProps = aOldEntity->ArrayOfProperties( EFalse );
// Iterate through old list of properties. Add missing properties from old
// contact item, if some of the properties is not included in new item.
for( TInt i = 0; i < oldProps->Count(); )
{
CParserProperty* oldProperty = oldProps->At( i );
//Check if the property is included in received vCard
CArrayPtr<CParserProperty>* properties = aNewEntity->PropertyL(
oldProperty->Name(), oldProperty->Uid(), EFalse );
if ( !properties )
{
// New vCard does not include certain property. Copy all matching properties from
// existing contact item.
CArrayPtr<CParserProperty>* oldProperties =
aOldEntity->PropertyL( oldProperty->Name(), oldProperty->Uid(), ETrue );
CleanupPtrArrayPushL( oldProperties );
for ( TInt j = oldProperties->Count()-1; j >= 0; --j )
{
CParserProperty* property = oldProperties->At( j );
oldProperties->Delete( j );
CleanupStack::PushL( property );
aNewEntity->AddPropertyL( property, EFalse );
CleanupStack::Pop( property );
aModified = ETrue;
}
CleanupStack::PopAndDestroy( oldProperties );
}
else
{
// If new vCard includes at least one property with same name we will not copy
// any any property with same name from existing contact item.
delete properties;
++i;
}
}
}
}
#ifdef __NSML_DEBUG__
CArrayPtr<CParserProperty>* props = aNewEntity->ArrayOfProperties( EFalse );
for( TInt i = 0; i < props->Count(); i++ )
{
TBuf8<512> b;
const CParserProperty* p = props->At( i );
b = p->Name();
const CArrayPtr<CParserParam>* pa = ( ( CNSmlProperty* )p )->Parameters();
if( pa )
{
for( TInt i2 = 0; i2 < pa->Count(); i2++ )
{
b.Append( _L8(":") );
b.Append( pa->At( i2 )->Name() );
}
}
DBG_ARGS8(_S8("CNSmlDataModBase::MergeEntityL(): %S"), &b);
}
#endif // __NSML_DEBUG__
_DBG_FILE("CNSmlDataModBase::MergeEntityL(): end");
}