1 /*

     2 * Copyright (c) 2009-2010 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *        Implementation of plugin base class

    16 *

    17 */

    18 

    19 

    20 #include <datamobilitycommsdattypes.h>

    21 #include <cmpluginbaseeng.h>

    22 #include <cmpsettingsconsts.h>

    23 #include <featmgr.h>

    24 #include <cmpluginembdestinationdef.h>

    25 

    26 #include "cmmserverdefs.h"

    27 #include "ccmpluginbaseengtextresolver.h"

    28 

    29 #include "OstTraceDefinitions.h"

    30 #ifdef OST_TRACE_COMPILER_IN_USE

    31 #include "ccmpluginbaseengTraces.h"

    32 #endif

    33 

    34 

    35 using namespace CMManager;

    36 using namespace CommsDat;

    37 

    38 const TInt KApMaxConnNameLength = 50;

    39 _LIT( KFormatPostfix, "%02d" );

    40 _LIT( KFormatLargePostfix, "%d" );

    41 _LIT( KFormatNameWithPostfix, "%S(%S)" );

    42 _LIT( KFormatNoPostfix, "%S" );

    43 const TInt KMaxPostfixLength = 5;

    44 

    45 _LIT( KDefWapGatewayIpAddress, "0.0.0.0" );

    46 

    47 _LIT( KLocationName, "Mobile" );

    48 

    49 _LIT( KDefaultIapName, "Connection Method" );

    50 

    51 

    52 EXPORT_C CCmClientPluginInstance* CCmClientPluginInstance::NewLC()

    53     {

    54     OstTraceFunctionEntry0( CCMCLIENTPLUGININSTANCE_NEWLC_ENTRY );

    55 

    56     CCmClientPluginInstance* self = new( ELeave ) CCmClientPluginInstance();

    57     CleanupStack::PushL( self );

    58     self->ConstructL();

    59 

    60     OstTraceFunctionExit0( CCMCLIENTPLUGININSTANCE_NEWLC_EXIT );

    61     return self;

    62     }

    63 

    64 EXPORT_C CCmClientPluginInstance* CCmClientPluginInstance::NewL()

    65     {

    66     OstTraceFunctionEntry0( CCMCLIENTPLUGININSTANCE_NEWL_ENTRY );

    67 

    68     CCmClientPluginInstance* self = CCmClientPluginInstance::NewLC();

    69     CleanupStack::Pop( self );

    70 

    71     OstTraceFunctionExit0( CCMCLIENTPLUGININSTANCE_NEWL_EXIT );

    72     return self;

    73     }

    74 

    75 CCmClientPluginInstance::CCmClientPluginInstance()

    76         :

    77         iNamingMethod( ENamingUnique ),

    78         iLocationEnabled( EFalse ),

    79         iIapId( 0 )

    80     {

    81     }

    82 

    83 EXPORT_C CCmClientPluginInstance::~CCmClientPluginInstance()

    84     {

    85     OstTraceFunctionEntry0( CCMCLIENTPLUGININSTANCE_CCMCLIENTPLUGININSTANCE_ENTRY );

    86 

    87     iGenRecordArray.ResetAndDestroy();

    88     iBearerSpecRecordArray.ResetAndDestroy();

    89 

    90     OstTraceFunctionExit0( CCMCLIENTPLUGININSTANCE_CCMCLIENTPLUGININSTANCE_EXIT );

    91     }

    92 

    93 // ---------------------------------------------------------------------------

    94 // Second phase constructor.

    95 // ---------------------------------------------------------------------------

    96 //

    97 void CCmClientPluginInstance::ConstructL()

    98     {

    99     }

   100 

   101 

   102 // ---------------------------------------------------------------------------

   103 // TCmPluginInitParam::TCmPluginInitParam

   104 // ---------------------------------------------------------------------------

   105 //

   106 EXPORT_C TCmPluginInitParam::TCmPluginInitParam( CommsDat::CMDBSession& aSession )

   107         :

   108         iSessionRef( aSession )

   109     {

   110     OstTraceFunctionEntry0( TCMPLUGININITPARAM_TCMPLUGININITPARAM_ENTRY );

   111 

   112     iNotused1 = NULL;

   113     iNotused2 = NULL;

   114 

   115     OstTraceFunctionExit0( TCMPLUGININITPARAM_TCMPLUGININITPARAM_EXIT );

   116     }

   117 

   118 // ---------------------------------------------------------------------------

   119 // CCmPluginBaseEng::CCmPluginBaseEng

   120 // ---------------------------------------------------------------------------

   121 //

   122 EXPORT_C CCmPluginBaseEng::CCmPluginBaseEng( TCmPluginInitParam *aInitParam )

   123         :

   124         iSession( aInitParam->iSessionRef ),

   125         iNamingMethod( ENamingUnique )

   126     {

   127     OstTraceFunctionEntry0( CCMPLUGINBASEENG_CCMPLUGINBASEENG_ENTRY );

   128 

   129     iDtor_ID_Key.iUid = 0;

   130     iBearerType = 0;

   131 

   132     iIapRecord = NULL;

   133     iProxyRecord = NULL;

   134     iServiceRecord = NULL;

   135     iNetworkRecord = NULL;

   136     iLocationRecord = NULL;

   137     iWapAPRecord = NULL;

   138     iWapIPBearerRecord = NULL;

   139     iMetaDataRecord = NULL;

   140 

   141     iCmId = 0;

   142     iMetadataTableId = 0;

   143     iLocationEnabled = EFalse;

   144 

   145     OstTraceFunctionExit0( CCMPLUGINBASEENG_CCMPLUGINBASEENG_EXIT );

   146     }

   147 

   148 // ---------------------------------------------------------------------------

   149 // CCmPluginBaseEng::~CCmPluginBaseEng

   150 // ---------------------------------------------------------------------------

   151 //

   152 EXPORT_C CCmPluginBaseEng::~CCmPluginBaseEng()

   153     {

   154     OstTraceFunctionEntry0( DUP1_CCMPLUGINBASEENG_CCMPLUGINBASEENG_ENTRY );

   155 

   156     iCmId = 0;

   157     delete iIapRecord; iIapRecord = NULL;

   158     delete iProxyRecord; iProxyRecord = NULL;

   159     delete iServiceRecord; iServiceRecord = NULL;

   160     delete iNetworkRecord; iNetworkRecord = NULL;

   161     delete iLocationRecord; iLocationRecord = NULL;

   162     delete iWapAPRecord; iWapAPRecord = NULL;

   163     delete iWapIPBearerRecord; iWapIPBearerRecord = NULL;

   164     delete iMetaDataRecord; iMetaDataRecord = NULL;

   165 

   166     iLocationEnabled = EFalse;

   167 

   168     REComSession::DestroyedImplementation( iDtor_ID_Key );

   169 

   170     OstTraceFunctionExit0( DUP1_CCMPLUGINBASEENG_CCMPLUGINBASEENG_EXIT );

   171     }

   172 

   173 // ---------------------------------------------------------------------------

   174 // CCmPluginBaseEng::ConstructL

   175 // ---------------------------------------------------------------------------

   176 //

   177 EXPORT_C void CCmPluginBaseEng::ConstructL()

   178     {

   179     OstTraceFunctionEntry0( CCMPLUGINBASEENG_CONSTRUCTL_ENTRY );

   180 

   181     TRAPD( err, iMetadataTableId = CCDIAPMetadataRecord::TableIdL( iSession ) );

   182     if ( err )

   183         {

   184         if ( err == KErrNotFound )

   185             {

   186             iMetadataTableId = CCDIAPMetadataRecord::CreateTableL( iSession );

   187             }

   188         else

   189             {

   190             User::LeaveIfError( err );

   191             }

   192         }

   193 

   194     OstTraceFunctionExit0( CCMPLUGINBASEENG_CONSTRUCTL_EXIT );

   195     }

   196 

   197 // ---------------------------------------------------------------------------

   198 // CCmPluginBaseEng::UpdateL

   199 // ---------------------------------------------------------------------------

   200 //

   201 EXPORT_C void CCmPluginBaseEng::UpdateL(

   202         CCmClientPluginInstance* aClientPluginInstance )

   203     {

   204     OstTraceFunctionEntry0( CCMPLUGINBASEENG_UPDATEL_ENTRY );

   205 

   206     PrepareToUpdateRecordsL( aClientPluginInstance );

   207 

   208     UpdateServiceRecordL( aClientPluginInstance );

   209     UpdateLocationRecordL( aClientPluginInstance );

   210     UpdateNetworkRecordL( aClientPluginInstance );

   211     UpdateIAPRecordL( aClientPluginInstance );

   212     UpdateWapRecordL( aClientPluginInstance );

   213     UpdateProxyRecordL( aClientPluginInstance );

   214     UpdateMetadataRecordL( aClientPluginInstance );

   215     UpdateConnPrefSettingL();

   216 

   217     UpdateBearerRecordsL(

   218             aClientPluginInstance->iGenRecordArray,

   219             aClientPluginInstance->iBearerSpecRecordArray );

   220 

   221     OstTraceFunctionExit0( CCMPLUGINBASEENG_UPDATEL_EXIT );

   222     }

   223 

   224 // ---------------------------------------------------------------------------

   225 // Delete this connection methond.

   226 // Record ids are checked to be sure that we delete only records

   227 // that were loaded before.

   228 // ---------------------------------------------------------------------------

   229 //

   230 EXPORT_C void CCmPluginBaseEng::DeleteL()

   231     {

   232     OstTraceFunctionEntry0( CCMPLUGINBASEENG_DELETEL_ENTRY );

   233 

   234     PrepareToDeleteRecordsL();

   235 

   236     if ( iIapRecord && iIapRecord->RecordId() )

   237         {

   238         iIapRecord->DeleteL( iSession );

   239         }

   240 

   241     if ( iProxyRecord && iProxyRecord->RecordId() )

   242         {

   243         iProxyRecord->DeleteL( iSession );

   244         }

   245 

   246     if ( iServiceRecord && iServiceRecord->RecordId() )

   247         {

   248         iServiceRecord->DeleteL( iSession );

   249         }

   250 

   251     if ( iNetworkRecord && iNetworkRecord->RecordId() )

   252         {

   253         iNetworkRecord->DeleteL( iSession );

   254         }

   255 

   256     if ( iLocationRecord && iLocationRecord->RecordId() )

   257         {

   258         iLocationRecord->DeleteL( iSession );

   259         }

   260 

   261     if ( iWapAPRecord && iWapAPRecord->RecordId() )

   262         {

   263         iWapAPRecord->DeleteL( iSession );

   264         }

   265 

   266     if ( iWapIPBearerRecord && iWapIPBearerRecord->RecordId() )

   267         {

   268         iWapIPBearerRecord->DeleteL( iSession );

   269         }

   270 

   271     if ( iMetaDataRecord && iMetaDataRecord->RecordId() )

   272         {

   273         iMetaDataRecord->DeleteL( iSession );

   274         }

   275 

   276     DeleteBearerRecordsL();

   277 

   278     OstTraceFunctionExit0( CCMPLUGINBASEENG_DELETEL_EXIT );

   279     }

   280 

   281 // ---------------------------------------------------------------------------

   282 // CCmPluginBaseEng::ReLoad

   283 // ---------------------------------------------------------------------------

   284 //

   285 EXPORT_C void CCmPluginBaseEng::ReLoadL()

   286     {

   287     OstTraceFunctionEntry0( CCMPLUGINBASEENG_RELOAD_ENTRY );

   288 

   289     delete iIapRecord; iIapRecord = NULL;

   290     delete iProxyRecord; iProxyRecord = NULL;

   291     delete iServiceRecord; iServiceRecord = NULL;

   292     delete iNetworkRecord; iNetworkRecord = NULL;

   293     delete iLocationRecord; iLocationRecord = NULL;

   294     delete iWapAPRecord; iWapAPRecord = NULL;

   295     delete iWapIPBearerRecord; iWapIPBearerRecord = NULL;

   296     delete iMetaDataRecord; iMetaDataRecord = NULL;

   297 

   298     iLocationEnabled = EFalse;

   299 

   300     ResetBearerRecords();

   301 

   302     LoadL( iCmId );

   303 

   304     OstTraceFunctionExit0( CCMPLUGINBASEENG_RELOAD_EXIT );

   305     }

   306 

   307 // ---------------------------------------------------------------------------

   308 // CCmPluginBaseEng::LoadL

   309 // ---------------------------------------------------------------------------

   310 //

   311 EXPORT_C void CCmPluginBaseEng::LoadL( TUint32 aIapId )

   312     {

   313     OstTraceFunctionEntry0( CCMPLUGINBASEENG_LOADL_ENTRY );

   314 

   315     // Embedded destination must be handled separately first.

   316     if ( aIapId > KCmDefaultDestinationAPTagId )

   317         {

   318         iCmId = aIapId;

   319         return;

   320         }

   321 

   322     DoLoadL( aIapId );

   323 

   324     OstTraceFunctionExit0( CCMPLUGINBASEENG_LOADL_EXIT );

   325     }

   326 

   327 // ---------------------------------------------------------------------------

   328 // CCmPluginBaseEng::CreateNewL

   329 // ---------------------------------------------------------------------------

   330 //

   331 EXPORT_C void CCmPluginBaseEng::CreateNewL( TUint32 aCmId )

   332     {

   333     OstTraceFunctionEntry0( CCMPLUGINBASEENG_CREATENEWL_ENTRY );

   334 

   335     if ( iCmId )

   336         // we already have IAP id ->

   337         {

   338         User::Leave( KErrAlreadyExists );

   339         }

   340 

   341     // Optional record, disabled by default.

   342     iLocationEnabled = EFalse;

   343 

   344     // Create mandatory records.

   345     iIapRecord = static_cast<CCDIAPRecord*>(

   346             CCDRecordBase::RecordFactoryL( KCDTIdIAPRecord ) );

   347     iNetworkRecord = static_cast<CCDNetworkRecord*>(

   348             CCDRecordBase::RecordFactoryL( KCDTIdNetworkRecord ) );

   349     iProxyRecord = static_cast<CCDProxiesRecord*>(

   350             CCDRecordBase::RecordFactoryL( KCDTIdProxiesRecord ) );

   351     NewWapRecordL();

   352     iWapIPBearerRecord->iWAPGatewayAddress.SetL( KDefWapGatewayIpAddress );

   353 

   354     iMetaDataRecord = NewMetadataRecordL( ETrue );

   355 

   356     // Call plugin to create its own records.

   357     CreateServiceRecordL();

   358 

   359     // Update iaprecord servicetype name.

   360     HBufC* servicetypeName( NULL );

   361     ServiceRecordNameLC( servicetypeName );

   362     iIapRecord->iServiceType.SetL( *servicetypeName );

   363     CleanupStack::PopAndDestroy( servicetypeName );

   364 

   365     // Update iaprecord bearertype name.

   366     HBufC* bearerTypeName( NULL );

   367     BearerRecordNameLC( bearerTypeName );

   368     iIapRecord->iBearerType.SetL( *bearerTypeName );

   369     CleanupStack::PopAndDestroy( bearerTypeName );

   370 

   371     CreateBearerRecordsL();

   372 

   373     EnableProxyL( EFalse );

   374 

   375     _LIT( KDefaultConnNameTextId, "txt_occ_setlabel_connection_name_val_connection" );

   376     HBufC* resolvedText( NULL );

   377     resolvedText = CCmPluginBaseEngTextResolver::ResolveTextL( KDefaultConnNameTextId );

   378     if ( resolvedText )

   379         {

   380         SetDefaultNameL( *resolvedText );

   381         }

   382     else

   383         {

   384         SetDefaultNameL( KDefaultIapName );

   385         }

   386 

   387     delete resolvedText;

   388     resolvedText = NULL;

   389 

   390     iIapRecord->iNetworkWeighting = 0; // it's always 0.

   391 

   392     if ( aCmId != 0 )

   393         {

   394         iIapRecord->SetRecordId( aCmId );

   395         iCmId = 0;

   396         }

   397     else

   398         {

   399         iIapRecord->SetRecordId( KCDNewRecordRequest );

   400         }

   401 

   402     OstTraceFunctionExit0( CCMPLUGINBASEENG_CREATENEWL_EXIT );

   403     }

   404 

   405 // ---------------------------------------------------------------------------

   406 // CCmPluginBaseEng::CreateCopyL

   407 // ---------------------------------------------------------------------------

   408 //

   409 EXPORT_C CCmPluginBaseEng* CCmPluginBaseEng::CreateCopyL(

   410         CCmClientPluginInstance* /*aClientPluginInstance*/ )

   411     {

   412     OstTraceFunctionEntry0( CCMPLUGINBASEENG_CREATECOPYL_ENTRY );

   413 

   414     TCmPluginInitParam params( iSession );

   415     CCmPluginBaseEng* copyInst = CreateInstanceL( params );

   416     CleanupStack::PushL( copyInst );

   417 

   418     PrepareToCopyDataL( copyInst );

   419     CopyDataL( copyInst );

   420     CleanupStack::Pop( copyInst );

   421 

   422     OstTraceFunctionExit0( CCMPLUGINBASEENG_CREATECOPYL_EXIT );

   423     return copyInst;

   424     }

   425 

   426 // ---------------------------------------------------------------------------

   427 // CCmPluginBaseEng::GetGenericTableIdsToBeObserved

   428 // ---------------------------------------------------------------------------

   429 //

   430 EXPORT_C void CCmPluginBaseEng::GetGenericTableIdsToBeObservedL(

   431         RArray<TUint32>& aTableIdArray ) const

   432     {

   433     OstTraceFunctionEntry0( CCMPLUGINBASEENG_GETGENERICTABLEIDSTOBEOBSERVED_ENTRY );

   434 

   435     // Service and bearer records should be added by plugins.

   436     aTableIdArray.AppendL( KCDTIdIAPRecord );

   437     aTableIdArray.AppendL( KCDTIdWAPAccessPointRecord );

   438     aTableIdArray.AppendL( KCDTIdWAPIPBearerRecord );

   439     aTableIdArray.AppendL( KCDTIdProxiesRecord );

   440     aTableIdArray.AppendL( iMetadataTableId );

   441 

   442     OstTraceFunctionExit0( CCMPLUGINBASEENG_GETGENERICTABLEIDSTOBEOBSERVED_EXIT );

   443     }

   444 

   445 // ---------------------------------------------------------------------------

   446 // CCmPluginBaseEng::CopyDataL

   447 // ---------------------------------------------------------------------------

   448 //

   449 void CCmPluginBaseEng::CopyDataL( CCmPluginBaseEng* aCopyInstance )

   450     {

   451     OstTraceFunctionEntry0( CCMPLUGINBASEENG_COPYDATAL_ENTRY );

   452 

   453     aCopyInstance->iLocationEnabled = iLocationEnabled;

   454     aCopyInstance->iNamingMethod = iNamingMethod;

   455     CopyRecordsL( aCopyInstance );

   456 

   457     OstTraceFunctionExit0( CCMPLUGINBASEENG_COPYDATAL_EXIT );

   458     }

   459 

   460 // ---------------------------------------------------------------------------

   461 // CCmPluginBaseEng::CopyRecordsL

   462 // ---------------------------------------------------------------------------

   463 //

   464 void CCmPluginBaseEng::CopyRecordsL( CCmPluginBaseEng* aCopyInstance )

   465     {

   466     OstTraceFunctionEntry0( CCMPLUGINBASEENG_COPYRECORDSL_ENTRY );

   467 

   468     CopyRecordDataL( KIapRecordIndex, aCopyInstance );

   469 

   470     // Ensure that IAP's name is set by the rules (Naming Method).

   471     SetNameL(

   472             iIapRecord->iRecordName.GetL(),

   473             aCopyInstance->iIapRecord,

   474             aCopyInstance->iNamingMethod );

   475 

   476     CopyRecordDataL( KServiceRecordIndex, aCopyInstance );

   477     CopyRecordDataL( KNetworkRecordIndex, aCopyInstance );

   478     CopyRecordDataL( KWAPAPRecordIndex, aCopyInstance );

   479     CopyRecordDataL( KWAPBearerRecordIndex, aCopyInstance );

   480     CopyRecordDataL( KMetaDataRecordIndex, aCopyInstance );

   481     CopyRecordDataL( KProxyRecordIndex, aCopyInstance );

   482 

   483     CopyBearerRecordsL( aCopyInstance );

   484 

   485     OstTraceFunctionExit0( CCMPLUGINBASEENG_COPYRECORDSL_EXIT );

   486     }

   487 

   488 // ---------------------------------------------------------------------------

   489 // CCmPluginBaseEng::CopyRecordDataL

   490 // ---------------------------------------------------------------------------

   491 //

   492 void CCmPluginBaseEng::CopyRecordDataL(

   493         TUint32 aRecordIdentifier,

   494         CCmPluginBaseEng* aCopyInstance )

   495     {

   496     OstTraceFunctionEntry0( CCMPLUGINBASEENG_COPYRECORDDATAL_ENTRY );

   497 

   498     switch ( aRecordIdentifier )

   499         {

   500         case KIapRecordIndex:

   501             {

   502             aCopyInstance->iIapRecord = static_cast<CCDIAPRecord*>(

   503                     CCDRecordBase::RecordFactoryL( KCDTIdIAPRecord ) );

   504             CopyRecordFieldsL( *iIapRecord, *aCopyInstance->iIapRecord );

   505             }

   506             break;

   507         case KServiceRecordIndex:

   508             {

   509             aCopyInstance->iServiceRecord = CopyServiceRecordL();

   510             // The name of the service record copy is changed during update

   511             // process, in PrepareToUpdateRecordsL()-method.

   512             }

   513             break;

   514         case KNetworkRecordIndex:

   515             {

   516             aCopyInstance->iNetworkRecord = static_cast<CCDNetworkRecord*>(

   517                     CCDRecordBase::RecordFactoryL( KCDTIdNetworkRecord ) );

   518             CopyRecordFieldsL( *iNetworkRecord, *aCopyInstance->iNetworkRecord );

   519             }

   520             break;

   521         case KWAPAPRecordIndex:

   522             {

   523             aCopyInstance->iWapAPRecord = static_cast<CCDWAPAccessPointRecord*>(

   524                     CCDRecordBase::RecordFactoryL( KCDTIdWAPAccessPointRecord ) );

   525             CopyRecordFieldsL( *iWapAPRecord, *aCopyInstance->iWapAPRecord );

   526             }

   527             break;

   528         case KWAPBearerRecordIndex:

   529             {

   530             aCopyInstance->iWapIPBearerRecord = static_cast<CCDWAPIPBearerRecord*>(

   531                     CCDRecordBase::RecordFactoryL( KCDTIdWAPIPBearerRecord ) );

   532             CopyRecordFieldsL( *iWapIPBearerRecord, *aCopyInstance->iWapIPBearerRecord );

   533             }

   534             break;

   535         case KMetaDataRecordIndex:

   536             {

   537             aCopyInstance->iMetaDataRecord = new( ELeave ) CCDIAPMetadataRecord( 

   538                     iMetadataTableId );

   539             CopyRecordFieldsL( *iMetaDataRecord, *aCopyInstance->iMetaDataRecord );

   540             }

   541             break;

   542         case KProxyRecordIndex:

   543             {

   544             if ( iProxyRecord )

   545                 {

   546                 aCopyInstance->iProxyRecord = static_cast<CCDProxiesRecord*>(

   547                         CCDRecordBase::RecordFactoryL( KCDTIdProxiesRecord ) );

   548                 CopyRecordFieldsL( *iProxyRecord, *aCopyInstance->iProxyRecord );

   549                 }

   550             }

   551             break;

   552         default:

   553             {

   554             User::Leave( KErrArgument );

   555             }

   556             break;

   557         }

   558 

   559     OstTraceFunctionExit0( CCMPLUGINBASEENG_COPYRECORDDATAL_EXIT );

   560     }

   561 

   562 // ---------------------------------------------------------------------------

   563 // Copies the values and attributes of all fields from aSource-record into

   564 // aDestination record. Does not copy the record element ID. Also, does not

   565 // touch any field in aDestination-record that is NULL in aSource-record.

   566 // ---------------------------------------------------------------------------

   567 //

   568 EXPORT_C void CCmPluginBaseEng::CopyRecordFieldsL(

   569         CommsDat::CMDBRecordBase& aSource,

   570         CommsDat::CMDBRecordBase& aDestination )

   571     {

   572     OstTraceFunctionEntry0( CCMPLUGINBASEENG_COPYRECORDFIELDSL_ENTRY );

   573 

   574     const SRecordTypeInfo* recordInfo = aSource.GetRecordInfo();

   575     if ( !recordInfo )

   576         {

   577         User::Leave( KErrCorrupt );

   578         }

   579 

   580     CMDBElement* ptrSource( NULL );

   581     CMDBElement* ptrDest( NULL );

   582 

   583     while ( recordInfo && recordInfo->iTypeId != 0 )

   584         {

   585         ptrSource = aSource.GetFieldByIdL( recordInfo->iTypeId );

   586         ptrDest = aDestination.GetFieldByIdL( recordInfo->iTypeId );

   587 

   588         if ( !( ptrSource->IsNull() ) )

   589             {

   590             // Make sure we see only basic type info. Masks out any additional info

   591             // on links (CommsDat internal stuff).

   592             switch ( recordInfo->iValType & 0x000000ff )

   593                 {

   594                 case CommsDat::EInt:

   595                 case CommsDat::EBool:

   596                     {

   597                     static_cast<CMDBField<TInt>&>( *ptrDest ).SetL(

   598                             static_cast<CMDBField<TInt>&>( *ptrSource ) );

   599                     }

   600                     break;

   601                 case CommsDat::EUint32:

   602                 case CommsDat::ELink:

   603                     {

   604                     static_cast<CMDBField<TUint32>&>( *ptrDest ).SetL(

   605                             static_cast<CMDBField<TUint32>&>( *ptrSource ) );

   606                     }

   607                     break;

   608                 case CommsDat::EDesC8:

   609                     {

   610                     static_cast<CMDBField<TDesC8>&>( *ptrDest ).SetL(

   611                             static_cast<CMDBField<TDesC8>&>( *ptrSource ) );

   612                     }

   613                     break;

   614                 case CommsDat::EText:

   615                 case CommsDat::EMedText:

   616                 case CommsDat::ELongText:

   617                     {

   618                     static_cast<CMDBField<TDesC>&>( *ptrDest ).SetL(

   619                             static_cast<CMDBField<TDesC>&>( *ptrSource ) );

   620                     }

   621                     break;

   622                 default:

   623                     {

   624                     User::Leave( KErrCorrupt );

   625                     }

   626                     break;

   627                 }

   628             ptrDest->ClearAttributes( ptrDest->Attributes() );

   629             ptrDest->SetAttributes( ptrSource->Attributes() );

   630             }

   631         recordInfo++;

   632         }

   633 

   634     OstTraceFunctionExit0( CCMPLUGINBASEENG_COPYRECORDFIELDSL_EXIT );

   635     }

   636 

   637 // ---------------------------------------------------------------------------

   638 // CCmPluginBaseEng::DoLoadL

   639 // ---------------------------------------------------------------------------

   640 //

   641 void CCmPluginBaseEng::DoLoadL( TUint32 aIapId )

   642     {

   643     OstTraceFunctionEntry0( CCMPLUGINBASEENG_DOLOADL_ENTRY );

   644 

   645     PrepareToLoadRecordsL();

   646 

   647     LoadIAPRecordL( aIapId );

   648     LoadWapRecordL();

   649     LoadMetadataRecordL();

   650     LoadNetworkRecordL();

   651 

   652     LoadServiceRecordL();

   653     LoadProxyRecordL();

   654 

   655     LoadBearerRecordsL();

   656 

   657     OstTraceFunctionExit0( CCMPLUGINBASEENG_DOLOADL_EXIT );

   658     }

   659 

   660 // ---------------------------------------------------------------------------

   661 // CCmPluginBaseEng::PrepareToLoadRecordsL

   662 // ---------------------------------------------------------------------------

   663 //

   664 void CCmPluginBaseEng::PrepareToLoadRecordsL()

   665     {

   666     OstTraceFunctionEntry0( CCMPLUGINBASEENG_PREPARETOLOADRECORDSL_ENTRY );

   667 

   668     iLocationEnabled = EFalse;

   669     PreparePluginToLoadRecordsL();

   670 

   671     OstTraceFunctionExit0( CCMPLUGINBASEENG_PREPARETOLOADRECORDSL_EXIT );

   672     }

   673 

   674 // ---------------------------------------------------------------------------

   675 // CCmPluginBaseEng::LoadIAPRecordL

   676 // ---------------------------------------------------------------------------

   677 //

   678 void CCmPluginBaseEng::LoadIAPRecordL( TUint32 aIapId )

   679     {

   680     OstTraceFunctionEntry0( CCMPLUGINBASEENG_LOADIAPRECORDL_ENTRY );

   681 

   682     iCmId = aIapId;

   683 

   684     // Load IAP record.

   685     CCDIAPRecord *iapRecord = static_cast<CCDIAPRecord*>(

   686             CCDRecordBase::RecordFactoryL( KCDTIdIAPRecord ) );

   687 

   688     CleanupStack::PushL( iapRecord );

   689 

   690     iapRecord->SetRecordId( iCmId );

   691     iapRecord->LoadL( iSession );

   692 

   693     CleanupStack::Pop( iapRecord );

   694     iIapRecord = iapRecord;

   695 

   696     OstTraceFunctionExit0( CCMPLUGINBASEENG_LOADIAPRECORDL_EXIT );

   697     }

   698 

   699 // ---------------------------------------------------------------------------

   700 // CCmPluginBaseEng::LoadProxySettingL

   701 // ---------------------------------------------------------------------------

   702 //

   703 void CCmPluginBaseEng::LoadProxyRecordL()

   704     {

   705     OstTraceFunctionEntry0( CCMPLUGINBASEENG_LOADPROXYSETTINGL_ENTRY );

   706 

   707     // Load Proxy record.

   708     CMDBRecordSet<CCDProxiesRecord>* proxieRS =

   709             new( ELeave ) CMDBRecordSet<CCDProxiesRecord>( KCDTIdProxiesRecord );

   710     CleanupStack::PushL(proxieRS);

   711 

   712     // Now try to find the linked proxy record.

   713     // Create new record.

   714     CCDProxiesRecord* proxyRecord = static_cast<CCDProxiesRecord*>(

   715             CCDRecordBase::RecordFactoryL( KCDTIdProxiesRecord ) );

   716     CleanupStack::PushL( proxyRecord );

   717 

   718     // Prime record.

   719     TPtrC serviceType( iIapRecord->iServiceType );

   720     proxyRecord->iServiceType.SetL( serviceType );

   721     proxieRS->iRecords.AppendL( proxyRecord ); // Ownership transfered.

   722 

   723     CleanupStack::Pop( proxyRecord );

   724     proxyRecord = NULL;

   725 

   726     if ( proxieRS->FindL(iSession) )

   727         {

   728         TInt i( 0 );

   729         while ( i < proxieRS->iRecords.Count() )

   730             // Now that we have a list of services with the proper service type

   731             // search for our proxy record and remove it from the array,

   732             // then destroy the array.

   733             {

   734             CCDProxiesRecord* proxyRecord = (*proxieRS)[i];

   735 

   736             // Compare the record id of these 2 services.

   737             if ( TUint32( proxyRecord->iService ) == TUint32( iIapRecord->iService ) )

   738                 {

   739                 iProxyRecord = proxyRecord;

   740                 // Take ownership of this record.

   741                 proxieRS->iRecords.Remove( i );

   742                 break;

   743                 }

   744             ++i;

   745             }

   746         }

   747 

   748     proxieRS->iRecords.ResetAndDestroy();

   749 

   750     if ( !iProxyRecord )

   751         {

   752         // This creates a proxy record, where usage is disabled.

   753         EnableProxyL( EFalse );

   754         }

   755 

   756     CleanupStack::PopAndDestroy( proxieRS );

   757 

   758     OstTraceFunctionExit0( CCMPLUGINBASEENG_LOADPROXYSETTINGL_EXIT );

   759     }

   760 

   761 // ---------------------------------------------------------------------------

   762 // CCmPluginBaseEng::LoadNetworkSettingL

   763 // ---------------------------------------------------------------------------

   764 //

   765 void CCmPluginBaseEng::LoadNetworkRecordL()

   766     {

   767     OstTraceFunctionEntry0( CCMPLUGINBASEENG_LOADNETWORKSETTINGL_ENTRY );

   768 

   769     CCDNetworkRecord* networkRecord = static_cast<CCDNetworkRecord*>(

   770             CCDRecordBase::RecordFactoryL( KCDTIdNetworkRecord ) );

   771     CleanupStack::PushL( networkRecord );

   772 

   773     networkRecord->SetRecordId( iIapRecord->iNetwork );

   774     TRAPD( err, networkRecord->LoadL( iSession ) );

   775     if ( err == KErrNotFound )

   776         {

   777         CleanupStack::PopAndDestroy( networkRecord );

   778 

   779         networkRecord = static_cast<CCDNetworkRecord*>(

   780                 CCDRecordBase::RecordFactoryL( KCDTIdNetworkRecord ) );

   781         }

   782     else

   783         // KErrNotFound -> doesn't matter. We will do it UpdateL()

   784         {

   785         User::LeaveIfError( err );

   786 

   787         CleanupStack::Pop( networkRecord );

   788         }

   789 

   790     iNetworkRecord = networkRecord;

   791 

   792     OstTraceFunctionExit0( CCMPLUGINBASEENG_LOADNETWORKSETTINGL_EXIT );

   793     }

   794 

   795 // ---------------------------------------------------------------------------

   796 // CCmPluginBaseEng::LoadLocationSettingL

   797 // ---------------------------------------------------------------------------

   798 //

   799 void CCmPluginBaseEng::LoadLocationRecordL()

   800     {

   801     OstTraceFunctionEntry0( CCMPLUGINBASEENG_LOADLOCATIONSETTINGL_ENTRY );

   802     OstTraceFunctionExit0( CCMPLUGINBASEENG_LOADLOCATIONSETTINGL_EXIT );

   803     }

   804 

   805 // ---------------------------------------------------------------------------

   806 // CCmPluginBaseEng::PrepareToUpdateRecordsL

   807 // ---------------------------------------------------------------------------

   808 //

   809 void CCmPluginBaseEng::PrepareToUpdateRecordsL(

   810         CCmClientPluginInstance* aClientPluginInstance )

   811     {

   812     OstTraceFunctionEntry0( CCMPLUGINBASEENG_PREPARETOUPDATERECORDSL_ENTRY );

   813 

   814     //TODO, Add null checks for mandatory generic record pointers.

   815     //

   816 

   817     // Set the record attributes to bearer specific records.

   818     CCDIAPRecord* iapRecord = static_cast<CCDIAPRecord*>(

   819             aClientPluginInstance->iGenRecordArray[KIapRecordIndex] );

   820 

   821     for ( TInt i = 0; i < aClientPluginInstance->iBearerSpecRecordArray.Count(); i++ )

   822         {

   823         CCDRecordBase* record = static_cast<CCDRecordBase*>(

   824                 aClientPluginInstance->iBearerSpecRecordArray[i] );

   825 

   826         CopyAttributes( iapRecord, record );

   827         }

   828 

   829     PreparePluginToUpdateRecordsL(

   830             aClientPluginInstance->iGenRecordArray,

   831             aClientPluginInstance->iBearerSpecRecordArray );

   832 

   833     OstTraceFunctionExit0( CCMPLUGINBASEENG_PREPARETOUPDATERECORDSL_EXIT );

   834     }

   835 

   836 // ---------------------------------------------------------------------------

   837 // CCmPluginBaseEng::UpdateIAPRecordL

   838 // ---------------------------------------------------------------------------

   839 //

   840 void CCmPluginBaseEng::UpdateIAPRecordL(

   841         CCmClientPluginInstance* aClientPluginInstance )

   842     {

   843     OstTraceFunctionEntry0( CCMPLUGINBASEENG_UPDATEIAPRECORDL_ENTRY );

   844 

   845     CCDIAPRecord* iapRecord = static_cast<CCDIAPRecord*>(

   846             aClientPluginInstance->iGenRecordArray[KIapRecordIndex] );

   847 

   848     if ( iCmId == 0 )

   849         {

   850         // Otherwise predefined iapid.

   851         if ( !iIapRecord->RecordId() )

   852             {

   853             iIapRecord->SetRecordId( KCDNewRecordRequest );

   854             }

   855 

   856         TUint32 id( 0 );

   857         id = ServiceRecordId();

   858         iIapRecord->iService = id;

   859 

   860         HBufC* name( NULL );

   861         ServiceRecordNameLC( name );

   862         iIapRecord->iServiceType.SetL( *name );

   863         CleanupStack::PopAndDestroy( name );

   864 

   865         BearerRecordIdL( id );

   866         iIapRecord->iBearer = id;

   867         BearerRecordNameLC( name );

   868         iIapRecord->iBearerType.SetL( *name );

   869         CleanupStack::PopAndDestroy( name );

   870 

   871         iIapRecord->iNetwork = iNetworkRecord->RecordId();

   872 

   873         iIapRecord->iLocation = GetLocationIdL();

   874 

   875         CopyAttributes( iapRecord, iIapRecord );

   876         CheckIfNameModifiedL( iapRecord, iIapRecord );

   877 

   878         iIapRecord->StoreL( iSession );

   879         // Have to be "reloaded" to get possible default values 

   880         // from template records.

   881         iIapRecord->LoadL( iSession );

   882 

   883         iCmId = iIapRecord->RecordId();

   884         aClientPluginInstance->iIapId = iCmId;

   885 

   886         CCDIAPRecord* tempIapRecord = static_cast<CCDIAPRecord*>(

   887                 CCDRecordBase::RecordFactoryL( KCDTIdIAPRecord ) );

   888         CleanupStack::PushL( tempIapRecord );

   889         CopyRecordFieldsL( *iIapRecord, *tempIapRecord );

   890         tempIapRecord->SetElementId( iIapRecord->ElementId() );

   891 

   892         aClientPluginInstance->iGenRecordArray.Remove( KIapRecordIndex );

   893         delete iapRecord;

   894         iapRecord = NULL;

   895 

   896         aClientPluginInstance->iGenRecordArray.InsertL(

   897                 static_cast<CommsDat::CCDRecordBase*>( tempIapRecord ),

   898                 KIapRecordIndex );

   899 

   900         CleanupStack::Pop( tempIapRecord );

   901         }

   902     else

   903         {

   904         delete iIapRecord;

   905         iIapRecord = NULL;

   906         iIapRecord = static_cast<CCDIAPRecord*>(

   907                 CCDRecordBase::RecordFactoryL( KCDTIdIAPRecord ) );

   908         CopyRecordFieldsL( *iapRecord, *iIapRecord );

   909 

   910         iIapRecord->SetElementId( iapRecord->ElementId() );

   911         iIapRecord->ModifyL( iSession );

   912         }

   913 

   914     OstTraceFunctionExit0( CCMPLUGINBASEENG_UPDATEIAPRECORDL_EXIT );

   915     }

   916 

   917 // ---------------------------------------------------------------------------

   918 // CCmPluginBaseEng::UpdateProxyRecordL

   919 // ---------------------------------------------------------------------------

   920 //

   921 void CCmPluginBaseEng::UpdateProxyRecordL(

   922         CCmClientPluginInstance* aClientPluginInstance )

   923     {

   924     OstTraceFunctionEntry0( CCMPLUGINBASEENG_UPDATEPROXYRECORDL_ENTRY );

   925 

   926     CCDIAPRecord* iapRecord = static_cast<CCDIAPRecord*>(

   927             aClientPluginInstance->iGenRecordArray[KIapRecordIndex] );

   928 

   929     CCDProxiesRecord* proxyRecord = static_cast<CCDProxiesRecord*>(

   930             aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] );

   931 

   932     if ( !iapRecord || !proxyRecord )

   933         {

   934         User::Leave( KErrCorrupt );

   935         }

   936 

   937     CopyAttributes( iapRecord, proxyRecord );

   938     CheckIfNameModifiedL( iapRecord, proxyRecord );

   939 

   940     delete iProxyRecord;

   941     iProxyRecord = NULL;

   942     iProxyRecord = static_cast<CCDProxiesRecord*>(

   943             CCDRecordBase::RecordFactoryL( KCDTIdProxiesRecord ) );

   944     CopyRecordFieldsL( *proxyRecord, *iProxyRecord );

   945     iProxyRecord->SetElementId( proxyRecord->ElementId() );

   946 

   947     if ( !iProxyRecord->RecordId() )

   948         {

   949         // New proxy setting -> create new record.

   950         iProxyRecord->iService = iServiceRecord->RecordId();

   951         iProxyRecord->iServiceType.SetL( iIapRecord->iServiceType );

   952 

   953         // By default protocol is set to "http".

   954         if ( TPtrC( proxyRecord->iProtocolName ).Length() == 0 )

   955             {

   956             iProxyRecord->iProtocolName.SetL( KDefProxyProtocolName );

   957             }

   958 

   959         iProxyRecord->SetRecordId( KCDNewRecordRequest );

   960         iProxyRecord->StoreL( iSession );

   961         // Have to be "reloaded" to get possible default values from template records.

   962         iProxyRecord->LoadL( iSession );

   963 

   964         proxyRecord->SetElementId( iProxyRecord->ElementId() );

   965         }

   966     else

   967         // Already existing record -> update only.

   968         {

   969         iProxyRecord->ModifyL( iSession );

   970         }

   971     CopyRecordFieldsL( *iProxyRecord, *proxyRecord );

   972 

   973     OstTraceFunctionExit0( CCMPLUGINBASEENG_UPDATEPROXYRECORDL_EXIT );

   974     }

   975 

   976 // ---------------------------------------------------------------------------

   977 // CCmPluginBaseEng::UpdateMetadataRecordL

   978 // ---------------------------------------------------------------------------

   979 //

   980 void CCmPluginBaseEng::UpdateMetadataRecordL(

   981         CCmClientPluginInstance* aClientPluginInstance )

   982     {

   983     OstTraceFunctionEntry0( CCMPLUGINBASEENG_UPDATEMETADATARECORDL_ENTRY );

   984 

   985     CCDIAPRecord* clientIapRecord = static_cast<CCDIAPRecord*>(

   986             aClientPluginInstance->iGenRecordArray[KIapRecordIndex] );

   987 

   988     CCDIAPMetadataRecord* clientMetadataRecord = static_cast<CCDIAPMetadataRecord*>(

   989             aClientPluginInstance->iGenRecordArray[KMetaDataRecordIndex] );

   990 

   991     // Adjust client side metadata record attributes and name if needed.

   992     CopyAttributes( clientIapRecord, clientMetadataRecord );

   993     CheckIfNameModifiedL( clientIapRecord, clientMetadataRecord );

   994 

   995     // Make a copy of client's metadata record and save to database.

   996     delete iMetaDataRecord;

   997     iMetaDataRecord = NULL;

   998     iMetaDataRecord = new( ELeave ) CCDIAPMetadataRecord( iMetadataTableId );

   999 

  1000     CopyRecordFieldsL( *clientMetadataRecord, *iMetaDataRecord );

  1001 

  1002     iMetaDataRecord->SetElementId( clientMetadataRecord->ElementId() );

  1003 

  1004     if ( !iMetaDataRecord->RecordId() )

  1005         {

  1006         iMetaDataRecord->iIAP = IAPRecordElementId();

  1007         iMetaDataRecord->SetRecordId( KCDNewRecordRequest );

  1008         iMetaDataRecord->StoreL( iSession );

  1009         // Have to be "reloaded" to get possible default values from template records.

  1010         iMetaDataRecord->LoadL( iSession );

  1011 

  1012         clientMetadataRecord->SetElementId( iMetaDataRecord->ElementId() );

  1013         }

  1014     else

  1015         {

  1016         iMetaDataRecord->ModifyL( iSession );

  1017         }

  1018     CopyRecordFieldsL( *iMetaDataRecord, *clientMetadataRecord );

  1019 

  1020     OstTraceFunctionExit0( CCMPLUGINBASEENG_UPDATEMETADATARECORDL_EXIT );

  1021     }

  1022 

  1023 // ---------------------------------------------------------------------------

  1024 // CCmPluginBaseEng::UpdateServiceRecordL

  1025 // ---------------------------------------------------------------------------

  1026 //

  1027 void CCmPluginBaseEng::UpdateServiceRecordL(

  1028     CCmClientPluginInstance* aClientPluginInstance )

  1029     {

  1030     OstTraceFunctionEntry0( CCMPLUGINBASEENG_UPDATESERVICERECORDL_ENTRY );

  1031 

  1032     CCDIAPRecord* iapRecord = static_cast<CCDIAPRecord*>(

  1033             aClientPluginInstance->iGenRecordArray[KIapRecordIndex] );

  1034 

  1035     CCDRecordBase* serviceRecord = static_cast<CCDRecordBase*>(

  1036             aClientPluginInstance->iGenRecordArray[KServiceRecordIndex] );

  1037 

  1038     CopyAttributes( iapRecord, serviceRecord );

  1039 

  1040     UpdateServiceRecordL(

  1041             aClientPluginInstance->iGenRecordArray,

  1042             aClientPluginInstance->iBearerSpecRecordArray );

  1043 

  1044     OstTraceFunctionExit0( CCMPLUGINBASEENG_UPDATESERVICERECORDL_EXIT );

  1045     }

  1046 

  1047 // ---------------------------------------------------------------------------

  1048 // CCmPluginBaseEng::UpdateNetworkRecordL

  1049 // ---------------------------------------------------------------------------

  1050 //

  1051 void CCmPluginBaseEng::UpdateNetworkRecordL(

  1052         CCmClientPluginInstance* aClientPluginInstance )

  1053     {

  1054     OstTraceFunctionEntry0( CCMPLUGINBASEENG_UPDATENETWORKRECORDL_ENTRY );

  1055 

  1056     CCDIAPRecord* iapRecord = static_cast<CCDIAPRecord*>(

  1057             aClientPluginInstance->iGenRecordArray[KIapRecordIndex] );

  1058 

  1059     CCDNetworkRecord* networkRecord = static_cast<CCDNetworkRecord*>(

  1060             aClientPluginInstance->iGenRecordArray[KNetworkRecordIndex] );

  1061 

  1062     CopyAttributes( iapRecord, networkRecord );

  1063 

  1064     delete iNetworkRecord;

  1065     iNetworkRecord = NULL;

  1066 

  1067     CheckIfNameModifiedL( iapRecord, networkRecord );

  1068 

  1069     iNetworkRecord = static_cast<CCDNetworkRecord*>(

  1070             CCDRecordBase::RecordFactoryL( KCDTIdNetworkRecord ) );

  1071     CopyRecordFieldsL( *networkRecord, *iNetworkRecord );

  1072 

  1073     iNetworkRecord->SetElementId( networkRecord->ElementId() );

  1074 

  1075     if ( !iNetworkRecord->RecordId() )

  1076         {

  1077         iNetworkRecord->SetRecordId( KCDNewRecordRequest );

  1078         iNetworkRecord->StoreL( iSession );

  1079         // Have to be "reloaded" to get possible default values from template records.

  1080         iNetworkRecord->LoadL( iSession );

  1081 

  1082         networkRecord->SetElementId( iNetworkRecord->ElementId() );

  1083         }

  1084     else

  1085         {

  1086         iNetworkRecord->ModifyL( iSession );

  1087         }

  1088     CopyRecordFieldsL( *iNetworkRecord, *networkRecord );

  1089 

  1090     OstTraceFunctionExit0( CCMPLUGINBASEENG_UPDATENETWORKRECORDL_EXIT );

  1091     }

  1092 

  1093 // ---------------------------------------------------------------------------

  1094 // CCmPluginBaseEng::UpdateLocationRecordL

  1095 // ---------------------------------------------------------------------------

  1096 //

  1097 void CCmPluginBaseEng::UpdateLocationRecordL(

  1098         CCmClientPluginInstance* /*aClientPluginInstance*/ )

  1099     {

  1100     OstTraceFunctionEntry0( CCMPLUGINBASEENG_UPDATELOCATIONRECORDL_ENTRY );

  1101     OstTraceFunctionExit0( CCMPLUGINBASEENG_UPDATELOCATIONRECORDL_EXIT );

  1102     }

  1103 

  1104 // ---------------------------------------------------------------------------

  1105 // CCmPluginBaseEng::UpdateConnPrefSettingL

  1106 // ---------------------------------------------------------------------------

  1107 //

  1108 void CCmPluginBaseEng::UpdateConnPrefSettingL()

  1109     {

  1110     OstTraceFunctionEntry0( CCMPLUGINBASEENG_UPDATECONNPREFSETTINGL_ENTRY );

  1111     OstTraceFunctionExit0( CCMPLUGINBASEENG_UPDATECONNPREFSETTINGL_EXIT );

  1112     }

  1113 

  1114 // ---------------------------------------------------------------------------

  1115 // CCmPluginBaseEng::EnableProxyL

  1116 // ---------------------------------------------------------------------------

  1117 //

  1118 void CCmPluginBaseEng::EnableProxyL( TBool aEnable )

  1119     {

  1120     OstTraceFunctionEntry0( CCMPLUGINBASEENG_ENABLEPROXYL_ENTRY );

  1121 

  1122     if ( !iServiceRecord )

  1123         {

  1124         User::Leave( KErrNotSupported );

  1125         }

  1126 

  1127     if ( !iProxyRecord )

  1128         {

  1129         iProxyRecord = static_cast<CCDProxiesRecord*>(

  1130                 CCDRecordBase::RecordFactoryL( KCDTIdProxiesRecord ) );

  1131         }

  1132 

  1133     iProxyRecord->iUseProxyServer = aEnable;

  1134