/*

* Copyright (c) 2002 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:  Terminal Control DM Adapter

*

*/

/*

./Terminal Security -+--> FileScan (E) -+--> Execute (E)

                                        |

                                        |

                                        |--> Results (G)

./Terminal Security -+--> FileDelete (E)

./Terminal Security -+--> DeviceWipe (E)

./Terminal Security -+--> Reboot (E)

./Terminal Security -+--> DeviceLock (G) -+--> Autolock Period : int (GR)

               |                      				

               |

               |--> LockLevel : int (GR)

               |

               |

               |--> LockCode : int (R)

               |

               |

               |--> Max Autolock Period : int (GR)

               |

               |--> Lock Code min length : int (GR)

               |

               |--> Lock Code max length : int (GR)

               |

               |--> Lock Code require upper and lower case letters : bool (GR)

               |

               |--> Lock Code require characters and numbers : bool (GR)

               |

               |--> Lock Code max repeated chars : int (GR)

               |

               |--> Lock Code history buffer : int (GR)

               |

               |--> Lock Code expiration : int (GR)

               |

               |--> Lock Code min change tolerance : int (GR)

               |

               |--> Lock Code min change interval : int (GR)

               |

               |--> Lock Code check specific strings : bool (GR)

               |

               |--> Lock Code disallow specific strings : chr (R)

               |

               |--> Lock Code allow specific strings : chr (R)

               |

               |--> Lock Code clear specific strings : null (E)

               |

               |--> Lock Code max attempts : int (GR)       

               |

               |--> Lock Code ConsecutiveNumbers : bool (GR)  

               |

               |--> Lock Code min special chars : int (GR)

               |

               |--> Lock code disallow simple : bool (GR)

./Terminal Security -+--> Local Operations (G) -+--> Start (E)

                                               |

                                               |

                                               |--> Stop (E)

./Terminal Security -+--> Processes (G) -+--> <X> * (G) -+--> ID (G)

                                                        |

                                                        |

                                                        |--> FromRAM (G)

                                                        |

                                                        |

                                                        |--> MemoryInfo (G)

                                                        |

                                                        |

                                                        |--> Filename (G)

*/

#ifdef __WINS__

#define __STIF_EMULATOR_TESTING__

#endif

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

#include "tcadapter.h"

// symbian

#ifndef __WINS_DEBUG_TESTING__

    #include <implementationproxy.h> // For TImplementationProxy definition

#endif

#include <fbs.h>

#include <f32file.h>

// s60

// tarm

#include <DMCert.h>

#include <SettingEnforcementInfo.h>

#include <PolicyEngineXACML.h>

#include "nsmldmuri.h"

#include "TPtrC8I.h"

#ifdef __Sml_DEBUG__

#pragma message("Sml Debugging is ON!")

#endif

#include "debug.h"

#include <featmgr.h>

const TInt KFlatBufSize = 128;

const TInt KFlatMimeBufSize = 20;

#if defined( __WINS_DEBUG_TESTING__ ) || defined ( __STIF_EMULATOR_TESTING__ )

_LIT( KDebugFileName, "C:\\tcadapter.log" );

#endif

