23 #include <featdiscovery.h>

    24 #include <featureuids.h>

    25 #include <networking/pfkeyv2.h>

    26 #include <networking/ipsecerr.h>

    27 #include <e32std.h>

    28 

    29 #include "sa_spec.h"

   171 	void ParseSecurityBundleL(RPolicyActions &aBundle, CTransportSelector *aTS, CPolicySelector* aPs);//UMA support 

   173 	void CheckFeatureSupportL(TUid aFeature);

   174 	

   191 

   192 private:

   196 	TBool iIPSecGANSupported; //To check whether FF_IPSEC_UMA_SUPPORT_ENABLE is defined and UMA supported

   867 /**

   868 * Parse security actions

   869 * @code [ sa-name '(' [ address ] ')' ]* '}'

   870 * @endcode

   871 *

   872 * Parse a (possibly empty) list of references to security specifications. This will

   873 * be the bundle of security actions for a selector.

   874 *

   875 * @retval aActions The colleted actions

   876 * @param aTS The traffic selector.

   877 * @param aPS the policy selector

   878 * * This is called only when UMA/ GAN is supported.

   879 */

   880 void TParser::ParseSecurityBundleL(RPolicyActions &aActions, CTransportSelector *aTS, CPolicySelector *aPs)

   881     {

   882     

   883     LOG(Log::Printf(_L("TParser::ParseSecurityBundleL(RPolicyActions &aActions, CTransportSelector *aTS, CPolicySelector *aPs)")));

   884           

   885     if(iIPSecGANSupported)

   886         {

   887         LOG(Log::Printf(_L("TParser::ParseSecurityBundleL: UMA supported FF_IPSEC_UMA_SUPPORT_ENABLE defined")));

   888         }

   889     else

   890         {

   891         LOG(Log::Printf(_L("TParser::ParseSecurityBundleL:functionality not suppoted.FF_IPSEC_UMA_SUPPORT_ENABLE not defined")));

   892         User::Leave(KErrNotSupported);

   893         }

   894     

   895     _LIT(K_tunnel,  "tunnel");

   896 

   897     token_type val;

   898 

   899     TUint opt = 0;

   900     _LIT(K_Exception,  "UMAException");//UMA exception defined

   901     for (;;)

   902         {

   903         val = NextToken();

   904         //

   905         // Experimental addition, allow optional bundle items

   906         // by prefixing them with '?'...

   907         //

   908         if (opt == 0 && val == token_question)

   909             {

   910             opt = 1;

   911             continue;

   912             }

   913         else if (val != token_string)

   914             break;

   915         // A temporary(?) special kluge: if the keyword is 'tunnel'

   916         // assume this is a plain tunnel specification, without any

   917         // relation to the IPSEC. if nobody defined a "tunnel" sa

   918         // specification. (should probably disallow 'tunnel' as SA

   919         // spec name, to avoid confusion.. )

   920         //

   921         CPolicySpec *spec = iSp->FindSpec(iToken);

   922 

   923         if(spec== NULL && !iToken.Compare(K_Exception))

   924             {

   925             LOG(Log::Printf(_L("Found Exception Policy identifier")));

   926             //FInd Next token... Things looks hacky here. IPsec really need re-designing.

   927             TInt tokenVal = (TInt)NextToken();

   928             LOG(Log::Printf(_L("NextToken value is = [%d]"),tokenVal));

   929             

   930             TBuf8<32> buf;

   931             buf.Copy(iToken);

   932             TLex8 lex(buf);

   933             TInt scope;

   934             lex.Val(scope);

   935             

   936             //assiging scope to the policy. This will be policy selector with Exception scope being setalong with

   937             //exception flags

   938             aPs->iScope_Exception = scope;

   939             LOG(Log::Printf(_L("TParser::ParseSecurityBundleL, Exception tunnel Scope is = [%d]"),scope));

   940             while((val = NextToken())!= token_brace_right)

   941                 {

   942                 //do nothing 

   943                 }  //while    

   944             break;

   945             }

   946 

   947         // A temporary(?) special kluge: if the keyword is 'tunnel'

   948         // assume this is a plain tunnel specification, without any

   949         // relation to the IPSEC. if nobody defined a "tunnel" sa

   950         // specification. (should probably disallow 'tunnel' as SA

   951         // spec name, to avoid confusion.. )

   952         //

   953         if (spec == NULL && iToken.Compare(K_tunnel) != 0)

   954             User::Leave(EIpsec_PolicySpecNotFound);

   955 

   956         if (NextToken() != token_par_left)

   957             User::Leave(EIpsec_PolicyLeftParen);

   958 

   959         CPolicyAction *action = new (ELeave) CPolicyAction;

   960         if (aActions.Append(action) != KErrNone)

   961             {

   962             action->Close();

   963             User::Leave(KErrNoMemory);

   964             }

   965         if ((action->iSpec = spec) != NULL)

   966             spec->Open();

   967         // Record the current selector into each action (this is to make it

   968         // easier to generate the TS list into Acquire message).

   969         if ((action->iTS = aTS) != NULL)

   970             aTS->Open();

   971         action->iOptional = opt;

   972 

   973         if ((val = NextToken()) == token_string)

   974             {

   975             SetAddressOrEndPointL(action->iTunnel, 0, EIpsec_PolicyInvalidIpAddress);

   976             action->iIsTunnel = 1;  // Flag a tunnel.

   977             val = NextToken();

   978             }

   979         if (val != token_par_right)

   980             User::Leave(EIpsec_PolicyRightParen);

   981         opt = 0;        // Optional only affects single item at time.

   982         }

   983     if (val != token_brace_right)

   984         User::Leave(EIpsec_PolicyCloseBraceExpected);

   985     }

   986 

   987 /**

   988 * Parse security actions

   989 * @code [ sa-name '(' [ address ] ')' ]* '}'

   990 * @endcode

   991 *

   992 * Parse a (possibly empty) list of references to security specifications. This will

   993 * be the bundle of security actions for a selector.

   994 *

   995 * @retval aActions The colleted actions

   996 * @param aTS The traffic selector.

   997 * This is called in case of No UMA/ GAN support.

   998 */ 

  1029 

  1030         // A temporary(?) special kluge: if the keyword is 'tunnel'

  1031         // assume this is a plain tunnel specification, without any

  1032         // relation to the IPSEC. if nobody defined a "tunnel" sa

  1033         // specification. (should probably disallow 'tunnel' as SA

  1034         // spec name, to avoid confusion.. )

  1035         //

  1282 		KEYWORD("UMAExceptionTrafficSelector"), //UMA support

  1292 		KEYENUM(UMAExceptionTrafficSelector),//exception bits

  1301 

  1302     CheckFeatureSupportL(NFeature::KFeatureIdFfIpsecUmaSupportEnable);

  1303 

  1347 			case E_UMAExceptionTrafficSelector:

  1348                     if(iIPSecGANSupported)

  1349                         {

  1350                         //UMA support

  1351                         LOG(Log::Printf(_L("TParser::ParseSelectorL Setting Exception selector flag")));

  1352                    //The flags signifies special case for UMA/exception selectors. These selectors

  1353                    //will be present in case when there is no inbound and bypass filter data or selectors

  1354                    //are set. This selector will only allow traffic whose scope match the exception scope 

  1355                         aPs->iFilterData|=KPolicyFilter_Exception;

  1356                         aPs->iFilterMask |= KPolicyFilter_Exception;

  1357                         }

  1358                     else

  1359                         {

  1360                         LOG(Log::Printf(_L("TParser::ParseSelectorL error GAN/ UMA feature is not enabled ")));

  1361                         }

  1362 	               break;				

  1404     

  1405 	}

  1406 /**

  1407  * To check the feature support

  1408  */

  1409 void TParser::CheckFeatureSupportL(TUid aFeature)

  1410     {

  1411     // Check Gan support from feature manager

  1412     iIPSecGANSupported = CFeatureDiscovery::IsFeatureSupportedL(aFeature);

  1413     

  1414     if(iIPSecGANSupported != (TInt)ETrue)

  1415 		{

  1416 		LOG(Log::Printf(_L("TParser::CheckFeatureSupport Error Checking Feature Support")));

  1417 		}

  1418 		else

  1419 		{

  1420 		LOG(Log::Printf(_L("TParser::CheckFeatureSupport %d Feature Supported %d"),aFeature,iIPSecGANSupported));

  1421 		}