diff -r 0f9fc722d255 -r b9b00b134b0d omadmadapters/nsmldmbmadapter/src/nsmldmbmadapter.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/omadmadapters/nsmldmbmadapter/src/nsmldmbmadapter.cpp Tue Jul 13 03:51:25 2010 +0530 @@ -0,0 +1,1675 @@ +/* +* Copyright (c) 2006 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: Bearer management DM adapter. Provides handling of + Bearer management related settings in Device management +* +*/ + + + +#include +#include + +#include "nsmldmbmadapter.h" +#include "bmadapterlogger.h" + +// ======== MEMBER FUNCTIONS ======== + + +// -------------------------------------------------------------------------- +// Maps plugin UID to its factory function (constructor) +// -------------------------------------------------------------------------- +const TImplementationProxy ImplementationTable[] = + { + IMPLEMENTATION_PROXY_ENTRY(0x101f6d2f, + CNSmlDmBmAdapter::NewL) + }; + +// -------------------------------------------------------------------------- +// For ecom plugin implementation +// ------------------------------------------------------------------------- + +EXPORT_C const TImplementationProxy* ImplementationGroupProxy( TInt& aTableCount ) + { + aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy); + return ImplementationTable; + } + +// -------------------------------------------------------------------------- +// CNSmlDmBmAdapter::NewL +// -------------------------------------------------------------------------- +CNSmlDmBmAdapter* CNSmlDmBmAdapter::NewL( MSmlDmCallback* aDmCallback ) + { + BMADAPTERLOGSTRING("CNSmlDmBmAdapter::NewL: Start") + CNSmlDmBmAdapter* self = new (ELeave) CNSmlDmBmAdapter( aDmCallback ); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop( self ); + BMADAPTERLOGSTRING("CNSmlDmBmAdapter::NewL: End") + return self; + } + +// -------------------------------------------------------------------------- +// CNSmlDmBmAdapter::CNSmlDmBmAdapter +// -------------------------------------------------------------------------- + +CNSmlDmBmAdapter::CNSmlDmBmAdapter( MSmlDmCallback* aDmCallback ) + : CSmlDmAdapter( aDmCallback ) + { + } + +// -------------------------------------------------------------------------- +// CNSmlDmBmAdapter::ConstructL +// -------------------------------------------------------------------------- +void CNSmlDmBmAdapter::ConstructL() + { + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::CNSmlDmBmAdapter: Start" ) + iSettingStore = CNSmlDmBmSettingStore::NewL( this ); + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::CNSmlDmBmAdapter: End" ) + } + +// -------------------------------------------------------------------------- +// CNSmlDmBmAdapter::~CNSmlDmBmAdapter +// -------------------------------------------------------------------------- +CNSmlDmBmAdapter::~CNSmlDmBmAdapter() + { + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::~CNSmlDmBmAdapter: Start" ) + iBuffer.ResetAndDestroy(); + iBuffer.Close(); + delete iSettingStore; + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::~CNSmlDmBmAdapter: End" ) + } + +// -------------------------------------------------------------------------- +// CNSmlDmBmAdapter::DDFVersionL +// Returns ddf version nr +// -------------------------------------------------------------------------- +void CNSmlDmBmAdapter::DDFVersionL( CBufBase& aDDFVersion ) + { + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::DDFVersionL: Start" ) + aDDFVersion.InsertL( 0, KNSmlDmBMAdapterDDFVersion ); + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::DDFVersionL:End" ) + } + +// -------------------------------------------------------------------------- +// CNSmlDmBmAdapter::DDFStructureL +// Constructs the DDF structure +// -------------------------------------------------------------------------- +void CNSmlDmBmAdapter::DDFStructureL( MSmlDmDDFObject& aDDF ) + { + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::DDFStructureL: Start" ) + TSmlDmAccessTypes accessTypes; + + // BearerManagementSNAP + MSmlDmDDFObject& bm = aDDF.AddChildObjectL( KNSmlDmBMAdapterBM ); + accessTypes.SetGet(); + accessTypes.SetAdd(); + bm.SetAccessTypesL( accessTypes ); + bm.SetOccurenceL( MSmlDmDDFObject::EOne ); + bm.SetScopeL( MSmlDmDDFObject::EPermanent ); + bm.SetDFFormatL( MSmlDmDDFObject::ENode ); + bm.AddDFTypeMimeTypeL( KNSmlDmBMAdapterTextPlain ); + bm.SetDescriptionL( KNSmlDmBMAdapterBMDescription ); + accessTypes.Reset(); + + + // BearerManagementSNAP/ + MSmlDmDDFObject& dynamic1 = bm.AddChildObjectGroupL(); + accessTypes.SetAdd(); + accessTypes.SetDelete(); + accessTypes.SetGet(); + accessTypes.SetReplace(); + dynamic1.SetAccessTypesL( accessTypes ); + dynamic1.SetOccurenceL( MSmlDmDDFObject::EZeroOrMore ); + dynamic1.SetScopeL( MSmlDmDDFObject::EDynamic ); + dynamic1.SetDFFormatL( MSmlDmDDFObject::ENode ); + dynamic1.AddDFTypeMimeTypeL( KNSmlDmBMAdapterTextPlain ); + dynamic1.SetDescriptionL( KNSmlDmBMAdapterDynamicDescription ); + accessTypes.Reset(); + + + // BearerManagementSNAP//Name + MSmlDmDDFObject& name = dynamic1.AddChildObjectL( KNSmlDmBMAdapterName ); + accessTypes.SetAdd(); + accessTypes.SetGet(); + accessTypes.SetReplace(); + name.SetAccessTypesL( accessTypes ); + name.SetOccurenceL( MSmlDmDDFObject::EOne ); + name.SetScopeL( MSmlDmDDFObject::EDynamic ); + name.SetDFFormatL( MSmlDmDDFObject::EChr ); + name.SetDescriptionL( KNSmlDmBMAdapterNameDescription ); + accessTypes.Reset(); + + // BearerManagementSNAP//IAPPrioityList + MSmlDmDDFObject& iapList = + dynamic1.AddChildObjectL( KNSmlDmBMAdapterIAPPriorityList ); + accessTypes.SetAdd(); + accessTypes.SetGet(); + accessTypes.SetReplace(); + iapList.SetAccessTypesL( accessTypes ); + iapList.SetOccurenceL( MSmlDmDDFObject::EOne ); + iapList.SetScopeL( MSmlDmDDFObject::EDynamic ); + iapList.SetDFFormatL( MSmlDmDDFObject::EChr ); + iapList.SetDescriptionL( KNSmlDmBMAdapterIAPPriorityListDescription ); + accessTypes.Reset(); + + // BearerManagementSNAP//EmbeddedSNAP + MSmlDmDDFObject& embedded = + dynamic1.AddChildObjectL( KNSmlDmBMAdapterEmbeddedSNAP ); + accessTypes.SetAdd(); + accessTypes.SetDelete(); + accessTypes.SetGet(); + accessTypes.SetReplace(); + embedded.SetAccessTypesL( accessTypes ); + embedded.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne ); + embedded.SetScopeL( MSmlDmDDFObject::EDynamic ); + embedded.SetDFFormatL( MSmlDmDDFObject::EChr ); + embedded.SetDescriptionL( KNSmlDmBMAdapterEmbeddedSNAPDescription ); + accessTypes.Reset(); + + // BearerManagementSNAP//Metadata + MSmlDmDDFObject& metadata = + dynamic1.AddChildObjectL( KNSmlDmBMAdapterMetadata ); + accessTypes.SetAdd(); + accessTypes.SetGet(); + accessTypes.SetReplace(); + metadata.SetAccessTypesL( accessTypes ); + metadata.SetOccurenceL( MSmlDmDDFObject::EOne ); + metadata.SetScopeL( MSmlDmDDFObject::EDynamic ); + metadata.SetDFFormatL( MSmlDmDDFObject::EInt ); + metadata.SetDescriptionL( KNSmlDmBMAdapterMetadataDescription ); + accessTypes.Reset(); + + + // BearerManagementSNAP//Protected + MSmlDmDDFObject& protection = + dynamic1.AddChildObjectL( KNSmlDmBMAdapterProtected ); + accessTypes.SetAdd(); + accessTypes.SetGet(); + accessTypes.SetReplace(); + protection.SetAccessTypesL( accessTypes ); + protection.SetOccurenceL( MSmlDmDDFObject::EOne ); + protection.SetScopeL( MSmlDmDDFObject::EDynamic ); + protection.SetDFFormatL( MSmlDmDDFObject::EInt ); + protection.SetDescriptionL( KNSmlDmBMAdapterProtectedDescription ); + accessTypes.Reset(); + + // BearerManagementSNAP//Hidden + MSmlDmDDFObject& hidden = dynamic1.AddChildObjectL( KNSmlDmBMAdapterHidden ); + accessTypes.SetAdd(); + accessTypes.SetGet(); + accessTypes.SetReplace(); + hidden.SetAccessTypesL( accessTypes ); + hidden.SetOccurenceL( MSmlDmDDFObject::EOne ); + hidden.SetScopeL( MSmlDmDDFObject::EDynamic ); + hidden.SetDFFormatL( MSmlDmDDFObject::EBool ); + hidden.SetDescriptionL( KNSmlDmBMAdapterHiddenDescription ); + accessTypes.Reset(); + + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::DDFStructureL: End" ) + } + +// ------------------------------------------------------------------------- +// CNSmlDmBmAdapter::UpdateLeafObjectL +// Adds or updates leaf node value. If snap object is +// in buffer this command is also buffered. Also if leaf node +// is embedded snap and that snap is buffered, the argument command +// is buffered. +// ------------------------------------------------------------------------- +void CNSmlDmBmAdapter::UpdateLeafObjectL( const TDesC8& aURI, + const TDesC8& aLUID, + const TDesC8& aObject, + const TDesC8& /*aType*/, + TInt aStatusRef ) + { + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::UpdateLeafObjectL: Start" ) + BMADAPTERLOGSTRING4( "\tUpdateLeafObjectL \tURI: %S, \n\tLUID: %S,\ + \tobject: %S ", + &aURI, &aLUID, &aObject ) + + TInt snapId = MapPredefinedSnapsL( aURI, aLUID ); + + // Check if parent snap node is found in the buffered settings + CSmlDmBmSettingsElement* snap = + GetSnapIfBuffered( RemoveLastURISeg( aURI ) ); + + // data for buffered SNAP -> Store command into buffer + if ( snap ) + { + CSmlDmBmCommandElement* cmd = + CSmlDmBmCommandElement::NewLC( ETrue, + aStatusRef, + KNSmlDmBmInvalidRef, + CNSmlDmBmAdapter::EAddCmd, + LastURISeg( aURI ), + aObject); + snap->NodeBuf().AppendL(cmd); + CleanupStack::Pop( cmd ); + BMADAPTERLOGSTRING2( "\tSnap %S found, buffering cmd", + snap->MappingName() ) + + } + // updates for an existing SNAP + else + { + + // If setting embedded SNAP node and the embedded SNAP node is still + // buffered -> Buffer also this command + if( !LastURISeg( aURI ).Compare( KNSmlDmBMAdapterEmbeddedSNAP ) ) + { + snap = GetSnapIfBuffered( aObject ); + + // embedded SNAP is buffered + if ( snap ) + { + CSmlDmBmCommandElement* cmd = + CSmlDmBmCommandElement::NewLC( ETrue, + aStatusRef, + KNSmlDmBmInvalidRef, + CNSmlDmBmAdapter::EAddCmd, + LastURISeg( aURI ), + aObject); + + // buffer this command + CSmlDmBmSettingsElement* setting = + CSmlDmBmSettingsElement::NewLC( RemoveLastURISeg( aURI ) ); + + // Check if SNAP was predefined or not + if( snapId == KErrNotFound ) + { + snapId = DesToIntL( aLUID ); + } + setting->SetLuid( snapId ); + iBuffer.AppendL( setting ); + CleanupStack::Pop( setting ); + setting->NodeBuf().AppendL(cmd); + CleanupStack::Pop( cmd ); + BMADAPTERLOGSTRING2( "\tEmbedded Snap %S buffered, buffering cmd", + snap->MappingName() ) + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::UpdateLeafObjectL: End" ) + return; + } + } + // execute command and return status + CSmlDmBmCommandElement* cmd = + CSmlDmBmCommandElement::NewLC( ETrue, + aStatusRef, + KNSmlDmBmInvalidRef, + CNSmlDmBmAdapter::EAddCmd, + LastURISeg( aURI ), + aObject); + if( snapId == KErrNotFound ) + { + snapId = DesToIntL( aLUID ); + } + iSettingStore->ExecuteCmdL( *cmd, snapId ); + BMADAPTERLOGSTRING2( "\tCmd executed with status: %d", + cmd->Status() ) + Callback().SetStatusL( aStatusRef, cmd->Status() ); + CleanupStack::PopAndDestroy( cmd ); + + } + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::UpdateLeafObjectL: End" ) + } +// -------------------------------------------------------------------------- +// CNSmlDmBmAdapter::DeleteObjectL +// Deletes node or leaf object. If the snap this command relates to is +// buffered, also the delete command is buffered. +// -------------------------------------------------------------------------- + +void CNSmlDmBmAdapter::DeleteObjectL( const TDesC8& aURI, + const TDesC8& aLUID, + TInt aStatusRef ) + { + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::DeleteObjectL: Start" ) + BMADAPTERLOGSTRING3( "\tDeleteObjectL \tURI: %S, \tLUID: %S", + &aURI, &aLUID ) + + CSmlDmBmCommandElement* cmd; + + TInt snapId = MapPredefinedSnapsL( aURI, aLUID ); + // check if node or leaf object and create command accordingly + // when updating, make sure that cmd is constructed + if ( NumOfURISegs( aURI ) == KNsmlDmBmSNAPNodeDepth ) + { + cmd = CSmlDmBmCommandElement::NewLC( EFalse, + aStatusRef, + KNSmlDmBmInvalidRef, + CNSmlDmBmAdapter::EDeleteCmd, + KNullDesC8, KNullDesC8 ); + } + else if ( ! LastURISeg( aURI ).Compare( KNSmlDmBMAdapterEmbeddedSNAP() ) ) + { + cmd = CSmlDmBmCommandElement::NewLC( ETrue, + aStatusRef, + KNSmlDmBmInvalidRef, + CNSmlDmBmAdapter::EDeleteCmd, + LastURISeg( aURI ), + KNullDesC8 ); + } + else + { + // unsupported node, framework should check this + Callback().SetStatusL( aStatusRef, CSmlDmAdapter::EError ); + BMADAPTERLOGSTRING( "\tCNSmlDmBmAdapter::DeleteObjectL: \ + Error, unsupported node" ) + return; + } + + // If this SNAP still in buffer -> buffer command for later execution + // Check if SNAP is found in the buffered settings + CSmlDmBmSettingsElement* snap = NULL; + if( cmd->Leaf() ) + { + snap = GetSnapIfBuffered( RemoveLastURISeg( aURI ) ); + } + else + { + snap = GetSnapIfBuffered( aURI ); + } + // when updating make sure that cmd is removed from cleanup + // stack and deleted if necessary + + // if cmd for buffered snap append cmd to buffer + if ( snap ) + { + snap->NodeBuf().AppendL( cmd ); + CleanupStack::Pop( cmd ); + BMADAPTERLOGSTRING2( "\tSnap %S found, buffering cmd", + snap->MappingName() ) + } + // if existing node, execute command + else if( aLUID.Length() > 0 || snapId != KErrNotFound ) + { + if( snapId == KErrNotFound ) + { + snapId = DesToIntL( aLUID ); + } + iSettingStore->ExecuteCmdL( *cmd, snapId ); + BMADAPTERLOGSTRING2( "\tCmd executed with status: %d ", + cmd->Status() ) + Callback().SetStatusL( aStatusRef, cmd->Status() ); + CleanupStack::PopAndDestroy( cmd ); + } + // unknown node + else + { + BMADAPTERLOGSTRING( "\tUnknown node\n" ) + Callback().SetStatusL( aStatusRef, CSmlDmAdapter::ENotFound ); + CleanupStack::PopAndDestroy( cmd ); + } + + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::DeleteObjectL: End" ) + } +// ------------------------------------------------------------------------- +// CNSmlDmBmAdapter::FetchLeafObjectL +// Fetches leaf object value. If the snap is buffered also this command +// will +// be buffered. +// ------------------------------------------------------------------------- +void CNSmlDmBmAdapter::FetchLeafObjectL( const TDesC8& aURI, + const TDesC8& aLUID, + const TDesC8& /*aType*/, + const TInt aResultsRef, + const TInt aStatusRef ) + { + BMADAPTERLOGSTRING( "NSmlDmBMAdapter::FetchLeafObjectL: Start" ) + BMADAPTERLOGSTRING3( "\tFetchLeafObjectL \tURI: %S, \tLUID: %S,", + &aURI, &aLUID ) + + TInt snapId = MapPredefinedSnapsL( aURI, aLUID ); + + // check if parent snap node is buffered + CSmlDmBmSettingsElement* snap = + GetSnapIfBuffered( RemoveLastURISeg( aURI ) ); + + // data for buffered SNAP -> Store command into buffer + if ( snap ) + { + CSmlDmBmCommandElement* cmd = + CSmlDmBmCommandElement::NewLC( ETrue, + aStatusRef, + aResultsRef, + CNSmlDmBmAdapter::EGetCmd, + LastURISeg( aURI ), + KNullDesC8); + snap->NodeBuf().AppendL( cmd ); + CleanupStack::Pop( cmd ); + BMADAPTERLOGSTRING2( "\tSnap %S found, buffering cmd", + snap->MappingName() ) + } + // otherwise execute cmd right away + else + { + + CSmlDmBmCommandElement* cmd = + CSmlDmBmCommandElement::NewLC( ETrue, + aStatusRef, + aResultsRef, + CNSmlDmBmAdapter::EGetCmd, + LastURISeg( aURI ), + KNullDesC8); + if( snapId == KErrNotFound ) + { + snapId = DesToIntL( aLUID ); + } + + iSettingStore->ExecuteCmdL( *cmd, snapId ); + BMADAPTERLOGSTRING2( "\tCmd executed with status: %d ", + cmd->Status() ) + // if executed return status + if ( cmd->Executed() ) + { + Callback().SetStatusL( aStatusRef, cmd->Status() ); + // if successful set results + if ( cmd->Status() == CSmlDmAdapter::EOk ) + { + BMADAPTERLOGSTRING2( "\tCmd executed with result: %S ", + cmd->Data() ) + CBufBase* result = CBufFlat::NewL( cmd->Data()->Size() ); + CleanupStack::PushL( result ); + result->InsertL( 0, *cmd->Data() ); + Callback().SetResultsL( aResultsRef, *result, KNullDesC8 ); + CleanupStack::PopAndDestroy( result ); + } + } + else + { + // failed to execute command + Callback().SetStatusL( aStatusRef, CSmlDmAdapter::EError ); + } + CleanupStack::PopAndDestroy( cmd ); + } + + BMADAPTERLOGSTRING( "NSmlDmBMAdapter::FetchLeafObjectL: End" ) + } + +// -------------------------------------------------------------------------- +// CNSmlDmBmAdapter::FetchLeafObjectSizeL +// Fetches leaf object size. If the snap is buffered also this command will +// be buffered. +// ------------------------------------------------------------------------- +void CNSmlDmBmAdapter::FetchLeafObjectSizeL( const TDesC8& aURI, + const TDesC8& aLUID, + const TDesC8& /* aType */, + TInt aResultsRef, + TInt aStatusRef ) + { + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::FetchLeafObjectSizeL: Start" ) + BMADAPTERLOGSTRING3( "\tFetchLeafObjectSizeL \tURI: %S, \tLUID: %S,", + &aURI, &aLUID ) + + TInt snapId = MapPredefinedSnapsL( aURI, aLUID ); + + // check if parent snap node is buffered + CSmlDmBmSettingsElement* snap = + GetSnapIfBuffered( RemoveLastURISeg( aURI ) ); + + // data for buffered SNAP -> Store command into buffer + if ( snap ) + { + CSmlDmBmCommandElement* cmd = + CSmlDmBmCommandElement::NewLC( ETrue, + aStatusRef, + aResultsRef, + CNSmlDmBmAdapter::EGetSizeCmd, + LastURISeg( aURI ), + KNullDesC8); + snap->NodeBuf().AppendL( cmd ); + CleanupStack::Pop( cmd ); + BMADAPTERLOGSTRING2( "\tSnap %S found, buffering cmd", + snap->MappingName() ) + } + // otherwise execute get size cmd right away + else + { + CSmlDmBmCommandElement* cmd = + CSmlDmBmCommandElement::NewLC( ETrue, + aStatusRef, + aResultsRef, + CNSmlDmBmAdapter::EGetSizeCmd, + LastURISeg( aURI ), + KNullDesC8); + if( snapId == KErrNotFound ) + { + snapId = DesToIntL( aLUID ); + } + iSettingStore->ExecuteCmdL( *cmd, snapId ); + BMADAPTERLOGSTRING2( "\tCmd executed with status: %d ", + cmd->Status() ) + // if executed get status + if ( cmd->Executed() ) + { + Callback().SetStatusL( aStatusRef, cmd->Status() ); + // if successful get results + if ( cmd->Status() == CSmlDmAdapter::EOk ) + { + BMADAPTERLOGSTRING2( "\tCmd executed with result: %S ", + cmd->Data() ) + CBufBase* result = CBufFlat::NewL( cmd->Data()->Size() ); + CleanupStack::PushL( result ); + result->InsertL( 0, *cmd->Data() ); + Callback().SetResultsL( aResultsRef, *result, KNullDesC8 ); + CleanupStack::PopAndDestroy( result ); + } + } + else + { + // failed to execute command + Callback().SetStatusL( aStatusRef, CSmlDmAdapter::EError ); + } + + CleanupStack::PopAndDestroy( cmd ); + } + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::FetchLeafObjectSizeL: End" ) + } + +// ------------------------------------------------------------------------ +// CNSmlDmBmAdapter::ChildURIListL +// Fetches child nodes of a node. these may be either all snap nodes +// or leaf nodes under a snap node. +// ------------------------------------------------------------------------ +void CNSmlDmBmAdapter::ChildURIListL( const TDesC8& aURI, + const TDesC8& aLUID, + const CArrayFix& + aPreviousURISegmentList, + TInt aResultsRef, + TInt aStatusRef ) + { + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::ChildURIListL: Start" ) + BMADAPTERLOGSTRING3( "\tChildURIListL URI: %S, LUID: %S ", + &aURI, &aLUID ) + + TInt snapId = MapPredefinedSnapsL( aURI, aLUID ); + + CBufBase* resultList = CBufFlat::NewL( KSmlMaxURISegLen ); + CleanupStack::PushL( resultList ); + // get all snap nodes + if ( !aURI.Compare(KNSmlDmBMAdapterBM) ) + { + RArray snaps = RArray( KNSmlDmBMGranularity ); + CleanupClosePushL( snaps ); + iSettingStore->GetSnapsL( snaps ); + TInt currentSNAP( -1 ); + for ( TInt i( 0 ); i < snaps.Count(); i++) + { + currentSNAP = snaps[i]; + BMADAPTERLOGSTRING2( "\tSnap id: %d, ", currentSNAP ) + + // check that not previously mapped + TBool found = EFalse; + + for ( TInt j( 0 ); j < aPreviousURISegmentList.Count(); j++ ) + { + TSmlDmMappingInfo mapping = aPreviousURISegmentList.At( j ); + // snap already has mapping + if ( currentSNAP == DesToIntL( mapping.iURISegLUID ) ) + { + BMADAPTERLOGSTRING2( " URI: %S exists ", &mapping.iURISeg ) + found = ETrue; + // add to result list + resultList->InsertL( resultList->Size(), + mapping.iURISeg); + break; + } + } + if ( !found ) + { + // This is new snap -> create URI and mapping and add + // node name to result + HBufC8* uri = HBufC8::NewLC( aURI.Length() + + KNSmlDmBmSeparator().Length() + + KSmlMaxURISegLen ); + + TPtr8 uriPtr = uri->Des(); + uriPtr.Format( aURI ); + uriPtr.Append( KNSmlDmBmSeparator ); + uriPtr.Append( KNSmlDmBMSNAPNamePrefix ); + HBufC8* luidBuf = IntToDes8L( currentSNAP ); + CleanupStack::PushL( luidBuf ); + uriPtr.Append( *luidBuf ); + + Callback().SetMappingL( uriPtr, *luidBuf ); + resultList->InsertL( resultList->Size(), + LastURISeg( uriPtr ) ); + BMADAPTERLOGSTRING2( "Creating mapping for URI %S ", &uriPtr ) + CleanupStack::PopAndDestroy( luidBuf ); + CleanupStack::PopAndDestroy( uri ); + } + // insert separator if not last + if ( i < snaps.Count() - 1 ) + { + resultList->InsertL( resultList->Size(), + KNSmlDmBmSeparator ); + } + } + CleanupStack::PopAndDestroy( &snaps ); + Callback().SetStatusL( aStatusRef, CSmlDmAdapter::EOk ); + Callback().SetResultsL( aResultsRef, *resultList, KNullDesC8 ); + } + // get child nodes of a snap node + else if ( NumOfURISegs( aURI ) == KNsmlDmBmSNAPNodeDepth ) + { + CSmlDmBmSettingsElement* snap = GetSnapIfBuffered( aURI ); + // if buffered, add this command to buffer + if( snap ) + { + CSmlDmBmCommandElement* cmd = + CSmlDmBmCommandElement::NewLC( EFalse, + aStatusRef, + aResultsRef, + CNSmlDmBmAdapter::EGetCmd, + KNullDesC8, + KNullDesC8 ); + snap->NodeBuf().AppendL( cmd ); + CleanupStack::Pop( cmd ); + BMADAPTERLOGSTRING2( "\tSnap %S found, buffering cmd", + snap->MappingName() ) + } + // existing snap must have luid mapped + else if( aLUID.Length() > 0 || snapId != KErrNotFound ) + { + CSmlDmBmCommandElement* cmd = + CSmlDmBmCommandElement::NewLC( EFalse, + aStatusRef, + aResultsRef, + CNSmlDmBmAdapter::EGetCmd, + KNullDesC8, + KNullDesC8 ); + if( snapId == KErrNotFound ) + { + snapId = DesToIntL( aLUID ); + } + + iSettingStore->ExecuteCmdL( *cmd, snapId ); + BMADAPTERLOGSTRING2( "\tCmd executed with status: %d ", + cmd->Status() ) + Callback().SetStatusL( aStatusRef, cmd->Status() ); + if( cmd->Status() == CSmlDmAdapter::EOk ) + { + resultList->InsertL( 0, *cmd->Data() ); + Callback().SetResultsL( aResultsRef, + *resultList, + KNullDesC8 ); + } + CleanupStack::PopAndDestroy( cmd ); + } + // invalid snap object + else + { + BMADAPTERLOGSTRING( "\tCNSmlDmBmAdapter::ChildURIListL: Error, \ + invalid snap node" ) + Callback().SetStatusL( aStatusRef, CSmlDmAdapter::ENotFound ); + } + } + else + { + BMADAPTERLOGSTRING( "\tChildURIListL: Invalid URI" ) + } + CleanupStack::PopAndDestroy( resultList ); + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::ChildURIListL: End" ) + } + +// -------------------------------------------------------------------------- +// CNSmlDmBmAdapter::AddNodeObjectL +// Adds a snap node. The node is buffered until all data is received. +// -------------------------------------------------------------------------- +void CNSmlDmBmAdapter::AddNodeObjectL( const TDesC8& aURI, + const TDesC8& aParentLUID, + TInt aStatusRef ) + { + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::AddNodeObjectL: Start" ) + BMADAPTERLOGSTRING3( "\tAddNodeObjectL \tURI: %S, \tparent LUID: %S,", + &aURI, &aParentLUID ) + if ( NumOfURISegs( aURI ) == KNsmlDmBmSNAPNodeDepth ) + { + // if same node already exists command fails + CSmlDmBmSettingsElement* setting = GetSnapIfBuffered( aURI ); + if( setting || aParentLUID.Compare( KNullDesC8) ) + { + BMADAPTERLOGSTRING( "\t Snap exists" ) + Callback().SetStatusL( aStatusRef, CSmlDmAdapter::EAlreadyExists ); + } + else if ( LastURISeg( aURI ).Length() > KSmlMaxURISegLen ) + { + BMADAPTERLOGSTRING( "\t Node name too long" ) + Callback().SetStatusL( aStatusRef, CSmlDmAdapter::EError ); + } + else + { + // Store command in buffer for later processing + setting = CSmlDmBmSettingsElement::NewLC( aURI ); + iBuffer.AppendL( setting ); + CleanupStack::Pop( setting ); + + // store the add node command + CSmlDmBmCommandElement* command = + CSmlDmBmCommandElement::NewLC( EFalse, + aStatusRef, + KNSmlDmBmInvalidRef, + CNSmlDmBmAdapter::EAddCmd, + KNullDesC8, + KNullDesC8 ); + TInt index( iBuffer.Count() - 1 ); + iBuffer[index]->NodeBuf().AppendL( command ); + CleanupStack::Pop( command ); + BMADAPTERLOGSTRING( "\t Cmd buffered" ) + } + } + + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::AddNodeObjectL: End" ) + } + +// ------------------------------------------------------------------------- +// CNSmlDmBmAdapter::UpdateLeafObjectL +// Not supported +// ------------------------------------------------------------------------- +void CNSmlDmBmAdapter::UpdateLeafObjectL( const TDesC8& /* aURI */, + const TDesC8& /* aLUID */, + RWriteStream*& /* aStream */, + const TDesC8& /* aType */, + TInt /* aStatusRef */ ) + { + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::UpdateLeafObjectL: Start" ) + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::UpdateLeafObjectL: End" ) + } + + + +// ------------------------------------------------------------------------- +// CNSmlDmBmAdapter::ExecuteCommandL +// Not supported +// ------------------------------------------------------------------------- +void CNSmlDmBmAdapter::ExecuteCommandL( const TDesC8& /* aURI */, + const TDesC8& /* aLUID */, + const TDesC8& /* aArgument */, + const TDesC8& /* aType */, + TInt aStatusRef ) + { + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::ExecuteCommandL: Start" ) + Callback().SetStatusL(aStatusRef, CSmlDmAdapter::EError); + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::ExecuteCommandL: End" ) + } +// ------------------------------------------------------------------------- +// CNSmlDmBmAdapter::ExecuteCommandL +// Not supported +// ------------------------------------------------------------------------- +void CNSmlDmBmAdapter::ExecuteCommandL( const TDesC8& /* aURI */, + const TDesC8& /* aLUID */, + RWriteStream*& /* aStream */, + const TDesC8& /* aType */, + TInt aStatusRef ) + { + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::ExecuteCommandL: Start" ) + Callback().SetStatusL( aStatusRef, CSmlDmAdapter::EError ); + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::ExecuteCommandL: End" ) + } + +// ------------------------------------------------------------------------- +// CNSmlDmBmAdapter::CopyCommandL +// Not supported +// ------------------------------------------------------------------------- +void CNSmlDmBmAdapter::CopyCommandL( const TDesC8& /* aTargetURI */ , + const TDesC8& /* aTargetLUID */ , + const TDesC8& /* aSourceURI */ , + const TDesC8& /* aSourceLUID */, + const TDesC8& /* aType */ , + TInt aStatusRef ) + { + //not supported + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::CopyCommandL: Sart" ) + Callback().SetStatusL( aStatusRef, CSmlDmAdapter::EError ); + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::CopyCommandL: End" ) + } +// ------------------------------------------------------------------------- +// CNSmlDmBmAdapter::StartAtomicL +// Not supported +// ------------------------------------------------------------------------- +void CNSmlDmBmAdapter::StartAtomicL() + { + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::StartAtomicL: Start" ) + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::StartAtomicL: End" ) + } +// ------------------------------------------------------------------------- +// CNSmlDmBmAdapter::CommitAtomicL +// Not supported +// ------------------------------------------------------------------------- +void CNSmlDmBmAdapter::CommitAtomicL() + { + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::CommitAtomicL: Start" ) + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::CommitAtomicL: End" ) + } + +// ------------------------------------------------------------------------- +// CNSmlDmBmAdapter::RollbackAtomicL +// Not supported +// ------------------------------------------------------------------------- +void CNSmlDmBmAdapter::RollbackAtomicL() + { + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::RollbackAtomicL: Start" ) + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::RollbackAtomicL: End" ) + } + +TBool CNSmlDmBmAdapter::StreamingSupport( TInt& /* aItemSize */ ) + { + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::StreamingSupport: Start" ) + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::StreamingSupport: End" ) + return EFalse; + } +// ------------------------------------------------------------------------- +// CNSmlDmBmAdapter::StreamCommittedL +// Not supported +// ------------------------------------------------------------------------- +void CNSmlDmBmAdapter::StreamCommittedL() + { + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::StreamCommittedL: Start" ) + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::StreamCommittedL: End" ) + } + +// ------------------------------------------------------------------------- +// CNSmlDmBmAdapter::CompleteOutstandingCmdsL +// CNSmlDmBmAdapter::CompleteOutstandingCmdsL +// ------------------------------------------------------------------------- +void CNSmlDmBmAdapter::CompleteOutstandingCmdsL() + { + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::CompleteOutstandingCmdsL: Start" ) + CSmlDmBmSettingsElement* settings( NULL ); + CSmlDmBmCommandElement* cmd( NULL ); + TInt err(0); + // Read through the buffer and execute commands + for ( TInt i(0); i < iBuffer.Count(); ) + { + settings = iBuffer[i]; + if( settings->NodeBuf().Count() ) + { + // the setting may be executed already if it has been an embedded + // snap for another snap + if ( !settings->Executed() ) + { + //execute commands for snap + TRAP( err, iSettingStore->StoreSnapL( *settings )); + } + // if can't recover from error, don't continue processing + // commands + if( err == KErrNoMemory || + err == KErrDiskFull ) + { + BMADAPTERLOGSTRING2( "\tCNSmlDmBmAdapter::\ + CompleteOutstandingCmdsL: Error %d", err ) + User::Leave( err ); + } + // if this is a new snap and created successfully, map luid + if ( !settings->NodeBuf()[0]->Leaf() && + settings->NodeBuf()[0]->CmdType() == CNSmlDmBmAdapter::EAddCmd && + settings->NodeBuf()[0]->Executed() && + settings->NodeBuf()[0]->Status() == CSmlDmAdapter::EOk ) + { + HBufC8* luid = IntToDes8L( settings->Luid() ); + CleanupStack::PushL( luid ); + Callback().SetMappingL( *settings->MappingName(), *luid ); + BMADAPTERLOGSTRING3( "\t Setting mapping %S - %S ", + settings->MappingName(), luid ) + CleanupStack::PopAndDestroy( luid ); + } + // set status for all commands executed and remove the command + for ( TInt j( 0 ); j < settings->NodeBuf().Count(); ) + { + + cmd = settings->NodeBuf()[j]; + + // return status values if executed + if ( cmd->Executed() ) + { + + Callback().SetStatusL( cmd->StatusRef(), + cmd->Status() ); + // for certain errors, don't continue command execution + if( cmd->Status() == CSmlDmAdapter::ENoMemory ) + { + // commands are deleted + iBuffer.ResetAndDestroy(); + BMADAPTERLOGSTRING( "\tCmd failed with CSmlDmAdapter::ENoMemory" ) + User::Leave( KErrNoMemory ); + } + else if( cmd->Status() == CSmlDmAdapter::EDiskFull ) + { + // commands are deleted + iBuffer.ResetAndDestroy(); + BMADAPTERLOGSTRING( "\tCmd failed with CSmlDmAdapter::EDiskFull" ) + User::Leave( KErrDiskFull ); + } + else + { + BMADAPTERLOGSTRING2( + "\tCmd failed with CSmlDmAdapter::%d", + cmd->Status() ) + } + // for get commands, also return the results + if ( cmd->CmdType() == CNSmlDmBmAdapter::EGetCmd || + cmd->CmdType() == CNSmlDmBmAdapter::EGetSizeCmd ) + { + CBufBase* result = CBufFlat::NewL( cmd->Data()->Size() ); + CleanupStack::PushL( result ); + result->InsertL( 0, *cmd->Data() ); + Callback().SetResultsL( cmd->ResultRef(), + *result, + KNullDesC8 ); + CleanupStack::PopAndDestroy( result ); + } + } + else + { + Callback().SetStatusL( cmd->StatusRef(), + CSmlDmAdapter::EError ); + } + settings->NodeBuf().Remove( j ); + delete cmd; + } + } + + // delete settings element and remove it from buffer + delete settings; + iBuffer.Remove( i ); + } + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::CompleteOutstandingCmdsL: End" ) + } + + + +// ------------------------------------------------------------------------- +// CNSmlDmBmAdapter::StoreSnapIfBufferedL +// If argument snap is found in the buffer iSettingStore->StoreSNAPL is +// called +// for it and LUID is mapped. SNAP is set as executed. +// This is called when checking if snap has embedded snap reference to +// another +// snap which is stored further in the command buffer. +// All embedded snap commands of this type are buffered and execution only +// happens with CompleteOutstandingCmdsL call. +// ------------------------------------------------------------------------- + +void CNSmlDmBmAdapter::StoreSnapIfBufferedL( const TDesC8& aURI ) + { + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::StoreSnapIfBufferedL: Start" ) + CSmlDmBmSettingsElement* snap = GetSnapIfBuffered( aURI ); + // if snap is in buffer and is a new snap + if( snap && !snap->Luid() ) + { + iSettingStore->StoreSnapL( *snap ); + // set mapping if succesfully executed + if ( snap->NodeBuf()[0]->Executed() && + snap->NodeBuf()[0]->Status() == CSmlDmAdapter::EOk ) + { + HBufC8* luid = IntToDes8L( snap->Luid() ); + CleanupStack::PushL( luid ); + Callback().SetMappingL( *snap->MappingName(), *luid); + CleanupStack::PopAndDestroy( luid ); + } + } + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::StoreSnapIfBufferedL: End" ) + } +// ------------------------------------------------------------------------- +// CNSmlDmBmAdapter::GetSnapUriFromLuidL +// Returns heap desciptor holding snap node URI matching the argument LUID +// ------------------------------------------------------------------------- +HBufC8* CNSmlDmBmAdapter::GetSnapUriFromLuidL( const TUint aSnapId ) + { + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::GetSnapURIFromLUIDL: Start" ) + HBufC8* uri( NULL ); + MSmlDmAdapter::TError err( MSmlDmAdapter::EOk ); + CBufBase* fetchRes = CBufFlat::NewL( KSmlMaxURISegLen ); + CleanupStack::PushL( fetchRes ); + // fetch all snap nodes + Callback().FetchLinkL( KNSmlDmBMAdapterBMURI, *fetchRes, err ); + + TPtr8 snapNodes = fetchRes->Ptr( 0 ); + + TInt numSnaps = NumOfURISegs( snapNodes ); + + // get uri-luid mappings for snap nodes + for ( TInt i( 0 ); i < numSnaps; i++ ) + { + TPtrC8 node = LastURISeg( snapNodes ); + + HBufC8* uriSeg = HBufC8::NewLC( KNSmlDmBmAdapterURIMaxLength + + node.Length()); + uriSeg->Des().Append( KNSmlDmBMAdapterBM() ); + uriSeg->Des().Append( KNSmlDmBmSeparator() ); + uriSeg->Des().Append( node ); + + HBufC8* luid = Callback().GetLuidAllocL( *uriSeg ); + CleanupStack::PopAndDestroy( uriSeg ); + CleanupStack::PushL( luid ); + // node may not have luid mapped if it's just created + if( luid->Size() ) + { + TInt id = DesToIntL( *luid ); + CleanupStack::PopAndDestroy( luid ); + if ( aSnapId == id ) + { + uri = HBufC8::NewLC( KNSmlDmBMAdapterBMURI().Size() + + KNSmlDmBmSeparator().Size() + + node.Size() ); + + uri->Des().Append( KNSmlDmBMAdapterBMURI() ); + uri->Des().Append( KNSmlDmBmSeparator() ); + uri->Des().Append( node ); + break; + } + } + else + { + CleanupStack::PopAndDestroy( luid ); + } + snapNodes = RemoveLastURISeg( snapNodes ); + } + + if( uri ) + { + CleanupStack::Pop( uri ); + } + + CleanupStack::PopAndDestroy( fetchRes ); + + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::IdArrayToIAPList: End" ) + return uri; + } + +// ------------------------------------------------------------------------- +// CNSmlDmBmAdapter::GetIapListL +// Returns heap desciptor holding a comma separated list of AP node URIs +// matching the luids in the argument array. +// ------------------------------------------------------------------------- +HBufC8* CNSmlDmBmAdapter::GetIapListL( const RArray& aIdArray ) + { + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::GetIapListL: Start" ) + HBufC8* iapList = HBufC8::NewLC( aIdArray.Count() * + ( KNSmlDmBmAdapterAPURIMaxLength + + KSmlMaxURISegLen ) ); + MSmlDmAdapter::TError err; + CBufBase* fetchRes = CBufFlat::NewL( KSmlMaxURISegLen ); + CleanupStack::PushL( fetchRes ); + // fetch dynamic AP nodes, so that LUID mapping is created + Callback().FetchLinkL( KNSmlDmBMAdapterIAPURI, *fetchRes, err ); + + // list of all nodes has a trailing '/' unlike regular uris, remove that + // for further handling + TPtr8 iapNodes = fetchRes->Ptr( 0 ); + if ( iapNodes.Length() > 0 && iapNodes[iapNodes.Length() - 1] == '/') + { + iapNodes = iapNodes.Left( iapNodes.Length() - 1 ); + } + + TInt numAPs = NumOfURISegs( iapNodes ); + + CArrayFixFlat* mappings = + new (ELeave) CArrayFixFlat( numAPs * + sizeof( TSmlDmMappingInfo ) ); + CleanupStack::PushL( mappings ); + + // get uri-luid mappings for all ap nodes + HBufC8* luid = NULL; + for ( TInt i( 0 ); i < numAPs; i++ ) + { + TSmlDmMappingInfo m; + m.iURISeg = LastURISeg( iapNodes ); + + HBufC8* uriSeg = HBufC8::NewLC( KNSmlDmBmAdapterAPURIMaxLength + + m.iURISeg.Length() ); + uriSeg->Des().Replace( 0, + uriSeg->Length(), + KNSmlDmBMAdapterIAPNode() ); + uriSeg->Des().Append( KNSmlDmBmSeparator() ); + uriSeg->Des().Append( m.iURISeg ); + + luid = Callback().GetLuidAllocL( *uriSeg ); + CleanupStack::PopAndDestroy( uriSeg ); + CleanupStack::PushL( luid ); + m.iURISegLUID.Set( *luid ); + mappings->AppendL( m ); + iapNodes = RemoveLastURISeg( iapNodes ); + } + + // find out URIs matching argument IAP ids + for (TInt i(0); i < aIdArray.Count(); i++) + { + TBool found = EFalse; + + for ( TInt j( 0 ); j < mappings->Count(); j++ ) + { + if ( aIdArray[i] == DesToIntL( mappings->At( j ).iURISegLUID ) ) + { + // add to result + iapList->Des().Append( KNSmlDmBMAdapterIAPURI() ); + iapList->Des().Append( KNSmlDmBmSeparator() ); + iapList->Des().Append( mappings->At(j).iURISeg ); + // not last -> add separator + if ( i < aIdArray.Count() - 1 ) + { + iapList->Des().Append( KNSmlDmBmUriListSeparator ); + } + found = ETrue; + break; + } + } + if ( ! found ) + { + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::GetIapListL: \ + Error IAP matching id not found" ) + User::Leave( KErrNotFound ); + } + } + + // cleanup each allocated luid + CleanupStack::PopAndDestroy( numAPs ); + CleanupStack::PopAndDestroy( mappings ); + CleanupStack::PopAndDestroy( fetchRes ); + CleanupStack::Pop( iapList ); + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::GetIapListL: End" ) + return iapList; + } + +// ------------------------------------------------------------------------- +// CNSmlDmBmAdapter::GetIdArrayL +// Returns array holding LUIDs matching the AP node in the argument list. +// ------------------------------------------------------------------------- +RArray CNSmlDmBmAdapter::GetIdArrayL( const TDesC8& aIAPList ) + { + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::GetIdArrayL: Start" ) + TPtrC8 uri; + RArray iaps; + CleanupClosePushL( iaps ); + uri.Set( aIAPList ); + // fetch AP nodes so that mappings are created + MSmlDmAdapter::TError err; + CBufBase* fetchRes = CBufFlat::NewL( KSmlMaxURISegLen ); + CleanupStack::PushL( fetchRes ); + // fetch dynamic AP nodes, so that LUID mappings are created + Callback().FetchLinkL( KNSmlDmBMAdapterIAPURI, *fetchRes, err ); + + for ( TInt i(0), n = NumOfURIs( aIAPList ); i < n; i++ ) + { + TPtrC8 thisURI = FirstURI( uri ); + // remove ./ from beginning + TPtrC8 apUri = thisURI.Mid( KNSmlDmBmAdapterURIPrefix().Length() ); + HBufC8* luid = Callback().GetLuidAllocL( apUri ); + CleanupStack::PushL( luid ); + TInt id = DesToIntL( *luid ); + CleanupStack::PopAndDestroy( luid ); + iaps.Append( id ); + uri.Set( RemoveFirstURI( uri ) ); + } + + CleanupStack::PopAndDestroy( fetchRes ); + CleanupStack::Pop( &iaps ); + BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::GetIdArrayL: End" ) + return iaps; + } + +// -------------------------------------------------------------------------- +// CNSmlDmBmAdapter::IntToDes8L +// Converts integer to 8bit descriptor +// -------------------------------------------------------------------------- +HBufC8* CNSmlDmBmAdapter::IntToDes8L( TInt aLuid ) const + { + HBufC8* buf = HBufC8::NewL( KMaxLengthOf32bitInteger ); + TPtr8 ptrBuf = buf->Des(); + + // Unless aLuid is casted as TInt64, PC-Lint reports: + // Significant prototype coercion + // + ptrBuf.Num( TInt64( aLuid ) ); + return buf; + } + +// -------------------------------------------------------------------------- +// CNSmlDmBmAdapter::DesToIntL +// Converts 8bit descriptor to int +// -------------------------------------------------------------------------- +TUint CNSmlDmBmAdapter::DesToIntL( const TDesC8& aLuid ) const + { + __UHEAP_MARK; + TLex8 lex( aLuid ); + TUint value( 0 ); + User::LeaveIfError( lex.Val( value ) ); + __UHEAP_MARKEND; + return value; + } + +// -------------------------------------------------------------------------- +// CNSmlDmBmAdapter::DesToBool +// Converts 8bit descriptor to a boolean value +// -------------------------------------------------------------------------- +TBool CNSmlDmBmAdapter::DesToBool(const TDesC8& aBoolDes, TBool& aBool ) const + { + __UHEAP_MARK; + if ( !aBoolDes.Compare( KNSmlDmBMBooleanTrue ) ) + { + aBool = ETrue; + } + else if ( !aBoolDes.Compare( KNSmlDmBMBooleanFalse ) ) + { + aBool = EFalse; + } + else + { + __UHEAP_MARKEND; + return EFalse; + } + __UHEAP_MARKEND; + return ETrue; + } + +// -------------------------------------------------------------------------- +// CNSmlDmBmAdapter::BoolToDes8LC +// Converts boolean value to 8bit descriptor +// -------------------------------------------------------------------------- + +HBufC8* CNSmlDmBmAdapter::BoolToDes8LC( TBool aBool) const + { + HBufC8* ret; + if( aBool ) + { + ret = HBufC8::NewLC( KNSmlDmBMBooleanTrue().Size() ); + ret->Des().Append( KNSmlDmBMBooleanTrue() ); + } + else + { + ret = HBufC8::NewLC( KNSmlDmBMBooleanFalse().Size() ); + ret->Des().Append( KNSmlDmBMBooleanFalse() ); + } + return ret; + } + + +// -------------------------------------------------------------------------- +// CNSmlDmBmAdapter::GetLuidAllocL +// The function calls the GetLuidAllocL function of the MSmlDmCallback to get +// the LUID which is mapped to aURI. +// -------------------------------------------------------------------------- +HBufC8* CNSmlDmBmAdapter::GetLuidAllocL( const TDesC8& aURI ) + { + return Callback().GetLuidAllocL( aURI ); + } + + +// -------------------------------------------------------------------------- +// CNSmlDmBmAdapter::GetSnapIfBuffered +// Returns a pointer to the snap CSmlDmBmSettingsElement object if found in +// the buffer +// -------------------------------------------------------------------------- +CSmlDmBmSettingsElement* CNSmlDmBmAdapter::GetSnapIfBuffered( const TDesC8& + aMappingName ) + { + CSmlDmBmSettingsElement* settings = NULL; + for ( TInt i( 0 ); iMappingName()->Compare( aMappingName ) ) + { + settings = iBuffer[i]; + break; + } + } + return settings; + } +// ------------------------------------------------------------------------- +// CNSmlDmBmAdapter::FirstURI +// Returns the first URI from a list of URIs +// ------------------------------------------------------------------------- +TPtrC8 CNSmlDmBmAdapter::FirstURI( const TDesC8& aURIList ) const + { + __UHEAP_MARK; + TInt i; + for ( i = 0; i < aURIList.Length(); i++ ) + { + if ( aURIList[i] == ',' ) + { + break; + } + } + if ( i == aURIList.Length() - 1 ) + { + __UHEAP_MARKEND; + return aURIList; + } + else + { + __UHEAP_MARKEND; + return aURIList.Mid( 0, i ); + } + } + +// -------------------------------------------------------------------------- +// CNSmlDmBmAdapter::NumOfURIs +// Returns the num of uris +// -------------------------------------------------------------------------- +TInt CNSmlDmBmAdapter::NumOfURIs( const TDesC8& aURIList ) const + { + __UHEAP_MARK; + if ( !aURIList.Length() ) + { + return 0; + } + TInt numOfURIs( 1 ); + for ( TInt i(0); i < aURIList.Length(); i++ ) + { + if ( aURIList[i] == ',' ) + { + numOfURIs++; + } + } + __UHEAP_MARKEND; + return numOfURIs; + } + +// -------------------------------------------------------------------------- +// CNSmlDmBmAdapter::RemoveFirstURI +// extracts first uri an returns the remaining part of the uri list +// -------------------------------------------------------------------------- +TPtrC8 CNSmlDmBmAdapter::RemoveFirstURI( const TDesC8& aURIList ) const + { + __UHEAP_MARK; + TInt i; + for ( i = 0; i < aURIList.Length(); i++ ) + { + if ( aURIList[i] == ',' ) + { + break; + } + } + if ( i < aURIList.Length() ) + { + __UHEAP_MARKEND; + return aURIList.Mid( i + 1 ); + } + else + { + __UHEAP_MARKEND; + return aURIList.Mid( i ); + } + + } +// -------------------------------------------------------------------------- +// CNSmlDmBmAdapter::LastURISeg +// Returns the last uri segemnt of a uri. +// -------------------------------------------------------------------------- +TPtrC8 CNSmlDmBmAdapter::LastURISeg( const TDesC8& aURI ) const + { + __UHEAP_MARK; + TInt i; + for ( i=aURI.Length()-1; i >= 0; i-- ) + { + if ( aURI[i]=='/' ) + { + break; + } + } + if ( i==0 ) + { + __UHEAP_MARKEND; + return aURI; + } + else + { + __UHEAP_MARKEND; + return aURI.Mid( i + 1 ); + } + } + +// -------------------------------------------------------------------------- +// CNSmlDmBmAdapter::RemoveLastURISeg +// returns parent uri, i.e. removes last uri segment +// -------------------------------------------------------------------------- +TPtrC8 CNSmlDmBmAdapter::RemoveLastURISeg( const TDesC8& aURI ) const + { + __UHEAP_MARK; + TInt i; + for ( i = aURI.Length()-1; i >= 0; i-- ) + { + if ( aURI[i]=='/' ) + { + break; + } + } + if ( i > -1 ) + { + __UHEAP_MARKEND; + return aURI.Left( i ); + } + else + { + __UHEAP_MARKEND; + return aURI; + } + + } + + + +// -------------------------------------------------------------------------- +// CNSmlDmBmAdapter::NumOfURISegs +// Returns the num of uri segs +// -------------------------------------------------------------------------- +TInt CNSmlDmBmAdapter::NumOfURISegs( const TDesC8& aURI ) const + { + __UHEAP_MARK; + TInt numOfURISegs( 1 ); + for ( TInt i(0); i < aURI.Length(); i++ ) + { + if ( aURI[i]=='/' ) + { + numOfURISegs++; + } + } + __UHEAP_MARKEND; + return numOfURISegs; + } + +TInt CNSmlDmBmAdapter::MapPredefinedSnapsL( const TDesC8& aURI, const TDesC8& aLUID ) +{ + TInt snapId( KErrNotFound ); + // If this is an add to pre-defined SNAPs then LUID we get is empty, but we still need + // to handle it. + if( aLUID.Length() == 0 && ( ( snapId = GetPredefinedSnapIdFromUri( aURI ) ) != KErrNotFound ) ) + { + // Check if SNAP with given ID exists (from CmManager) + iCmManagerExt.OpenL(); + TRAPD( err, RCmDestinationExt dest = iCmManagerExt.DestinationL( snapId ) ); + iCmManagerExt.Close(); + + // If exists -> Call SetMapping to set LUID. + if( err == KErrNone ) + { + HBufC8* uri = HBufC8::NewLC( KNSmlDmBMAdapterBM().Length() + + KNSmlDmBmSeparator().Length() + + KSmlMaxURISegLen ); + + TPtr8 uriPtr = uri->Des(); + uriPtr.Format( KNSmlDmBMAdapterBM ); + uriPtr.Append( KNSmlDmBmSeparator ); + uriPtr.Append( KNSmlDmBMSNAPNamePrefix ); + HBufC8* luidBuf = IntToDes8L( snapId ); + CleanupStack::PushL( luidBuf ); + uriPtr.Append( *luidBuf ); + + Callback().SetMappingL( uriPtr, *luidBuf ); + + BMADAPTERLOGSTRING2( "Creating mapping for URI %S ", &uriPtr ) + CleanupStack::PopAndDestroy( luidBuf ); + CleanupStack::PopAndDestroy( uri ); + } + } + return snapId; +} + +TInt CNSmlDmBmAdapter::GetPredefinedSnapIdFromUri( const TDesC8& aURI ) const + { + TInt ret = KErrNotFound; + + // First check that URI starts with BearerManagementSNAP + TInt startIndex = aURI.Find( KNSmlDmBMAdapterBM ); + + if( startIndex == KErrNotFound ) + { + return KErrNotFound; + } + + // Then assume there is separator + startIndex += KNSmlDmBMAdapterBM().Length() + KNSmlDmBmSeparator().Length(); + + if( startIndex >= aURI.Length() ) + { + // No separator. This was an access to ./BearerManagementSNAP + return KErrNotFound; + } + + TPtrC8 predefinedUriStart = aURI.Mid( startIndex ); + + startIndex = predefinedUriStart.Find( KNSmlDmBMSNAPNamePrefix ); + + // Result should be zero ( = start of string) + if( startIndex != 0 ) + { + return KErrNotFound; + } + + startIndex += KNSmlDmBMSNAPNamePrefix().Length(); + + TInt endIndex = 0; + + endIndex = predefinedUriStart.Find( KNSmlDmBmSeparator ); + + + + if ( endIndex == KErrNotFound ) + { + TPtrC8 snapId = predefinedUriStart.Mid( startIndex ); + TRAPD( err, ret = DesToIntL( snapId ) ); + if( err != KErrNone ) + { + ret = KErrNotFound; + } + } + else + { + TPtrC8 snapId = predefinedUriStart.Mid( startIndex, endIndex - startIndex ); + TRAPD( err, ret = DesToIntL( snapId ) ); + if( err != KErrNone ) + { + ret = KErrNotFound; + } + } + return ret; + } + + + +//---------------------- CSmlDmBmCommandElement -------------------------// + +// -------------------------------------------------------------------------- +// CSmlDmBmCommandElement* CSmlDmBmCommandElement::NewLC +// -------------------------------------------------------------------------- + +CSmlDmBmCommandElement* CSmlDmBmCommandElement::NewLC( TBool aLeaf, + TInt aStatusRef, + TInt aResultRef, + CNSmlDmBmAdapter::TCommandType aCmdType, + const TDesC8& aLastUriSeg, + const TDesC8& aData ) + { + CSmlDmBmCommandElement* self = new (ELeave) CSmlDmBmCommandElement( aLeaf, + aStatusRef, + aResultRef, + aCmdType ); + CleanupStack::PushL(self); + self->ConstructL( aLastUriSeg, aData ); + return self; + } + +// -------------------------------------------------------------------------- +// CSmlDmBmCommandElement::~CSmlDmBmCommandElement +// -------------------------------------------------------------------------- +CSmlDmBmCommandElement::~CSmlDmBmCommandElement() + { + delete iLastUriSeg; + delete iData; + } + +// -------------------------------------------------------------------------- +// CSmlDmBmCommandElement::CSmlDmBmCommandElement +// -------------------------------------------------------------------------- +CSmlDmBmCommandElement::CSmlDmBmCommandElement( TBool aLeaf, + TInt aStatusRef, + TInt aResultRef, + CNSmlDmBmAdapter::TCommandType aCmdType ) + : iStatus( CSmlDmAdapter::EError ), + iLeaf( aLeaf ), + iStatusRef( aStatusRef ), + iResultRef( aResultRef ), + iCmdType( aCmdType ), + iData( NULL ) + + { + } + +// -------------------------------------------------------------------------- +// CSmlDmBmCommandElement::ConstructL +// -------------------------------------------------------------------------- +void CSmlDmBmCommandElement::ConstructL( const TDesC8& aLastUriSeg, + const TDesC8& aData ) + { + iLastUriSeg = aLastUriSeg.AllocL(); + iData = aData.AllocL(); + } + +//---------------------- CSmlDmBmSettingsElement -------------------------// + +// -------------------------------------------------------------------------- +// CSmlDmBmSettingsElement* CSmlDmBmSettingsElement::NewLC +// -------------------------------------------------------------------------- +CSmlDmBmSettingsElement* CSmlDmBmSettingsElement::NewLC( const TDesC8& aMappingName ) + { + CSmlDmBmSettingsElement* self = new (ELeave) CSmlDmBmSettingsElement(); + CleanupStack::PushL(self); + self->ConstructL( aMappingName ); + return self; + } +// -------------------------------------------------------------------------- +// CSmlDmBmSettingsElement::~CSmlDmBmSettingsElement +// -------------------------------------------------------------------------- +CSmlDmBmSettingsElement::~CSmlDmBmSettingsElement() + { + // deallocate all elements + iNodeBuf.ResetAndDestroy(); + iNodeBuf.Close(); + delete iMappingName; + } + +// -------------------------------------------------------------------------- +// CSmlDmBmSettingsElement::CSmlDmBmSettingsElement +// -------------------------------------------------------------------------- +CSmlDmBmSettingsElement::CSmlDmBmSettingsElement() + : iExecuted( EFalse ), + iLuid( 0 ), + iMappingName( NULL ) + { + + } +// -------------------------------------------------------------------------- +// CSmlDmBmSettingsElement::ConstructL +// -------------------------------------------------------------------------- +void CSmlDmBmSettingsElement::ConstructL( const TDesC8& aMappingName ) + { + iMappingName = aMappingName.AllocL(); + }