const TInt CTcAdapter::iAccessTypeList[ETcNodeNotUsedAndAlwaysLast+1] =

    {

    /*ETcNodeTerminalControl*/     CTcAdapter::EGet

    ,/*ETcNodeFileScan*/            CTcAdapter::EExecute

#ifdef TCADAPTER_FILESCAN_EXECUTE_LEAF

    ,/*ETcNodeFileScanExecute*/     CTcAdapter::EExecute

#endif

    ,/*ETcNodeFileScanResults*/     CTcAdapter::EGet

    ,/*ETcNodeFileDelete*/          CTcAdapter::EExecute

    ,/*ETcNodeDeviceLock*/          CTcAdapter::EGet

    ,/*ETcNodeAutoLockPeriod*/      CTcAdapter::EGet | CTcAdapter::EReplace

    ,/*ETcNodeMaxAutoLockPeriod*/   CTcAdapter::EGet | CTcAdapter::EReplace

    ,/*ETcNodeLockLevel*/           CTcAdapter::EGet | CTcAdapter::EReplace

    ,/*ETcNodeLockCode*/            CTcAdapter::EReplace

// --------- Enhanced features BEGIN ------------------

//#ifdef __SAP_DEVICE_LOCK_ENHANCEMENTS

    ,/*ETcNodeLockCodeMinLength*/    CTcAdapter::EGet | CTcAdapter::EReplace

    ,/*ETcNodeLockCodeMaxLength*/    CTcAdapter::EGet | CTcAdapter::EReplace

    ,/*ETcNodeLockCodeRequireUpperAndLower*/ 	

    	CTcAdapter::EGet | CTcAdapter::EReplace

    ,/*ETcNodeLockCodeRequireCharsAndNumbers*/ 	

    	CTcAdapter::EGet | CTcAdapter::EReplace

    ,/*ETcNodeLockCodeMaxRepeatedCharacters*/  	

    	CTcAdapter::EGet | CTcAdapter::EReplace

    ,/*ETcNodeLockCodeHistoryBuffer*/           

    	CTcAdapter::EGet | CTcAdapter::EReplace

    ,/*ETcNodeLockCodeExpiration*/           	

    	CTcAdapter::EGet | CTcAdapter::EReplace

    ,/*ETcNodeLockCodeMinChangeTolerance*/    	

    	CTcAdapter::EGet | CTcAdapter::EReplace

    ,/*ETcNodeLockCodeMinChangeInterval*/      	

    	CTcAdapter::EGet | CTcAdapter::EReplace

    ,/*ETcNodeLockCodeCheckSpecificStrings*/  	

    	CTcAdapter::EGet | CTcAdapter::EReplace

    ,/*ETcNodeLockCodeDisallowSpecific*/       	

    	CTcAdapter::EReplace

    ,/*ETcNodeLockCodeAllowSpecific*/           

    	CTcAdapter::EReplace

    ,/*ETcNodeLockCodeClearSpecificStrings*/  	

    	CTcAdapter::EExecute

    ,/*ETcNodeLockCodeMaxAttempts*/           	

    	CTcAdapter::EGet | CTcAdapter::EReplace

    ,/*ETcNodeLockConsecutiveNumbers*/          

    	CTcAdapter::EGet | CTcAdapter::EReplace

    ,/*ETcNodeLockCodeMinSpecialCharacters*/   

        CTcAdapter::EGet | CTcAdapter::EReplace

    ,/*ETcNodeLockDisallowSimple*/          

        CTcAdapter::EGet | CTcAdapter::EReplace

//#endif

// --------- Enhanced features END --------------------

    ,/*ETcNodeDeviceWipe*/          CTcAdapter::EExecute

    ,/*ETcNodeProcesses*/           CTcAdapter::EGet

    ,/*ETcNodeProcessesX*/          CTcAdapter::EGet

    ,/*ETcNodeID*/                  CTcAdapter::EGet

    ,/*ETcNodeFromRAM*/             CTcAdapter::EGet

    ,/*ETcNodeMemoryInfo*/          CTcAdapter::EGet

    ,/*ETcNodeFilename*/            CTcAdapter::EGet

    ,/*ETcNodeReboot*/              CTcAdapter::EExecute

    ,/*ETcNodeLocalOperations*/     CTcAdapter::EGet

    ,/*ETcNodeStart*/               CTcAdapter::EExecute

    ,/*ETcNodeStop*/                CTcAdapter::EExecute

    ,/**/                           CTcAdapter::ENoAccess

    };

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

// CTcAdapter* CTcAdapter::NewL( )

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

CTcAdapter* CTcAdapter::NewL( MSmlDmCallback* aDmCallback )

    {

    RDEBUG("CTcAdapter::NewL()");

    CTcAdapter* self = NewLC( aDmCallback );

    CleanupStack::Pop( self );

    return self;

    }

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

// CTcAdapter* CTcAdapter::NewLC( )

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

