/** @file   

 * Copyright (c) 2009 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:  Defines CUpnpSecurityManagerEngine

 *

 */

// INCLUDES

#include <e32property.h> 

#include "upnpsecuritymanagerengine.h"

#include "upnpsecuritydbconnection.h"

_LIT( KComponentLogfile, "upnpsecurityserver.txt");

#include "upnplog.h"

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

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

// CUpnpSecurityManagerEngine::CUpnpSecurityManagerEngine

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CUpnpSecurityManagerEngine::CUpnpSecurityManagerEngine()

    {

    __LOG( "[UpnpSecurity]\t CUpnpSecurityManagerEngine::\

CUpnpSecurityManagerEngine" );

    }

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

// CUpnpSecurityManagerEngine::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CUpnpSecurityManagerEngine::ConstructL()

    {

    __LOG( "[UpnpSecurity]\t CUpnpSecurityManagerEngine::ConstructL" );

    // create database connection object

    iDbConnection = CUpnpSecurityDbConnection::NewL();

    iDbConnection->OpenDatabaseL();

    // Clean the access lists after phone reboot 

    ResetListsOnFirstRunL();

    // load lists from database

    iDbConnection->GetAllFilenamesL( iAllowedFiles );

    iDbConnection->GetAllIpAddressesL( iAllowedAddresses );

    }

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

// CUpnpSecurityManagerEngine::ResetListsOnFirstRunL

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

//

void CUpnpSecurityManagerEngine::ResetListsOnFirstRunL()

    {

    // create RProperty used as reboot marker

    TInt err = RProperty::Define( RProcess().SecureId(), EUPnPSecManFirstRun,

        RProperty::EInt );

    if ( err != KErrAlreadyExists )

        {

        // property wasn't defined, so it's the first run and we clear lists

        User::LeaveIfError( err ); // other errors may occur

        // clear lists

        ResetFileListL();

        ResetAddressListL();

        }

    }

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

// CUpnpSecurityManagerEngine::NewL

// Two-phased constructor.

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

//

CUpnpSecurityManagerEngine* CUpnpSecurityManagerEngine::NewL()

    {

    __LOG( "[UpnpSecurity]\t CUpnpSecurityManagerEngine::NewL" );

    CUpnpSecurityManagerEngine* self =

            new (ELeave) CUpnpSecurityManagerEngine();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CUpnpSecurityManagerEngine::CUpnpSecurityManagerEngine

// Destructor.

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

//

CUpnpSecurityManagerEngine::~CUpnpSecurityManagerEngine()

    {

    __LOG( "[UpnpSecurity]\t CUpnpSecurityManagerEngine::\

~CUpnpAuthorisationNotifier" );

    // Reset whitelists

    iAllowedFiles.ResetAndDestroy();

    iAllowedAddresses.Reset();

    delete iDbConnection;

    }

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

// CUpnpSecurityManagerEngine::ResetFileListL

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

//

void CUpnpSecurityManagerEngine::ResetFileListL()

    {

    iAllowedFiles.ResetAndDestroy();

    iDbConnection->DeleteAllFilenamesL();

    }

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

// CUpnpSecurityManagerEngine::ResetAddressListL

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

//

void CUpnpSecurityManagerEngine::ResetAddressListL()

    {

    iAllowedAddresses.Reset();

    iDbConnection->DeleteAllIpAddressesL();

    }

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

// CUpnpSecurityManagerEngine::CheckAuthorizationL

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

//

TAccessType CUpnpSecurityManagerEngine::CheckAuthorization(

    const TInetAddr& aIpAddress, const TDesC& aFileName )

    {

    __LOG( "[UpnpSecurity]\t CUpnpSecurityManagerEngine::CheckAuthorization" );

    TAccessType accessType = ENoneAllowed;

    // Check the lists 

    TInt addressFound = KErrNotFound;

    if ( aIpAddress != TInetAddr( KInetAddrNone ) )

        {

        addressFound = FindAddressFromArray( aIpAddress );

        }

    TInt fileFound = KErrNotFound;

    if ( aFileName.Length() > 0 )

        {

        fileFound = FindFileFromArray( aFileName );

        }

    // Neither address or file was not

    if ( (addressFound == KErrNotFound) && (fileFound == KErrNotFound) )

        {

        accessType = ENoneAllowed;

        }

    // Address could be found but file not

    else if ( (addressFound >= 0) && (fileFound == KErrNotFound) )

        {

        accessType = EAddressAllowed;

        }

    // File could be found but not address

    else if ( (addressFound == KErrNotFound) && (fileFound >= 0) )

        {

        accessType = EFileAllowed;

        }

    // Both were in the white lists

    else

        {

        accessType = EFileAndAddressAllowed;

        }

    return accessType;

    }

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

// CUpnpSecurityManagerEngine::AddNewFileL

// Adds new file to allowed file array, if not existing yet.

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

//

void CUpnpSecurityManagerEngine::AddNewFileL( const TDesC& aFileName )

    {

    __LOG( "[UpnpSecurity]\t CUpnpSecurityManagerEngine::AddNewFileL" );

    if ( FindFileFromArray( aFileName ) == KErrNotFound )

        {

        HBufC* tmpBuffer = aFileName.AllocLC();

        iAllowedFiles.AppendL( tmpBuffer );

        CleanupStack::Pop( tmpBuffer );

        iDbConnection->AddFilenameL( aFileName );

        }

    }

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

// CUpnpSecurityManagerEngine::RemoveFileL

// Removes file from allowed array.

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

//

void CUpnpSecurityManagerEngine::RemoveFileL( const TDesC& aFileName )

    {

    __LOG( "[UpnpSecurity]\t CUpnpSecurityManagerEngine::RemoveFileL" );

    TInt index = FindFileFromArray( aFileName );

    if ( index != KErrNotFound )

        {

        __LOG( "[UpnpSecurity]\t CUpnpSecurityManagerEngine, \

file removed from whitelist." );

        delete iAllowedFiles[index];

        iAllowedFiles.Remove( index );

        iDbConnection->DeleteFilenameL( aFileName );

        }

    else

        {

        __LOG( "[UpnpSecurity]\t CUpnpSecurityManagerEngine, \

FILE NOT FOUND!" );

        User::Leave( KErrNotFound );

        }

    }

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

// CUpnpSecurityManagerEngine::FindFileFromArray

// Finds file from array and returns the index.

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

//

TInt CUpnpSecurityManagerEngine::FindFileFromArray( const TDesC& aFileName )

    {

    __LOG( "[UpnpSecurity]\t CUpnpSecurityManagerEngine::\

FindFileFromArray" );

    TInt retVal = KErrNotFound;

    for ( TInt index = 0; index < iAllowedFiles.Count(); ++index )

        {

        // Check if file names are the same

        // Use folding to remove case sensitiveness

        if ( aFileName.CompareF( *iAllowedFiles[index] ) == 0 )

            {

            retVal = index;

            break;

            }

        }

    __LOG2( "CUpnpSecurityManagerEngine::FindFileFromArray(%S) retVal=%d",

            &aFileName, retVal );

    return retVal;

    }

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

// CUpnpSecurityManagerEngine::AddNewAddressL

// Adds new address to allowed address array, if not existing yet.

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

//

void CUpnpSecurityManagerEngine::AddNewAddressL( const TInetAddr& aIpAddress )

    {

    __LOG( "[UpnpSecurity]\t CUpnpSecurityManagerEngine::AddNewAddressL" );

    if ( FindAddressFromArray( aIpAddress ) == KErrNotFound )

        {

        iAllowedAddresses.AppendL( aIpAddress );

        iDbConnection->AddIpAddressL( aIpAddress );

        }

    }

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

// CUpnpSecurityManagerEngine::RemoveAddressL

// Removes existing address from IP address array.

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

//

void CUpnpSecurityManagerEngine::RemoveAddressL( const TInetAddr& aIpAddress )

    {

    __LOG( "[UpnpSecurity]\t CUpnpSecurityManagerEngine::RemoveAddressL" );

    TInt index = FindAddressFromArray( aIpAddress );

    if ( index != KErrNotFound )

        {

        iAllowedAddresses.Remove( index );

        iDbConnection->DeleteIpAddressL( aIpAddress );

        __LOG( "[UpnpSecurity]\t CUpnpSecurityManagerEngine, \

address remove from array." );

        }

    else

        {

        __LOG( "[UpnpSecurity]\t CUpnpSecurityManagerEngine, \

address NOT found from the array!" );

        User::Leave( KErrNotFound );

        }

    }

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

// CUpnpSecurityManagerEngine::FindAddressFromArray

// Finds file from array and returns the index.

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

//

TInt CUpnpSecurityManagerEngine::FindAddressFromArray(

    const TInetAddr& aIpAddress )

    {

    __LOG( "[UpnpSecurity]\t CUpnpSecurityManagerEngine::\

FindAddressFromArray" );

    TInt retVal = KErrNotFound;

    for ( TInt index = 0; index < iAllowedAddresses.Count(); ++index )

        {

        // Compare only IP Address

        if ( iAllowedAddresses[index].Address() == aIpAddress.Address() )

            {

            retVal = index;

            break;

            }

        }

    TFileName ipAddress;

    aIpAddress.Output( ipAddress );

    __LOG2( "CUpnpSecurityManagerEngine::FindAddressFromArray(%S) retVal=%d",

            &ipAddress, retVal );

    return retVal;

    }

// End of File