/** @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 : SQLite Connection class
 *
 */
// INCLUDES
#include <e32base.h>
#include <bautils.h>
#include <sysutil.h>
#include <in_sock.h>
#include "upnpsecuritydbconnection.h"
#include "upnpsecuritysqlclausedef.h"
// CONSTANTS
_LIT( KUpnpSecurityDbFileName, "upnpsec.sq" );
_LIT8( KUpnpSecuritySqlPragmaCacheSize,
        "PRAGMA cache_size=1024;PRAGMA page_size=4096;" );

const TInt KDatabaseMinDiskSpace = 20000;

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

// -----------------------------------------------------------------------------
// CUpnpSecurityDbConnection::NewL
// Second phase constructor.
// -----------------------------------------------------------------------------
//
CUpnpSecurityDbConnection* CUpnpSecurityDbConnection::NewL()
    {
    CUpnpSecurityDbConnection* self = CUpnpSecurityDbConnection::NewLC();
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CUpnpSecurityDbConnection::NewLC
// Second phase constructor.
// -----------------------------------------------------------------------------
//    
CUpnpSecurityDbConnection* CUpnpSecurityDbConnection::NewLC()
    {
    CUpnpSecurityDbConnection* self =
            new (ELeave) CUpnpSecurityDbConnection();
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }

// -----------------------------------------------------------------------------
// CUpnpSecurityDbConnection::~CUpnpSecurityDbConnection
// Destructor.
// -----------------------------------------------------------------------------
//
CUpnpSecurityDbConnection::~CUpnpSecurityDbConnection()
    {
    CloseDb();
    iFs.Close();
    }

// -----------------------------------------------------------------------------
// CUpnpSecurityDbConnection::CUpnpSecurityDbConnection
// Default constructor.
// -----------------------------------------------------------------------------
//    
CUpnpSecurityDbConnection::CUpnpSecurityDbConnection()
    {
    }

// -----------------------------------------------------------------------------
// CUpnpSecurityDbConnection::ConstructL
// -----------------------------------------------------------------------------
//   
void CUpnpSecurityDbConnection::ConstructL()
    {
    User::LeaveIfError( iFs.Connect() );
    const TInt driveLetterPrefixLength( 2 );//letter + ':'
    TBuf<driveLetterPrefixLength> driveLetterPrefix;
    
    TChar driveLetter;
    RFs::DriveToChar( DatabaseDrive(), driveLetter );
    const TChar KColon( ':' );
    driveLetterPrefix.Append( driveLetter );
    driveLetterPrefix.Append( KColon );

    iFs.CreatePrivatePath( DatabaseDrive() );
    User::LeaveIfError( iFs.PrivatePath( iDbFileName ) );
    iDbFileName.Insert( 0, driveLetterPrefix );
    iDbFileName.Append( KUpnpSecurityDbFileName );

    }

// -----------------------------------------------------------------------------
// CUpnpSecurityDbConnection::OpenDb
// Opens database connection and sets Cache size. 
// -----------------------------------------------------------------------------
//
TInt CUpnpSecurityDbConnection::OpenDb( const TDesC& aDb )
    {
    CloseDb();
    return iDatabase.Open( aDb, &KUpnpSecuritySqlPragmaCacheSize );
    }

// -----------------------------------------------------------------------------
// CUpnpSecurityDbConnection::ExecuteL
// ExecuteL, execute SQL command.
// -----------------------------------------------------------------------------
//
void CUpnpSecurityDbConnection::ExecuteL( const TDesC8& aCommand )
    {
    TInt err( iDatabase.Exec( aCommand ) );
    if ( KErrNone > err )
        {
        User::Leave( err );
        }
    }

// -----------------------------------------------------------------------------
// CUpnpSecurityDbConnection::CloseDb
// Close database connection.
// -----------------------------------------------------------------------------
//
void CUpnpSecurityDbConnection::CloseDb()
    {
    iDatabase.Close();
    }

// -----------------------------------------------------------------------------
// CUpnpSecurityDbConnection::CreateDbFile
// Creates db file.
// -----------------------------------------------------------------------------
//
TInt CUpnpSecurityDbConnection::CreateDbFile( const TDesC& aDb )
    {
    return iDatabase.Create( aDb, &KUpnpSecuritySqlPragmaCacheSize );
    }

// -----------------------------------------------------------------------------
// CUpnpSecurityDbConnection::Validate
// Check validity of database.
// -----------------------------------------------------------------------------
//
TBool CUpnpSecurityDbConnection::Validate()
    {
    TBool result = EFalse;
    RSqlStatement statement;
    TInt err = statement.Prepare( iDatabase, KUpnpSecSqlValidateTableExistence );
    result = !err && (statement.Next() == KSqlAtRow);
    statement.Close();
    return result;
    }

// -----------------------------------------------------------------------------
// CUpnpSecurityDbConnection::CreateTablesL
// Create tables.
// -----------------------------------------------------------------------------
//
void CUpnpSecurityDbConnection::CreateTablesL()
    {
    ExecuteL( KUpnpSecSqlDropAddressList );
    ExecuteL( KUpnpSecSqlDropFileList );

    ExecuteL( KUpnpSecSqlCreateAddressList );
    ExecuteL( KUpnpSecSqlCreateFileList );
    }

// -----------------------------------------------------------------------------
// CUpnpSecurityDbConnection::OpenDatabaseL
// Prepare database for use, create new if not exist.
// -----------------------------------------------------------------------------
//
void CUpnpSecurityDbConnection::OpenDatabaseL()
    {
    EnsureDiskSpaceL();

    if ( OpenDb( iDbFileName ) != KErrNone )
        {
        User::LeaveIfError( CreateDbFile( iDbFileName ) );
        }

    if ( !Validate() )
        {
        CreateTablesL();
        }
    }

// -----------------------------------------------------------------------------
// CUpnpSecurityDbConnection::AddIpAddressL
// Add ip address to DB.
// -----------------------------------------------------------------------------
//
void CUpnpSecurityDbConnection::AddIpAddressL( const TInetAddr& aIpAddress )
    {
    EnsureDiskSpaceL();
    ExecStatementL( KUpnpSecSqlInsertIpAddress, aIpAddress.Address() );
    }

// -----------------------------------------------------------------------------
// CUpnpSecurityDbConnection::AddFilenameL
// Add filename to DB.
// -----------------------------------------------------------------------------
//
void CUpnpSecurityDbConnection::AddFilenameL( const TDesC& aFilename )
    {
    EnsureDiskSpaceL();
    ExecStatementL( KUpnpSecSqlInsertFile, aFilename );
    }

// -----------------------------------------------------------------------------
// CUpnpSecurityDbConnection::DeleteIpAddressL
// Delete ip address to DB.
// -----------------------------------------------------------------------------
//
void CUpnpSecurityDbConnection::DeleteIpAddressL( const TInetAddr& aIpAddress )
    {
    ExecStatementL( KUpnpSecSqlDeleteIpAddress, aIpAddress.Address() );
    }

// -----------------------------------------------------------------------------
// CUpnpSecurityDbConnection::DeleteFilenameL
// Delete filename to DB.
// -----------------------------------------------------------------------------
//
void CUpnpSecurityDbConnection::DeleteFilenameL( const TDesC& aFilename )
    {
    ExecStatementL( KUpnpSecSqlDeleteFile, aFilename );
    }

// -----------------------------------------------------------------------------
// CUpnpSecurityDbConnection::DeleteAllIpAddressesL
// Delete all ip addresses to DB.
// -----------------------------------------------------------------------------
//
void CUpnpSecurityDbConnection::DeleteAllIpAddressesL()
    {
    ExecStatementL( KUpnpSecSqlDeleteAllIpAddresses );
    }

// -----------------------------------------------------------------------------
// CUpnpSecurityDbConnection::DeleteAllFilenamesL
// Delete all filenames to DB.
// -----------------------------------------------------------------------------
//
void CUpnpSecurityDbConnection::DeleteAllFilenamesL()
    {
    ExecStatementL( KUpnpSecSqlDeleteAllFiles );
    }

// -----------------------------------------------------------------------------
// CUpnpSecurityDbConnection::ExecStatementL
// Execute given db command
// -----------------------------------------------------------------------------
//
void CUpnpSecurityDbConnection::ExecStatementL( const TDesC8& aCommand )
    {
    RSqlStatement statement;
    User::LeaveIfError( statement.Prepare( iDatabase, aCommand ) );
    CleanupClosePushL( statement );
    User::LeaveIfError( statement.Exec() );
    CleanupStack::PopAndDestroy( &statement );    
    }

// -----------------------------------------------------------------------------
// CUpnpSecurityDbConnection::ExecStatementL
// Execute given db command
// -----------------------------------------------------------------------------
//
void CUpnpSecurityDbConnection::ExecStatementL( const TDesC8& aCommand,
    const TDesC& aTextToBind )
    {
    RSqlStatement statement;
    User::LeaveIfError( statement.Prepare( iDatabase, aCommand ) );
    CleanupClosePushL( statement );
    User::LeaveIfError( statement.BindText( 0, aTextToBind ) );
    User::LeaveIfError( statement.Exec() );
    CleanupStack::PopAndDestroy( &statement );
    }

// -----------------------------------------------------------------------------
// CUpnpSecurityDbConnection::ExecStatementL
// Execute given db command
// -----------------------------------------------------------------------------
//
void CUpnpSecurityDbConnection::ExecStatementL( const TDesC8& aCommand,
    TInt aIntToBind )
    {
    RSqlStatement statement;
    User::LeaveIfError( statement.Prepare( iDatabase, aCommand ) );
    CleanupClosePushL( statement );    
    User::LeaveIfError( statement.BindInt( 0, aIntToBind ) );
    User::LeaveIfError( statement.Exec() );
    CleanupStack::PopAndDestroy( &statement );
    }

// -----------------------------------------------------------------------------
// CUpnpSecurityDbConnection::GetAllIpAddressesL
// Get all ips.
// -----------------------------------------------------------------------------
//
void CUpnpSecurityDbConnection::GetAllIpAddressesL(
    RArray<TInetAddr>& aAddressArray )
    {
    TInt err;
    RSqlStatement statement;
    User::LeaveIfError( statement.Prepare( iDatabase,
        KUpnpSecSqlSelectAllIpAddresses ) );
    CleanupClosePushL( statement );
    TInt columnIndex = statement.ColumnIndex( KUpnpSecSqlIp );

    while ( (err = statement.Next()) == KSqlAtRow )
        {
        TUint32 data = statement.ColumnInt( columnIndex );
        aAddressArray.AppendL( TInetAddr( data, 0 ) );
        }

    if ( err != KSqlAtEnd )
        {
        User::LeaveIfError( err );
        }

    CleanupStack::PopAndDestroy( &statement );
    }

// -----------------------------------------------------------------------------
// CUpnpSecurityDbConnection::GetAllFilenamesL
// Get all filenames. 
// -----------------------------------------------------------------------------
//
void CUpnpSecurityDbConnection::GetAllFilenamesL(
    RPointerArray<HBufC>& aFilenameArray )
    {
    TInt err;
    RSqlStatement statement;
    User::LeaveIfError( statement.Prepare( iDatabase, KUpnpSecSqlSelectAllFiles ) );
    CleanupClosePushL( statement );

    TInt columnIndex = statement.ColumnIndex( KUpnpSecSqlFilename );

    while ( (err = statement.Next()) == KSqlAtRow )
        {
        TPtrC data = statement.ColumnTextL( columnIndex );
        HBufC* filename = data.AllocLC();
        aFilenameArray.AppendL( filename );
        CleanupStack::Pop( filename );
        }

    if ( err != KSqlAtEnd )
        {
        User::LeaveIfError( err );
        }

    CleanupStack::PopAndDestroy( &statement );
    }

// -----------------------------------------------------------------------------
// CUpnpSecurityDbConnection::EnsureDiskSpaceL
// Leaves if there is not enough disk space 
// -----------------------------------------------------------------------------
//
void CUpnpSecurityDbConnection::EnsureDiskSpaceL()
    {
    if ( SysUtil::DiskSpaceBelowCriticalLevelL( &iFs, KDatabaseMinDiskSpace,
         DatabaseDrive()) )
        {
        User::Leave( KErrDiskFull );
        }
    }

// -----------------------------------------------------------------------------
// CUpnpSecurityDbConnection::DatabaseDrive()
// Return drive on which database file is kept  
// -----------------------------------------------------------------------------
//
TDriveNumber CUpnpSecurityDbConnection::DatabaseDrive()
    {
    return RFs::GetSystemDrive();
    }

//  End of File