CTcAdapter* CTcAdapter::NewLC( MSmlDmCallback* aDmCallback )

    {

    RDEBUG("CTcAdapter::NewLC()");

    CTcAdapter* self = new( ELeave ) CTcAdapter(aDmCallback);

    CleanupStack::PushL( self );

    self->ConstructL( aDmCallback );

    return self;

    }

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

// CTcAdapter::CTcAdapter()

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

CTcAdapter::CTcAdapter(TAny* aEcomArguments)

: CTARMDmAdapter((MSmlDmCallback*)aEcomArguments)

, iConnected(EFalse)

, iAutoLockPeriod(-1)

, iLockLevel(-1)

, iMaxAutoLockPeriod(-1)

// --------- Enhanced features BEGIN ------------------

//#ifdef __SAP_DEVICE_LOCK_ENHANCEMENTS

, iLockCodeMinLength( -1 )

, iLockCodeMaxLength( -1 )

, iLockCodeRequireUpperAndLowerInt( -1 )

, iLockCodeRequireCharsAndNumbersInt( -1 )

, iLockCodeMaxRepeatedCharacters( -1 )

, iLockCodeHistoryBuffer( -1 )

, iLockCodeExpiration( -1 )

, iLockCodeMinChangeTolerance( -1 )

, iLockCodeMinChangeInterval( -1 )

, iLockCodeCheckSpecificStringsInt( -1 )

, iLockCodeMaxAttempts( -1 )

, iLockCodeConsecutiveNumbersInt( -1 )

, iLockCodeMinSpecialCharacters( -1 )

, iLockCodeDisallowSimpleInt( -1 )

//#endif

// --------- Enhanced features END --------------------

    {

    memset(&iAccessHistory[0], CTcAdapter::ENoAccess, sizeof(iAccessHistory));

    }

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

// CTcAdapter::~CTcAdapter()

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

CTcAdapter::~CTcAdapter()

    {

    RDEBUG("CTcAdapter::~CTcAdapter()");

    iTCSession.Close();

    iTC.Close();

    }

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

//  CTcAdapter::DDFVersionL()

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

void CTcAdapter::DDFVersionL( CBufBase& aDDFVersion )

    {

    RDEBUG("CTcAdapter::DDFVersionL()");

    aDDFVersion.InsertL( 0, KSmlTCDDFVersion );

    }

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

//  CTcAdapter::DDFStructureL()

//

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

