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: Task handler for getting IP version.

    15 *

    16 */

    17 

    18 

    19 

    20 #include "protocolversiongetter.h"

    21 #include "ipsecpolparser.h"

    22 #include "log.h"

    23 

    24 CProtocolVersionGetter* CProtocolVersionGetter::NewL(MTaskHandlerManager* aManager,

    25                                                      const TTaskArrivedEventData& aTaskInfo)

    26     {

    27     CProtocolVersionGetter* self = new (ELeave) CProtocolVersionGetter(aManager, aTaskInfo);

    28     CleanupStack::PushL(self);

    29     self->ConstructL();

    30     CleanupStack::Pop(); // self

    31     return self;

    32     }

    33 

    34 CProtocolVersionGetter::CProtocolVersionGetter(MTaskHandlerManager* aManager,

    35                                                const TTaskArrivedEventData& aTaskInfo)

    36     : CTaskHandler(aManager, aTaskInfo, EGetProtocolVersionCancelEvent, &iEventSpecDes)

    37     {

    38     }

    39 

    40 void CProtocolVersionGetter::ConstructL()

    41     {

    42     CActiveScheduler::Add(this);

    43     User::LeaveIfError(iEventMediator.Connect());

    44     User::LeaveIfError(iVpnServ.Connect());

    45     }

    46     

    47 CProtocolVersionGetter::~CProtocolVersionGetter()

    48     {

    49     Cancel();

    50     iEventMediator.Close();

    51     iVpnServ.Close();

    52     }

    53 

    54 void CProtocolVersionGetter::StartTaskHandling()

    55     {

    56     GotoState(KStateGetProtocolVersion);

    57     }

    58 

    59 void CProtocolVersionGetter::ChangeStateL()

    60     {

    61     switch (NextState())

    62         {

    63         case KStateGetProtocolVersion:

    64             StateGetProtocolVersionL();

    65             break;

    66 

    67         default:

    68             User::Panic(KSitName, EPanicInvalidTaskHandlerState);

    69         }

    70     }

    71 

    72 void CProtocolVersionGetter::CancelOngoingOperation()

    73     {

    74     switch (CurrState())

    75         {

    76         case KStateGetProtocolVersion:

    77             // There's no ongoing external request to cancel

    78             break;

    79 

    80         default:

    81             User::Panic(KSitName, EPanicInvalidTaskHandlerState);

    82         }

    83     }

    84     

    85 void CProtocolVersionGetter::StateGetProtocolVersionL()

    86     {

    87     SetCurrState(KStateGetProtocolVersion);

    88     

    89     // The protocol version getting process

    90     // consists of one step only

    91     GetProtocolVersionL();

    92 

    93     TaskComplete(KErrNone);

    94     }

    95 

    96 void CProtocolVersionGetter::ReportResult(TInt aStatus)

    97     {

    98     // Report the process status and protocol version

    99     // information to the Event Mediator

   100 

   101     iEventData.iTaskStatus = aStatus;

   102     // Protocol version is already in iEventData

   103     

   104     TPckg<TGetProtocolVersionEventData> eventDataDes(iEventData);

   105     ReportEvent(EGetProtocolVersionEvent, iEventSpecDes, eventDataDes);

   106     }

   107 

   108 void CProtocolVersionGetter::GetProtocolVersionL()

   109     {

   110     HBufC8* policyData = NULL;

   111     

   112     // Load policy data via VPN Manager

   113     User::LeaveIfError(iVpnServ.GetPolicyData(iEventSpecDes().iPolicyId, policyData));

   114     CleanupStack::PushL(policyData);

   115     

   116     ParseProtocolVersionL(*policyData);

   117 

   118     CleanupStack::PopAndDestroy(); // policyData

   119     }

   120     

   121 void CProtocolVersionGetter::ParseProtocolVersionL(const TDesC8& aPolicyData)

   122     {

   123     // Parse the data

   124     CIpSecurityPiece* pieceData  = new (ELeave) CIpSecurityPiece;

   125     CleanupStack::PushL(pieceData);

   126     pieceData->ConstructL();

   127 

   128    // Copy policy to 16bit buffer

   129     TInt length = aPolicyData.Length();

   130     HBufC *policyDataHBufC16 = HBufC::NewL(length);

   131     CleanupStack::PushL(policyDataHBufC16);

   132     TPtr ptr(policyDataHBufC16->Des());

   133     ptr.Copy(aPolicyData);

   134 

   135     TIpSecParser parser(ptr); // Store policy to secparser

   136     TInt err = parser.ParseAndIgnoreIKEL(pieceData);

   137     if (err != KErrNone)

   138         {

   139         HBufC* errorInfo = HBufC16::NewL(200);

   140         errorInfo->Des().Copy(pieceData->iErrorInfo);

   141         LOG(TPtr ptr = errorInfo->Des(); Log::Printf(_L("Parsing error info: %S\n"), &ptr));

   142         delete errorInfo;

   143         CleanupStack::PopAndDestroy(2); // pieceData, policyDataHBufC16

   144         User::Leave(err);

   145         }

   146 

   147     CleanupStack::PopAndDestroy(1); // policyDataHBufC16

   148 

   149     CSecurityPolicy *securityPolicy = pieceData->Policies();

   150     CSelectorList* selectorList = securityPolicy->SelectorList();

   151     TInt selectorCount = selectorList->Count();

   152     for (TInt i = 0; i < selectorCount; i++)

   153         {

   154         CPolicySelector *policySelector = selectorList->At(i);

   155         if (policySelector->iRemote.Family() == KAfInet6)

   156             {

   157             iEventData.iProtocolVersion = EVersionIp6;

   158             CleanupStack::PopAndDestroy(1); // pieceData

   159             return;

   160             }

   161         }

   162     if (selectorCount > 0)

   163         {

   164         iEventData.iProtocolVersion = EVersionIp;

   165         }

   166 

   167     CleanupStack::PopAndDestroy(1); // pieceData

   168     }