/*

* Copyright (c) 2000 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: Implementation of terminalsecurity components

*

*/

// INCLUDE FILES

#include <e32base.h>

#include <e32std.h>

#include <ecom/implementationproxy.h>

#include <SCPParamObject.h>

#include <featmgr.h>

#include "SCPPatternPlugin.h"

#include "SCP_IDs.h"

// ============================= LOCAL FUNCTIONS  =============================

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

// ----------------------------------------------------------------------------

// CSCPPatternPlugin::NewL

// Two-phased contructor

// (static, may leave)

// Status : Approved

// ----------------------------------------------------------------------------

//

CSCPPatternPlugin* CSCPPatternPlugin::NewL()

    {

	CSCPPatternPlugin* self = new ( ELeave ) CSCPPatternPlugin();

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( self );

    Dprint ( ( _L( "( 0x%x ) CSCPPatternPlugin::NewL()" ), self ) );

    return self;

    }

// ----------------------------------------------------------------------------

// CSCPPatternPlugin::CSCPPatternPlugin

// Constructor

// Status : Approved

// ----------------------------------------------------------------------------

//

CSCPPatternPlugin::CSCPPatternPlugin()   

    {

    Dprint ( ( _L( "CSCPPatternPlugin::CSCPPatternPlugin()" ) ) );

    return;

    }

// ----------------------------------------------------------------------------

// CSCPPatternPlugin::ConstructL

// 2nd phase construction

// (may leave)

// Status : Approved

// ----------------------------------------------------------------------------

//

void CSCPPatternPlugin::ConstructL()

    {       

    FeatureManager::InitializeLibL();

	if(!FeatureManager::FeatureSupported(KFeatureIdSapDeviceLockEnhancements))

	{

    	FeatureManager::UnInitializeLib();

   		User::Leave( KErrNotSupported );

  	}

   	FeatureManager::UnInitializeLib();    

    Dprint ( ( _L( "CSCPPatternPlugin::ConstructL()" ) ) );

    return;

    }

// ----------------------------------------------------------------------------

// CSCPPatternPlugin::~CSCPPatternPlugin

// Destructor

// Status : Approved

// ----------------------------------------------------------------------------

//

CSCPPatternPlugin::~CSCPPatternPlugin()

    {

    Dprint( ( _L( "CSCPPatternPlugin::~CSCPPatternPlugin()" ) ) ) ;

	// Closes the resource file reader. 

	// This function is called after finishing reading all resources

    iRf.Close();   

    return;

    }

// ----------------------------------------------------------------------------

// CSCPPatternPlugin::HandleEvent

// 

// 

// Status : Approved

// ----------------------------------------------------------------------------