void CTcAdapter::DDFStructureL( MSmlDmDDFObject& aDDF )

    {

    RDEBUG("CTcAdapter::DDFStructureL()" );

    TSmlDmAccessTypes accessTypesGet;

    accessTypesGet.SetGet();

#ifdef TCADAPTER_FILESCAN_EXECUTE_LEAF

    TSmlDmAccessTypes accessTypeExecute;

    accessTypeExecute.SetExec();

#endif

    /*

    Node: ./TerminalSecurity

    This node is the root node for all terminal control functionality.

·    Support: Mandatory

·    Occurs: One

·    Format: Node

·    Access Types: Get

·    Values: N/A

    */

    MSmlDmDDFObject& tc = aDDF.AddChildObjectL( KTCNodeName );

    FillNodeInfoL(tc, accessTypesGet, MSmlDmDDFObject::EOne, 

    	MSmlDmDDFObject::EPermanent,

        MSmlDmDDFObject::ENode, KTCNodeDescription, KNullDesC8() );

    TSmlDmAccessTypes accessTypesExec;

    accessTypesExec.SetExec();

    /*

    Node: ./TerminalSecurity/FileScan

    The file scan feature delivers to admin a list 

    of files or folders found in device.

·    Support: Mandatory

·    Occurs: One

·    Format: Node

·    Access Types: Exec

·    Values: N/A

    */

    MSmlDmDDFObject& fs = tc.AddChildObjectL( KTCFileScanNodeName );

    FillNodeInfoL( fs, accessTypesExec, MSmlDmDDFObject::EOne, 

    		MSmlDmDDFObject::EPermanent,

        MSmlDmDDFObject::ENode, KTCFileScanNodeDescription, KNullDesC8() );    

#ifdef TCADAPTER_FILESCAN_EXECUTE_LEAF

    /*

    Node: ./TerminalSecurity/FileScan/Execute

    This node can be used to execute file scan operation.

·    Support: Mandatory

·    Occurs: One

·    Format: NULL

·    Access Types: Exec

·    Values: N/A

    */

    MSmlDmDDFObject& fse = fs.AddChildObjectL( KTCFileScanExecuteNodeName );

    FillNodeInfoL( fse, accessTypeExecute, MSmlDmDDFObject::EOne, 

    		MSmlDmDDFObject::EPermanent,

        MSmlDmDDFObject::ENull, 

        KTCFileScanExecuteNodeDescription, KNullDesC8() );

#endif

    /*

    Node: ./TerminalSecurity/FileScan/Results

    This node will hold the scan results

·    Support: Mandatory

·    Occurs: One

·    Format: Xml

·    Access Types: Get

·    Values: extended Obex folder listing objects

    */

    MSmlDmDDFObject& fsr = fs.AddChildObjectL( KTCFileScanResultsNodeName );

    FillNodeInfoL( fsr, accessTypesGet, MSmlDmDDFObject::EOne, 

    		MSmlDmDDFObject::EPermanent,

        MSmlDmDDFObject::EXml, KTCFileScanResultsNodeDescription, 

        KSmlTCTextXml() );

    /*

    Node: ./TerminalSecurity/FileDelete

    Deletes a file or empty folder

·    Support: Mandatory

·    Occurs: One

·    Format: N/A

·    Access Types: Exec

·    Values: N/A

    */

    MSmlDmDDFObject& fd = tc.AddChildObjectL( KTCFileDeleteNodeName );

    FillNodeInfoL( fd, accessTypesExec, MSmlDmDDFObject::EOne, 

    		MSmlDmDDFObject::EPermanent,

        MSmlDmDDFObject::ENode, KTCFileDeleteNodeDescription, KNullDesC8() );

    /*

    Node: ./TerminalSecurity/DeviceLock

    The parent node for all DeviceLock related nodes

·    Support: Mandatory

·    Occurs: One

·    Format: Node

·    Access Types: Get

·    Values: N/A

    */

    MSmlDmDDFObject& dl = tc.AddChildObjectL( KTCDeviceLockNodeName );

    FillNodeInfoL( dl, accessTypesGet, MSmlDmDDFObject::EOne, 

    		MSmlDmDDFObject::EPermanent,

        MSmlDmDDFObject::ENode, KTCDeviceLockNodeDescription, 

        KNullDesC8() );

    TSmlDmAccessTypes accessTypesGetReplace;

    accessTypesGetReplace.SetGet();

    accessTypesGetReplace.SetReplace();

    /*

    Node: ./TerminalSecurity/DeviceLock/AutoLockPeriod

    AutoLockPeriod is an integer that tells after how many 

    minutes the device will be automatically locked if not used

·    Status: Optional

·    Occurs: One

·    Format: integer

·    Access Types: Get, Replace

·    Values: Any integer in range device accepts.

    */

    MSmlDmDDFObject& alp = dl.AddChildObjectL( KTCAutoLockPeriodNodeName );

    FillNodeInfoL( alp, accessTypesGetReplace, MSmlDmDDFObject::EOne, 

    		MSmlDmDDFObject::EPermanent,

        MSmlDmDDFObject::EInt, KTCAutoLockPeriodNodeDescription, 

        KSmlTCTextPlain() );

    /*

    Node: ./TerminalSecurity/DeviceLock/MaxAutoLockPeriod

    MaxAutoLockPeriod is an integer that tells maximum value of AutoLockPeriod

·    Status: Optional

·    Occurs: One

·    Format: integer

·    Access Types: Get, Replace

·    Values: Any integer in range device accepts.

    */

    MSmlDmDDFObject& malp = dl.AddChildObjectL( KTCMaxAutoLockPeriodNodeName );

    FillNodeInfoL( malp, accessTypesGetReplace, MSmlDmDDFObject::EOne, 

    		MSmlDmDDFObject::EPermanent,

        MSmlDmDDFObject::EInt, KTCMaxAutoLockPeriodNodeDescription, 

        KSmlTCTextPlain() );

    /*

    Node: ./TerminalSecurity/DeviceLock/LockLevel

    Lock level tells whether lock is enabled, and what type of lock it is

·    Support: Mandatory

·    Occurs: One

·    Format: integer

·    Access Types: Get, Replace

·    Values: See examples below

    Example Values:

    0 - indicates lock is disabled

    1 - Indicates user lock is active. 

    		User can open lock by User secure code.

    2 - indicates admin lock is active. 

    		Lock can be opened only by Admin secure code.

    */

    MSmlDmDDFObject& ll = dl.AddChildObjectL( KTCLockLevelNodeName );

    FillNodeInfoL( ll, accessTypesGetReplace, MSmlDmDDFObject::EOne, 

    		MSmlDmDDFObject::EPermanent,

        MSmlDmDDFObject::EInt, KTCLockLevelNodeDescription, KSmlTCTextPlain() );

    TSmlDmAccessTypes accessTypesReplace;

    accessTypesReplace.SetReplace();

    /*

    Node: ./TerminalSecurity/DeviceLock/LockCode

    LockCode is the character sequence that is needed to open locked device

·    Status: Optional

·    Occurs: One

·    Format: chr

·    Access Types: Replace

·    Values: Depends on device.

    */

    MSmlDmDDFObject& lc = dl.AddChildObjectL( KTCLockCodeNodeName );

    FillNodeInfoL( lc, accessTypesReplace, MSmlDmDDFObject::EOne, 

    		MSmlDmDDFObject::EPermanent,

        MSmlDmDDFObject::EChr, KTCLockCodeNodeDescription, KSmlTCTextPlain() );

//#ifdef __SAP_DEVICE_LOCK_ENHANCEMENTS

// -------- Enhanced features BEGIN

	/*

    Node: ./TerminalSecurity/DeviceLock/LockCodeMinLength

    LockCode minimum length, 4-256 characters

·    Status: Optional

·    Occurs: One

·    Format: integer

·    Access Types: Get, Replace

·    Values: Depends on device.

    */

    MSmlDmDDFObject& lcmin = dl.AddChildObjectL( KTCLockCodeMinLengthNodeName );

    FillNodeInfoL( lcmin, accessTypesGetReplace, MSmlDmDDFObject::EOne, 

    		MSmlDmDDFObject::EPermanent,

        MSmlDmDDFObject::EInt, KTCLockCodeMinLengthNodeDescription, 

        KSmlTCTextPlain() );

	/*

    Node: ./TerminalSecurity/DeviceLock/LockCodeMaxLength

    LockCode maximum length, 4-256 characters

·    Status: Optional

·    Occurs: One

·    Format: integer

·    Access Types: Get, Replace

·    Values: Depends on device.

    */

    MSmlDmDDFObject& lcmax = dl.AddChildObjectL( KTCLockCodeMaxLengthNodeName );

    FillNodeInfoL( lcmax, accessTypesGetReplace, MSmlDmDDFObject::EOne, 

    		MSmlDmDDFObject::EPermanent,

        MSmlDmDDFObject::EInt, KTCLockCodeMaxLengthNodeDescription, 

        KSmlTCTextPlain() );

	/*

    Node: ./TerminalSecurity/DeviceLock/LockCodeRequireUpperAndLower

    If enabled the LockCode must contain both upper and lower case letters

·    Status: Optional

·    Occurs: One

·    Format: bool

·    Access Types: Get, Replace

·    Values: Depends on device.

    */

    MSmlDmDDFObject& lcrequl = 

    	dl.AddChildObjectL( KTCLockCodeRequireUpperAndLowerNodeName );

    FillNodeInfoL( lcrequl, accessTypesGetReplace, MSmlDmDDFObject::EOne, 

    		MSmlDmDDFObject::EPermanent,

        MSmlDmDDFObject::EBool, KTCLockCodeRequireUpperAndLowerNodeDescription, 

        KSmlTCTextPlain() );

	/*

    Node: ./TerminalSecurity/DeviceLock/LockCodeRequireCharsAndNumbers