1 /*

     2 * Copyright (c) 2008-2009 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:  IKEv1 plugin session

    15 *

    16 */

    17 

    18 

    19 #include <random.h>

    20 #include <vpnlogmessages.rsg>

    21 #include "ikev1plugin.h"

    22 #include "ikedebug.h"

    23 #include "ikev1negotiation.h"

    24 #include "ikev1isakmpstream.h"

    25 #include "pfkeymsg.h"

    26 #include "ikepolparser.h"

    27 #include "kmdapi.h"

    28 #include "ikev1crack.h"

    29 #include "ikev1infonegotiation.h"

    30 #include "ikev1SA.h"

    31 #include "ikev1sender.h"

    32 #include "ikesocketdefs.h"

    33 #include "ikedatainterface.h"

    34 #include "vpnaddrinfo.h"

    35 #include "ipsecsaspiretriever.h"

    36 

    37 // CLASS HEADER

    38 #include "ikev1pluginsession.h"

    39 

    40 // ======== MEMBER FUNCTIONS ========

    41 

    42 // ---------------------------------------------------------------------------

    43 // Two-phased constructor.

    44 // ---------------------------------------------------------------------------

    45 //

    46 CIkev1PluginSession* CIkev1PluginSession::NewL( TUint32 aVpnIapId,

    47                                                 TUint32 aVpnNetId,

    48                                                 TUint32 aVpnInterfaceIndex,

    49                                                 MIkeDataInterface& aDataInterface,

    50                                                 CIkev1Plugin& aPlugin,

    51                                                 CPFKeySocketIf& aPFKeySocketIf,

    52                                                 MIkeDebug& aDebug )

    53     {

    54     CIkev1PluginSession* self = new ( ELeave ) CIkev1PluginSession( aVpnIapId,

    55                                                                     aVpnNetId,

    56                                                                     aVpnInterfaceIndex,

    57                                                                     aDataInterface,

    58                                                                     aPlugin,

    59                                                                     aPFKeySocketIf,

    60                                                                     aDebug );

    61     CleanupStack::PushL( self );

    62     self->ConstructL();

    63     CleanupStack::Pop( self );

    64     return self;

    65     }

    66     

    67 // ---------------------------------------------------------------------------

    68 // Destructor.

    69 // ---------------------------------------------------------------------------

    70 //

    71 CIkev1PluginSession::~CIkev1PluginSession()

    72     {

    73     // Cancel client's requests.

    74     DoCompleteNegotiateWithHost( KErrCancel );

    75     DoCompleteDeleteSession( KErrCancel );

    76     DoCompleteNotifyError( KErrCancel );

    77     DoCompleteInternalAddressChanged( KErrCancel );    

    78     

    79     if ( iDialogWaitQueue )

    80         {

    81         CIkev1Dialog::PurgeDialogQueue( iDialogWaitQueue );

    82         }   

    83 

    84     CIkev1Negotiation* negotiation;    

    85     while ( iFirstNegotiation )

    86         {

    87         negotiation = iFirstNegotiation;

    88         delete negotiation; // destructor removes object from queue, too

    89         }

    90     

    91     DoEmptySendQueue();

    92     iSendQueue.Close();

    93     

    94     while ( iIkev1SAs.Count() )

    95         {

    96         CIkev1SA* ikev1SA = iIkev1SAs[0];

    97         iIkev1SAs.Remove(0);

    98         delete ikev1SA;

    99         }

   100     iIkev1SAs.Close();

   101     

   102     delete iReceiver;

   103     delete iSender;

   104     delete iIkeData;

   105     delete iInternalAddress;

   106     

   107     iPlugin.IkePluginSessionDeleted( this );

   108     }

   109 

   110 // ---------------------------------------------------------------------------

   111 // Constructor.

   112 // ---------------------------------------------------------------------------

   113 //

   114 CIkev1PluginSession::CIkev1PluginSession( TUint32 aVpnIapId,

   115                                           TUint32 aVpnNetId,

   116                                           TUint32 aVpnInterfaceIndex,

   117                                           MIkeDataInterface& aDataInterface,

   118                                           CIkev1Plugin& aPlugin,

   119                                           CPFKeySocketIf& aPFKeySocketIf,

   120                                           MIkeDebug& aDebug )

   121 : iVpnIapId( aVpnIapId ),

   122   iVpnNetId( aVpnNetId ),

   123   iVpnInterfaceIndex( aVpnInterfaceIndex ),

   124   iDataInterface( aDataInterface ),

   125   iPlugin( aPlugin ),

   126   iPFKeySocketIf( aPFKeySocketIf ),

   127   iDebug( aDebug )

   128     {

   129     }

   130 

   131 // ---------------------------------------------------------------------------

   132 // Second phase construction.

   133 // ---------------------------------------------------------------------------

   134 //

   135 void CIkev1PluginSession::ConstructL()

   136     {

   137     TPtr8 ptr( (TUint8*)&iSAIdSeed, sizeof(iSAIdSeed) );

   138     ptr.SetLength( sizeof(iSAIdSeed) );

   139     TRandom::RandomL( ptr );  

   140     iSAIdSeed &= 0x7fffffff;  // Reset the most significant bit    

   141 

   142     iReceiver = CIkev1Receiver::NewL( iDataInterface,

   143                                       *this );   

   144     iSender = CIkev1Sender::NewL( iDataInterface,

   145                                   *this,

   146                                   iDebug );    

   147     

   148     DEBUG_LOG1( _L("CIkev1PluginSession::ConstructL, SAId seed: %d"),

   149             iSAIdSeed );

   150     }    

   151 

   152 // ---------------------------------------------------------------------------

   153 // Handles IKE SA deletion request.

   154 // ---------------------------------------------------------------------------

   155 //

   156 TBool CIkev1PluginSession::DeleteIkeSA( TIkev1SAData* aIkev1SaData,

   157                                         TBool aSilentClose )

   158     {

   159     //

   160     // An IKE SA delete request received

   161     // Check first does there exists an ongoing negotiation on this IKE

   162     // SA deleted and delete this block. 

   163     // Allocate a new negotiation with TIkev1SAData and initiate IKE SA

   164     // deletion request

   165     //

   166     DEBUG_LOG1( _L("Deleting IKEv1 SA SAID =  %d"),

   167             aIkev1SaData->iSAId );

   168     

   169     CIkev1Negotiation* negotiation = FindNegotiation( aIkev1SaData->iSAId );

   170     while ( negotiation )

   171         {

   172         delete negotiation; // destructor removes object from queue, too

   173         negotiation = FindNegotiation( aIkev1SaData->iSAId );         

   174         }

   175 

   176     TBool started( EFalse );

   177 

   178     if ( !aSilentClose )

   179         {

   180         DeleteIpsecSAs( aIkev1SaData->iSAId );

   181         

   182         TRAPD( err, 

   183                 {

   184                 // Trap the SendDeleteL -- it can fail, but the failure won't be fatal 

   185                 // (delete payload just won't be sent)

   186                 negotiation = CIkev1Negotiation::NewL( this,

   187                                                        iPFKeySocketIf,

   188                                                        iDebug,

   189                                                        aIkev1SaData,

   190                                                        RESPONDER ); // Nevermind INITIATOR or RESPONDER

   191                 negotiation->SendDeleteL( PROTO_ISAKMP );

   192                 } );

   193                 

   194         delete negotiation;

   195         negotiation = NULL;

   196         

   197         if ( err == KErrNone ) 

   198             {

   199             // DELETE payload sent succesfully.

   200             DEBUG_LOG( _L("CIkev1PluginSession::DeleteIkeSAL() IKEv1 delete send OK") );            

   201             started = ETrue;

   202             }

   203         else 

   204             {

   205             DEBUG_LOG1( _L("CIkev1PluginSession::DeleteIkeSAL() IKEv1 delete send failed, err=%d"), err );

   206             }

   207         }

   208 #ifdef _DEBUG

   209     else

   210         {

   211         DEBUG_LOG( _L("Forced close, no delete payload(s) sent"));

   212         }

   213 #endif    

   214     ExpireIkev1SA( aIkev1SaData->iSAId );  // Set expired to delete IKE SA

   215     

   216     if ( FindIkev1SA() == NULL &&

   217          FirstNegotiation() == NULL )

   218         {

   219         // Set error status, when expired IKE SA was the only IKE SA and there

   220         // is no ongoing negotiation.        

   221         iErrorStatus = KKmdIkeNegotFailed;

   222         }

   223 

   224     return started;

   225     }

   226 

   227 // ---------------------------------------------------------------------------

   228 // Handles IKE SA rekeying request.

   229 // ---------------------------------------------------------------------------

   230 //

   231 void CIkev1PluginSession::RekeyIkeSAL( TIkev1SAData* aIkev1SaData,

   232                                        CSARekeyInfo* aSaRekeyInfo )

   233     {

   234     CIkev1Negotiation* negotiation = CIkev1Negotiation::NewL( this,

   235                                                               iPFKeySocketIf,

   236                                                               iDebug,

   237                                                               aIkev1SaData->iRemoteAddr,

   238                                                               EFalse );

   239     CleanupStack::PushL( negotiation );

   240     negotiation->SetRekeyInfo( aSaRekeyInfo );                

   241     negotiation->InitNegotiationL();

   242     if ( negotiation->Finished() )

   243         {

   244         CleanupStack::PopAndDestroy( negotiation );

   245         }

   246     else 

   247         {

   248         CleanupStack::Pop( negotiation );  

   249         }

   250     }

   251 

   252 // ---------------------------------------------------------------------------

   253 // Handles IKE SA keepalive request.

   254 // ---------------------------------------------------------------------------

   255 //

   256 void CIkev1PluginSession::KeepAliveIkeSAL( TIkev1SAData* aIkev1SaData )

   257     {

   258     CIkev1Negotiation* negotiation = CIkev1Negotiation::NewL( this,

   259                                                               iPFKeySocketIf,

   260                                                               iDebug,

   261                                                               aIkev1SaData,

   262                                                               RESPONDER );

   263     CleanupStack::PushL( negotiation );

   264     negotiation->SendKeepAliveMsgL( aIkev1SaData );

   265     if ( negotiation->Finished() )

   266         {

   267         CleanupStack::PopAndDestroy( negotiation );

   268         }

   269     else

   270         {

   271         CleanupStack::Pop( negotiation );  

   272         }

   273     }

   274 

   275 // ---------------------------------------------------------------------------

   276 // Creates IKE SA.

   277 // ---------------------------------------------------------------------------

   278 //

   279 void CIkev1PluginSession::CreateIkev1SAL( TIkev1SAData& aIkev1SaData,

   280                                           CSARekeyInfo* aSaRekey )

   281     {

   282     CIkev1SA* ikev1SA = CIkev1SA::NewL( *this,

   283                                         aIkev1SaData,

   284                                         aSaRekey,

   285                                         iDebug );

   286     

   287     if ( !aIkev1SaData.iInitiator )

   288         {

   289         // Move SPI list from previous IKE SA to new IKE SA

   290         for ( TInt i=0;i<iIkev1SAs.Count();i++ )

   291             {

   292             CIkev1SA* previousSA = iIkev1SAs[i];

   293             if ( previousSA->iSPIList != NULL )

   294                 {

   295                 DEBUG_LOG(_L("Move SPI list to new IKE SA"));

   296                 delete ikev1SA->iSPIList;

   297                 ikev1SA->iSPIList = previousSA->iSPIList;

   298                 previousSA->iSPIList = new (ELeave) CIpsecSPIList(1);  // Dummy;

   299                 break;

   300                 }

   301             }        

   302         }        

   303     

   304     // Cancel IKE SA rekeying from other IKE SAs.

   305     for ( TInt i=0;i<iIkev1SAs.Count();i++ )

   306         {

   307         CIkev1SA* cancelSA = iIkev1SAs[i];

   308         cancelSA->CancelRekey();

   309         }

   310     

   311     CleanupStack::PushL( ikev1SA );

   312     iIkev1SAs.AppendL( ikev1SA );

   313     CleanupStack::Pop( ikev1SA );    

   314     }

   315 

   316 // ---------------------------------------------------------------------------

   317 // Updates IKE SA.

   318 // ---------------------------------------------------------------------------

   319 //

   320 void CIkev1PluginSession::UpdateIkev1SAL( TUint32 aSaId,

   321                                           TBool aExpired,

   322                                           TIkev1SAData* aIkev1SaData )

   323     {

   324     if ( !aExpired )

   325         {

   326         CIkev1SA* Ikev1SA = FindIkev1SAWithId( aSaId );

   327         if ( Ikev1SA )

   328             {

   329             Ikev1SA->UpdateSAL( aExpired, aIkev1SaData );

   330             }

   331         }

   332     else

   333         {

   334         ExpireIkev1SA( aSaId );

   335         }

   336     }

   337 

   338 // ---------------------------------------------------------------------------

   339 // Expires IKE SA.

   340 // ---------------------------------------------------------------------------

   341 //

   342 void CIkev1PluginSession::ExpireIkev1SA( TUint32 aSaId )

   343     {

   344     CIkev1SA* ikev1SA = FindIkev1SAWithId( aSaId );

   345     if ( ikev1SA )

   346         {

   347         ikev1SA->ExpireSA();

   348         }

   349     }

   350 

   351 // ---------------------------------------------------------------------------

   352 // Removes IKE SA.

   353 // ---------------------------------------------------------------------------

   354 //

   355 void CIkev1PluginSession::RemoveIkeSA( CIkev1SA* aIkev1Sa,

   356                                        TInt aStatus )

   357     {        

   358     TInt dpdRetryCount( 0 );

   359     

   360     for ( TInt i=0;i<iIkev1SAs.Count();i++ )

   361         {

   362         CIkev1SA* sa = iIkev1SAs[i]; 

   363         if ( aIkev1Sa == sa )

   364             {

   365             // Remove IKE SA from array.

   366             dpdRetryCount = sa->iHdr.iDPDRetry;

   367             iIkev1SAs.Remove(i);

   368             delete sa;

   369             break;

   370             }   

   371         }

   372     

   373     if ( (iErrorStatus == KErrNone) &&

   374          (dpdRetryCount > KMaxDpdRetryCount) &&

   375          (FindIkev1SA() == NULL) )

   376         {

   377         // If DPD retry count was reached for only IKE SA, set error status.

   378         iErrorStatus = KKmdIkeNoResponseErr;        

   379         }

   380         

   381     // If session deletion has been requested, complete session deletion

   382     // request.        

   383     DoCompleteDeleteSession( aStatus );

   384         

   385     // If fatal error has occured, complete error notification.    

   386     if ( iErrorStatus != KErrNone )

   387         {

   388         DoHandleError( iErrorStatus );

   389         }

   390     }

   391 

   392 // IKE SA find methods.

   393 

   394 CIkev1SA* CIkev1PluginSession::FindIkev1SA()

   395     {

   396     for ( TInt i=0;i<iIkev1SAs.Count();i++ )

   397         {

   398         CIkev1SA* sa = iIkev1SAs[i]; 

   399         if ( (!sa->IsExpired()) )

   400             {

   401             return sa;

   402             }   

   403         }

   404     return NULL;

   405     }

   406 

   407 CIkev1SA* CIkev1PluginSession::FindIkev1SA( const TCookie& aCookie_I,

   408                                             const TCookie& aCookie_R )

   409     {

   410     for ( TInt i=0;i<iIkev1SAs.Count();i++ )

   411         {

   412         CIkev1SA* sa = iIkev1SAs[i]; 

   413         if ( (sa->iHdr.iCookie_I ==  aCookie_I) &&

   414              (sa->iHdr.iCookie_R ==  aCookie_R) &&

   415              (!sa->IsExpired()) )

   416             {

   417             return sa;

   418             }   

   419         }

   420     return NULL;

   421     }

   422 

   423 CIkev1SA* CIkev1PluginSession::FindIkev1SAWithId( TUint32 aSaId )

   424     {

   425     for ( TInt i=0;i<iIkev1SAs.Count();i++ )

   426         {

   427         CIkev1SA* sa = iIkev1SAs[i]; 

   428         if ( (sa->iHdr.iSAId == aSaId) &&

   429              (!sa->IsExpired()) )

   430             {

   431             return sa;

   432             }   

   433         }

   434     return NULL;

   435     }

   436 

   437 CIkev1SA* CIkev1PluginSession::FindIkev1SA( const TInetAddr& aAddr )

   438     {

   439     for ( TInt i=0;i<iIkev1SAs.Count();i++ )

   440         {

   441         CIkev1SA* sa = iIkev1SAs[i]; 

   442         if (  sa->iHdr.iRemoteAddr.Match(aAddr) &&

   443               (!sa->IsExpired()) ) 

   444             {

   445             return sa;

   446             }   

   447         }

   448     return NULL;

   449     }

   450 

   451 CIkev1SA* CIkev1PluginSession::FindIkev1SA( const TInetAddr& aAddr,

   452                                             TUint32 aInboundSpi )

   453     {

   454     for ( TInt i=0;i<iIkev1SAs.Count();i++ )

   455         {

   456         CIkev1SA* sa = iIkev1SAs[i]; 

   457         if (  sa->iHdr.iRemoteAddr.Match(aAddr) &&

   458               (!sa->IsExpired()) ) 

   459             {

   460             if ( sa->FindIpsecSPI(aInboundSpi, ETrue) )

   461                 {

   462                 return sa;

   463                 }

   464             }   

   465         }

   466     return NULL;

   467     }

   468 

   469 TIkev1SAData* CIkev1PluginSession::FindIkev1SAData()

   470     {

   471     TIkev1SAData* saData = NULL;        

   472     CIkev1SA* ikev1SA = FindIkev1SA();

   473     if ( ikev1SA )

   474         {

   475         saData = (TIkev1SAData*)&ikev1SA->iHdr;

   476         }

   477     return saData;

   478     }

   479 

   480 TIkev1SAData* CIkev1PluginSession::FindIkev1SAData( const TCookie& aCookie_I,

   481                                                     const TCookie& aCookie_R )

   482     {

   483     TIkev1SAData* saData = NULL;        

   484     CIkev1SA* ikev1SA = FindIkev1SA( aCookie_I, aCookie_R );

   485     if ( ikev1SA )

   486         {

   487         saData = (TIkev1SAData*)&ikev1SA->iHdr;

   488         }

   489     return saData;

   490     }

   491 

   492 TIkev1SAData* CIkev1PluginSession::FindIkev1SAData( TUint32 aSaId )

   493     {

   494     TIkev1SAData* saData = NULL;        

   495     CIkev1SA* ikev1SA = FindIkev1SAWithId( aSaId );

   496     if ( ikev1SA )

   497         {

   498         saData = (TIkev1SAData*)&ikev1SA->iHdr;

   499         }

   500     return saData;

   501     }

   502 

   503 TIkev1SAData* CIkev1PluginSession::FindIkev1SAData( const TInetAddr& aAddr,

   504                                                     TUint32 aInboundSpi )

   505     {

   506     TIkev1SAData* saData = NULL;        

   507     CIkev1SA* ikev1SA = FindIkev1SA( aAddr, aInboundSpi );

   508     if ( ikev1SA )

   509         {

   510         saData = (TIkev1SAData*)&ikev1SA->iHdr;

   511         }

   512     return saData;

   513     }    

   514 

   515 TIkev1SAData* CIkev1PluginSession::FindIkev1SADataWithAddr( const TInetAddr& aAddr )

   516     {

   517     TIkev1SAData* saData = NULL;        

   518     CIkev1SA* ikev1SA = FindIkev1SA( aAddr );

   519     if ( ikev1SA )

   520         {

   521         saData = (TIkev1SAData*)&ikev1SA->iHdr;

   522         }

   523     return saData;

   524     }    

   525 

   526 // ---------------------------------------------------------------------------

   527 // Handles IPsec SA deletion request.

   528 // ---------------------------------------------------------------------------

   529 //

   530 void CIkev1PluginSession::DeleteIpsecSAL( TIkev1SAData* aIkev1SaData,

   531                                           TIpsecSPI* aIpsecSpi )

   532     {

   533     //

   534     // Send a delete payload for specified IPSec SA 

   535     //

   536     CIkev1Negotiation* negotiation = CIkev1Negotiation::NewL( this,

   537                                                               iPFKeySocketIf,

   538                                                               iDebug,                                                              

   539                                                               aIkev1SaData,

   540                                                               RESPONDER );

   541     CleanupStack::PushL( negotiation );

   542     negotiation->SendDeleteL( aIpsecSpi->iProtocol,

   543                               aIpsecSpi->iSPI );

   544     CleanupStack::PopAndDestroy( negotiation );

   545     }

   546 

   547 // ---------------------------------------------------------------------------

   548 // Deletes IPsec SAs.

   549 // ---------------------------------------------------------------------------

   550 //

   551 void CIkev1PluginSession::DeleteIpsecSAs( TUint32 aSaId )

   552     {

   553     CIkev1SA* ikev1SA = FindIkev1SAWithId( aSaId );

   554     if ( ikev1SA )

   555         {

   556         ikev1SA->DeleteIpsecSAs(); 

   557         }   

   558     }

   559 

   560 // ---------------------------------------------------------------------------

   561 // Deletes IPsec SPI.

   562 // ---------------------------------------------------------------------------

   563 //

   564 TBool CIkev1PluginSession::DeleteIpsecSpi( TUint32 aSaId,

   565                                            TUint32 aSpi,

   566                                            TBool aInbound )

   567     {

   568     TBool status = EFalse;

   569     CIkev1SA* ikev1SA = FindIkev1SAWithId( aSaId );

   570     if ( ikev1SA )

   571         {

   572         status = ikev1SA->DeleteIpsecSPI( aSpi, aInbound );

   573         }

   574     return status;

   575     }

   576 

   577 // ---------------------------------------------------------------------------

   578 // Adds IPsec SPI to IKE SA.

   579 // ---------------------------------------------------------------------------

   580 //

   581 void CIkev1PluginSession::AddIpsecSPIToSAL( TUint32 aSaId,

   582                                             TIpsecSPI& aIpsecSpi )

   583     {

   584     CIkev1SA* ikev1SA = FindIkev1SAWithId( aSaId );

   585     if ( ikev1SA )

   586         {

   587         ikev1SA->AddIpsecSPIL( aIpsecSpi );

   588         }

   589     }

   590 

   591 // ---------------------------------------------------------------------------

   592 // Returns dialog anchor.

   593 // ---------------------------------------------------------------------------

   594 //

   595 CIkev1Dialog** CIkev1PluginSession::DialogAnchor()

   596     {

   597     return &iDialogWaitQueue;

   598     }

   599 

   600 // ---------------------------------------------------------------------------

   601 // Returns debug trace interface.

   602 // ---------------------------------------------------------------------------

   603 //

   604 MIkeDebug& CIkev1PluginSession::Debug()

   605     {

   606     return iDebug;

   607     }

   608 

   609 // ---------------------------------------------------------------------------

   610 // Gets SA id.

   611 // ---------------------------------------------------------------------------

   612 //

   613 TUint32 CIkev1PluginSession::GetSAId()

   614     {

   615     iSAIdSeed++;

   616     return iSAIdSeed;

   617     }

   618 

   619 // ---------------------------------------------------------------------------

   620 // Deletes ISAKMP SAs.

   621 // ---------------------------------------------------------------------------

   622 //

   623 void CIkev1PluginSession::DeleteISAKMPSAsL( TDeleteISAKMP* aDeletePayload,

   624                                             const CIkev1Negotiation& aInfoNegotiation )

   625     {

   626     TCookie cookie_I, cookie_R;

   627 

   628     // It should always be only one.

   629     for ( TInt i=0; i < aDeletePayload->NumSPI(); i++ )

   630         {

   631         if ( aDeletePayload->SPISize() < 2 * ISAKMP_COOKIE_SIZE ) //The ISAKMPSA SPI is the union of both cookies

   632             {

   633             DEBUG_LOG( _L("Bad SPI Size for a ISAKMP SA. (SA Not deleted)") );

   634             return;

   635             }

   636         cookie_I.Copy( aDeletePayload->SPI(i), ISAKMP_COOKIE_SIZE );

   637         cookie_R.Copy( aDeletePayload->SPI(i) + ISAKMP_COOKIE_SIZE,

   638                        ISAKMP_COOKIE_SIZE);

   639 

   640         CIkev1Negotiation* neg = iFirstNegotiation;

   641         while ( neg )

   642             {

   643             CIkev1Negotiation* current = neg;

   644             neg = neg->iNext;

   645 

   646             // Delete any active negotiations with the same cookies.

   647             // Currently used negotiation is not deleted.

   648             if ( ( current != &aInfoNegotiation ) &&

   649                  ( current->iCookie_I == cookie_I ) &&

   650                  ( current->iCookie_R == cookie_R ) )

   651                 {

   652                 DEBUG_LOG( _L("Active negotiation deleted.") );

   653                 delete current;

   654                 current = NULL;

   655                 }

   656             }

   657         

   658         // Expire IKE SA.

   659         TIkev1SAData* sa = FindIkev1SAData( cookie_I, cookie_R );

   660         if ( sa )

   661             {

   662             UpdateIkev1SAL( sa->iSAId, ETrue );

   663             }

   664         }

   665     }

   666 

   667 // ---------------------------------------------------------------------------

   668 // Gets local IP address.

   669 // ---------------------------------------------------------------------------

   670 //

   671 TInt CIkev1PluginSession::GetLocalAddress( TInetAddr& aAddr )

   672     {

   673     TInt err( KErrNone );

   674     if ( iLocalAddr.IsUnspecified() )

   675         {

   676         err = iDataInterface.GetLocalAddress( iLocalAddr );

   677         }

   678     

   679     aAddr = iLocalAddr;

   680     return err;

   681     }

   682 

   683 // ---------------------------------------------------------------------------

   684 // Sends IKE message.

   685 // ---------------------------------------------------------------------------

   686 //    

   687 void CIkev1PluginSession::SendIkeMsgL( const TDesC8& aIkeMsg,

   688                                        TInetAddr& aDestAddr,

   689                                        TBool aUseNatPort )

   690     {

   691     // Construct buffer for storing IKE message data.

   692     TInt localPort = ( aUseNatPort ?

   693                        IkeSocket::KIkePort4500 :

   694                        IkeSocket::KIkePort500 );    

   695     TInt length = aIkeMsg.Length();    

   696     if ( localPort == IkeSocket::KIkePort4500 )

   697         {

   698         // Reserve space for <non-ESP marker>.

   699         length += NON_ESP_MARKER_SIZE;

   700         }    

   701     HBufC8* ikeMsg = HBufC8::NewL( length );    

   702     TPtr8 ptr = ikeMsg->Des();    

   703     if ( localPort == IkeSocket::KIkePort4500 )

   704         {    

   705         // Append <non-ESP marker> to the beginning of IKE message.

   706         TUint32 nonEspMarker = NON_ESP_MARKER;        

   707         TUint8* nonEspPtr = (TUint8*)&nonEspMarker;

   708         ptr.Append( nonEspPtr, NON_ESP_MARKER_SIZE );

   709         } 

   710     // Append IKE message data to descriptor.

   711     ptr.Append( aIkeMsg );    

   712     

   713     DoSendUdpDataL( ikeMsg, // Ownership transferred.

   714                     aDestAddr,

   715                     localPort,

   716                     0 );

   717     }

   718 

   719 // ---------------------------------------------------------------------------

   720 // Sends NAT keep-alive packet.

   721 // ---------------------------------------------------------------------------

   722 //    

   723 void CIkev1PluginSession::SendNatKeepAliveL( TInetAddr& aDestAddr,

   724                                              const TDesC8& aData,

   725                                              TUint8 aDscp )

   726     {

   727     DEBUG_LOG(_L("CIkev1PluginSession::SendNatKeepAliveL"));

   728     HBufC8* udpData = HBufC8::NewL( aData.Length() );

   729     *udpData = aData;

   730     TInt localPort = aDestAddr.Port();

   731     DoSendUdpDataL( udpData, // Ownership transferred.

   732                     aDestAddr,

   733                     localPort,

   734                     aDscp );

   735     }

   736 

   737 // ---------------------------------------------------------------------------

   738 // Sends Nokia NAT keep-alive packet.

   739 // ---------------------------------------------------------------------------

   740 //    

   741 void CIkev1PluginSession::SendNokiaNatKeepAliveL( TInetAddr& aDestAddr,

   742                                                   const TDesC8& aData,

   743                                                   TUint8 aDscp )    

   744     {

   745     DEBUG_LOG(_L("CIkev1PluginSession::SendNokiaNatKeepAliveL"));

   746     SendNatKeepAliveL( aDestAddr,

   747                        aData,

   748                        aDscp );

   749     }

   750 

   751 // ---------------------------------------------------------------------------

   752 // Handles completion of IKE SA establishment.

   753 // ---------------------------------------------------------------------------

   754 //    

   755 void CIkev1PluginSession::IkeSaCompleted( TInt aStatus,

   756                                           CInternalAddress* aInternalAddress )

   757     {

   758     delete iInternalAddress;

   759     iInternalAddress = aInternalAddress;

   760     

   761     DoCompleteNegotiateWithHost( aStatus );

   762     }

   763 

   764 // ---------------------------------------------------------------------------

   765 // Deletes negotiation object.

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

   767 //    

   768 void CIkev1PluginSession::DeleteNegotiation( CIkev1Negotiation* aNegotiation )

   769     {

   770     TInt err = ErrorStatus();

   771     delete aNegotiation;        

   772     

   773     if ( err == KErrNone &&

   774          (iClientStatusNegotiate != NULL ||

   775           iClientStatusDelete != NULL) &&

   776          (FindIkev1SA() == NULL) )

   777         {

   778         // If negotiate or delete session request has been issued, and

   779         // there are no IKE SAs, client is completed with error.

   780         err = KKmdIkeNegotFailed;

   781         }

   782 

   783     DEBUG_LOG1(_L("IKEv1 negotiation deleted, status=%d"),

   784             err );

   785     

   786     if ( err != KErrNone )

   787         {

   788         //

   789         // IKE negotiation failed.

   790         //

   791         DoHandleError( err );

   792         }        

   793     }

   794 

   795 // Negotiation linking and find methods.

   796 

   797 void CIkev1PluginSession::LinkNegotiation( CIkev1Negotiation* aNegotiation )

   798     {  

   799     aNegotiation->iNext = iFirstNegotiation;  

   800     iFirstNegotiation = aNegotiation; 

   801     }    

   802     

   803 CIkev1Negotiation* CIkev1PluginSession::FirstNegotiation()

   804     {

   805     return iFirstNegotiation;

   806     }

   807 

   808 CIkev1Negotiation* CIkev1PluginSession::FindNegotiation( TCookie aInit,

   809                                                          TCookie aResp,

   810                                                          TUint8 aExchange,

   811                                                          TUint32 aMsgId )

   812     {

   813     CIkev1Negotiation* negotiation;

   814     TCookie NULL_COOKIE;

   815     NULL_COOKIE.FillZ(ISAKMP_COOKIE_SIZE);

   816 

   817     if ( aExchange == ISAKMP_EXCHANGE_INFO )

   818         {

   819         for ( negotiation = iFirstNegotiation;

   820               negotiation;

   821               negotiation = negotiation->iNext )

   822             {

   823             if ( (negotiation->iCookie_I.Compare(aInit) == 0 ) &&

   824                  ((negotiation->iCookie_R.Compare(aResp) == 0 ) ||

   825                    (negotiation->iCookie_R.Compare(NULL_COOKIE) == 0)) )

   826                 {   

   827                 return negotiation;

   828                 }   

   829             }

   830         

   831         }   

   832     else

   833         {

   834         for ( negotiation = iFirstNegotiation;

   835               negotiation;

   836               negotiation = negotiation->iNext )

   837             {            

   838             if ( negotiation->iCookie_I.Compare(aInit) == 0 )

   839                 {

   840                 if ( (negotiation->iMessageId == aMsgId) ||

   841                      (negotiation->iMessageId == 0) )

   842                     {

   843                     if ( (negotiation->iCookie_R.Compare(aResp) == 0 ) ||

   844                          (negotiation->iCookie_R.Compare(NULL_COOKIE) == 0) ||

   845                          (aResp.Compare(NULL_COOKIE) == 0) )

   846                         {

   847                         return negotiation;

   848                         }

   849                     }

   850                 }

   851             }           

   852         }   

   853 

   854     return NULL; // Not found

   855     }

   856 

   857 CIkev1Negotiation* CIkev1PluginSession::FindNegotiation( TUint32 aSaId )

   858     {

   859     //

   860     // Find IKEv1 negotiation object using SA id as search argument 

   861     //

   862     CIkev1Negotiation* negotiation = iFirstNegotiation;

   863     while ( negotiation )

   864         {

   865         if ( negotiation->SAId() == aSaId )

   866             {   

   867             break;

   868             }   

   869 

   870         negotiation = negotiation->iNext;

   871         }   

   872     return negotiation;     

   873     }

   874 

   875 void CIkev1PluginSession::RemoveNegotiation( CIkev1Negotiation* aNegotiation )

   876     {

   877     CIkev1Negotiation* prev = NULL;

   878     CIkev1Negotiation* negotiation  = iFirstNegotiation;

   879     

   880     while ( negotiation )

   881         {

   882         if ( negotiation == aNegotiation )

   883             {

   884             if ( prev )

   885                 {

   886                 prev->iNext = negotiation->iNext;

   887                }

   888            else 

   889                {

   890                iFirstNegotiation = negotiation->iNext;

   891                }

   892             break;  

   893             }

   894         prev = negotiation;

   895         negotiation = negotiation->iNext;

   896         }   

   897     }

   898 

   899 // ---------------------------------------------------------------------------

   900 // Handles completion of authentication dialog processing.

   901 // ---------------------------------------------------------------------------

   902 //    

   903 TInt CIkev1PluginSession::AuthDialogCompletedL( CAuthDialogInfo* aUserInfo )

   904     {

   905     CIkev1Negotiation* negotiation = FindNegotiation( aUserInfo->SAId() );

   906     if ( negotiation )

   907         {

   908         DEBUG_LOG1( _L("Dialog completed for SAID: %d"),

   909                 aUserInfo->SAId() );

   910         

   911         negotiation->AuthDialogCompletedL(aUserInfo);

   912         if ( negotiation->Finished() )

   913             {

   914             DeleteNegotiation( negotiation );

   915             }   

   916         return KErrNone;

   917         }   

   918     DEBUG_LOG1( _L("Dialog completed, no negotiation found for SAID: %d"),

   919             aUserInfo->SAId() );

   920     return KErrNotFound;

   921     }

   922 

   923 

   924 // ---------------------------------------------------------------------------

   925 // Handles change of internal address.

   926 // ---------------------------------------------------------------------------

   927 //    

   928 TBool CIkev1PluginSession::InternalAddressChangedL( const CInternalAddress& aInternalAddr )

   929     {

   930     TBool internalAddressChanged( ETrue );

   931     

   932     if ( iInternalAddress )

   933         {

   934         if ( iInternalAddress->iClientIntAddr.Match(aInternalAddr.iClientIntAddr) )                    

   935             {

   936             internalAddressChanged = EFalse;

   937             }

   938         }        

   939     

   940     delete iInternalAddress;

   941     iInternalAddress = NULL;

   942     iInternalAddress = CInternalAddress::NewL( aInternalAddr );

   943     

   944     if ( internalAddressChanged )

   945         {

   946         DoCompleteInternalAddressChanged( KErrNone );

   947         }

   948     

   949     return internalAddressChanged;

   950     }

   951 

   952 // ---------------------------------------------------------------------------

   953 // Gets acceptable IPsec policies for specified selectors.

   954 // ---------------------------------------------------------------------------

   955 //

   956 CIpsecSaSpecList* CIkev1PluginSession::GetIpseSaSpecListLC( const TInetAddr& aLocalAddr, const TInetAddr& aLocalMask, 

   957                                                             const TInetAddr& aRemoteAddr, const TInetAddr& aRemoteMask,

   958                                                             TInt aProtocol )

   959 

   960     {

   961     return iPlugin.GetIpseSaSpecListLC( aLocalAddr, aLocalMask, 

   962                                         aRemoteAddr, aRemoteMask,

   963                                         aProtocol, iVpnNetId );

   964     }

   965 

   966 // ---------------------------------------------------------------------------

   967 // Matches destination address to remote address in IKE policy data.

   968 // ---------------------------------------------------------------------------

   969 //

   970 TBool CIkev1PluginSession::MatchDestinationAddress( const TInetAddr& aDestAddr )

   971     {

   972     TBool match( EFalse );

   973     

   974     if ( iIkeData )

   975         {

   976         match = iIkeData->iAddr.Match( aDestAddr );

   977         }    

   978     return match;

   979     }

   980 

   981 // ---------------------------------------------------------------------------

   982 // Handles fatal error.

   983 // ---------------------------------------------------------------------------

   984 //

   985 void CIkev1PluginSession::HandleError( TInt aStatus )

   986     {

   987     DoHandleError( aStatus );

   988     }

   989 

   990 // ---------------------------------------------------------------------------

   991 // Returns error status.

   992 // ---------------------------------------------------------------------------

   993 //

   994 TInt CIkev1PluginSession::ErrorStatus()

   995     {

   996     return iErrorStatus;

   997     }

   998 

   999 // ---------------------------------------------------------------------------

  1000 // Sets error status.

  1001 // ---------------------------------------------------------------------------

  1002 //

  1003 void CIkev1PluginSession::SetErrorStatus( TInt aStatus )

  1004     {

  1005     if ( iErrorStatus == KErrNone )

  1006         {

  1007         iErrorStatus = aStatus;

  1008         }

  1009     }

  1010 

  1011 // ---------------------------------------------------------------------------

  1012 // Returns VPN IAP id.

  1013 // ---------------------------------------------------------------------------

  1014 //

  1015 TUint32 CIkev1PluginSession::VpnIapId()

  1016     {

  1017     return iVpnIapId;

  1018     }

  1019 

  1020 // ---------------------------------------------------------------------------

  1021 // Returns VPN interface index.

  1022 // ---------------------------------------------------------------------------

  1023 //

  1024 TUint32 CIkev1PluginSession::VpnInterfaceIndex()

  1025     {

  1026     return iVpnInterfaceIndex;

  1027     }

  1028 

  1029 // ---------------------------------------------------------------------------

  1030 // Returns IKE policy data.

  1031 // ---------------------------------------------------------------------------

  1032 //

  1033 CIkeData& CIkev1PluginSession::IkeData()

  1034     {

  1035     __ASSERT_DEBUG( iIkeData != NULL,

  1036                     User::Invariant() );

  1037     return *iIkeData;

  1038     }

  1039 

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

  1041 // Returns UID.

  1042 // ---------------------------------------------------------------------------

  1043 //

  1044 TUint32 CIkev1PluginSession::Uid()

  1045     {

  1046     return iPlugin.Uid();

  1047     }

  1048 

  1049 // ---------------------------------------------------------------------------

  1050 // Returns event logger interface.

  1051 // ---------------------------------------------------------------------------

  1052 //

  1053 MKmdEventLoggerIf& CIkev1PluginSession::EventLogger()

  1054     {

  1055     return iPlugin.EventLogger();

  1056     }      

  1057 

  1058 // ---------------------------------------------------------------------------

  1059 // Returns internal address (NULL if does not exist). 

  1060 // ---------------------------------------------------------------------------

  1061 //

  1062 CInternalAddress* CIkev1PluginSession::InternalAddressL()

  1063     {

  1064     DEBUG_LOG(_L("CIkev1PluginSession::InternalAddressL"));

  1065     

  1066     CInternalAddress* internalAddress = NULL;

  1067     if ( iInternalAddress != NULL )

  1068         {

  1069         internalAddress = CInternalAddress::NewL( *iInternalAddress );    

  1070         }

  1071     return internalAddress;            

  1072     }

  1073 

  1074 // ---------------------------------------------------------------------------

  1075 // From class MIkev1SenderCallback

  1076 // Handles completion of sending.

  1077 // ---------------------------------------------------------------------------

  1078 //

  1079 void CIkev1PluginSession::SendUdpDataCompleted( TInt aStatus )

  1080     {    

  1081     if ( iSendQueue.Count() != 0 )

  1082         {

  1083         // Send queue is not empty.

  1084         // Send next item from queue.

  1085         TIkeSendQueueItem item = iSendQueue[0];

  1086         HBufC8* udpData = item.UdpData();

  1087         TInetAddr destAddr = item.DestAddr();

  1088         TInt localPort = item.LocalPort();

  1089         TUint8 dscp = item.Dscp();

  1090         iSendQueue.Remove(0);

  1091         DoSendUdpData( udpData,

  1092                        destAddr,

  1093                        localPort,

  1094                        dscp );

  1095         

  1096         }

  1097     else

  1098         {

  1099         // IKE message send queue is empty.

  1100         // If session deletion has been requested, complete request.

  1101         DoCompleteDeleteSession( aStatus );

  1102         }

  1103     }

  1104 

  1105 // ---------------------------------------------------------------------------

  1106 // Handles PFKEY message.

  1107 // ---------------------------------------------------------------------------

  1108 //

  1109 void CIkev1PluginSession::PfkeyMessageReceived( const TPfkeyMessage& aPfkeyMessage )

  1110     {

  1111     TRAPD( err, DoPfkeyMessageReceivedL( aPfkeyMessage) );

  1112     err = err;

  1113     DEBUG_LOG1(_L("CIkev1PluginSession::PfkeyMessageReceivedL, err=%d"), err);

  1114     }

  1115 

  1116 // Methods to build and send PFKEY API primitives to IPsec

  1117 

  1118 void CIkev1PluginSession::AcquireSAError( TIpsecSAData& aSAData,

  1119                                           TInt aError )

  1120     {

  1121     iPlugin.AcquireSAError( aSAData, aError );

  1122     }

  1123 

  1124 void CIkev1PluginSession::UpdateSAL( TIpsecSAData& aSaData )

  1125     {

  1126     iPlugin.UpdateSAL( aSaData );

  1127     }

  1128 

  1129 void CIkev1PluginSession::AddSAL( TIpsecSAData& aSaData )

  1130     {

  1131     iPlugin.AddSAL( aSaData );

  1132     }

  1133 

  1134 void CIkev1PluginSession::DeleteIpsecSA( TIpsecSPI& aIpsecSpi )