/*

* 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 "SCPSpecificStringsPlugin.h"

#include "SCP_IDs.h"

#include <featmgr.h>

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

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

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

// CSCPSpecificStringsPlugin::NewL

// Two-phased contructor

// (static, may leave)

// Status : Approved

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

//

CSCPSpecificStringsPlugin* CSCPSpecificStringsPlugin::NewL()

    {

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

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( self );

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

    return self;

    }

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

// CSCPSpecificStringsPlugin::CSCPSpecificStringsPlugin

// Constructor

// Status : Approved

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

//

CSCPSpecificStringsPlugin::CSCPSpecificStringsPlugin()

    {

    Dprint ( ( _L( "CSCPSpecificStringsPlugin::CSCPSpecificStringsPlugin()" ) ) );

    return;

    }

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

// CSCPSpecificStringsPlugin::ConstructL

// 2nd phase construction

// (may leave)

// Status : Approved

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

//

void CSCPSpecificStringsPlugin::ConstructL()

    {

    FeatureManager::InitializeLibL();

	if(!FeatureManager::FeatureSupported(KFeatureIdSapDeviceLockEnhancements))

	{

    	FeatureManager::UnInitializeLib();

   		User::Leave( KErrNotSupported );

  	}

   	FeatureManager::UnInitializeLib();

    return;

    }

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

// CSCPSpecificStringsPlugin::HandleEvent

// 

// 

// Status : Approved

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

//    

	{	

	if ( iFs == NULL )

	    {

	    }

	// check for Case

	switch ( aID )

	    {

		case ( KSCPEventValidate ) :

    		{   		

			TBool specificstringscheck;

			// Get params

			CSCPParamObject& config = iEventHandler->GetParameters();

			// Check if validation is required.

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

				  specificstringscheck ) !=  KErrNone )

				   specificstringscheck = EFalse;

			 if ( specificstringscheck )

			    {

			 	// Check for specific strings			 	

				// Get the configFile's path.

				// If this fails, there is something badly wrong(Private folder is not there)

				TInt errSCF = SetConfigFile ();

				if (errSCF != KErrNone)

				    {

					break; // Break out from Case!

				    }

			 	// Get the password from the paramObject

	     		TBuf<KSCPPasscodeMaxLength> securitycode;

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

                    {

                	// Nothing to do anymore

                   	Dprint( (_L("CSCPSpecificStringsPlugin::HandleEvent()\

                   	ERROR: KSCPEventPasswordChanged/KSCPParamPassword is  != KErrNone") ));

					break; // Break out from the Case!;

                    }			 	

			 	TBool forbiddensecuritycode = EFalse;

			 	TInt errCSS = CheckSpecificStrings ( securitycode, forbiddensecuritycode );

			 	if (errCSS != KErrNone)

				    {

					break; // Break out from Case!

    				}

			 	if ( forbiddensecuritycode )

			    	{

			    } // end of specificstringscheck

			break;

		    } // End of KSCPEventValidate

	    case ( KSCPEventRetrieveConfiguration ):

	        {

	        // This event is sent when a client wishes to retrieve the value for the given parameter.

	        // None of the parameters, which handle the string-buffer cannot be retrieved by anyone,

	        // so we'll return KErrNotSupported. Note that EPasscodeCheckSpecificStrings is OK to get.

	        // Get the ID from the paramObject   

	        TInt paramID = -1;    

			if ( aParam.Get( KSCPParamID, paramID ) != KErrNone )

			    {

				// Nothing to do anymore

				break;

    			}   

			if ( ( paramID ==  RTerminalControl3rdPartySession::EPasscodeDisallowSpecific )

				||  ( paramID ==  RTerminalControl3rdPartySession::EPasscodeAllowSpecific)

				||  ( paramID ==  RTerminalControl3rdPartySession::EPasscodeClearSpecificStrings) )

			    {

	                Dprint ( ( _L( "CSCPSpecificStringsPlugin::HandleEvent():\

	                    Get not supported for %d" ), paramID ) );

	            }

	        break;

	        }

		// same for All plugins

		case ( KSCPEventConfigurationQuery ):

    		{   		

			TInt paramID = -1; 

			// Get the ID from the paramObject      

			if ( aParam.Get( KSCPParamID, paramID ) != KErrNone )

			    {

				// Nothing to do anymore

				break;

			    }            

			if ( paramID == (RTerminalControl3rdPartySession::EPasscodeCheckSpecificStrings)

				||  paramID ==  (RTerminalControl3rdPartySession::EPasscodeDisallowSpecific)

				||  paramID ==  (RTerminalControl3rdPartySession::EPasscodeAllowSpecific)

				||  paramID ==  (RTerminalControl3rdPartySession::EPasscodeClearSpecificStrings) )

				TInt retStatus = KErrNone;

			    if ( paramID != RTerminalControl3rdPartySession::EPasscodeCheckSpecificStrings )

			        {

        		    // Set the storage attribute, so the server won't save the value,

        		    // we'll do it ourselves.

			        }

				switch ( paramID )

				    {

					case ( RTerminalControl3rdPartySession::EPasscodeCheckSpecificStrings ):

					    {

						// 1015				

						TInt paramValue;

						if ( (aParam.Get( KSCPParamValue, paramValue ) != KErrNone) ||

							 ( paramValue < 0 ) || 	( paramValue > 1 ) ) 

						       retStatus = KErrArgument;

					    break;

					    }

					// 1016

					// Handle param change for strings to block

					case ( RTerminalControl3rdPartySession::EPasscodeDisallowSpecific ):

					    {

						// Get the params value's length

						// If param length is not correct, there's something very wrong. out

						TInt paramlength = aParam.GetParamLength( KSCPParamValue );

						if ( paramlength <= 0)

						    {

							retStatus = KErrArgument;

							break; // from case!

						    }

						HBufC* paramvaluebuf = NULL;

						TRAPD( err, paramvaluebuf = HBufC::NewL( paramlength ) );

						if ( err != KErrNone )

						    {

						    retStatus = err;

						    break;

						    }

						TPtr paramptr = paramvaluebuf->Des();

						aParam.Get( KSCPParamValue, paramptr );

						// Check for basic test

						if ( IsNotValidWord ( paramptr ) )

						    {

							retStatus = KErrArgument;

							delete paramvaluebuf;

							break;

    						}

						// Send them to parser and store them

						TInt errgPS = KErrNone;

						TRAPD( err2, errgPS = ParseAndStoreL( paramptr ) );

						if ( err2 != KErrNone )

						    {

						    errgPS = err2;

						    }

						delete paramvaluebuf;

						if (errgPS != KErrNone)

						    {

							if (errgPS == KErrArgument)

							    {

								retStatus = KErrArgument;

								break; // from case!

							break; // Break out.

						    } 

					    break;

					    }

					// 1017

					// Handle param change for strings exclude from the list

					case ( RTerminalControl3rdPartySession::EPasscodeAllowSpecific ):

					    {

						// Get the params value's length

						// If param length is not correct, there's something very wrong. out

						TInt paramlength = aParam.GetParamLength( KSCPParamValue );

						if ( paramlength <= 0)

						    {

							retStatus = KErrArgument;

							break; // from case!

						    }

						HBufC* paramvaluebuf = NULL;

						TRAPD( err, paramvaluebuf = HBufC::NewL( paramlength ) );

						if ( err != KErrNone )

						    {

						    retStatus = err;

						    break;

						    }

						TPtr paramptr = paramvaluebuf->Des();

						aParam.Get( KSCPParamValue, paramptr );

						// Check for basic test

						if ( IsNotValidWord ( paramptr ) )

						    {

							retStatus = KErrArgument;

							delete paramvaluebuf;

							break;

						    }

						// Send the word to remover and gets them off the list

						TInt errgPR = KErrNone;

						TRAPD( err2, errgPR = ParseAndRemoveL( paramptr ) );

						if ( err2 != KErrNone )

						    {

						    errgPR = err2;

						    }

						delete paramvaluebuf;

						if (errgPR != KErrNone)

						    {

							if (errgPR == KErrArgument)

							    {

							    retStatus = KErrArgument;

								break; // from case!

							    }

							break; // Break out.

						    } 												

					    break;

					    }												

					case ( RTerminalControl3rdPartySession::EPasscodeClearSpecificStrings ):

					    {					

						// 1018, Flush the config file

						break;

					    }							

    				} // End of switch                          

			    }

			break;

		    } //End of KSCPEventConfigurationQuery Case

        case ( KSCPEventReset ):

              {

              // Reset the configuration for this plugin.

              TRAP_IGNORE( FlushConfigFileL() );

              break;

              }

	} // End of  switch ( aID )

	}

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

// CSCPSpecificStringsPlugin::SetEventHandler

// SetEventHandler

// 

// Status : Approved

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

//    

void CSCPSpecificStringsPlugin::SetEventHandler( MSCPPluginEventHandler* aHandler )

	{

	iEventHandler = aHandler;

	iFs = &(iEventHandler->GetFsSession());

	}	

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

// CSCPSpecificStringsPlugin::~CSCPSpecificStringsPlugin

// Destructor

// Status : Approved

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

//

CSCPSpecificStringsPlugin::~CSCPSpecificStringsPlugin()

    {

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

	iRf.Close();   

	return;

    }