//    

	{	

	Dprint ( ( _L( "CSCPPatternPlugin::HandleEvent()" ) ) );

	TBool isInvalid = EFalse;

	// check for Case

    switch ( aID )

        {

        case ( KSCPEventValidate ):

            {

		     // Get required params for bounds

			CSCPParamObject& config = iEventHandler->GetParameters();	

			TBool argumentError = EFalse;

			// These are the dault values for ThisPlugIn's functions

			TInt passcodeminlength, passcodemaxlength, passcodemaxrepeatedcharacters, passcodeminspecialcharacters;

			TBool passcoderequireupperandlower, passcoderequirecharsandnumbers, passcodeconsecutivenumbers, passcodedisallowsimple;

			// Get Values with ID's

			if ( config.Get( ( RTerminalControl3rdPartySession::EPasscodeMinLength), 

				passcodeminlength ) !=  KErrNone )

					passcodeminlength = KSCPPasscodeMinLength;

			if ( config.Get( (RTerminalControl3rdPartySession::EPasscodeMaxLength),

				 passcodemaxlength ) !=  KErrNone )

					passcodemaxlength = KSCPPasscodeMaxLength;

			if ( config.Get( (RTerminalControl3rdPartySession::EPasscodeMaxRepeatedCharacters), 

				 passcodemaxrepeatedcharacters	 ) !=  KErrNone )

					passcodemaxrepeatedcharacters = 0;

			if ( config.Get( (RTerminalControl3rdPartySession::EPasscodeRequireCharsAndNumbers), 

				 passcoderequirecharsandnumbers ) !=  KErrNone )

					passcoderequirecharsandnumbers = EFalse;

			if ( config.Get( (RTerminalControl3rdPartySession::EPasscodeRequireUpperAndLower), 

				 passcoderequireupperandlower ) !=  KErrNone )

					passcoderequireupperandlower = EFalse;

			if ( config.Get( (RTerminalControl3rdPartySession::EPasscodeConsecutiveNumbers), 

				 passcodeconsecutivenumbers ) !=  KErrNone )

					passcodeconsecutivenumbers = EFalse;

            if ( config.Get( (RTerminalControl3rdPartySession::EPasscodeMinSpecialCharacters), 

                 passcodeminspecialcharacters   ) !=  KErrNone )

                    passcodeminspecialcharacters = 0;

            if ( config.Get( (RTerminalControl3rdPartySession::EPasscodeDisallowSimple), 

                 passcodedisallowsimple ) !=  KErrNone )

                    passcodedisallowsimple = EFalse;

            // Get the password from the paramObject

            TBuf<KSCPPasscodeMaxLength> password;

            if ( aParam.Get( KSCPParamPassword, password ) != KErrNone )

                {

                // Nothing to do anymore

                break;

        	// The first rule is to check if securitycode has any

        	// forbidden chars, like WhiteSpace etc...

        	// If so, there is a problem >> KErrArgument

			for (TInt c1=0; c1 < password.Length(); c1++)

			    {

			  TChar ch = static_cast<TChar>( password[c1] );

			  TChar::TCategory chCat = ch.GetCategory();

			  if ( ch.IsSpace() )

				    {   

					argumentError = ETrue;

					break;

				    }

			    }			 

			// Argument failure, not supposed to be! Out!

        	if (argumentError) break;

			// if all required bounds are zero, there is nothing to do.

			if ( passcodemaxlength != 0 || 

				 passcodeminlength != 0 ||

				 passcodemaxrepeatedcharacters != 0 ||

				 passcoderequireupperandlower ||

				 passcoderequirecharsandnumbers || 

				 passcodeconsecutivenumbers ||

				 passcodeminspecialcharacters != 0 ||

				 passcodedisallowsimple)

			    {			

				// Declare the Check flags										

				TBool istoosimilar = EFalse;					

				TBool consecutively = EFalse;

				TBool consecutivechars = ETrue;

				TBool singlerepeat = ETrue;

				TInt digitCount = 0;	// for passcoderequirecharsandnumbers

				TInt lowerCount = 0;	// for passcoderequireupperandlower

				TInt upperCount = 0;	// for passcoderequireupperandlower

				TInt alphaCount = 0;	// for passcoderequirecharsandnumbers

				TInt specialCount = 0;  // for passcodeminspecialcharacters

				TChar temp = '1';

			 	 // Check for required check or not.

	        	if (passcodeminlength != 0)

	        	    {

		        	// check for Min lenght

		            if (  password.Length() < passcodeminlength )

		                {

		                isInvalid = ETrue;

		                }

		        	// Check for required check or not.

		        		// Check for Max Lenght

		             	    {

		                    isInvalid = ETrue;

		           	    }

				    }

		  			// Check for required check or not.

		  			if ( passcodemaxrepeatedcharacters != 0 )

		  			    {

			  			// Check for TooManySameChars

			  			TRAPD( err, istoosimilar = TooManySameCharsL(password,passcodemaxrepeatedcharacters) );

					  	if ( ( err == KErrNone ) && ( istoosimilar ) )

				  	    }

	   				// Check for Alphadigit

	   				if ( passcoderequirecharsandnumbers)

	   				    {

	   					for (TInt adcounter=0; adcounter < password.Length(); adcounter++)

			  			    {						

							if ( static_cast<TChar>( password[adcounter] ).IsDigit() ) 

						  		digitCount++;

							if ( static_cast<TChar>( password[adcounter] ).IsAlpha() )

						  		alphaCount++;

						    }

		  				if (digitCount >= password.Length() || alphaCount >= password.Length()

		  				           || digitCount == 0 || alphaCount == 0 )

		  				    {

		  				    }

	   				    }	// End of Alphadigit Check

					// passcodeconsecutivenumbers

					if (passcodeconsecutivenumbers)

					    {

						consecutively = consecutivelyCheck(password);

						if ( consecutively )

						    {

		                    isInvalid = ETrue;

						    }

					    } 

		        	// Check for required check or not.

		        	if (passcoderequireupperandlower)

		        	    {

		        	    for (TInt counter=0; counter < password.Length(); counter++)

		  			    {

						if ( static_cast<TChar>( password[counter] ).IsAlpha() )

							{

							if ( static_cast<TChar>( password[counter] ).IsUpper() )

					  		upperCount++;

							if ( static_cast<TChar>( password[counter] ).IsLower() )

					  		lowerCount++;

							}

		  			    }

		  			    if ( upperCount == 0 || lowerCount == 0)

		  			    	{

		  			    	isInvalid = ETrue;

		  			    	}

                    // Check for required check or not.

                    if (passcodeminspecialcharacters != 0)

                        {

                        for (TInt specialcounter=0; specialcounter< password.Length(); specialcounter++)

                            {

                            if ( ! (static_cast<TChar>( password[specialcounter] ).IsAlpha() ) )

                                specialCount++;

                            }

                        if ( specialCount < passcodeminspecialcharacters )

                            {

                            isInvalid = ETrue;

                    	}

                    if (passcodedisallowsimple)

                        {

                        for (TInt counter=0; counter< (password.Length()-1); counter++)

                            {

                            if ( (static_cast<TChar>(password[counter])) != (static_cast<TChar>(password[counter+1])) )

                                {

                                singlerepeat = EFalse;

                                break;

                                }

                            }

                        if (singlerepeat)

                            {

                            isInvalid = ETrue;

                            }

                            for (TInt counter=0; counter< (password.Length()-1); counter++)

                                {

                                //The consecutivity to be checked with only Alphanumeric characters.

                                //The check is being made for only the increasing order. Decreasing order is left for