1 /*

     2 * Copyright (c) 2006 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:  VPN plug-in IF implementation class.

    15 *

    16 */

    17 

    18 #include <AknsUtils.h>

    19 #include <cmpluginvpn.mbg>

    20 #include <cmpluginvpnui.rsg>

    21 #include <cmmanager.rsg>

    22 #include <StringLoader.h>

    23 #include <data_caging_path_literals.hrh>

    24 #include <cmpluginbaseeng.h>

    25 #include <cmpluginbase.h>

    26 #include <cmcommonui.h>

    27 #include <aknPopup.h>

    28 #include <aknlistquerydialog.h>

    29 #include <AknIconArray.h>

    30 #include <vpnapidefs.h>

    31 #include <cmpluginwlandef.h>

    32 // #include <vpnapi.h>

    33 #include <centralrepository.h>

    34 #include <settingsinternalcrkeys.h>

    35 #include <featmgr.h>

    36 #include <ConeResLoader.h>

    37 #include <bautils.h>

    38 

    39 #include <commsdattypesv1_1_partner.h>

    40 #include <commsdattypeinfov1_1_internal.h>

    41 

    42 #include "cmlogger.h"

    43 #include "cmmanagerimpl.h"

    44 #include "cmdestinationimpl.h"

    45 #include "cmvpncommonconstants.h"

    46 #include <cmcommonconstants.h>

    47 #include "cmpluginvpn.h"

    48 #include "cmpvpnsettingsdlg.h"

    49 #include "cmpvpnpolicyselectiondlg.h"

    50 #include "cmpvpnnextlayerselectdlg.h"

    51 

    52 using namespace CMManager;

    53 

    54 _LIT( KPluginVpnFileIcons, "z:cmpluginvpn.mbm" );

    55 //_LIT(KListItemFormat, "%d\t%S\t%S");

    56 

    57 static const TCmAttribConvTable SVpnConvTbl[] = 

    58     {

    59         { EVpnServicePolicyName, EPluginVpnAttribRangeMax, NULL },

    60         { EVpnServicePolicy, KCDTIdVPNPolicyName, NULL,

    61           R_QTN_VPN_SETT_VPN_IAP_POLICY_REFERENCE,

    62           0, EConvCompulsory, R_QTN_VPN_SETT_VPN_IAP_POLICY_REFERENCE_COMPULSORY, 0, NULL, NULL },

    63         { EVpnServicePolicyName, 0, NULL,

    64           R_QTN_VPN_SETT_VPN_IAP_POLICY_REFERENCE,

    65           0, EConvCompulsory, R_QTN_VPN_SETT_VPN_IAP_POLICY_REFERENCE_COMPULSORY, 0, NULL, NULL },

    66         { EVpnIapId, KCDTIdVPNIAPRecord, NULL },

    67         { EVpnNetworkId, KCDTIdVPNNetwork, &ReadOnlyAttributeL },

    68         { 0, 0, NULL }

    69     };

    70 

    71 static const TCmAttribConvTable SVpnVirtualIAPNextLayerConvTbl[] = 

    72     {

    73         { ECmNextLayerIapId, ECmNextLayerSNAPId+1, NULL },

    74         { ECmNextLayerIapId, KCDTIdVirtualNextLayerIAP, NULL },

    75         { ECmNextLayerSNAPId, KCDTIdVirtualNextLayerSNAP, NULL },

    76         { 0, 0, NULL }

    77     };

    78     

    79 _LIT( KVpnVirtualBearerName, "vpnbearer" );

    80 _LIT( KVpnVirtualBearerAgent, "vpnconnagt.agt" );

    81 _LIT( KVpnVirtualBearerNif, "tunnelnif" );

    82 

    83 // constants needed for the virtualbearer table

    84 const TInt KNoTimeout = -1;

    85 const TUint32 KLastSessionTimeout = 3;

    86 

    87 

    88 const TUint32 KContainsVpn =        0x01;

    89 const TUint32 KLinksBackToParent =  0x02;

    90 const TUint32 KEmptyDest =          0x04;

    91 const TUint32 KNoNonVirtuals =      0x08;

    92 

    93 const TUint32 KBindDenied = KLinksBackToParent | KContainsVpn;

    94 

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

    96 // CCmPluginVpn::NewL()

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

    98 //

    99 CCmPluginVpn* CCmPluginVpn::NewL( TCmPluginInitParam* aInitParam )

   100     {

   101 

   102     CRepository* repository = CRepository::NewLC(KCRUidCommunicationSettings);

   103 

   104     TInt vpnSupported;

   105     repository->Get(KSettingsVPNSupported, vpnSupported);

   106 

   107     CleanupStack::PopAndDestroy(repository);

   108 

   109     if( !vpnSupported )

   110         {

   111         User::Leave( KErrNotSupported );

   112         }

   113 

   114     CCmPluginVpn* self = new( ELeave ) CCmPluginVpn( aInitParam );

   115     CleanupStack::PushL( self );

   116     self->ConstructL();

   117     CleanupStack::Pop( self );

   118     return self;

   119     }

   120 

   121 // --------------------------------------------------------------------------

   122 // CCmPluginVpn::~CCmPluginVpn()

   123 // --------------------------------------------------------------------------

   124 //

   125 CCmPluginVpn::~CCmPluginVpn()

   126     {

   127     CCmPluginVpn::AdditionalReset();

   128     

   129     RemoveResourceFile( KPluginVPNResDirAndFileName );

   130     

   131     iBindableMethods.Reset();

   132     iBindableMethods.Close();

   133     delete iPolicyName;

   134     CLOG_CLOSE;

   135     }

   136 

   137 // --------------------------------------------------------------------------

   138 // CCmPluginVpn::CreateInstanceL

   139 // --------------------------------------------------------------------------

   140 //

   141 CCmPluginBaseEng* CCmPluginVpn::CreateInstanceL( TCmPluginInitParam& aInitParam ) const

   142     {

   143     CCmPluginVpn* self = new( ELeave ) CCmPluginVpn( &aInitParam );

   144     CleanupStack::PushL( self );

   145     self->ConstructL();

   146     CleanupStack::Pop( self );

   147 

   148     return self;

   149     }

   150     

   151 // --------------------------------------------------------------------------

   152 // CCmPluginVpn::CCmPluginVpn()

   153 // --------------------------------------------------------------------------

   154 //

   155 CCmPluginVpn::CCmPluginVpn( TCmPluginInitParam* aInitParam )

   156     : CCmPluginBaseEng( aInitParam )

   157     , iBindableMethods( KCmArraySmallGranularity )

   158     {

   159     CLOG_CREATE;

   160     iBearerType = KPluginVPNBearerTypeUid;

   161     }

   162 

   163 // --------------------------------------------------------------------------

   164 // CCmPluginVpn::ConstructL()

   165 // --------------------------------------------------------------------------

   166 //

   167 void CCmPluginVpn::ConstructL()

   168     {

   169     CCmPluginBaseEng::ConstructL();

   170 

   171     TRAP_IGNORE( iVirtualTableId = 

   172                         CCDVirtualIAPNextLayerRecord::TableIdL( Session() ) );

   173     if( !iVirtualTableId )

   174         {

   175         iVirtualTableId = CCDVirtualIAPNextLayerRecord::CreateTableL( Session() );

   176         }

   177 

   178     AddResourceFileL( KPluginVPNResDirAndFileName );

   179     

   180     AddConverstionTableL( (CCDRecordBase**)&iServiceRecord, NULL, SVpnConvTbl );

   181     

   182     iPolicyName = KNullDesC().AllocL();

   183     }

   184     

   185 // --------------------------------------------------------------------------

   186 // CCmPluginVpn::GetIntAttributeL()

   187 // --------------------------------------------------------------------------

   188 //

   189 TUint32 CCmPluginVpn::GetIntAttributeL( const TUint32 aAttribute ) const

   190     {

   191     LOGGER_ENTERFN( "CCmPluginVpn::GetIntAttributeL" );

   192 

   193     TUint32 retVal( 0 );

   194     

   195     switch( aAttribute )

   196         {

   197         case ECmBearerIcon:

   198             {

   199             TAknsItemID id;

   200             

   201             MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance();

   202                    

   203             TParse mbmFile;

   204             User::LeaveIfError( mbmFile.Set( KPluginVpnFileIcons, 

   205                                              &KDC_BITMAP_DIR, 

   206                                              NULL ) );

   207                    

   208             retVal = (TUint32)AknsUtils::CreateGulIconL( 

   209                                     skinInstance, 

   210                                     id,

   211                                     mbmFile.FullName(), 

   212                                     EMbmCmpluginvpnQgn_prop_vpn_access_point, 

   213                                     EMbmCmpluginvpnQgn_prop_vpn_access_point_mask );

   214             }

   215             break;

   216                

   217         case ECmCommsDBBearerType:

   218             {

   219             retVal = KCommDbBearerVirtual;

   220             }

   221             break;

   222         

   223         case ECmDefaultUiPriority:

   224         case ECmDefaultPriority:            

   225             {

   226             retVal = aAttribute == ECmDefaultPriority ?

   227                         GlobalBearerPriority( TPtrC(KCDTypeNameVPNService) ) :

   228                         GlobalUiBearerPriority( TPtrC(KCDTypeNameVPNService) );

   229             }

   230             break;  

   231             

   232         case EVpnIapId:

   233             {

   234             if( !ServiceRecordExists() )

   235                 {

   236                 User::Leave( KErrNotSupported );

   237                 }

   238 

   239             retVal = ServiceRecord().iServiceIAP;

   240             }

   241             break;

   242         case EVpnNetworkId:

   243             {

   244             if( !ServiceRecordExists() )

   245                 {

   246                 User::Leave( KErrNotSupported );

   247                 }

   248 

   249             retVal = ServiceRecord().iServiceNetwork;

   250             }

   251             break;

   252         case ECmNextLayerIapId:    

   253             {

   254             retVal = iVirtualRecord->iNextLayerIAP;

   255             }  

   256             break;

   257         case ECmNextLayerSNAPId:           

   258             {

   259             retVal = iVirtualRecord->iNextLayerSNAP;

   260             }  

   261             break;

   262         case ECmIapId:

   263         case ECmId:

   264         case ECmWapId:

   265         case ECmIapServiceId:

   266         case ECmInvalidAttribute:

   267         case ECmLoadResult:

   268         case ECmBearerType:

   269         case ECmSeamlessnessLevel:

   270         case ECmElementID:

   271         case ECmNetworkId:

   272         case ECmProxyPortNumber:

   273         case ECmExtensionLevel:

   274         case ECmWapIPWSPOption:

   275         case ECmWapIPProxyPort:

   276         case ECmNamingMethod:

   277             {

   278             retVal = CCmPluginBaseEng::GetIntAttributeL( aAttribute );

   279             }

   280             break;

   281         

   282         default:

   283             {

   284             User::Leave( KErrNotSupported );

   285             }

   286         }

   287         

   288     return retVal;

   289     }

   290 

   291 // --------------------------------------------------------------------------

   292 // CCmPluginVpn::GetBoolAttributeL()

   293 // --------------------------------------------------------------------------

   294 //

   295 TBool CCmPluginVpn::GetBoolAttributeL( const TUint32 aAttribute ) const

   296     {

   297     LOGGER_ENTERFN( "CCmPluginVpn::GetBoolAttributeL" );

   298 

   299     TBool retVal( EFalse );

   300 

   301     switch( aAttribute )

   302         {

   303         case ECmAddToAvailableList:

   304             {

   305             retVal = EFalse;

   306             }

   307             break;

   308             

   309         case ECmChargeCardUsageEnabled:

   310             {

   311             retVal = EFalse;

   312             }

   313             break;

   314         case ECmBearerHasUi:

   315             {

   316             retVal = ETrue;

   317             break;

   318             }

   319         case ECmCoverage:

   320         case ECmDestination:

   321         case ECmIPv6Supported:

   322         case ECmHidden:

   323         case ECmProtected:

   324         case ECmMetaHighlight:

   325         case ECmMetaHiddenAgent:

   326         case ECmProxyUsageEnabled:

   327         case ECmConnected:

   328         case ECmIsLinked:

   329         case ECmWapIPSecurity:

   330             {

   331             retVal = CCmPluginBaseEng::GetBoolAttributeL( aAttribute );

   332             }

   333             break;

   334         case ECmVirtual:

   335             {

   336             return ETrue;

   337             }           

   338         default:

   339             {

   340             User::Leave( KErrNotSupported );

   341             

   342             }

   343         }

   344         

   345     return retVal;

   346     }

   347 

   348 // --------------------------------------------------------------------------

   349 // CCmPluginVpn::GetStringAttributeL()

   350 // --------------------------------------------------------------------------

   351 //

   352 HBufC* CCmPluginVpn::GetStringAttributeL( const TUint32 aAttribute ) const

   353     {

   354     LOGGER_ENTERFN( "CCmPluginVpn::GetStringAttributeL" );

   355 

   356     HBufC* retVal = NULL;

   357     

   358     switch( aAttribute )

   359         {           

   360         case ECmBearerSupportedName:

   361             {

   362             retVal = AllocReadL( R_QTN_NETW_CONSET_BEARER_SUPPORTED_VPN );

   363             }

   364             break;

   365         

   366         case EVpnServicePolicyName:

   367             {

   368             if( !ServiceRecordExists() )

   369                 {

   370                 User::Leave( KErrNotSupported );

   371                 }

   372             else 

   373                 {

   374                 CCmPluginVpn* tmp = const_cast< CCmPluginVpn * >( this );

   375                 tmp->UpdatePolicyNameL();

   376                 }

   377             retVal = iPolicyName->AllocL();

   378             break;

   379             }

   380         case EVpnServicePolicy:

   381             {

   382             if( !ServiceRecordExists() )

   383                 {

   384                 User::Leave( KErrNotSupported );

   385                 }

   386 

   387             if( !ServiceRecord().iServicePolicy.IsNull() )

   388                 {

   389                 retVal = ServiceRecord().iServicePolicy.GetL().AllocL();

   390                 } 

   391             else

   392                 {

   393                 retVal = KNullDesC().AllocL();

   394                 }

   395             }

   396             break;

   397             

   398         case ECmName:   

   399         case ECmProxyServerName:

   400         case ECmProxyProtocolName:

   401         case ECmProxyExceptions:

   402         case ECmWapIPGatewayAddress:

   403         case ECmWapIPProxyLoginName:

   404         case ECmWapIPProxyLoginPass:

   405         case ECmStartPage:

   406             {

   407             retVal = CCmPluginBaseEng::GetStringAttributeL( aAttribute );

   408             }

   409             break;

   410             

   411         default:

   412             {

   413             User::Leave( KErrNotSupported );

   414             }

   415             break;

   416         }

   417         

   418     return retVal;

   419     }

   420 

   421 // --------------------------------------------------------------------------

   422 // CCmPluginVpn::GetString8AttributeL()

   423 // --------------------------------------------------------------------------

   424 //

   425 HBufC8* CCmPluginVpn::GetString8AttributeL( const TUint32 aAttribute ) const

   426     {

   427     LOGGER_ENTERFN( "CCmPluginVpn::GetString8AttributeL" );

   428 

   429     HBufC8* retVal = NULL;

   430     

   431     switch( aAttribute )

   432         {

   433         default:

   434             {

   435             User::Leave( KErrNotSupported );

   436             }

   437             break;

   438         }

   439         

   440     return retVal;

   441     }

   442 

   443 // --------------------------------------------------------------------------

   444 // CCmPluginVpn::SetIntAttributeL()

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

   446 //

   447 void CCmPluginVpn::SetIntAttributeL( const TUint32 aAttribute, 

   448                                             TUint32 aValue )

   449     {

   450     LOGGER_ENTERFN( "CCmPluginVpn::SetIntAttributeL" );

   451 

   452     switch( aAttribute )

   453         {

   454         case ECmNextLayerIapId: 

   455         case EVpnIapId:

   456             {

   457             CheckRecordIdValidityL( this, EVpnIapId, &aValue );

   458             

   459             // ServiceRecord.iServiceIAP should be 0 according to 

   460             // DM CommsDat Contents v1.4, but for now it is made

   461             // backward compatible

   462             if( !ServiceRecordExists() )

   463                 {

   464                 User::Leave( KErrNotSupported );

   465                 }

   466             

   467             ServiceRecord().iServiceIAP = aValue;

   468             ServiceRecord().iServiceNetwork = 0;

   469             ServiceRecord().iServiceSNAP = 0;

   470             iVirtualRecord->iNextLayerIAP = aValue;

   471             iVirtualRecord->iNextLayerSNAP = 0;            

   472             }

   473             break;

   474 

   475         case EVpnNetworkId:

   476         case ECmNextLayerSNAPId:

   477             {

   478             // To keep backwards compability, keep these 2 attributes

   479             // (EVpnNetworkId & ECmNextLayerSNAPId) together even though

   480             // network id and destination id are no longer exactly the same.

   481             if( !ServiceRecordExists() )

   482                 {

   483                 User::Leave( KErrNotSupported );

   484                 }

   485 

   486             TInt destinationId( 0 );

   487             destinationId = CheckValidityAndConvertDestinationIdL( aValue );

   488             TMDBElementId defaultAP = DefaultAPRecordL();

   489             

   490             ServiceRecord().iServiceIAP = 0;

   491             ServiceRecord().iServiceNetwork = 0;

   492             ServiceRecord().iServiceSNAP = defaultAP;

   493             iVirtualRecord->iNextLayerIAP = 0;

   494             iVirtualRecord->iNextLayerSNAP = destinationId;

   495             }

   496             break;

   497 

   498         case ECmSeamlessnessLevel:

   499         case ECmProxyPortNumber:

   500         case ECmNamingMethod:

   501         case ECmWapIPWSPOption:

   502         case ECmWapIPProxyPort:

   503             {

   504             CCmPluginBaseEng::SetIntAttributeL( aAttribute, aValue );

   505             }

   506             break;

   507             

   508         default:

   509             {

   510             User::Leave( KErrNotSupported );

   511             }

   512             break;

   513         }

   514     }

   515 

   516 // --------------------------------------------------------------------------

   517 // CCmPluginVpn::SetBoolAttributeL()

   518 // --------------------------------------------------------------------------

   519 //

   520 void CCmPluginVpn::SetBoolAttributeL( const TUint32 aAttribute, 

   521                                       TBool aValue )

   522     {

   523     LOGGER_ENTERFN( "CCmPluginVpn::SetBoolAttributeL" );

   524 

   525     switch( aAttribute )

   526         {

   527         case ECmChargeCardUsageEnabled:

   528             {

   529             User::Leave( KErrNotSupported );

   530             }

   531             break;

   532 

   533         case ECmHidden:

   534         case ECmProtected:

   535         case ECmMetaHighlight:

   536         case ECmMetaHiddenAgent:

   537         case ECmProxyUsageEnabled:

   538         case ECmWapIPSecurity:

   539             {

   540             CCmPluginBaseEng::SetBoolAttributeL( aAttribute, aValue );

   541             }

   542             break;

   543             

   544         default:

   545             {

   546             User::Leave( KErrNotSupported );

   547             }

   548             break;

   549         }

   550     }

   551 

   552 // --------------------------------------------------------------------------

   553 // CCmPluginVpn::SetStringAttributeL()

   554 // --------------------------------------------------------------------------

   555 //

   556 void CCmPluginVpn::SetStringAttributeL( const TUint32 aAttribute, 

   557                                         const TDesC16& aValue )

   558     {

   559     LOGGER_ENTERFN( "CCmPluginVpn::SetStringAttributeL" );

   560 

   561     switch( aAttribute )

   562         {

   563         case EVpnServicePolicyName:

   564             {

   565             HBufC* tmp = aValue.AllocLC();

   566             delete iPolicyName;

   567             iPolicyName = tmp;

   568             CleanupStack::Pop( tmp );

   569             break;

   570             }        

   571         case EVpnServicePolicy:

   572             {

   573             if( !ServiceRecordExists() )

   574                 {

   575                 User::Leave( KErrNotSupported );

   576                 }

   577             

   578             CLOG_WRITE_1( "New policy set:[%S]", &aValue );

   579             ServiceRecord().iServicePolicy.SetL( aValue );

   580             }

   581             break;

   582         case ECmProxyServerName:

   583             {

   584             CCmPluginBaseEng::SetStringAttributeL( aAttribute, aValue );

   585             if( !aValue.Length() || !iProxyRecord->iPortNumber )

   586                 {

   587                 iProxyRecord->iPortNumber = KVpnProxyPortNumberDefault;

   588                 }

   589             }

   590             break;

   591 

   592         case ECmName:

   593         case ECmProxyProtocolName:

   594         case ECmProxyExceptions:

   595         case ECmWapIPGatewayAddress:

   596         case ECmWapIPProxyLoginName:

   597         case ECmWapIPProxyLoginPass:

   598         case ECmStartPage:

   599             {

   600             CCmPluginBaseEng::SetStringAttributeL( aAttribute, aValue );

   601             }

   602             break;

   603 

   604         default:

   605             {

   606             User::Leave( KErrNotSupported );

   607             }

   608             break;

   609         }

   610     }

   611 

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

   613 // CCmPluginVpn::SetString8AttributeL()

   614 // --------------------------------------------------------------------------

   615 //

   616 void CCmPluginVpn::SetString8AttributeL( const TUint32 aAttribute, 

   617                                          const TDesC8& /*aValue*/ )

   618     {

   619     LOGGER_ENTERFN( "CCmPluginVpn::SetString8AttributeL" );

   620 

   621     switch( aAttribute )

   622         {

   623         default:

   624             {

   625             User::Leave( KErrNotSupported );

   626             }

   627             break;

   628         }

   629     }

   630 

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

   632 // CCmPluginVpn::CanHandleIapIdL()

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

   634 //

   635 TBool CCmPluginVpn::CanHandleIapIdL( TUint32 aIapId ) const

   636     {

   637     LOGGER_ENTERFN( "CCmPluginVpn::CanHandleIapIdL1" );

   638     TBool retVal( EFalse );

   639     

   640     CCDIAPRecord *iapRecord = static_cast<CCDIAPRecord *>

   641                             (CCDRecordBase::RecordFactoryL(KCDTIdIAPRecord));

   642         

   643     CleanupStack::PushL( iapRecord );

   644     iapRecord->SetRecordId( aIapId );

   645     

   646     TRAPD( err, iapRecord->LoadL( Session() ));

   647 

   648     if( !err )

   649         {

   650         CanHandleIapIdL( iapRecord );

   651         }

   652     

   653     CleanupStack::PopAndDestroy( iapRecord );

   654     return retVal;

   655     }

   656 

   657 // --------------------------------------------------------------------------

   658 // CCmPluginVpn::CanHandleIapIdL()

   659 // --------------------------------------------------------------------------

   660 //

   661 TBool CCmPluginVpn::CanHandleIapIdL( CCDIAPRecord *aIapRecord ) const

   662     {

   663     LOGGER_ENTERFN( "CCmPluginVpn::CanHandleIapIdL" );

   664     

   665     TBool retVal( EFalse );

   666     

   667     if( TPtrC(aIapRecord->iServiceType) == TPtrC(KCDTypeNameVPNService) ||

   668         TPtrC(aIapRecord->iBearerType) == TPtrC(KCDTypeNameVirtualBearer) )

   669         {

   670         retVal = ETrue;

   671         }

   672 

   673     return retVal;

   674     }

   675 

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

   677 // CCmPluginVpn::RunSettingsL()

   678 // --------------------------------------------------------------------------

   679 //        

   680 TInt CCmPluginVpn::RunSettingsL()

   681     {

   682     LOGGER_ENTERFN( "CCmPluginVpn::RunSettingsL" );

   683     CmPluginVpnSettingsDlg* dlg = CmPluginVpnSettingsDlg::NewL( *this );

   684     

   685     return dlg->ConstructAndRunLD();

   686     }        

   687 

   688 // --------------------------------------------------------------------------

   689 // CCmPluginVpn::LoadServiceSettingL()

   690 // --------------------------------------------------------------------------

   691 //        

   692 void CCmPluginVpn::LoadServiceSettingL()

   693     {

   694     LOGGER_ENTERFN( "CCmPluginVpn::LoadServiceSettingL" );

   695     

   696     if( TPtrC(KCDTypeNameVPNService) == iIapRecord->iServiceType  )

   697         {

   698         iServiceRecord = static_cast<CCDVPNServiceRecord *>

   699                     (CCDRecordBase::RecordFactoryL(KCDTIdVPNServiceRecord));

   700         }

   701     else

   702         // this IAP service is not supported by this plugin.

   703         {

   704         User::Leave( KErrNotSupported );

   705         }

   706 

   707         

   708     CCmPluginBaseEng::LoadServiceSettingL();

   709     }

   710     

   711 

   712 // --------------------------------------------------------------------------

   713 // CCmPluginVpn::LoadAdditionalRecordsL()

   714 // --------------------------------------------------------------------------

   715 //        

   716 void CCmPluginVpn::LoadAdditionalRecordsL()

   717     {

   718     LOGGER_ENTERFN( "CCmPluginVpn::LoadAdditionalRecordsL" );

   719 

   720     iVirtualRecord = new (ELeave) CCDVirtualIAPNextLayerRecord( iVirtualTableId );

   721     

   722     CMDBRecordSet<CCDVirtualIAPNextLayerRecord>* virtualRS = 

   723               new(ELeave) CMDBRecordSet<CCDVirtualIAPNextLayerRecord>( iVirtualTableId );

   724     CleanupStack::PushL( virtualRS );

   725     

   726     CCDVirtualIAPNextLayerRecord* record = 

   727                             new (ELeave) CCDVirtualIAPNextLayerRecord( iVirtualTableId );

   728     

   729     record->iIAP = iIapId;

   730     CleanupStack::PushL( record );

   731     virtualRS->iRecords.AppendL( record );

   732     CleanupStack::Pop( record );

   733     record = NULL;

   734     

   735     if( virtualRS->FindL( Session() ) )

   736         {

   737         iVirtualRecord->SetRecordId( (*virtualRS)[0]->RecordId() );

   738         

   739         iVirtualRecord->LoadL( Session() );

   740         

   741         CLOG_WRITE_3( "Next layer: IAP[%d], NextSNAP[%d], NextIAP[%d]",

   742                       TUint( iVirtualRecord->iIAP ),

   743                       TUint( iVirtualRecord->iNextLayerSNAP ),

   744                       TUint( iVirtualRecord->iNextLayerIAP ) );

   745         }

   746     else

   747         {

   748         CLOG_WRITE( "Virtual records not found" );

   749         }

   750     

   751     CleanupStack::PopAndDestroy( virtualRS );

   752     AddConverstionTableL( (CCDRecordBase**)&iVirtualRecord, NULL, SVpnVirtualIAPNextLayerConvTbl );

   753     

   754     if (iIapRecord->iRecordName.GetL() == KNullDesC) 

   755         {

   756         //now we have next layer info, so generate default cm name if name is empty (new cm)

   757         GenerateDefaultCmNameL();

   758         }

   759         

   760     if ( !iProxyRecord->iPortNumber )

   761         {

   762         iProxyRecord->iPortNumber = KVpnProxyPortNumberDefault;

   763         }

   764     }

   765 

   766 // --------------------------------------------------------------------------

   767 // CCmPluginVpn::InitializeWithUiL()

   768 // --------------------------------------------------------------------------

   769 //        

   770 TBool CCmPluginVpn::InitializeWithUiL( TBool /*aManuallyConfigure*/ )

   771     {

   772     LOGGER_ENTERFN( "CCmPluginVpn::InitializeWithUiL" );

   773     TInt retVal( EFalse );

   774     

   775     // Compile a list of bindable methods, issue a warning if none found

   776     if ( BindableRealConnectionsExistL() )

   777         {

   778         // check if the intended destination is not available for VPN,

   779         // or, if the destination has not been set yet, whether there is 

   780         // at least one suitable destination to place it in

   781         TBool validParent = EFalse;

   782         

   783         if ( iParentDest )

   784             {

   785             // parent destination is known

   786             // check if it is not linked by any other VPN

   787             validParent = !HasUpstreamVpnL( iParentDest, ETrue );

   788             }

   789         else

   790             {

   791             // parent destination is not known yet

   792             // check if there is any destination into which this VPN could be put

   793 

   794             // trigger the recalculation

   795             RArray<TUint32> parents ( CmMgr().DestinationCountL() );

   796             CleanupClosePushL( parents );

   797             

   798             CmMgr().AllDestinationsL( parents );

   799             

   800             FilterPossibleParentsL( parents );

   801 

   802             // if there is only one such destination, we should filter out 

   803             // that one from the underlying candidates

   804             if ( parents.Count() == 1 )

   805                 {

   806                 TInt destIndex = iBindableMethods.Find( parents[0] );

   807                 if ( destIndex != KErrNotFound )

   808                     {

   809                     // got it, now remove

   810                     iBindableMethods.Remove( destIndex );

   811                     }

   812 

   813                 if ( iBindableMethods.Count() )

   814                     {

   815                     // if there are still some methods to bind to,

   816                     // mark the destination as valid

   817                     validParent = ETrue;

   818                     }

   819                     

   820                 }

   821             else 

   822                 {

   823                 validParent = ( parents.Count() > 0 );

   824                 }

   825                 

   826             CleanupStack::PopAndDestroy( &parents );

   827             }

   828 

   829         if ( !validParent )

   830             {

   831             TCmCommonUi::ShowNoteL( R_CMWIZARD_NO_VPN_STACKING,

   832                                     TCmCommonUi::ECmErrorNote );

   833             

   834             return retVal;

   835             }

   836               

   837         

   838         // Check VPN policies installed on the device

   839         if ( ShowPolicySelectionDlgL() )

   840             {

   841             retVal = ShowRealConnectionSelectionDlgL();

   842 

   843             if ( retVal )

   844                 {

   845                 if ( iIapRecord->iRecordName.GetL() == KNullDesC ) 

   846                     {

   847                     // now we have next layer info, so generate default cm name 

   848                     GenerateDefaultCmNameL();

   849                     }

   850                 

   851                 }

   852             }

   853         }

   854     else

   855         {

   856         HBufC* buf = AllocReadL( R_QTN_NETW_CONSET_INFO_NO_CM_TO_BIND_TO );

   857         TPtr ptr ( buf->Des() );

   858         CleanupStack::PushL( buf );

   859         TCmCommonUi::ShowNoteL( ptr, TCmCommonUi::ECmErrorNote );

   860         CleanupStack::PopAndDestroy( buf );

   861         }              

   862     

   863     return retVal;

   864     }

   865 

   866 

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

   868 // CCmPluginVpn::ServiceRecord()

   869 // --------------------------------------------------------------------------

   870 //        

   871 CCDVPNServiceRecord& CCmPluginVpn::ServiceRecord() const

   872     {

   873     LOGGER_ENTERFN( "CCmPluginVpn::ServiceRecord" );

   874     return *static_cast<CCDVPNServiceRecord*>( iServiceRecord );

   875     }

   876 

   877 // --------------------------------------------------------------------------

   878 // CCmPluginVpn::ServiceRecordExists()

   879 // --------------------------------------------------------------------------

   880 // 

   881 TBool CCmPluginVpn::ServiceRecordExists() const

   882     {

   883     if ( !iServiceRecord )

   884         {

   885         return EFalse;

   886         }

   887     return ETrue;

   888     }

   889     

   890 // --------------------------------------------------------------------------

   891 // CCmPluginVpn::CreateNewServiceRecordL()

   892 // --------------------------------------------------------------------------

   893 //        

   894 void CCmPluginVpn::CreateNewServiceRecordL()

   895     {

   896     LOGGER_ENTERFN( "CCmPluginVpn::CreateNewServiceRecordL" );

   897 

   898     delete iServiceRecord; iServiceRecord = NULL;

   899     

   900     iServiceRecord = static_cast<CCDVPNServiceRecord *>

   901                     (CCDRecordBase::RecordFactoryL( KCDTIdVPNServiceRecord ));

   902 

   903     CLOG_WRITE("New service record, policy emptied");

   904     ServiceRecord().iServicePolicy.SetL( KNullDesC );

   905     ServiceRecord().iServiceIAP = 0;

   906     ServiceRecord().iServiceNetwork = 0;

   907     ServiceRecord().iServiceSNAP = 0;

   908 

   909     

   910     iProxyRecord->iPortNumber = KVpnProxyPortNumberDefault;

   911 

   912     SetIntAttributeL( ECmSeamlessnessLevel, ESeamlessnessShowprogress );

   913     }

   914 

   915 // ---------------------------------------------------------------------------

   916 // CCmPluginVpn::CreateAdditionalRecordsL

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

   918 //

   919 void CCmPluginVpn::CreateAdditionalRecordsL()

   920     {

   921     LOGGER_ENTERFN( "CCmPluginVpn::CreateAdditionalRecordsL" );

   922 

   923     delete iVirtualRecord;

   924     iVirtualRecord = NULL;

   925     

   926     iVirtualRecord = new (ELeave) CCDVirtualIAPNextLayerRecord( iVirtualTableId );

   927     }

   928 

   929 // ---------------------------------------------------------------------------

   930 // CCmPluginVpn::UpdateServiceRecordL

   931 // ---------------------------------------------------------------------------

   932 //

   933 void CCmPluginVpn::UpdateServiceRecordL()

   934     {

   935     LOGGER_ENTERFN( "CCmPluginVpn::UpdateServiceRecordL" );

   936 

   937     CCmPluginBaseEng::UpdateServiceRecordL();

   938     }

   939 

   940 // ---------------------------------------------------------------------------

   941 // CCmPluginVpn::UpdateAdditionalRecordsL

   942 // ---------------------------------------------------------------------------

   943 //

   944 void CCmPluginVpn::UpdateAdditionalRecordsL()

   945     {

   946     LOGGER_ENTERFN( "CCmPluginVpn::UpdateAdditionalRecordsL" );

   947 

   948     CheckIfNameModifiedL( iVirtualRecord );

   949     

   950     if( !iVirtualRecord->RecordId() )

   951         {

   952         iVirtualRecord->SetRecordId( KCDNewRecordRequest );

   953         

   954         iVirtualRecord->iIAP = iIapId;

   955         iVirtualRecord->StoreL( Session() );

   956         }

   957     else

   958         {

   959         iVirtualRecord->ModifyL( Session() );

   960         }

   961     }

   962 

   963 // ---------------------------------------------------------------------------

   964 // CCmPluginVpn::ServiceRecordIdLC

   965 // ---------------------------------------------------------------------------

   966 //

   967 void CCmPluginVpn::ServiceRecordIdLC( HBufC* &aName, 

   968                                       TUint32& aRecordId )

   969     {

   970     LOGGER_ENTERFN( "CCmPluginVpn::ServiceRecordIdLC" );

   971 

   972     aName = TPtrC( KCDTypeNameVPNService ).AllocLC();

   973     aRecordId = iServiceRecord->RecordId();

   974     }

   975 

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

   977 // CCmPluginVpn::BearerRecordIdLC()

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

   979 //        

   980 void CCmPluginVpn::BearerRecordIdLC( HBufC* &aBearerName, 

   981                                      TUint32& aRecordId )

   982     {

   983     LOGGER_ENTERFN( "CCmPluginVpn::BearerRecordIdLC" );

   984 

   985     CMDBRecordSet<CCDVirtualBearerRecord>* bearersRS = 

   986               new(ELeave) CMDBRecordSet<CCDVirtualBearerRecord>

   987                                                    (KCDTIdVirtualBearerRecord);

   988     CleanupStack::PushL( bearersRS );

   989 

   990     // Now try to find the linked proxy record

   991     // create new record

   992     CCDVirtualBearerRecord* bearerRecord = 

   993                 static_cast<CCDVirtualBearerRecord *>

   994                     (CCDRecordBase::RecordFactoryL(KCDTIdVirtualBearerRecord));

   995 

   996     CleanupStack::PushL( bearerRecord );

   997     

   998     bearerRecord->iBearerAgent.SetL( KVpnVirtualBearerAgent );

   999     

  1000     bearersRS->iRecords.AppendL( bearerRecord );

  1001 

  1002     CleanupStack::Pop( bearerRecord );

  1003     bearerRecord = NULL;

  1004     

  1005     CLOG_WRITE_1( "Looking for bearer: [%d]", TUint32(iIapRecord->iService) );

  1006     

  1007     if ( !bearersRS->FindL( Session() ) )

  1008         // No bearer record found -> create a default one.

  1009         {

  1010         bearerRecord = static_cast<CCDVirtualBearerRecord *>

  1011                     (CCDRecordBase::RecordFactoryL(KCDTIdVirtualBearerRecord));

  1012         CleanupStack::PushL(bearerRecord);

  1013 

  1014         bearerRecord->iRecordName.SetL( KVpnVirtualBearerName );

  1015         bearerRecord->iBearerAgent.SetL( KVpnVirtualBearerAgent );

  1016         bearerRecord->iVirtualBearerNifName.SetL(KVpnVirtualBearerNif);

  1017         bearerRecord->iLastSocketActivityTimeout = (TUint32)KNoTimeout;

  1018         bearerRecord->iLastSessionClosedTimeout = KLastSessionTimeout;

  1019         bearerRecord->iLastSocketClosedTimeout = (TUint32)KNoTimeout;

  1020         

  1021         bearerRecord->SetRecordId( KCDNewRecordRequest );

  1022         bearerRecord->StoreL( Session() );

  1023         

  1024         aRecordId = bearerRecord->RecordId();

  1025 

  1026         CleanupStack::PopAndDestroy(bearerRecord);

  1027         }

  1028     else

  1029         {

  1030         aRecordId = (*bearersRS)[0]->RecordId();

  1031         }

  1032 

  1033     CleanupStack::PopAndDestroy( bearersRS );

  1034 

  1035     aBearerName = TPtrC( KCDTypeNameVirtualBearer ).AllocLC();

  1036     }

  1037 

  1038 // --------------------------------------------------------------------------

  1039 // CCmPluginVpn::AdditionalReset()

  1040 // --------------------------------------------------------------------------

  1041 //        

  1042 void CCmPluginVpn::AdditionalReset()

  1043     {

  1044     LOGGER_ENTERFN( "CCmPluginVpn::AdditionalReset" );

  1045 

  1046     delete iNetworkRecord;

  1047     iNetworkRecord = NULL;

  1048 

  1049     delete iVirtualRecord;

  1050     iVirtualRecord = NULL;

  1051     }

  1052 

  1053 // --------------------------------------------------------------------------

  1054 // CCmPluginVpn::PrepareToUpdateRecordsL()

  1055 // --------------------------------------------------------------------------

  1056 //        

  1057 void CCmPluginVpn::PrepareToUpdateRecordsL()

  1058     {

  1059     LOGGER_ENTERFN( "CCmPluginVpn::PrepareToUpdateRecordsL" );

  1060     // Check here if every data of the connection method is valid

  1061     // before records were saved to CommsDat.

  1062     // Set incorrect attribute id in iInvalidAttribute and leave

  1063     // with KErrArgument.

  1064     }

  1065 

  1066 // --------------------------------------------------------------------------

  1067 // CCmPluginVpn::ShowPolicySelectionDlgL

  1068 // --------------------------------------------------------------------------

  1069 //  

  1070 TBool CCmPluginVpn::ShowPolicySelectionDlgL()

  1071     {

  1072     LOGGER_ENTERFN( "CCmPluginVpn::ShowPolicySelectionDlgL" );

  1073 

  1074     TBool retVal ( EFalse );

  1075     

  1076     CmPluginVpnPolicySelectionDlg* dlg = 

  1077                                 CmPluginVpnPolicySelectionDlg::NewL( *this );

  1078     CleanupStack::PushL( dlg );

  1079     retVal = dlg->ShowPolicySelectionListL();

  1080     CleanupStack::PopAndDestroy();

  1081     

  1082     return retVal;

  1083     }

  1084 

  1085 

  1086 // --------------------------------------------------------------------------

  1087 // CCmPluginVpn::BindableRealConnectionsExistL

  1088 // --------------------------------------------------------------------------

  1089 //  

  1090 TBool CCmPluginVpn::BindableRealConnectionsExistL()

  1091     {

  1092     LOGGER_ENTERFN( "CCmPluginVpn::BindableRealConnectionsExistL" );

  1093 

  1094     TBool retVal ( EFalse );

  1095     

  1096     iBindableMethods.Close();

  1097     

  1098     // Compile and array of destination IDs which the VPN CM can be bound to

  1099     // includes Uncategorised destination and Easy WLAN if valid

  1100     CmMgr().AllDestinationsL( iBindableMethods );

  1101 

  1102     // Filter out invalid methods

  1103     for ( TInt i = 0; i < iBindableMethods.Count(); i++ )

  1104         {

  1105         TUint32 bindresult = 

  1106                 CanDestUsedAsUnderlyingConnectionL( iBindableMethods[i] );

  1107                 

  1108         if ( bindresult & (KBindDenied | KNoNonVirtuals | KEmptyDest ) )

  1109             {

  1110             iBindableMethods.Remove( i );

  1111             i--;

  1112             }

  1113         }

  1114     

  1115     // If there are destination IDs which the VPN CM can be bound to.

  1116     if( iBindableMethods.Count() )

  1117         {

  1118         retVal = ETrue;

  1119         }

  1120 

  1121     // 2. Are there uncategorised connection methods which aren't virtual?

  1122     RArray<TUint32> cmArray ( KCmArrayMediumGranularity );

  1123     CleanupClosePushL( cmArray );

  1124     CmMgr().ConnectionMethodL( cmArray, EFalse );

  1125     

  1126     for ( TInt k = 0; k < cmArray.Count(); k++ )

  1127         {

  1128         TInt bearerType (0);

  1129         TRAPD( err, bearerType = CmMgr().GetConnectionMethodInfoIntL( 

  1130             cmArray[k], ECmBearerType ););

  1131 

  1132         //if no plugin is found to handle the bearertype, GetConnectionMethodInfoIntL leaves with KErrNotSupported

  1133         if ( err == KErrNotSupported )