1 /*

     2 * Copyright (c) 2003 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: Handles API requests for VPN Manager.

    15 *

    16 */

    17 

    18 

    19 

    20 #include "vpnapiservant.h"

    21 #include "policystore.h"

    22 #include "policyimporter.h"

    23 #include "pwdchanger.h"

    24 #include "vpnapidefs.h"

    25 #include "vpnmanagerserverdefs.h"

    26 #include "vpnmaninternal.h"

    27 #include "log_r6.h"

    28 

    29 

    30 CVpnApiServant* CVpnApiServant::NewL(RFs& aFs)

    31     {

    32     CVpnApiServant* self = new (ELeave) CVpnApiServant(aFs);

    33     CleanupStack::PushL(self);

    34     self->ConstructL();

    35     CleanupStack::Pop(); // self

    36     return self;

    37     }

    38 

    39 CVpnApiServant::CVpnApiServant(RFs& aFs) : iFs(aFs)

    40     {

    41     }

    42 

    43 void CVpnApiServant::ConstructL()

    44     {

    45     iPolicyStore = CPolicyStore::NewL(iFs);

    46     INIT_EVENT_LOGGER(*iPolicyStore);

    47     }

    48 

    49 CVpnApiServant::~CVpnApiServant()

    50     {

    51     delete iPolicyStore;

    52     RELEASE_EVENT_LOGGER;

    53     }

    54     

    55 TBool CVpnApiServant::ServiceL(const RMessage2& aMessage)

    56     {

    57     TBool requestHandled = ETrue;

    58     

    59     switch (aMessage.Function())

    60         {

    61         case EVpnImportPolicy:

    62             ImportPolicyL(aMessage);

    63             break;

    64             

    65         case EVpnCancelImport:

    66             CancelImportPolicy(aMessage);

    67             break;

    68             

    69         case EVpnEnumeratePolicies:

    70             EnumeratePoliciesL(aMessage);

    71             break;

    72             

    73         case EVpnGetPolicyInfo:

    74             GetPolicyInfoL(aMessage);

    75             break;

    76             

    77         case EVpnGetPolicyDetails:

    78             GetPolicyDetailsL(aMessage);

    79             break;

    80             

    81         case EVpnDeletePolicy:

    82             DeletePolicyL(aMessage);

    83             break;

    84             

    85         case EVpnChangePassword:

    86             ChangePasswordL(aMessage);

    87             break;

    88 

    89         case EVpnCancelChange:

    90             CancelChangePassword(aMessage);

    91             break;

    92 

    93         case EVpnGetPolicySize:

    94             GetPolicySizeL(aMessage);

    95             break;

    96             

    97         case EVpnGetPolicyData:

    98             GetPolicyDataL(aMessage);

    99             break;

   100 

   101         // New methods (to facilitate

   102         // OMA DM based policy management)

   103         

   104         case EVpnAddPolicy:

   105             AddPolicyL(aMessage);

   106             break;

   107 

   108         case EVpnUpdatePolicyDetails:

   109             UpdatePolicyDetailsL(aMessage);

   110             break;

   111             

   112         case EVpnUpdatePolicyData:

   113             UpdatePolicyDataL(aMessage);

   114             break;

   115             

   116         default:

   117             requestHandled = EFalse;

   118             break;

   119         }

   120 

   121     return requestHandled;

   122     }

   123 

   124 void CVpnApiServant::ImportPolicyL(const RMessage2& aMessage)

   125     {

   126     if (iPolicyImporter)

   127         {

   128         aMessage.Complete(KVpnErrImportOngoing);

   129         }

   130     else

   131         {

   132         TInt len = aMessage.GetDesLength(0);

   133         HBufC* input = HBufC::NewL(len);

   134         CleanupStack::PushL(input);

   135         

   136         TPtr ptrInput = input->Des();

   137         aMessage.ReadL(FIRST_ARGUMENT, ptrInput);

   138         

   139         if (input->Length() > 0)

   140             {                    

   141             iPolicyImporter = CPolicyImporter::NewL(aMessage, *this, *iPolicyStore, iFs);

   142             iPolicyImporter->ImportPolicyL(*input);

   143             }

   144         else

   145             {

   146             aMessage.Complete(KVpnErrPolicyNotFound);

   147             }

   148 

   149         CleanupStack::PopAndDestroy(); // input

   150         }

   151     }

   152 

   153 void CVpnApiServant::ImportSinglePolicyL(const TDesC& aDir, TVpnPolicyId& aNewPolicyId,

   154                                          TRequestStatus& aStatus)

   155     {

   156     if (iPolicyImporter)

   157         {

   158         User::Leave(KVpnErrImportOngoing);

   159         }

   160     else

   161         {

   162         iPolicyImporter = CPolicyImporter::NewL(aStatus, *this, *iPolicyStore, iFs);

   163         aStatus = KRequestPending;

   164         iPolicyImporter->ImportSinglePolicyL(aDir, aNewPolicyId);

   165         }

   166     }

   167     

   168 void CVpnApiServant::CancelImportPolicy(const RMessage2& aMessage)

   169     {

   170     if (iPolicyImporter)

   171         {

   172         iPolicyImporter->Cancel();

   173         delete iPolicyImporter;

   174         iPolicyImporter = NULL;

   175         }

   176     

   177     aMessage.Complete(KErrNone);

   178     }

   179 

   180 void CVpnApiServant::CancelImportSinglePolicy()

   181     {

   182     if (iPolicyImporter)

   183         {

   184         iPolicyImporter->Cancel();

   185         delete iPolicyImporter;

   186         iPolicyImporter = NULL;

   187         }

   188     }

   189     

   190 void CVpnApiServant::PolicyImportComplete()

   191     {

   192     delete iPolicyImporter;

   193     iPolicyImporter = NULL;

   194     }

   195 

   196 void CVpnApiServant::EnumeratePoliciesL(const RMessage2& aMessage)

   197     {

   198     TInt policyCount = iPolicyStore->PolicyCount();

   199 

   200     TPckg<TInt> pckgPolicyCount(policyCount);

   201     aMessage.WriteL(FIRST_ARGUMENT, pckgPolicyCount);

   202 

   203     aMessage.Complete(KErrNone);

   204     }

   205 

   206 void CVpnApiServant::GetPolicyInfoL(const RMessage2& aMessage)

   207     {

   208 	TInt expectedPolicyCount = aMessage.Int0();

   209 

   210     if (expectedPolicyCount != iPolicyStore->PolicyCount())

   211         {

   212         aMessage.Complete(KVpnErrPolicyCountChanged);

   213         return;

   214         }

   215 

   216     TUint8* rawPolicyData = iPolicyStore->RawPolicyData();

   217     

   218 	// Write the state array back to the client's address space

   219 	TPtrC8 policyData(rawPolicyData, expectedPolicyCount * sizeof(TVpnPolicyInfo));

   220     

   221     aMessage.WriteL(SECOND_ARGUMENT, policyData);

   222 

   223     aMessage.Complete(KErrNone);

   224     }

   225 

   226 void CVpnApiServant::GetPolicyDetailsL(const RMessage2& aMessage)

   227     {

   228     LOG(Log::Printf(_L("CVpnApiServant::GetPolicyDetailsL")));    

   229     

   230     TVpnPolicyId policyId;

   231     TPckg<TVpnPolicyId> pckgPolicyId(policyId);

   232 

   233     aMessage.ReadL(FIRST_ARGUMENT, pckgPolicyId);

   234 

   235     TVpnPolicyDetails policyDetails;

   236     TInt ret = iPolicyStore->GetPolicyDetailsL(policyId, policyDetails);

   237 

   238     if (ret == KErrNone)

   239         {

   240         TPckg<TVpnPolicyDetails> pckgPolicyDetails(policyDetails);

   241         aMessage.WriteL(SECOND_ARGUMENT, pckgPolicyDetails);

   242         }

   243         

   244             

   245     aMessage.Complete(ret);

   246     

   247     LOG(Log::Printf(_L("CVpnApiServant::GetPolicyDetailsL: aMesage completed withd %d"), ret));    

   248     }

   249 

   250 void CVpnApiServant::DeletePolicyL(const RMessage2& aMessage)

   251     {

   252     TVpnPolicyId policyId;

   253     TPckg<TVpnPolicyId> pckgPolicyId(policyId);

   254 

   255     aMessage.ReadL(FIRST_ARGUMENT, pckgPolicyId);

   256 

   257     TVpnPolicyDetails *policyDetails = new (ELeave) TVpnPolicyDetails;

   258     CleanupStack::PushL(policyDetails);    

   259     

   260     iPolicyStore->GetPolicyDetailsL(policyId, *policyDetails);    

   261     iPolicyStore->DeletePolicyL(policyId);

   262 

   263 

   264     HBufC8* tempBuf = HBufC8::NewLC(policyDetails->iName.Length());

   265     tempBuf->Des().Copy(policyDetails->iName);

   266     

   267     LOG_EVENT(R_VPN_MSG_DELETED_POLICY, tempBuf, NULL, 0, 0);

   268 

   269     CleanupStack::PopAndDestroy(2); //tempBuf, policyDetails

   270     

   271     aMessage.Complete(KErrNone);

   272     }

   273 

   274 void CVpnApiServant::ChangePasswordL(const RMessage2& aMessage)

   275     {

   276     if (iPwdChanger)

   277         {

   278         aMessage.Complete(KVpnErrPwdChangeOngoing);

   279         }

   280     else

   281         {

   282         iPwdChanger = CPwdChanger::NewL(aMessage, *this);

   283         iPwdChanger->ChangePassword();

   284         }

   285     }

   286 

   287 void CVpnApiServant::CancelChangePassword(const RMessage2& aMessage)

   288     {

   289     if (iPwdChanger)

   290         {

   291         iPwdChanger->Cancel();

   292         delete iPwdChanger;

   293         iPwdChanger = NULL;

   294         }

   295     

   296     aMessage.Complete(KErrNone);

   297     }

   298 

   299 void CVpnApiServant::PasswordChangeComplete()

   300     {

   301     delete iPwdChanger;

   302     iPwdChanger = NULL;

   303     }

   304 

   305 void CVpnApiServant::GetPolicySizeL(const RMessage2& aMessage)

   306     {

   307     TVpnPolicyId policyId;

   308     TPckg<TVpnPolicyId> pckgPolicyId(policyId);

   309 

   310     aMessage.ReadL(FIRST_ARGUMENT, pckgPolicyId);

   311 

   312     TInt policySize = PolicySizeL(policyId);

   313 

   314     TPckg<TInt> pckgPolicySize(policySize);

   315     aMessage.WriteL(SECOND_ARGUMENT, pckgPolicySize);

   316 

   317     aMessage.Complete(KErrNone);

   318     }

   319 

   320 void CVpnApiServant::GetPolicyDataL(const RMessage2& aMessage)

   321     {

   322     TVpnPolicyId policyId;

   323     TPckg<TVpnPolicyId> pckgPolicyId(policyId);

   324 

   325     aMessage.ReadL(FIRST_ARGUMENT, pckgPolicyId);

   326 

   327     TInt expectedPolicySize;

   328     TPckg<TInt> pckgExpectedPolicySize(expectedPolicySize);

   329 

   330     aMessage.ReadL(SECOND_ARGUMENT, pckgExpectedPolicySize);

   331 

   332     TInt currentPolicySize = PolicySizeL(policyId);

   333 

   334     if (expectedPolicySize != currentPolicySize)

   335         {

   336         aMessage.Complete(KVpnErrPolicySizeChanged);

   337         return;

   338         }

   339 

   340     HBufC8* policyData = NULL;

   341     User::LeaveIfError(iPolicyStore->LoadPolicyDataL(policyId, policyData));

   342     CleanupStack::PushL(policyData);

   343     

   344     aMessage.WriteL(THIRD_ARGUMENT, *policyData);

   345 

   346     CleanupStack::PopAndDestroy(); // policyData

   347 

   348     aMessage.Complete(KErrNone);

   349     }

   350     

   351 CPolicyStore* CVpnApiServant::PolicyStore()

   352     {

   353     return iPolicyStore;

   354     }

   355 

   356 TInt CVpnApiServant::PolicySizeL(const TVpnPolicyId& aPolicyId)

   357     {

   358     HBufC8* policyData = NULL;

   359     

   360     User::LeaveIfError(iPolicyStore->LoadPolicyDataL(aPolicyId, policyData));

   361     TInt policySize = policyData->Size();

   362     delete policyData;

   363     

   364     return policySize;

   365     }

   366 

   367 // New methods to facilitate OMA DM based VPN policy management

   368 

   369 void CVpnApiServant::AddPolicyL(const RMessage2& aMessage)

   370     {

   371     

   372     LOG(Log::Printf(_L("CVpnApiServant::AddPolicyL")));    

   373     

   374     // Read policy details

   375     TVpnPolicyDetails *policyDetails = new (ELeave) TVpnPolicyDetails;

   376     CleanupStack::PushL(policyDetails);

   377     

   378     TPckg<TVpnPolicyDetails> pckgPolicyDetails(*policyDetails);

   379 

   380     aMessage.ReadL(FIRST_ARGUMENT, pckgPolicyDetails);

   381 

   382     // Read policy data

   383     TInt len = aMessage.GetDesLength(SECOND_ARGUMENT);

   384     HBufC8* policyData = HBufC8::NewL(len);

   385     CleanupStack::PushL(policyData);

   386 

   387     TPtr8 ptrPolicyData = policyData->Des();

   388     aMessage.ReadL(SECOND_ARGUMENT, ptrPolicyData);

   389 

   390 

   391     LOG(Log::Printf(_L("Calling: iPolicyStore->AddNewPolicyL")));    

   392     // Add the policy to the policy store

   393     TRAPD(err, iPolicyStore->AddNewPolicyL(*policyDetails, *policyData));

   394     if (err == KErrNone)

   395     {

   396         TBuf<20> serverName(_L("VPN DM Server"));

   397         TPtrC8 tempCastPtr8(reinterpret_cast<const TUint8*>(serverName.Ptr()), serverName.Length() * 2);

   398         LOG_EVENT(R_VPN_MSG_INSTALLED_POLICY_SERVER, &(policyDetails->iId),

   399                 &tempCastPtr8, err, EFalse);

   400     }

   401     else

   402     {

   403         LOG_EVENT(R_VPN_MSG_INSTALLED_POLICY_SERVER, &(policyDetails->iId), NULL,

   404                  err, EFalse);

   405         User::Leave(err);

   406     }    

   407 

   408     LOG(Log::Printf(_L("Writing back policy details")));    

   409     // Write back the possibly changed policy details

   410     aMessage.WriteL(FIRST_ARGUMENT, pckgPolicyDetails);

   411 

   412     CleanupStack::PopAndDestroy(policyData);    

   413     CleanupStack::PopAndDestroy(); //policyDetails

   414 

   415     aMessage.Complete(KErrNone);

   416     }

   417 

   418 void CVpnApiServant::UpdatePolicyDetailsL(const RMessage2& aMessage)

   419     {

   420     LOG(Log::Printf(_L("CVpnApiServant::UpdatePolicyDetailsL")));    

   421     

   422     // Read policy details

   423     TVpnPolicyDetails* policyDetails = new (ELeave) TVpnPolicyDetails;

   424     CleanupStack::PushL(policyDetails);

   425     

   426     TPckg<TVpnPolicyDetails> pckgPolicyDetails(*policyDetails);

   427 

   428     aMessage.ReadL(FIRST_ARGUMENT, pckgPolicyDetails);

   429 

   430     // Update the policy details

   431     TRAPD(err, iPolicyStore->UpdatePolicyDetailsL(*policyDetails));

   432     if (err != KErrNone)

   433     {

   434         LOG_EVENT(R_VPN_MSG_INSTALLED_POLICY_SERVER, &(policyDetails->iId), NULL,

   435                  err, ETrue);

   436         User::Leave(err);

   437     }

   438 

   439     // Write back the possibly changed policy details

   440     aMessage.WriteL(FIRST_ARGUMENT, pckgPolicyDetails);

   441 

   442     CleanupStack::PopAndDestroy(); //policyDetails

   443     

   444     aMessage.Complete(KErrNone);

   445     }

   446     

   447 void CVpnApiServant::UpdatePolicyDataL(const RMessage2& aMessage)

   448     {

   449     // Read policy ID

   450     TVpnPolicyId policyId;

   451     TPckg<TVpnPolicyId> pckgPolicyId(policyId);

   452 

   453     aMessage.ReadL(FIRST_ARGUMENT, pckgPolicyId);

   454 

   455     // Read policy data

   456     TInt len = aMessage.GetDesLength(SECOND_ARGUMENT);

   457     HBufC8* policyData = HBufC8::NewL(len);

   458     CleanupStack::PushL(policyData);

   459 

   460     TPtr8 ptrPolicyData = policyData->Des();

   461     aMessage.ReadL(SECOND_ARGUMENT, ptrPolicyData);

   462 

   463     // Update the policy data

   464     TRAPD(err, iPolicyStore->UpdatePolicyDataL(policyId, *policyData));

   465     if (err == KErrNone)

   466     {

   467         TBufC8<20> serverName(_L8("VPN DM Server"));

   468         LOG_EVENT(R_VPN_MSG_INSTALLED_POLICY_SERVER, &policyId,

   469                 &serverName, err, ETrue);

   470     }

   471     else

   472     {

   473         LOG_EVENT(R_VPN_MSG_INSTALLED_POLICY_SERVER, &policyId, NULL,

   474                  err, ETrue);

   475         User::Leave(err);

   476     }

   477     CleanupStack::PopAndDestroy(); // policyData

   478 

   479     aMessage.Complete(KErrNone);

   480     }