/** @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 the CUpnpSecAccessController class

 *

 */

// INCLUDES

#include <e32base.h>

#include <upnpmediaserversettings.h>

#include "upnpsecaccesscontroller.h"

#include "upnpsecuritymanagerclientsession.h"

_LIT( KComponentLogfile, "upnpsecurity.txt");

#include "upnplog.h"

// CONSTANTS

_LIT8( KSecurityPluginName, "UpnpSecurityManager" );

_LIT( KMediaServerXMLFile, "MediaServer1\\MediaServer1.xml" );

_LIT( KConnectionManagerXMLFile, "MediaServer1\\ConnectionManager1.xml" );

_LIT( KContentDirectoryXMLFile, "MediaServer1\\ContentDirectory1.xml" );

_LIT( KIconFile0, "MediaServer1\\icon\\0" );

_LIT( KIconFile1, "MediaServer1\\icon\\1" );

_LIT( KIconFile2, "MediaServer1\\icon\\2" );

_LIT( KIconFile3, "MediaServer1\\icon\\3" );

_LIT8( KGetProtocolInfo, "GetProtocolInfo" );

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

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

// CUpnpSecAccessController::NewL

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

//

EXPORT_C CUpnpSecAccessController* CUpnpSecAccessController::NewL()

    {

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

    CUpnpSecAccessController* self = new (ELeave) CUpnpSecAccessController;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CUpnpSecAccessController::ConstructL

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

//

void CUpnpSecAccessController::ConstructL()

    {

    iSecurityManagerClientSession = new (ELeave) RUpnpSecurityManagerClientSession();

    User::LeaveIfError( iSecurityManagerClientSession->Connect( ) );

    }

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

// CUpnpSecAccessController::CUpnpSecAccessController

// Constructor.

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

//

CUpnpSecAccessController::CUpnpSecAccessController()

    {

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

CUpnpSecAccessController" );

    }

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

// CUpnpSecAccessController::~CUpnpSecAccessController

// Destructor.

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

//

EXPORT_C CUpnpSecAccessController::~CUpnpSecAccessController()

    {

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

~CUpnpSecAccessController" );

    if ( iSecurityManagerClientSession )

        {

        iSecurityManagerClientSession->Close();

        delete iSecurityManagerClientSession;

        }

    }

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

// CUpnpSecAccessController::EnableMediaServerSecurityL

// Enables the security plugin in Media Server.

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

//

EXPORT_C void CUpnpSecAccessController::EnableMediaServerSecurityL()

    {

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

EnableMediaServerSecurityL" );

    SetSecurityManagerSettingL( KSecurityPluginName );

    }

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

// CUpnpSecAccessController::DisableMediaServerSecurityL

// Disables the security plugin in Media Server.

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

//

EXPORT_C void CUpnpSecAccessController::DisableMediaServerSecurityL()

    {

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

DisableMediaServerSecurityL" );

    SetSecurityManagerSettingL( KNullDesC8 );

    }

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

// CUpnpSecAccessController::SetSecurityManagerSettingL

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

//

void CUpnpSecAccessController::SetSecurityManagerSettingL( const TDesC8& aSettingToSet )

    {

    CUpnpMediaServerSettings* settings = CUpnpMediaServerSettings::NewL();

    CleanupStack::PushL( settings );

    User::LeaveIfError( settings->SetL(

                    UpnpMediaServerSettings::ESecurityManager, aSettingToSet ) );

    // Clean up

    CleanupStack::PopAndDestroy( settings );    

    }

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

// CUpnpSecAccessController::IsMediaServerSecurityEnabledL

// Returns the status of the Media Server security plugin.

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

//

EXPORT_C TBool CUpnpSecAccessController::IsMediaServerSecurityEnabledL()

    {

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

IsMediaServerSecurityEnabledL" );

    TBool returnValue = EFalse;

    CUpnpMediaServerSettings* settings = CUpnpMediaServerSettings::NewL();

    CleanupStack::PushL( settings );

    HBufC8* value =

    settings->GetL( UpnpMediaServerSettings::ESecurityManager );

    CleanupStack::PushL( value );

    if ( value && value->Des() != KNullDesC8 )

        {

        returnValue = ETrue;

        }

    // Clean up

    CleanupStack::PopAndDestroy( value );

    value = NULL;

    CleanupStack::PopAndDestroy( settings );

    settings = NULL;

    return returnValue;

    }

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

// CUpnpSecAccessController::AddAllowedFile

// Adds file to notifier allowed list.

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

//

EXPORT_C TInt CUpnpSecAccessController::AddAllowedFile(

        const TDesC& aFileName )

    {

    __LOG( "[UpnpSecurity]\t CUpnpSecAccessController::AddAllowedFile" );

    TInt error = KErrNone;

    if ( !IsAllowedFile( aFileName ) )

        {

        TRAP(error, iSecurityManagerClientSession->AddFileL( aFileName ));

        }

    return error;

    }

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

// CUpnpSecAccessController::RemoveAllowedFile

// Removes file from notifier allowed list.

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

//

EXPORT_C TInt CUpnpSecAccessController::RemoveAllowedFile(

        const TDesC& aFileName )

    {

    __LOG( "[UpnpSecurity]\t CUpnpSecAccessController::RemoveAllowedFile" );

    TInt error = KErrNone;

    if ( !IsAllowedFile( aFileName ) )

        {

        // We're not expecting an answer...

        TRAP(error, iSecurityManagerClientSession->RemoveFileL( aFileName ));

        }

    return error;

    }

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

// CUpnpSecAccessController::AddAllowedAddress

// Adds IP Address to notifier allowed list.

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

//

EXPORT_C TInt CUpnpSecAccessController::AddAllowedAddress(

        const TInetAddr& aIpAddress )

    {

    __LOG( "[UpnpSecurity]\t CUpnpSecAccessController::AddAllowedAddress" );

    TInt error = KErrNone;

    TRAP( error, iSecurityManagerClientSession->AddAddressL( aIpAddress ));

    return error;

    }

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

// CUpnpSecAccessController::RemoveAllowedAddress

// Removes IP address from notifier allowed list.

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

//

EXPORT_C TInt CUpnpSecAccessController::RemoveAllowedAddress(

        const TInetAddr& aIpAddress )

    {

    __LOG( "[UpnpSecurity]\t CUpnpSecAccessController::AddAllowedAddress" );

    TInt error = KErrNone;

    TRAP( error, iSecurityManagerClientSession->RemoveAddressL( aIpAddress ));

    return error;

    }

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

// CUpnpSecAccessController::ResetFileList

// Resets allowed files list.

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

//

EXPORT_C TInt CUpnpSecAccessController::ResetFileList()

    {

    __LOG( "[UpnpSecurity]\t CUpnpSecAccessController::ResetFileList" );

    TInt error = KErrNone;

    TRAP( error, iSecurityManagerClientSession->ResetFileListL() );

    return error;

    }

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

// CUpnpSecAccessController::ResetAddressList

// Resets allowed addresses list.

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

//

EXPORT_C TInt CUpnpSecAccessController::ResetAddressList()

    {

    __LOG( "[UpnpSecurity]\t CUpnpSecAccessController::ResetAddressList" );

    TInt error = KErrNone;

    TRAP( error, iSecurityManagerClientSession->ResetAddressListL());

    return error;

    }

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

// CUpnpSecAccessController::QueryAuthorizationL

// Query user to authorize connection from an IP-address.

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

//

EXPORT_C void CUpnpSecAccessController::QueryAuthorizationL(

        const TInetAddr& aIpAddress )

    {

    __LOG( "[UpnpSecurity]\t CUpnpSecAccessController:: QueryAuthorizationL" );

    iSecurityManagerClientSession->QueryAuthorisationL( aIpAddress );

    }

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

// CUpnpSecAccessController::CheckAuthorizationL

// Checks if the given IP-address/action/file is authorized.

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

//

EXPORT_C void CUpnpSecAccessController::CheckAuthorizationL(

        const TInetAddr& aIpAddress, const TDesC& aFileName,

        const TDesC8& aActionName )

    {

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

CheckAuthorizationL" );

    TBool authorized = EFalse;

    // First, check if the access to the file can be automatically authorized

    if ( aFileName != KNullDesC )

        {

        authorized = IsAllowedFile( aFileName );

        }

    // If file was not authorized, check the action

    if ( !authorized && aActionName != KNullDesC8 )

        {

        authorized = IsAllowedAction( aActionName );

        }

    // If neither file or action were authorized, query the authorization

    // from the notifier

    if ( !authorized )

        {

        TAccessType accessType = iSecurityManagerClientSession->CheckAuthorizationL(

                aIpAddress, aFileName );

        // If the address, file or both are allowed, authorize the access

        if ( accessType == EAddressAllowed || accessType == EFileAllowed

                || accessType == EFileAndAddressAllowed )

            {

            authorized = ETrue;

            }

        }

    // Leave if not authorized

    if ( !authorized )

        {

        User::Leave( KErrAccessDenied );

        }

    }

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

// CUpnpSecAccessController::IsAllowedFile

// Checks if the requested file is automatically allowed.

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

//

TBool CUpnpSecAccessController::IsAllowedFile( const TDesC& aFileName )

    {

    __LOG( "[UpnpSecurity]\t CUpnpSecAccessController::IsAllowedFile" );

    TBool returnValue = EFalse;

    if ( aFileName.Length( ) > 0 )

        {

        // Do folded find (non-case-sensitive)

        if ( aFileName.FindF( KMediaServerXMLFile ) != KErrNotFound

                || aFileName.FindF( KConnectionManagerXMLFile )

                    != KErrNotFound

                || aFileName.FindF( KContentDirectoryXMLFile )

                    != KErrNotFound

                || aFileName.FindF( KIconFile0 ) != KErrNotFound

                || aFileName.FindF( KIconFile1 ) != KErrNotFound

                || aFileName.FindF( KIconFile2 ) != KErrNotFound

                || aFileName.FindF( KIconFile3 ) != KErrNotFound )

            {

            returnValue = ETrue;

            }

        }

    return returnValue;

    }

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

// CUpnpSecAccessController::IsAllowedAction

// Checks if the requested action is automatically allowed.

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

//

TBool CUpnpSecAccessController::IsAllowedAction( const TDesC8& aActionName )

    {

    __LOG( "[UpnpSecurity]\t CUpnpSecAccessController::IsAllowedAction" );

    TBool returnValue = EFalse;

    if ( aActionName.Length( ) > 0 )

        {

        if ( aActionName.CompareF( KGetProtocolInfo ) == 0 )

            {

            returnValue = ETrue;

            }

        }

    return returnValue;

    }

//  End of File