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 Lan Plugin interface implementation

    16 *      for Lan Bearer

    17 *

    18 *

    19 */

    20 

    21 

    22 #include "cmpluginlan.h"

    23 

    24 #include "datamobilitycommsdattypes.h"

    25 #include <cmmanagerdef.h>

    26 #include <ecom/ecom.h>  // For REComSession

    27 #include <featmgr.h>

    28 

    29 #include "OstTraceDefinitions.h"

    30 #ifdef OST_TRACE_COMPILER_IN_USE

    31 #include "cmpluginlanTraces.h"

    32 #endif

    33 

    34 

    35 using namespace CMManager;

    36 using namespace CommsDat;

    37 

    38 _LIT( KEmpty, "" );

    39 

    40 _LIT( KLanBearerName, "LANBearer" );

    41 _LIT( KLanBearerAgent, "nullagt.agt" );

    42 _LIT( KLanBearerNif, "ethint" );

    43 

    44 _LIT( KLanLDDFileName, "enet" );

    45 _LIT( KLanPDDFileName, "ethernet" );

    46 

    47 _LIT( KLanLDDName, "Ethernet" );

    48 _LIT( KLanPDDName, "Ethernet.Wins" );

    49 _LIT( KLanPacketDriverName, "EtherPkt.drv" );

    50 

    51 

    52 const TBool KDefIpAddrFromServer = ETrue;

    53 const TBool KDefIpDnsAddrFromServer = ETrue;

    54 const TBool KDefIp6DnsAddrFromServer = ETrue;

    55 

    56 const TInt KLanLastSocketActivityTimeout = -1;

    57 const TInt KLanLastSocketClosedTimeout = -1;

    58 const TInt KLanLastSessionClosedTimeout = -1;

    59 

    60 

    61 // ---------------------------------------------------------

    62 // CCmPluginLan::NewOutgoingL()

    63 // ---------------------------------------------------------

    64 //

    65 CCmPluginLan* CCmPluginLan::NewL( TCmPluginInitParam* aInitParam )

    66     {

    67     OstTraceFunctionEntry0( CCMPLUGINLAN_NEWL_ENTRY );

    68 

    69     CCmPluginLan* self = new( ELeave ) CCmPluginLan( aInitParam );

    70     CleanupStack::PushL( self );

    71     self->ConstructL();

    72     CleanupStack::Pop( self );

    73 

    74     OstTraceFunctionExit0( CCMPLUGINLAN_NEWL_EXIT );

    75     return self;

    76     }

    77 

    78 // ----------------------------------------------------------------------------

    79 // CCmPluginLan::CreateInstanceL

    80 // ----------------------------------------------------------------------------

    81 //

    82 CCmPluginBaseEng* CCmPluginLan::CreateInstanceL( TCmPluginInitParam& aInitParam ) const

    83     {

    84     OstTraceFunctionEntry0( CCMPLUGINLAN_CREATEINSTANCEL_ENTRY );

    85 

    86     CCmPluginLan* self = new( ELeave ) CCmPluginLan( &aInitParam );

    87     CleanupStack::PushL( self );

    88     self->ConstructL();

    89     CleanupStack::Pop( self );

    90 

    91     OstTraceFunctionExit0( CCMPLUGINLAN_CREATEINSTANCEL_EXIT );

    92     return self;

    93     }

    94 

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

    96 // CCmPluginLan::~CCmPluginLan()

    97 // ---------------------------------------------------------

    98 //

    99 CCmPluginLan::~CCmPluginLan()

   100     {

   101     OstTraceFunctionEntry0( CCMPLUGINLAN_CCMPLUGINLAN_ENTRY );

   102 

   103     ResetBearerRecords();

   104 

   105     OstTraceFunctionExit0( CCMPLUGINLAN_CCMPLUGINLAN_EXIT );

   106     }

   107 

   108 // ---------------------------------------------------------

   109 // CCmPluginLan::CCmPluginLan()

   110 // ---------------------------------------------------------

   111 //

   112 CCmPluginLan::CCmPluginLan( TCmPluginInitParam* aInitParam )

   113         :

   114         CCmPluginBaseEng( aInitParam )

   115     {

   116     OstTraceFunctionEntry0( DUP1_CCMPLUGINLAN_CCMPLUGINLAN_ENTRY );

   117 

   118     iBearerType = KUidLanBearerType;

   119     iBearerRecord = NULL;

   120     iBearerPriorityTableId = 0;

   121 

   122     OstTraceFunctionExit0( DUP1_CCMPLUGINLAN_CCMPLUGINLAN_EXIT );

   123     }

   124 

   125 // ---------------------------------------------------------

   126 // CCmPluginLan::ConstructL()

   127 // ---------------------------------------------------------

   128 //

   129 void CCmPluginLan::ConstructL()

   130     {

   131     OstTraceFunctionEntry0( CCMPLUGINLAN_CONSTRUCTL_ENTRY );

   132 

   133     // Feature Manager is initialized by the CmmServer, so no need to do it here.

   134 

   135     CCmPluginBaseEng::ConstructL();

   136     

   137     // Get bearer priority table ID.

   138     TRAP_IGNORE( iBearerPriorityTableId = 

   139             CCDGlobalBearerTypePriorizationRecord::TableIdL( iSession ) );

   140 

   141     if ( !iBearerPriorityTableId )

   142         {

   143         iBearerPriorityTableId = 

   144                 CCDGlobalBearerTypePriorizationRecord::CreateTableL( iSession );

   145         }

   146 

   147     OstTraceFunctionExit0( CCMPLUGINLAN_CONSTRUCTL_EXIT );

   148     }

   149 

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

   151 // CCmPluginLan::CanHandleIapIdL()

   152 // ---------------------------------------------------------

   153 //

   154 TBool CCmPluginLan::CanHandleIapIdL( TUint32 aIapId ) const

   155     {

   156     OstTraceFunctionEntryExt( CCMPLUGINLAN_CANHANDLEIAPIDL_ENTRY, this );

   157 

   158     TBool retVal( EFalse );

   159 

   160     CCDIAPRecord *iapRecord = static_cast<CCDIAPRecord *>

   161                             ( CCDRecordBase::RecordFactoryL( KCDTIdIAPRecord ) );

   162 

   163     CleanupStack::PushL( iapRecord );

   164     iapRecord->SetRecordId( aIapId );

   165 

   166     TRAPD( err, iapRecord->LoadL( iSession ) );

   167 

   168     if ( !err )

   169         {

   170         retVal = CanHandleIapIdL( iapRecord );

   171         }

   172 

   173     CleanupStack::PopAndDestroy( iapRecord );

   174 

   175     OstTraceFunctionExitExt( CCMPLUGINLAN_CANHANDLEIAPIDL_EXIT, this, retVal );

   176 

   177     return retVal;

   178     }

   179 

   180 // ---------------------------------------------------------

   181 // CCmPluginLan::CanHandleIapIdL()

   182 // ---------------------------------------------------------

   183 //

   184 TBool CCmPluginLan::CanHandleIapIdL( CCDIAPRecord *aIapRecord ) const

   185     {

   186     OstTraceFunctionEntryExt( DUP1_CCMPLUGINLAN_CANHANDLEIAPIDL_ENTRY, this );

   187 

   188     TBool retVal( EFalse );

   189 

   190     if ( (TPtrC( aIapRecord->iServiceType ) == TPtrC( KCDTypeNameLANService ) ) &&

   191         TPtrC( aIapRecord->iBearerType ) == TPtrC( KCDTypeNameLANBearer ) )

   192         {

   193         retVal = ETrue;

   194         }

   195 

   196     OstTraceFunctionExitExt( DUP1_CCMPLUGINLAN_CANHANDLEIAPIDL_EXIT, this, retVal );

   197 

   198     return retVal;

   199     }

   200 

   201 // ----------------------------------------------------------------------------

   202 // CCmPluginLan::PreparePluginToUpdateRecordsL()

   203 // ----------------------------------------------------------------------------

   204 //

   205 void CCmPluginLan::PreparePluginToLoadRecordsL()

   206     {

   207     OstTraceFunctionEntry0( CCMPLUGINLAN_PREPAREPLUGINTOLOADRECORDSL_ENTRY );

   208     OstTraceFunctionExit0( CCMPLUGINLAN_PREPAREPLUGINTOLOADRECORDSL_EXIT );

   209     }

   210 

   211 // ----------------------------------------------------------------------------

   212 // CCmPluginLan::PreparePluginToUpdateRecordsL()

   213 // ----------------------------------------------------------------------------

   214 //

   215 void CCmPluginLan::PreparePluginToUpdateRecordsL(

   216         RPointerArray<CommsDat::CCDRecordBase>& aGenRecordArray,

   217         RPointerArray<CommsDat::CCDRecordBase>& aBearerSpecRecordArray )

   218     {

   219     OstTraceFunctionEntry0( CCMPLUGINLAN_PREPAREPLUGINTOUPDATERECORDSL_ENTRY );

   220 

   221     CCDIAPRecord* iapRecord =

   222                 static_cast<CCDIAPRecord*>( aGenRecordArray[KIapRecordIndex] );

   223 

   224     CCDLANServiceRecord* serviceRecord =

   225             static_cast<CCDLANServiceRecord*>( aGenRecordArray[KServiceRecordIndex] );

   226 

   227     CheckIfNameModifiedL( iapRecord, serviceRecord );

   228 

   229     CheckDNSServerAddressL( ETrue,

   230                             serviceRecord->iIp6NameServer1,

   231                             serviceRecord->iIp6NameServer2,

   232                             serviceRecord->iIp6DnsAddrFromServer );

   233 

   234     CheckDNSServerAddressL( EFalse,

   235                             serviceRecord->iIpNameServer1,

   236                             serviceRecord->iIpNameServer2,

   237                             serviceRecord->iIpDnsAddrFromServer );

   238 

   239     SetDaemonNameL( aGenRecordArray, aBearerSpecRecordArray );

   240 

   241     OstTraceFunctionExit0( CCMPLUGINLAN_PREPAREPLUGINTOUPDATERECORDSL_EXIT );

   242     }

   243 

   244 // --------------------------------------------------------------------------

   245 // CCmPluginLan::CreateServiceRecordL

   246 // --------------------------------------------------------------------------

   247 //

   248 void CCmPluginLan::CreateServiceRecordL()

   249     {

   250     OstTraceFunctionEntry0( CCMPLUGINLAN_CREATESERVICERECORDL_ENTRY );

   251 

   252     delete iServiceRecord;

   253     iServiceRecord = NULL;

   254 

   255     iServiceRecord = static_cast<CCDLANServiceRecord*>(

   256             CCDRecordBase::RecordFactoryL( KCDTIdLANServiceRecord ) );

   257 

   258     CCDLANServiceRecord* lanServiceRecord = static_cast<CCDLANServiceRecord*>( iServiceRecord );

   259 

   260     if ( FeatureManager::FeatureSupported( KFeatureIdIPv6 ) )

   261         {

   262         lanServiceRecord->iIfNetworks.SetL( KDefIspIfNetworksIPv4IPv6LAN );

   263         }

   264     else

   265         {

   266         lanServiceRecord->iIfNetworks.SetL( KDefIspIfNetworksIPv4 );

   267         }

   268 

   269     lanServiceRecord->iIpGateway.SetL( KUnspecifiedIPv4 );

   270     lanServiceRecord->iIpAddrFromServer.SetL( KDefIpAddrFromServer );

   271 

   272     lanServiceRecord->iIpAddr.SetL( KUnspecifiedIPv4 );

   273 

   274     lanServiceRecord->iIpDnsAddrFromServer.SetL( KDefIpDnsAddrFromServer );

   275 

   276     lanServiceRecord->iIpNameServer1.SetL( KUnspecifiedIPv4 );

   277     lanServiceRecord->iIpNameServer2.SetL( KUnspecifiedIPv4 );

   278     lanServiceRecord->iIp6DnsAddrFromServer.SetL( KDefIp6DnsAddrFromServer );

   279     lanServiceRecord->iIp6NameServer1.SetL( KDynamicIpv6Address );

   280     lanServiceRecord->iIp6NameServer2.SetL( KDynamicIpv6Address );

   281 

   282     if ( KDefIpAddrFromServer )

   283         {

   284         lanServiceRecord->iConfigDaemonManagerName.SetL( KDaemonManagerName );

   285         lanServiceRecord->iConfigDaemonName.SetL( KConfigDaemonName );

   286         }

   287     else

   288         {

   289         lanServiceRecord->iConfigDaemonManagerName.SetL( KEmpty );

   290         lanServiceRecord->iConfigDaemonName.SetL( KEmpty );

   291         }

   292 

   293     OstTraceFunctionExit0( CCMPLUGINLAN_CREATESERVICERECORDL_EXIT );

   294     }

   295 

   296 // --------------------------------------------------------------------------

   297 // CCmPluginLan::LoadServiceRecordL

   298 // --------------------------------------------------------------------------

   299 //

   300 void CCmPluginLan::LoadServiceRecordL()

   301     {

   302     OstTraceFunctionEntry0( CCMPLUGINLAN_LOADSERVICERECORDL_ENTRY );

   303 

   304     if ( TPtrC( KCDTypeNameLANService ) == iIapRecord->iServiceType )

   305         {

   306         iServiceRecord = static_cast<CCDLANServiceRecord *>(

   307                 CCDRecordBase::RecordFactoryL( KCDTIdLANServiceRecord ) );

   308 

   309         ServiceRecord().SetRecordId( iIapRecord->iService );

   310         ServiceRecord().LoadL( iSession );

   311         }

   312     else

   313         {

   314         // This IAP service is not supported by this plugin.

   315         User::Leave( KErrNotSupported );

   316         }

   317 

   318     OstTraceFunctionExit0( CCMPLUGINLAN_LOADSERVICERECORDL_EXIT );

   319     }

   320 

   321 // ---------------------------------------------------------------------------

   322 // CCmPluginLan::PrepareToCopyDataL

   323 // ---------------------------------------------------------------------------

   324 //

   325 void CCmPluginLan::PrepareToCopyDataL( CCmPluginBaseEng* /*aCopyInstance*/ )

   326     {

   327     OstTraceFunctionEntry0( CCMPLUGINLAN_PREPARETOCOPYDATAL_ENTRY );

   328     OstTraceFunctionExit0( CCMPLUGINLAN_PREPARETOCOPYDATAL_EXIT );

   329     }

   330 

   331 // ---------------------------------------------------------------------------

   332 // CCmPluginLan::CopyServiceRecordL

   333 // ---------------------------------------------------------------------------

   334 //

   335 CommsDat::CCDRecordBase* CCmPluginLan::CopyServiceRecordL()

   336     {

   337     OstTraceFunctionEntry0( CCMPLUGINLAN_COPYSERVICERECORDL_ENTRY );

   338 

   339     // New service record to be returned.

   340     CCDRecordBase* serviceRecord = static_cast<CCDLANServiceRecord*>(

   341             CCDRecordBase::RecordFactoryL( KCDTIdLANServiceRecord ) );

   342     CleanupStack::PushL( serviceRecord );

   343 

   344     CCDLANServiceRecord* tempServiceRecordPtrToNew =

   345             static_cast<CCDLANServiceRecord*>( serviceRecord );

   346 

   347     // CommsDat version of service record.

   348     CCDLANServiceRecord* origServiceRecord =

   349             static_cast<CCDLANServiceRecord*>( iServiceRecord );

   350 

   351     if ( !origServiceRecord->iRecordTag.IsNull() )

   352         {

   353         tempServiceRecordPtrToNew->iRecordTag.SetL(

   354                 origServiceRecord->iRecordTag );

   355         }

   356     if ( !origServiceRecord->iRecordName.IsNull() )

   357         {

   358         tempServiceRecordPtrToNew->iRecordName.SetL(

   359                 origServiceRecord->iRecordName );

   360         }

   361     if ( !origServiceRecord->iServiceEnableLlmnr.IsNull() )

   362         {

   363         tempServiceRecordPtrToNew->iServiceEnableLlmnr.SetL(

   364                 origServiceRecord->iServiceEnableLlmnr );

   365         }

   366     if ( !origServiceRecord->iIfNetworks.IsNull() )

   367         {

   368         tempServiceRecordPtrToNew->iIfNetworks.SetL(

   369                 origServiceRecord->iIfNetworks );

   370         }

   371     if ( !origServiceRecord->iIpNetmask.IsNull() )

   372         {

   373         tempServiceRecordPtrToNew->iIpNetmask.SetL(

   374                 origServiceRecord->iIpNetmask );

   375         }

   376     if ( !origServiceRecord->iIpGateway.IsNull() )

   377         {

   378         tempServiceRecordPtrToNew->iIpGateway.SetL(

   379                 origServiceRecord->iIpGateway );

   380         }

   381     if ( !origServiceRecord->iIpAddrFromServer.IsNull() )

   382         {

   383         tempServiceRecordPtrToNew->iIpAddrFromServer.SetL(

   384                 origServiceRecord->iIpAddrFromServer );

   385         }

   386     if ( !origServiceRecord->iIpAddr.IsNull() )

   387         {

   388         tempServiceRecordPtrToNew->iIpAddr.SetL(

   389                 origServiceRecord->iIpAddr );

   390         }

   391     if ( !origServiceRecord->iIpDnsAddrFromServer.IsNull() )

   392         {

   393         tempServiceRecordPtrToNew->iIpDnsAddrFromServer.SetL(

   394                 origServiceRecord->iIpDnsAddrFromServer );

   395         }

   396     if ( !origServiceRecord->iIpNameServer1.IsNull() )

   397         {

   398         tempServiceRecordPtrToNew->iIpNameServer1.SetL(

   399                 origServiceRecord->iIpNameServer1 );

   400         }

   401     if ( !origServiceRecord->iIpNameServer2.IsNull() )

   402         {

   403         tempServiceRecordPtrToNew->iIpNameServer2.SetL(

   404                 origServiceRecord->iIpNameServer2 );

   405         }

   406     if ( !origServiceRecord->iIp6DnsAddrFromServer.IsNull() )

   407         {

   408         tempServiceRecordPtrToNew->iIp6DnsAddrFromServer.SetL(

   409                 origServiceRecord->iIp6DnsAddrFromServer );

   410         }

   411     if ( !origServiceRecord->iIp6NameServer1.IsNull() )

   412         {

   413         tempServiceRecordPtrToNew->iIp6NameServer1.SetL(

   414                 origServiceRecord->iIp6NameServer1 );

   415         }

   416     if ( !origServiceRecord->iIp6NameServer2.IsNull() )

   417         {

   418         tempServiceRecordPtrToNew->iIp6NameServer2.SetL(

   419                 origServiceRecord->iIp6NameServer2 );

   420         }

   421     if ( !origServiceRecord->iIpAddrLeaseValidFrom.IsNull() )

   422         {

   423         tempServiceRecordPtrToNew->iIpAddrLeaseValidFrom.SetL(

   424                 origServiceRecord->iIpAddrLeaseValidFrom );

   425         }

   426     if ( !origServiceRecord->iIpAddrLeaseValidTo.IsNull() )

   427         {

   428         tempServiceRecordPtrToNew->iIpAddrLeaseValidTo.SetL(

   429                 origServiceRecord->iIpAddrLeaseValidTo );

   430         }

   431     if ( !origServiceRecord->iConfigDaemonManagerName.IsNull() )

   432         {

   433         tempServiceRecordPtrToNew->iConfigDaemonManagerName.SetL(

   434                 origServiceRecord->iConfigDaemonManagerName );

   435         }

   436     if ( !origServiceRecord->iConfigDaemonName.IsNull() )

   437         {

   438         tempServiceRecordPtrToNew->iConfigDaemonName.SetL(

   439                 origServiceRecord->iConfigDaemonName );

   440         }

   441     if ( !origServiceRecord->iServiceExtensionTableName.IsNull() )

   442         {

   443         tempServiceRecordPtrToNew->iServiceExtensionTableName.SetL(

   444                 origServiceRecord->iServiceExtensionTableName );

   445         }

   446     if ( !origServiceRecord->iServiceExtensionTableRecordId.IsNull() )

   447         {

   448         tempServiceRecordPtrToNew->iServiceExtensionTableRecordId.SetL(

   449                 origServiceRecord->iServiceExtensionTableRecordId );

   450         }

   451 

   452     CleanupStack::Pop( serviceRecord );

   453 

   454     OstTraceFunctionExit0( CCMPLUGINLAN_COPYSERVICERECORDL_EXIT );

   455     return serviceRecord;

   456     }

   457 

   458 // ----------------------------------------------------------------------------

   459 // CCmPluginLan::UpdateServiceRecordL()

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

   461 //

   462 void CCmPluginLan::UpdateServiceRecordL(

   463         RPointerArray<CommsDat::CCDRecordBase>& aGenRecordArray,

   464         RPointerArray<CommsDat::CCDRecordBase>& /*aBearerSpecRecordArray*/ )

   465     {

   466     OstTraceFunctionEntry0( CCMPLUGINLAN_UPDATESERVICERECORDL_ENTRY );

   467 

   468     // Delete the original record and create a copy from the client's copy.

   469     delete iServiceRecord;

   470     iServiceRecord = NULL;

   471 

   472     iServiceRecord = static_cast<CCDLANServiceRecord*>(

   473             CCDRecordBase::RecordFactoryL( KCDTIdLANServiceRecord ) );

   474 

   475     CCDLANServiceRecord* origServiceRecord = static_cast<CCDLANServiceRecord*>( iServiceRecord );

   476 

   477     // Client's copy of lan service record.

   478     CCDLANServiceRecord* clientServiceRecordCopy =

   479             static_cast<CCDLANServiceRecord*>( aGenRecordArray[KServiceRecordIndex] );

   480 

   481     CopyRecordFieldsL( *clientServiceRecordCopy, *origServiceRecord );

   482 

   483     origServiceRecord->SetElementId( clientServiceRecordCopy->ElementId() );

   484 

   485     if ( !origServiceRecord->RecordId() )

   486         {

   487         origServiceRecord->SetRecordId( KCDNewRecordRequest );

   488         origServiceRecord->StoreL( iSession );

   489 

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

   491         origServiceRecord->LoadL( iSession );

   492 

   493         // Update received element ID to client's copy too.

   494         clientServiceRecordCopy->SetElementId( origServiceRecord->ElementId() );

   495         }

   496     else

   497         {

   498         origServiceRecord->ModifyL( iSession );

   499         }

   500 

   501     CCmPluginBaseEng::CopyRecordFieldsL( *origServiceRecord,

   502             *clientServiceRecordCopy );

   503 

   504     OstTraceFunctionExit0( CCMPLUGINLAN_UPDATESERVICERECORDL_EXIT );

   505     }

   506 

   507 // ---------------------------------------------------------------------------

   508 // CCmPluginLan::CreateBearerRecordsL

   509 // ---------------------------------------------------------------------------

   510 //

   511 void CCmPluginLan::CreateBearerRecordsL()

   512     {

   513     OstTraceFunctionEntry0( CCMPLUGINLAN_CREATEBEARERRECORDSL_ENTRY );

   514     OstTraceFunctionExit0( CCMPLUGINLAN_CREATEBEARERRECORDSL_EXIT );

   515     }

   516 

   517 // --------------------------------------------------------------------------

   518 // CCmPluginLan::LoadBearerRecordsL

   519 // --------------------------------------------------------------------------

   520 //

   521 void CCmPluginLan::LoadBearerRecordsL()

   522     {

   523     OstTraceFunctionEntry0( CCMPLUGINLAN_LOADBEARERRECORDSL_ENTRY );

   524     OstTraceFunctionExit0( CCMPLUGINLAN_LOADBEARERRECORDSL_EXIT );

   525     }

   526 

   527 // ---------------------------------------------------------------------------

   528 // CCmPluginLan::ServiceRecord()

   529 // ---------------------------------------------------------------------------

   530 //

   531 CCDLANServiceRecord& CCmPluginLan::ServiceRecord() const

   532     {

   533     OstTraceFunctionEntry0( CCMPLUGINLAN_SERVICERECORD_ENTRY );

   534 

   535     return *static_cast<CCDLANServiceRecord*>( iServiceRecord );

   536     }

   537 

   538 // ---------------------------------------------------------------------------

   539 // CCmPluginLan::ServiceRecordIdLC

   540 // ---------------------------------------------------------------------------

   541 //

   542 TUint32 CCmPluginLan::ServiceRecordId() const

   543     {

   544     OstTraceFunctionEntry0( CCMPLUGINLAN_SERVICERECORDID_ENTRY );

   545 

   546     return ServiceRecord().RecordId();

   547     }

   548 

   549 // ---------------------------------------------------------------------------

   550 // CCmPluginLan::ServiceRecordNameLC

   551 // ---------------------------------------------------------------------------

   552 //

   553 void CCmPluginLan::ServiceRecordNameLC( HBufC* &aName )

   554     {

   555     OstTraceFunctionEntry0( CCMPLUGINLAN_SERVICERECORDNAMELC_ENTRY );

   556 

   557     aName = TPtrC( KCDTypeNameLANService ).AllocLC();

   558 

   559     OstTraceFunctionExit0( CCMPLUGINLAN_SERVICERECORDNAMELC_EXIT );

   560     }

   561 

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

   563 // CCmPluginLan::BearerRecordIdL()

   564 // ---------------------------------------------------------------------------

   565 //

   566 void CCmPluginLan::BearerRecordIdL( TUint32& aRecordId )

   567     {

   568     CCDLANBearerRecord* lanBearerRecord = static_cast<CCDLANBearerRecord*>(

   569             CCDRecordBase::RecordFactoryL( KCDTIdLANBearerRecord ) );

   570     CleanupStack::PushL( lanBearerRecord );

   571 

   572     lanBearerRecord->iRecordName.SetL( TPtrC( KLanBearerName ) );

   573     if ( !lanBearerRecord->FindL( iSession ) )

   574         { // Bearer not found -> create dummy values.

   575         lanBearerRecord->SetRecordId( KCDNewRecordRequest );

   576         lanBearerRecord->iBearerAgent = KLanBearerAgent;

   577         lanBearerRecord->iRecordName = KLanBearerName;

   578         lanBearerRecord->iLanBearerNifName = KLanBearerNif;

   579 

   580         lanBearerRecord->iLanBearerLddFilename = KLanLDDFileName;

   581         lanBearerRecord->iLanBearerLddName = KLanLDDName;

   582         lanBearerRecord->iLanBearerPddFilename = KLanPDDFileName;

   583         lanBearerRecord->iLanBearerPddName = KLanPDDName;

   584         lanBearerRecord->iLanBearerPacketDriverName = KLanPacketDriverName;

   585         lanBearerRecord->iLastSocketActivityTimeout = (TUint32)KLanLastSocketActivityTimeout;

   586         lanBearerRecord->iLastSessionClosedTimeout = (TUint32)KLanLastSessionClosedTimeout;

   587         lanBearerRecord->iLastSocketClosedTimeout = (TUint32)KLanLastSocketClosedTimeout;

   588 

   589         lanBearerRecord->StoreL( iSession );

   590         }

   591 

   592     aRecordId = lanBearerRecord->RecordId();

   593 

   594     CleanupStack::PopAndDestroy( lanBearerRecord );

   595     }

   596 

   597 // ---------------------------------------------------------------------------

   598 // CCmPluginLan::BearerRecordNameLC()

   599 // ---------------------------------------------------------------------------

   600 //

   601 void CCmPluginLan::BearerRecordNameLC( HBufC*& aBearerName )

   602     {

   603     OstTraceFunctionEntry0( CCMPLUGINLAN_BEARERRECORDNAMELC_ENTRY );

   604 

   605     aBearerName = TPtrC( KCDTypeNameLANBearer ).AllocLC();

   606 

   607     OstTraceFunctionExit0( CCMPLUGINLAN_BEARERRECORDNAMELC_EXIT );

   608     }

   609 

   610 // ---------------------------------------------------------------------------

   611 // CCmPluginLan::GetBearerSpecificRecordsL

   612 // ---------------------------------------------------------------------------

   613 //

   614 void CCmPluginLan::GetBearerSpecificRecordsL(

   615         RPointerArray<CommsDat::CCDRecordBase>& /*aRecordArray*/ )

   616     {

   617     OstTraceFunctionEntry0( CCMPLUGINLAN_GETBEARERSPECIFICRECORDSL_ENTRY );

   618     OstTraceFunctionExit0( CCMPLUGINLAN_GETBEARERSPECIFICRECORDSL_EXIT );

   619     }

   620 

   621 // --------------------------------------------------------------------------

   622 // CCmPluginLan::DeleteBearerRecordsL

   623 // --------------------------------------------------------------------------

   624 //

   625 void CCmPluginLan::DeleteBearerRecordsL()

   626     {

   627     OstTraceFunctionEntry0( CCMPLUGINLAN_DELETEBEARERRECORDSL_ENTRY );

   628     OstTraceFunctionExit0( CCMPLUGINLAN_DELETEBEARERRECORDSL_EXIT );

   629     }

   630 

   631 // ----------------------------------------------------------------------------

   632 // CCmPluginLan::UpdateBearerRecordsL()

   633 // ----------------------------------------------------------------------------

   634 //

   635 void CCmPluginLan::UpdateBearerRecordsL(

   636         RPointerArray<CommsDat::CCDRecordBase>& /*aGenRecordArray*/,

   637         RPointerArray<CommsDat::CCDRecordBase>& /*aBearerSpecRecordArray*/ )

   638     {

   639     OstTraceFunctionEntry0( CCMPLUGINLAN_UPDATEBEARERRECORDSL_ENTRY );

   640     OstTraceFunctionExit0( CCMPLUGINLAN_UPDATEBEARERRECORDSL_EXIT );

   641     }

   642 

   643 // ---------------------------------------------------------

   644 // CCmPluginLan::ResetBearerRecords()

   645 // ---------------------------------------------------------

   646 //

   647 void CCmPluginLan::ResetBearerRecords()

   648     {

   649     OstTraceFunctionEntry0( CCMPLUGINLAN_RESETBEARERRECORDS_ENTRY );

   650     OstTraceFunctionExit0( CCMPLUGINLAN_RESETBEARERRECORDS_EXIT );

   651     }

   652 

   653 // ---------------------------------------------------------------------------

   654 // CCmPluginLan::SetDaemonNameL

   655 // ---------------------------------------------------------------------------

   656 //

   657 void CCmPluginLan::SetDaemonNameL(

   658         RPointerArray<CommsDat::CCDRecordBase>& aGenRecordArray,

   659         RPointerArray<CommsDat::CCDRecordBase>& aBearerSpecRecordArray )

   660     {

   661     OstTraceFunctionEntry0( CCMPLUGINLAN_SETDAEMONNAMEL_ENTRY );

   662 

   663     // We have to check first that these values have not been set (or changed)

   664     // by any 3rd party SW to ensure that we don't break their settings.

   665     HBufC* daemonName = GetBearerStringAttributeL(

   666             ECmConfigDaemonManagerName,

   667             aGenRecordArray,

   668             aBearerSpecRecordArray );

   669     if ( daemonName )

   670         {

   671         if ( daemonName->Compare( KDaemonManagerName ) != 0 )

   672             {

   673             delete daemonName;

   674             OstTraceFunctionExit1( CCMPLUGINWLAN_SETDAEMONNAMEL_EXIT, this );

   675             OstTraceFunctionExit0( CCMPLUGINLAN_SETDAEMONNAMEL_EXIT );

   676             return;

   677             }

   678         delete daemonName;

   679         }

   680 

   681     // Use DHCP if we can.

   682     TBool ipfromSrv = GetBearerBoolAttributeL(

   683             ECmIPAddFromServer,

   684             aGenRecordArray,

   685             aBearerSpecRecordArray );

   686     if ( ipfromSrv )

   687         {

   688         SetBearerStringAttributeL(

   689                 ECmConfigDaemonManagerName,

   690                 KDaemonManagerName,

   691                 aGenRecordArray,

   692                 aBearerSpecRecordArray );

   693         SetBearerStringAttributeL(ECmConfigDaemonName,

   694                 KConfigDaemonName,

   695                 aGenRecordArray,

   696                 aBearerSpecRecordArray );

   697         }

   698     else

   699         {

   700         if ( FeatureManager::FeatureSupported( KFeatureIdIPv6 ) )

   701             {

   702             SetBearerStringAttributeL(

   703                     ECmConfigDaemonManagerName,

   704                     KDaemonManagerName,

   705                     aGenRecordArray,

   706                     aBearerSpecRecordArray );

   707             SetBearerStringAttributeL(

   708                     ECmConfigDaemonName,

   709                     KConfigDaemonName,

   710                     aGenRecordArray,

   711                     aBearerSpecRecordArray );

   712             }

   713         else

   714             {

   715             SetBearerStringAttributeL(

   716                     ECmConfigDaemonManagerName,

   717                     KNullDesC(),

   718                     aGenRecordArray,

   719                     aBearerSpecRecordArray );

   720             SetBearerStringAttributeL(

   721                     ECmConfigDaemonName,

   722                     KNullDesC(),

   723                     aGenRecordArray,

   724                     aBearerSpecRecordArray );

   725             }

   726         }

   727 

   728     OstTraceFunctionExit0( DUP1_CCMPLUGINLAN_SETDAEMONNAMEL_EXIT );

   729     }

   730 

   731 // --------------------------------------------------------------------------

   732 // CCmPluginLan::GetBearerIntAttributeL

   733 // --------------------------------------------------------------------------

   734 //

   735 TUint32 CCmPluginLan::GetBearerIntAttributeL(

   736         TUint32 aAttribute,

   737         RPointerArray<CommsDat::CCDRecordBase>& aGenRecordArray,

   738         RPointerArray<CommsDat::CCDRecordBase>& /*aBearerSpecRecordArray*/ )

   739     {

   740     OstTraceFunctionEntry0( CCMPLUGINLAN_GETBEARERINTATTRIBUTEL_ENTRY );

   741 

   742     TUint32 retVal( 0 );

   743 

   744     CCDLANServiceRecord* serviceRecord =

   745             static_cast<CCDLANServiceRecord*>( aGenRecordArray[KServiceRecordIndex] );

   746 

   747     switch ( aAttribute )

   748         {

   749         case ECmInvalidAttribute:

   750             {

   751             // This attribute has been deprecated since Symbian^4.

   752             User::Leave( KErrNotSupported ); //TODO, update attribute definition comments.

   753             }

   754             break;

   755         case ECmExtensionLevel:

   756             {

   757             retVal = KExtensionBaseLevel;

   758             }

   759             break;

   760         case ECmCommsDBBearerType:

   761             {

   762             retVal = KCommDbBearerLAN;

   763             }

   764             break;

   765         case ECmDefaultUiPriority:

   766             {

   767             retVal = GetDefPriorityL( aAttribute );

   768             }

   769             break;

   770         case ECmDefaultPriority:

   771             {

   772             retVal = GetDefPriorityL( aAttribute );

   773             }

   774             break;

   775         case ELanServiceExtensionTableRecordId:

   776             {

   777             if ( !serviceRecord->iServiceExtensionTableRecordId.IsNull() )

   778                 {

   779                 retVal = serviceRecord->iServiceExtensionTableRecordId.RecordId();

   780                 }

   781             else

   782                 {

   783                 retVal = 0;

   784                 }

   785             }

   786             break;

   787         default:

   788             {

   789             User::Leave( KErrNotSupported );

   790             }

   791             break;

   792         }

   793 

   794     OstTraceFunctionExit0( CCMPLUGINLAN_GETBEARERINTATTRIBUTEL_EXIT );

   795     return retVal;

   796     }

   797 

   798 // --------------------------------------------------------------------------

   799 // CCmPluginLan::GetBearerBoolAttributeL

   800 // --------------------------------------------------------------------------

   801 //

   802 TBool CCmPluginLan::GetBearerBoolAttributeL(

   803         TUint32 aAttribute,

   804         RPointerArray<CommsDat::CCDRecordBase>& aGenRecordArray,

   805         RPointerArray<CommsDat::CCDRecordBase>& /*aBearerSpecRecordArray*/ )

   806     {

   807     OstTraceFunctionEntry0( CCMPLUGINLAN_GETBEARERBOOLATTRIBUTEL_ENTRY );

   808 

   809     TBool retVal( 0 );

   810 

   811     CCDLANServiceRecord* serviceRecord =

   812                 static_cast<CCDLANServiceRecord*>( aGenRecordArray[KServiceRecordIndex] );

   813 

   814     switch ( aAttribute )

   815         {

   816         case ECmCoverage:

   817             {

   818             retVal = ETrue;

   819             }

   820             break;

   821         case ECmDestination:

   822             {

   823             retVal = EFalse;

   824             }

   825             break;

   826         case ECmBearerHasUi:

   827             {

   828             retVal = EFalse;

   829             }

   830             break;

   831         case ECmIPv6Supported:

   832             {

   833             retVal = FeatureManager::FeatureSupported( KFeatureIdIPv6 );

   834             }

   835             break;

   836         case ECmIPAddFromServer:

   837         case ELanIpAddrFromServer:

   838             {

   839             retVal = serviceRecord->iIpAddrFromServer;

   840             }

   841             break;

   842         case ECmIPDNSAddrFromServer:

   843         case ELanIpDNSAddrFromServer:

   844             {

   845             retVal = serviceRecord->iIpDnsAddrFromServer;

   846             }

   847             break;

   848         case ECmIP6DNSAddrFromServer:

   849         case ELanIp6DNSAddrFromServer:

   850             {

   851             retVal = serviceRecord->iIp6DnsAddrFromServer;

   852             }

   853             break;

   854         default:

   855             {

   856             User::Leave( KErrNotSupported );

   857             }

   858             break;

   859         }

   860 

   861     OstTraceFunctionExit0( CCMPLUGINLAN_GETBEARERBOOLATTRIBUTEL_EXIT );

   862     return retVal;

   863     }

   864 

   865 // --------------------------------------------------------------------------

   866 // CCmPluginLan::GetBearerStringAttributeL

   867 // --------------------------------------------------------------------------

   868 //

   869 HBufC* CCmPluginLan::GetBearerStringAttributeL(

   870         TUint32 aAttribute,

   871         RPointerArray<CommsDat::CCDRecordBase>& aGenRecordArray,

   872         RPointerArray<CommsDat::CCDRecordBase>& /*aBearerSpecRecordArray*/ )

   873     {

   874     OstTraceFunctionEntry0( CCMPLUGINLAN_GETBEARERSTRINGATTRIBUTEL_ENTRY );

   875 

   876     HBufC* retVal = NULL;

   877 

   878     CCDLANServiceRecord* serviceRecord =

   879             static_cast<CCDLANServiceRecord*>( aGenRecordArray[KServiceRecordIndex] );

   880 

   881     switch ( aAttribute )

   882         {

   883         case ECmIFNetworks:

   884         case ELanIfNetworks:

   885             {

   886             retVal = TPtrC( serviceRecord->iIfNetworks ).AllocL();

   887             }

   888             break;

   889         case ECmIPNetmask:

   890         case ELanIpNetMask:

   891             {

   892             retVal = TPtrC( serviceRecord->iIpNetmask ).AllocL();

   893             }

   894             break;

   895         case ECmIPGateway:

   896         case ELanIpGateway:

   897             {

   898             retVal = TPtrC( serviceRecord->iIpGateway ).AllocL();

   899             }

   900             break;

   901         case ECmIPAddress:

   902         case ELanIpAddr:

   903             {

   904             retVal = TPtrC( serviceRecord->iIpAddr ).AllocL();

   905             }

   906             break;

   907         case ECmIPNameServer1:

   908         case ELanIpNameServer1:

   909             {

   910             retVal = TPtrC( serviceRecord->iIpNameServer1 ).AllocL();

   911             }

   912             break;

   913         case ECmIPNameServer2:

   914         case ELanIpNameServer2:

   915             {

   916             retVal = TPtrC( serviceRecord->iIpNameServer2 ).AllocL();

   917             }

   918             break;

   919         case ECmIP6NameServer1:

   920         case ELanIp6NameServer1:

   921             {

   922             retVal = TPtrC( serviceRecord->iIp6NameServer1 ).AllocL();

   923             }

   924             break;

   925         case ECmIP6NameServer2:

   926         case ELanIp6NameServer2:

   927             {

   928             retVal = TPtrC( serviceRecord->iIp6NameServer2 ).AllocL();

   929             }

   930             break;

   931         case ECmIPAddrLeaseValidFrom:

   932         case ELanIpAddrLeaseValidFrom:

   933             {

   934             retVal = TPtrC( serviceRecord->iIpAddrLeaseValidFrom ).AllocL();

   935             }

   936             break;

   937         case ECmIPAddrLeaseValidTo:

   938         case ELanIpAddrLeaseValidTo:

   939             {

   940             retVal = TPtrC( serviceRecord->iIpAddrLeaseValidTo ).AllocL();

   941             }

   942             break;

   943         case ECmConfigDaemonManagerName:

   944         case ELanConfigDaemonManagerName:

   945             {

   946             retVal = TPtrC( serviceRecord->iConfigDaemonManagerName ).AllocL();

   947             }

   948             break;

   949         case ECmConfigDaemonName:

   950         case ELanConfigDaemonName:

   951             {

   952             retVal = TPtrC( serviceRecord->iConfigDaemonName ).AllocL();

   953             }

   954             break;

   955         case ELanServiceExtensionTableName:

   956             {

   957             retVal = TPtrC( serviceRecord->iServiceExtensionTableName ).AllocL();

   958             }

   959             break;

   960         default:

   961             {

   962             User::Leave( KErrNotSupported );

   963             }

   964             break;

   965         }

   966 

   967     OstTraceFunctionExit0( CCMPLUGINLAN_GETBEARERSTRINGATTRIBUTEL_EXIT );

   968     return retVal;

   969     }

   970 

   971 // --------------------------------------------------------------------------

   972 // CCmPluginLan::GetBearerString8AttributeL

   973 // --------------------------------------------------------------------------

   974 //

   975 HBufC8* CCmPluginLan::GetBearerString8AttributeL(

   976         TUint32 aAttribute,

   977         RPointerArray<CommsDat::CCDRecordBase>& /*aGenRecordArray*/,

   978         RPointerArray<CommsDat::CCDRecordBase>& /*aBearerSpecRecordArray*/ )

   979     {

   980     OstTraceFunctionEntry0( CCMPLUGINLAN_GETBEARERSTRING8ATTRIBUTEL_ENTRY );

   981 

   982     HBufC8* retVal( NULL );

   983 

   984     switch ( aAttribute )

   985         {

   986         default:

   987             {

   988             User::Leave( KErrNotSupported );

   989             }

   990             break;

   991         }

   992 

   993     OstTraceFunctionExit0( CCMPLUGINLAN_GETBEARERSTRING8ATTRIBUTEL_EXIT );

   994     return retVal;

   995     }

   996 

   997 // --------------------------------------------------------------------------

   998 // CCmPluginLan::SetBearerIntAttributeL

   999 // --------------------------------------------------------------------------

  1000 //

  1001 void CCmPluginLan::SetBearerIntAttributeL(

  1002         TUint32 aAttribute,

  1003         TUint32 aValue,

  1004         RPointerArray<CommsDat::CCDRecordBase>& aGenRecordArray,

  1005         RPointerArray<CommsDat::CCDRecordBase>& /*aBearerSpecRecordArray*/ )

  1006     {

  1007     OstTraceFunctionEntry0( CCMPLUGINLAN_SETBEARERINTATTRIBUTEL_ENTRY );

  1008 

  1009     CCDLANServiceRecord* serviceRecord =

  1010             static_cast<CCDLANServiceRecord*>( aGenRecordArray[KServiceRecordIndex] );

  1011 

  1012     switch ( aAttribute )

  1013         {

  1014         case ECmExtensionLevel:

  1015         case ECmCommsDBBearerType:

  1016         case ECmDefaultUiPriority:

  1017         case ECmDefaultPriority:

  1018             {

  1019             User::Leave( KErrArgument );

  1020             }

  1021             break;

  1022         case ELanServiceExtensionTableRecordId:

  1023             {

  1024             serviceRecord->iServiceExtensionTableRecordId = aValue;

  1025             }

  1026             break;

  1027         default:

  1028             {

  1029             User::Leave( KErrNotSupported );

  1030             }

  1031             break;

  1032         }

  1033 

  1034     OstTraceFunctionExit0( CCMPLUGINLAN_SETBEARERINTATTRIBUTEL_EXIT );

  1035     }

  1036 

  1037 // --------------------------------------------------------------------------

  1038 // CCmPluginLan::SetBearerBoolAttributeL

  1039 // --------------------------------------------------------------------------

  1040 //

  1041 void CCmPluginLan::SetBearerBoolAttributeL(

  1042         TUint32 aAttribute,

  1043         TBool aValue,

  1044         RPointerArray<CommsDat::CCDRecordBase>& aGenRecordArray,

  1045         RPointerArray<CommsDat::CCDRecordBase>& /*aBearerSpecRecordArray*/ )

  1046     {

  1047     OstTraceFunctionEntry0( CCMPLUGINLAN_SETBEARERBOOLATTRIBUTEL_ENTRY );

  1048 

  1049     CCDLANServiceRecord* serviceRecord =

  1050                 static_cast<CCDLANServiceRecord*>( aGenRecordArray[KServiceRecordIndex] );

  1051 

  1052     switch ( aAttribute )

  1053         {

  1054         case ECmIPAddFromServer:

  1055         case ELanIpAddrFromServer:

  1056             {

  1057             serviceRecord->iIpAddrFromServer.SetL( aValue );

  1058             }

  1059             break;

  1060         case ECmIPDNSAddrFromServer:

  1061         case ELanIpDNSAddrFromServer:

  1062             {

  1063             serviceRecord->iIpDnsAddrFromServer.SetL( aValue );

  1064             }

  1065             break;

  1066         case ECmIP6DNSAddrFromServer:

  1067         case ELanIp6DNSAddrFromServer:

  1068             {

  1069             serviceRecord->iIp6DnsAddrFromServer.SetL( aValue );

  1070             }

  1071             break;

  1072         default:

  1073             {

  1074             User::Leave( KErrNotSupported );

  1075             }

  1076             break;

  1077         }

  1078 

  1079     OstTraceFunctionExit0( CCMPLUGINLAN_SETBEARERBOOLATTRIBUTEL_EXIT );

  1080     }

  1081 

  1082 // --------------------------------------------------------------------------

  1083 // CCmPluginLan::SetBearerStringAttributeL

  1084 // --------------------------------------------------------------------------

  1085 //

  1086 void CCmPluginLan::SetBearerStringAttributeL(

  1087         TUint32 aAttribute,

  1088         const TDesC16& aValue,

  1089         RPointerArray<CommsDat::CCDRecordBase>& aGenRecordArray,

  1090         RPointerArray<CommsDat::CCDRecordBase>& aBearerSpecRecordArray )

  1091     {

  1092     OstTraceFunctionEntry0( CCMPLUGINLAN_SETBEARERSTRINGATTRIBUTEL_ENTRY );

  1093 

  1094     CCDLANServiceRecord* serviceRecord =

  1095             static_cast<CCDLANServiceRecord*>( aGenRecordArray[KServiceRecordIndex] );

  1096 

  1097     switch ( aAttribute )

  1098         {

  1099         case ECmIFNetworks:

  1100         case ELanIfNetworks:

  1101             {

  1102             serviceRecord->iIfNetworks.SetL( aValue );

  1103             }

  1104             break;

  1105         case ECmIPNetmask:

  1106         case ELanIpNetMask:

  1107             {

  1108             serviceRecord->iIpNetmask.SetL( aValue );

  1109             }

  1110             break;

  1111         case ECmIPGateway:

  1112         case ELanIpGateway:

  1113             {

  1114             serviceRecord->iIpGateway.SetL( aValue );

  1115             }

  1116             break;

  1117         case ECmIPAddress:

  1118         case ELanIpAddr:

  1119             {

  1120             if ( ( aValue.Compare( KUnspecifiedIPv4 ) == 0 ) ||

  1121                     ( aValue.Compare( KNullDesC ) == 0 ) )

  1122                 {

  1123                 // If unspecified or NULL address is set dynamic

  1124                 // IP must be enabled.

  1125                 SetBearerBoolAttributeL( ECmIPAddFromServer,

  1126                                          ETrue,

  1127                                          aGenRecordArray,

  1128                                          aBearerSpecRecordArray );

  1129                 }

  1130             else

  1131                 {

  1132                 // If valid address is set dynamic IP is disabled.

  1133                 SetBearerBoolAttributeL( ECmIPAddFromServer,

  1134                                          EFalse,