diff -r 000000000000 -r 33413c0669b9 vpnengine/vpnmanager/src/cmmanagerutils.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/vpnengine/vpnmanager/src/cmmanagerutils.cpp	Thu Dec 17 09:14:51 2009 +0200
@@ -0,0 +1,305 @@
+/*
+* Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:   Utility methods for handling connection settings
+*
+*/
+
+#include "cmmanagerutils.h"
+
+#include <cmconnectionmethoddef.h> // default ccm definitions
+#include <cmpluginvpndef.h> // vpn specific ccm definitions
+#include <cmdestinationext.h>
+#include <cmmanagerext.h>
+
+#include "eventlogger.h"
+#include "log_r6.h"
+
+
+static const TUint KMaxDestinationNameLength = 32;
+
+
+void CmManagerUtils::CreateVPNConnectionMethodToIntranetL(const TVpnPolicyInfo& aVpnPolicyInfo,
+                                                          CEventLogger& aEventLogger)
+    {
+    LOG_("CmManagerUtils::CreateVPNConnectionMethodToIntranetL \n");
+    
+    using namespace CMManager;
+    
+    RCmManagerExt cmManagerExt;
+    cmManagerExt.OpenL();        
+    CleanupClosePushL( cmManagerExt );     
+
+    //Makes sure that Internet Destination Exists
+    RArray<TUint32> destinationArray;    
+    cmManagerExt.AllDestinationsL( destinationArray );
+    CleanupClosePushL(destinationArray);    
+        
+    TUint32 internetDestinationId = 0;
+    for (TInt i = 0; i < destinationArray.Count(); ++i)
+        {
+        RCmDestinationExt destination = cmManagerExt.DestinationL( destinationArray[i] );
+        CleanupClosePushL(destination);
+        
+        TUint32 purposeMetaData = destination.MetadataL( ESnapMetadataPurpose );
+        if ( ESnapPurposeInternet ==  purposeMetaData )
+            {
+            internetDestinationId = destinationArray[i];
+            CleanupStack::PopAndDestroy(); //destination
+            break;
+            }                
+        CleanupStack::PopAndDestroy(); //destination
+        }
+    
+    
+    if ( internetDestinationId != 0)
+        {                        
+        //Generate name for the connection method
+        HBufC* name = CreateConnectionMethodNameLC(cmManagerExt,
+                                                   aVpnPolicyInfo.iName);
+        
+        //Create VPN connection method        
+        RCmConnectionMethodExt vpnConnectionMethod =
+            CreateNewConnectionMethodToIntranetL(cmManagerExt,
+                                                 *name,
+                                                 aVpnPolicyInfo.iId,
+                                                 internetDestinationId);                        
+            
+        CleanupClosePushL( vpnConnectionMethod );
+        TUint32 connectionMethodId = vpnConnectionMethod.GetIntAttributeL( ECmId );
+        aEventLogger.LogEvent(R_VPN_MSG_CREATED_VPN_ACCESS_POINT_WITH_SNAP,
+                              &(aVpnPolicyInfo.iId), NULL,
+                              connectionMethodId, internetDestinationId);
+        CleanupStack::PopAndDestroy(&vpnConnectionMethod);       
+        CleanupStack::PopAndDestroy(name);
+        }
+    else
+        {
+        LOG_("No Internet destination: VPN connection method not created. \n");
+        }
+    
+    CleanupStack::PopAndDestroy(); //destinationArray  
+    CleanupStack::PopAndDestroy(); //cmManagerExt
+    
+    LOG_("CmManagerUtils::CreateVPNConnectionMethodToIntranetL - end \n");
+    }
+
+void CmManagerUtils::SetVpnConnectionMethodAttributesL(RCmConnectionMethodExt& aConnectionMethod,
+                                                       const TDesC& aConnectionMethodName,                                                       
+                                                       const TVpnPolicyId aPolicyId,
+                                                       const TUint32 aInternetDestinationId)
+    {
+    using namespace CMManager;
+    
+    LOG_("CmManagerUtils::SetVpnConnectionMethodAttributesL \n");                                                   
+    
+    aConnectionMethod.SetIntAttributeL( ECmNamingMethod, ENamingNothing );
+    aConnectionMethod.SetStringAttributeL( ECmName, aConnectionMethodName );
+    aConnectionMethod.SetStringAttributeL( EVpnServicePolicy, aPolicyId );      
+    aConnectionMethod.SetIntAttributeL( ECmNextLayerSNAPId, aInternetDestinationId );
+         
+    LOG_("CmManagerUtils::SetVpnConnectionMethodAttributesL - end \n");
+    }
+
+HBufC* CmManagerUtils::CreateConnectionMethodNameLC(RCmManagerExt& aCmManagerExt,
+                                                    const TDesC& aPolicyName)
+    {
+    using namespace CMManager;
+    
+    LOG_("CmManagerUtils::CreateConnectionMethodNameLC \n");
+    
+    HBufC* name = HBufC::NewLC(KMaxDestinationNameLength);
+    TPtr namePtr = name->Des();
+    
+    RArray<TUint32> connections;
+    CleanupClosePushL( connections );    
+    aCmManagerExt.ConnectionMethodL( connections, EFalse, EFalse, EFalse );
+    
+    TInt connectionMethodCount = connections.Count();    
+    TBool matchFound = EFalse;
+    TInt counter = 1;
+    do 
+        {       
+        matchFound = EFalse;
+        
+        namePtr.Copy(aPolicyName.Left(KMaxDestinationNameLength));   
+        if (counter > 1)
+            {
+            TBuf<10> numberValue;
+            numberValue.Format(_L("(%d)"), counter);
+            if (namePtr.MaxLength() < numberValue.Length() + namePtr.Length())                
+                {
+                namePtr.SetLength(namePtr.MaxLength() - numberValue.Length());
+                
+                }
+            namePtr.Append(numberValue);
+            }
+             
+        for (TInt i = 0; i < connectionMethodCount; i++)
+            {
+           RCmConnectionMethodExt connectionMethod = aCmManagerExt.ConnectionMethodL( connections[i] );
+           CleanupClosePushL(connectionMethod);
+           HBufC* existingName = connectionMethod.GetStringAttributeL( ECmName );
+           CleanupStack::PopAndDestroy(); //connectionMethod
+            
+            if (name->Compare(*existingName) == 0)
+                {
+                delete existingName;
+                matchFound = ETrue;
+                break;
+                }                   
+            delete existingName;                    
+            }
+        counter++;
+        }while(matchFound);
+        
+    CleanupStack::PopAndDestroy(); // connections    
+    LOG_("CmManagerUtils::CreateConnectionMethodNameLC - end \n");
+    return name;
+    }
+
+
+HBufC* CmManagerUtils::CreateIntranetDestinationNameLC(RCmManagerExt& aCmManagerExt)
+    {
+    _LIT(KDestinationNameBase, "Intranet");
+    _LIT(KDestinationNumberFormat, "(%d)");
+    
+    HBufC* destinationName = HBufC::NewLC(KMaxDestinationNameLength);
+    TPtr destinationNamePtr = destinationName->Des();
+    
+    RArray<TUint32> destArray;
+    aCmManagerExt.AllDestinationsL(destArray);
+    CleanupClosePushL(destArray);
+   
+    TUint counter = 1;    
+    do
+        {
+        destinationNamePtr = KDestinationNameBase;
+        if (counter > 1)
+            {        
+            TBuf<10> numberValue;
+            numberValue.Format(KDestinationNumberFormat, counter);
+            destinationNamePtr.Append(numberValue);
+            }
+    
+        for (TInt i = 0; i < destArray.Count(); ++i)
+            {
+            RCmDestinationExt destination = aCmManagerExt.DestinationL(destArray[i]);
+            CleanupClosePushL(destination);
+            HBufC* name = destination.NameLC();
+            
+            if (name->Compare(*destinationName) == 0)
+                {
+                destinationNamePtr.Zero();
+                CleanupStack::PopAndDestroy(name);
+                CleanupStack::PopAndDestroy(); //destination
+                break;
+                }
+            
+            CleanupStack::PopAndDestroy(name);
+            CleanupStack::PopAndDestroy(); //destination
+            }
+        counter++;
+        }while(destinationName->Length() == 0);
+    
+    CleanupStack::PopAndDestroy(); //destArray
+    return destinationName;
+    }
+
+
+RCmConnectionMethodExt CmManagerUtils::CreateNewConnectionMethodToIntranetL(RCmManagerExt& aCmManagerExt,
+                                                                            const TDesC& aConnectionMethodName,
+                                                                            const TVpnPolicyId aPolicyId,
+                                                                            const TUint32 aInternetDestinationId)
+    {
+    LOG_("CmManagerUtils::CreateNewConnectionMethodToIntranetL \n");
+    using namespace CMManager;
+
+    RCmDestinationExt intranetDestination;
+    RCmConnectionMethodExt vpnConnectionMethod;
+    TBool intranetSnapFound = EFalse;
+    
+    RArray<TUint32> destinationArray;    
+    aCmManagerExt.AllDestinationsL( destinationArray );
+    CleanupClosePushL(destinationArray);    
+    
+    //Try to find Intranet Destination using metadata.        
+    for (TInt i = 0; i < destinationArray.Count(); ++i)
+        {
+        intranetDestination = aCmManagerExt.DestinationL( destinationArray[i] );
+        CleanupClosePushL(intranetDestination);
+        
+        TUint32 purposeMetaData = intranetDestination.MetadataL( ESnapMetadataPurpose );
+        if ( purposeMetaData ==  ESnapPurposeIntranet)
+            {
+            //Jumps out and leaves the destination 
+            //in the clenaup stack.     
+            intranetSnapFound = ETrue;
+            // create new vpn record with default values to intranet
+            vpnConnectionMethod = 
+                intranetDestination.CreateConnectionMethodL( KPluginVPNBearerTypeUid );
+            SetVpnConnectionMethodAttributesL( vpnConnectionMethod,
+                                               aConnectionMethodName,
+                                               aPolicyId,
+                                               aInternetDestinationId );
+            intranetDestination.UpdateL();
+            break;
+            }                
+        CleanupStack::PopAndDestroy(); //intranetDestination
+        }            
+                                                
+    if (!intranetSnapFound)
+        {                      
+        //If not found Create the Intranet Destination.
+        //If the Intranet destination is not supported this leaves.
+        HBufC* intranetSnapName = CreateIntranetDestinationNameLC(aCmManagerExt);            
+        intranetDestination = 
+            aCmManagerExt.CreateDestinationL( *intranetSnapName );
+        CleanupStack::PopAndDestroy(intranetSnapName);
+
+        CleanupClosePushL(intranetDestination);
+        TRAPD(err, intranetDestination.SetMetadataL( ESnapMetadataPurpose, 
+                                                     ESnapPurposeIntranet ));
+
+        //Intranet metadata is not supported in all platforms.
+        if (err == KErrNone)
+            {
+             // create new vpn record with default values  to intranet
+            vpnConnectionMethod = 
+                intranetDestination.CreateConnectionMethodL( KPluginVPNBearerTypeUid );
+            SetVpnConnectionMethodAttributesL( vpnConnectionMethod,
+                                               aConnectionMethodName,
+                                               aPolicyId,
+                                               aInternetDestinationId );
+            intranetDestination.UpdateL();
+             }
+        else
+            {
+ 
+            // create new vpn record with default values   
+            vpnConnectionMethod = 
+                aCmManagerExt.CreateConnectionMethodL( KPluginVPNBearerTypeUid );
+            SetVpnConnectionMethodAttributesL( vpnConnectionMethod,
+                                               aConnectionMethodName,
+                                               aPolicyId,
+                                               aInternetDestinationId );
+            vpnConnectionMethod.UpdateL();
+            }
+        }
+
+    CleanupStack::PopAndDestroy(&intranetDestination); 
+    CleanupStack::PopAndDestroy(&destinationArray); 
+    
+    LOG_("CmManagerUtils::CreateNewConnectionMethodToIntranetL - end \n");
+    return vpnConnectionMethod;
+    }