1 /*

     2 * Copyright (c) 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:  VPN Agile provision Web Service Client

    15 *

    16 */

    17 

    18 #include <SenXmlServiceDescription.h>

    19 #include <SenServiceConnection.h>

    20 #include <SenServiceManager.h>

    21 #include <SenIdentityProvider.h>

    22 #include "agileprovisionws.h"

    23 #include "agileprovisiondefs.h"

    24 #include "policyinstaller_constants.h"

    25 #include "base64.h" 

    26 

    27 

    28 EXPORT_C CAgileProvisionWs* CAgileProvisionWs::NewL()

    29     {

    30 	CAgileProvisionWs* self = NewLC();

    31 	CleanupStack::Pop(); // self

    32 	return self;

    33     }

    34 

    35 

    36 EXPORT_C CAgileProvisionWs* CAgileProvisionWs::NewLC() 	

    37     {

    38 	CAgileProvisionWs* self = new (ELeave) CAgileProvisionWs();

    39 	CleanupStack::PushL(self);

    40 	self->ConstructL();

    41 	return self;

    42     }

    43 

    44 CAgileProvisionWs::CAgileProvisionWs()

    45     {

    46     }

    47 

    48 

    49 void CAgileProvisionWs::ConstructL()

    50     {

    51     }

    52 

    53 

    54 CAgileProvisionWs::~CAgileProvisionWs()

    55     {

    56     delete iPService;

    57     delete iServiceAddr;

    58     }

    59 

    60 EXPORT_C void CAgileProvisionWs::GetPolicy(const TDesC8& aEndPointUri, const TUint aIapId,

    61                                            TRequestStatus& aStatus)

    62     {

    63     __ASSERT_DEBUG( iClientStatus == NULL,

    64                     User::Invariant() );

    65     

    66     // Store client's request status.

    67        

    68     iClientStatus = &aStatus;

    69     *iClientStatus = KRequestPending;

    70 

    71     TRAPD( err, DoGetPolicyL( aEndPointUri, aIapId) );

    72     if ( err != KErrNone )

    73         {

    74         DoComplete( err );

    75         }

    76     }

    77 

    78 EXPORT_C void CAgileProvisionWs::CancelGetPolicy()

    79     {

    80     if ( iPService != NULL )

    81         {

    82         iPService->CancelTransaction();

    83         delete iPService;

    84         iPService = NULL;

    85         }

    86     DoComplete( KErrCancel );

    87     }

    88 

    89 EXPORT_C void CAgileProvisionWs::SetServiceAddr(const HBufC8* aServiceAddr)

    90     {

    91     iServiceAddr=aServiceAddr;

    92     }

    93 

    94 void CAgileProvisionWs::DoGetPolicyL(const TDesC8& aEndPointUri, const TUint aIapId)

    95     {

    96     

    97     CSenXmlServiceDescription* pServiceDesc = CSenXmlServiceDescription::NewLC( aEndPointUri,

    98                                                                                     KNullDesC8() );

    99     iEndPointUri=&aEndPointUri;

   100     pServiceDesc->SetFrameworkIdL( KDefaultBasicWebServicesFrameworkID );            

   101     delete iPService;

   102     iPService = NULL;

   103 

   104     iPService  = CAgileProvisionServiceService::NewL( *this, *pServiceDesc );

   105     

   106     CleanupStack::PopAndDestroy( pServiceDesc );

   107     

   108     iPService->iIapId= aIapId;   

   109     

   110     iState = KStateGettingConf;

   111       

   112     }

   113 

   114 void CAgileProvisionWs::HandleMessageL(const TDesC8& aMessage)

   115 {

   116     

   117     iPService->ResetTransactionId();

   118     

   119     if ( iState == KStateGettingConf )

   120         {

   121         HandleGetConfSoapInL( aMessage );

   122         GenerateCertReqL();

   123         iPService->GetCertificateAsyncL(iPService->iCertreq);

   124         iState = KStateGettingCertificate;

   125         }

   126     else if ( iState == KStateGettingCertificate )

   127         {

   128         HandleGetCertificateSoapInL( aMessage );        

   129         DoComplete( KErrNone );

   130         iState = KStateInitial;

   131         }

   132     else

   133         {

   134         User::Leave( KErrArgument );

   135         }

   136 }

   137 

   138 void CAgileProvisionWs::HandleErrorL(const TInt aErrorCode, const TDesC8&  /*aError*/)

   139     {

   140     DoComplete( aErrorCode );

   141     }

   142 

   143 

   144 void CAgileProvisionWs::SetStatus(const TInt aStatus)

   145     {

   146     TInt err = KErrNone;

   147     if ( aStatus == KSenConnectionStatusReady )

   148         {

   149         TRAP( err, iPService->GetConfAsyncL() );

   150         }

   151     else if ( aStatus == KSenConnectionStatusCreateFailed )

   152         {

   153         err = aStatus;

   154         }

   155     else

   156         {

   157         // Do nothing.

   158         }

   159     

   160     if ( err != KErrNone )

   161         {

   162         DoComplete( err );

   163         }

   164     }

   165 

   166 EXPORT_C void CAgileProvisionWs::HandleGetConfSoapInL(const TDesC8& aMessage)

   167     {

   168     CSenXmlReader *pXmlReader = CSenXmlReader::NewL();

   169     CleanupStack::PushL(pXmlReader);

   170      

   171     //CSenDomFragment

   172     CSenDomFragment* pBase = CSenDomFragment::NewL();

   173     CleanupStack::PushL(pBase);

   174 

   175     //must set the content handler

   176     pXmlReader->SetContentHandler(*pBase);

   177    // and the reader

   178     pBase->SetReader(*pXmlReader);

   179 

   180     pXmlReader->ParseL(aMessage);

   181     

   182     RPointerArray<CSenElement>& array = pBase->AsElement().ElementsL();

   183         

   184 	//start the listing of the elements, first level is 1

   185     TInt contentType(1);

   186 		

   187 	TInt vpnFilePathLth = KAgileProvisionPolicyFileName().Length() + KTempDirectory().Length();

   188 	HBufC* vpnFilePathBuf = HBufC::NewLC(vpnFilePathLth);

   189 	TPtr vpnFilePath(vpnFilePathBuf->Des());

   190 	vpnFilePath.Copy(KTempDirectory);

   191 	vpnFilePath.Append(KAgileProvisionPolicyFileName);

   192        

   193 	ParseFileFromSoapEnvelopeL(array, contentType, 1, vpnFilePath);

   194     

   195     CleanupStack::PopAndDestroy(vpnFilePathBuf); // file

   196     CleanupStack::PopAndDestroy(pBase); // delete pXmlReader, procMsg, responseStr

   197     CleanupStack::PopAndDestroy(pXmlReader); // delete pXmlReader, procMsg, responseStr

   198     }

   199 

   200 

   201 EXPORT_C void CAgileProvisionWs::HandleGetCertificateSoapInL(const TDesC8& aMessage)

   202     {

   203     CSenXmlReader *pXmlReader = CSenXmlReader::NewL();

   204     CleanupStack::PushL(pXmlReader);

   205      

   206     //CSenDomFragment

   207     CSenDomFragment* pBase = CSenDomFragment::NewL();

   208     CleanupStack::PushL(pBase);

   209 

   210     //must set the content handler

   211     pXmlReader->SetContentHandler(*pBase);

   212    // and the reader

   213     pBase->SetReader(*pXmlReader);

   214 

   215     pXmlReader->ParseL(aMessage);

   216     

   217     RPointerArray<CSenElement>& array = pBase->AsElement().ElementsL();

   218 

   219     //start the listing of the elements, first level is 1

   220        

   221     TInt vpnFilePathLth = KAgileProvisionCertificateFileName().Length() + KTempDirectory().Length();

   222     HBufC* vpnFilePathBuf = HBufC::NewLC(vpnFilePathLth);

   223     TPtr vpnFilePath(vpnFilePathBuf->Des());

   224     vpnFilePath.Copy(KTempDirectory);

   225     vpnFilePath.Append(KAgileProvisionCertificateFileName);

   226     TInt contentType(2);

   227     ParseFileFromSoapEnvelopeL(array, contentType, 1, vpnFilePath);

   228     

   229     CleanupStack::PopAndDestroy(vpnFilePathBuf); // file

   230     CleanupStack::PopAndDestroy(pBase); // delete pXmlReader, procMsg, responseStr

   231     CleanupStack::PopAndDestroy(pXmlReader); // delete pXmlReader, procMsg, responseStr

   232     

   233     }

   234 

   235 // The listing of the elements is done in ListNodesL function:

   236 void CAgileProvisionWs::ParseFileFromSoapEnvelopeL(RPointerArray<CSenElement>& aArray, 

   237                                                        TInt aContentType,TInt aLevel, TDesC& aFileName )

   238     {

   239 

   240     TInt size = aArray.Count();

   241     for(TInt i=0; i<size; i++)

   242         {

   243         //get an element

   244         CSenElement* pElement = aArray[i];

   245         if ( pElement->HasContent() )

   246             {

   247             //get the content of the element

   248             TPtrC8 content =  pElement->Content();

   249             TBase64Codec* base64Inst = new (ELeave) TBase64Codec();

   250             CleanupStack::PushL(base64Inst);

   251             HBufC8* dataBuf = base64Inst->Base64DecodeLC(content);

   252             HBufC8* fileBuf = base64Inst->Base64DecodeLC(*dataBuf);

   253                        

   254             //CA from getConf envelope

   255             if ( aContentType == 1 && i==1 )

   256                 {

   257                 CAgileCryptoCert* agileClientCert = CAgileCryptoCert::NewL(fileBuf->Des(), EFalse);

   258                 CleanupStack::PushL(agileClientCert);

   259                 agileClientCert->SaveCACertL();

   260                 CleanupStack::PopAndDestroy(agileClientCert);

   261                 }

   262             else if ( aContentType == 2)

   263                 {

   264                 CAgileCryptoCert* agileClientCert = CAgileCryptoCert::NewL(fileBuf->Des(), ETrue);

   265                 CleanupStack::PushL(agileClientCert);

   266                 agileClientCert->SaveClientCertL(iKeyRef,KPublicKeyLen);

   267                 CleanupStack::PopAndDestroy(agileClientCert);

   268                 }

   269             else           

   270                 {

   271                 RFile file;

   272                 RFs iFs;

   273                 TInt err= iFs.Connect();

   274                 CleanupClosePushL(file);

   275                 User::LeaveIfError(file.Replace(iFs, aFileName, EFileWrite));

   276                 User::LeaveIfError(file.Write(*fileBuf));

   277                 

   278                 //write pin file

   279                 TInt vpnPinFilePathLth = KAgileProvisionPinFileName().Length() + KTempDirectory().Length();

   280                 HBufC* vpnPinFilePathBuf = HBufC::NewLC(vpnPinFilePathLth);

   281                 TPtr vpnPinFilePath(vpnPinFilePathBuf->Des());

   282                 vpnPinFilePath.Copy(KTempDirectory);

   283                 vpnPinFilePath.Append(KAgileProvisionPinFileName);

   284                 User::LeaveIfError(file.Replace(iFs, vpnPinFilePath, EFileWrite));

   285                 CleanupStack::PopAndDestroy(vpnPinFilePathBuf); // file                

   286                 file.Flush();

   287                 file.Close();

   288                 CleanupStack::PopAndDestroy(&file);

   289                 iFs.Close();

   290                 }

   291             

   292             

   293 			CleanupStack::PopAndDestroy(fileBuf);

   294             CleanupStack::PopAndDestroy(dataBuf);

   295             CleanupStack::PopAndDestroy(base64Inst);

   296                        

   297             

   298             }

   299   

   300         //get the first child

   301         CSenElement* child = pElement->Child(0);

   302 

   303         //check if element has childs

   304         if( child )

   305             {

   306             //get the child elements

   307             RPointerArray<CSenElement>& tree = pElement->ElementsL();

   308 

   309             //list child elements by a recursive call

   310             ParseFileFromSoapEnvelopeL(tree, aContentType, ++aLevel, aFileName);

   311             }

   312         aLevel--;

   313         } //for loop ends

   314   }

   315 

   316 EXPORT_C void CAgileProvisionWs::GenerateCertReqL()

   317     {

   318     TRequestStatus status;

   319     CAgileCryptoPrivKey* agileCryptoPrivKey = CAgileCryptoPrivKey::NewL();

   320     CleanupStack::PushL(agileCryptoPrivKey);

   321     CAgileCryptoGenerateKeypair* agileCryptoGenerateKeypair = CAgileCryptoGenerateKeypair::NewL(agileCryptoPrivKey);

   322     CleanupStack::PushL(agileCryptoGenerateKeypair);

   323     

   324     // generate key

   325     agileCryptoGenerateKeypair->GenerateKeypairL(KPublicKeyLen, iKeyRef, status);

   326     User::WaitForRequest(status);

   327     

   328     // generate subjectname

   329     _LIT8(KCnHeader, "CN=");

   330     _LIT8(KCnUsername, "vpnuser");

   331     TInt distinguishedNameLth = KCnHeader().Length() + KCnUsername().Length();

   332     HBufC8* distinguishedNameHBuf = HBufC8::NewLC(distinguishedNameLth);

   333     TPtr8 distinguishedName(distinguishedNameHBuf->Des());

   334     distinguishedName.Copy(KCnHeader);

   335     distinguishedName.Append(KCnUsername);

   336 

   337     // generate certreq

   338     const TInt KDmAdMaxCertReqRefLth = KMaxFileName;

   339     HBufC* certReqRef = HBufC::NewLC(KDmAdMaxCertReqRefLth);

   340     TPtr certReqRefPtr(certReqRef->Des());

   341     TInt certReqSize;

   342     

   343     agileCryptoPrivKey->GenerateCertReqL(*distinguishedNameHBuf, //subjectname

   344                                                            KNullDesC8, // subjectaltname

   345                                                            KNullDesC8, //aChallengePassword,

   346                                                            KNullDesC8, //DnsName,

   347                                                            iKeyRef,

   348                                                            certReqRefPtr,

   349                                                            certReqSize);

   350 

   351 

   352     // read certreq

   353     TRetBufCertReq certReq;

   354     certReq = agileCryptoPrivKey->ReadCertReqL(certReqRefPtr, certReqSize);

   355     if ( iPService )

   356         {

   357         iPService->iCertreq = certReq;

   358         }

   359     else

   360         {

   361         delete certReq;

   362         certReq=NULL;

   363         }

   364     

   365     CleanupStack::PopAndDestroy(certReqRef);

   366     CleanupStack::PopAndDestroy(distinguishedNameHBuf);

   367     CleanupStack::PopAndDestroy(agileCryptoGenerateKeypair);

   368     CleanupStack::PopAndDestroy(agileCryptoPrivKey);            

   369     }

   370 

   371 void CAgileProvisionWs::DoComplete( const TInt aStatus )

   372     {

   373     if ( iClientStatus != NULL )

   374         {

   375         User::RequestComplete( iClientStatus,

   376                                aStatus );

   377         }

   378     }