/*

* Copyright (c) 2005 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 RIscApi class

*

*/

// INCLUDE FILES

#include <E32svr.H>

#include <f32file.h>

#include <iscapi.h>

#include <IscDefinitions.h>

#include <iscdefinitions.h>

#include "IscTrace.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

_LIT( KIscApiPanic,"IscApi Panic" );

_LIT( KIscDriverName,"IscDriver" );

_LIT( KIscDriverExtensionName,"IscDriverExtension" );

// MACROS

// LOCAL CONSTANTS AND MACROS

_LIT( KIniFile,"Z:\\resource\\ISC\\isc_config.ini" );

_LIT( KMultiplexerLdd,"MultiplexerLdd" );

_LIT( KDataTransmissionLdd,"DataTransmissionLdd" );

_LIT( KDataTransmissionPdd,"DataTransmissionPdd" );

_LIT( KPdd,"PDD" );

_LIT( KLdd,"LDD" );

_LIT( KHashSign,"#" );

_LIT( KSemiColon,";" );

_LIT( KEqualSign,"=" );

_LIT( KIscDriverLdd, "iscdriver.ldd" );

_LIT( KIscDriverExtensionLdd, "iscdriverextension.ldd" );

const TInt KZeroLength( KErrNone );

const TInt KStartPosition( KErrNone );

const TInt KOneParam( 1 );

const TInt KTwoParams( 2 );

const TInt KThreeParams( 3 );

const TInt KFirstParam( 0 );

const TInt KSecondParam( 1 );

const TInt KThirdParam( 2 );

const TInt KMajor( KErrNone );

const TInt KMinor( KErrNone );

const TInt KBuild( KErrNone );

const TInt KAddPosition( 1 );

const TInt KInfoLength( 1 );

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

// RIscApi::RIscApi

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

// might leave.

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

//

EXPORT_C RIscApi::RIscApi()

    :iNeededLen( NULL, KZeroLength ),

     iNeededDataLen( NULL, KZeroLength ),

     iConnectionStatus( NULL, KZeroLength ),

     iFlowControlStatus( NULL, KZeroLength ),

     iOpen( EFalse ),   

     iChannelNumber( KIscFrameReceiverNotFound )

#ifdef __WINS__

     ,iInitializing( EFalse )

#endif

    {

    }

EXPORT_C RIscApi::~RIscApi()

    {

    if( iOpen || iChannelNumber != KIscFrameReceiverNotFound )

        {

        Close();

        }

    else

    	{

    	// Do nothing.	

    	}

    }

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

// RIscApi::Initialize

// Initialize the ISC Interface

// ( other items were commented in a header ).

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

//

EXPORT_C void RIscApi::InitializeModemInterface

        ( 

        TRequestStatus& aStatus

        )

    {

    A_TRACE( ( _T( "RIscApi::InitializeModemInterface(0x%x)" ), &aStatus ) );

#ifdef __WINS__

    iInitializing = ETrue;

#endif

    CTrapCleanup* cleanup = CTrapCleanup::New();

    TInt r( KErrNone );

    TInt r2( KErrNone );

    HBufC8* multiplexerInit = NULL;

    TRAP( r, ( multiplexerInit = HBufC8::NewL( KIscIniLineLength ) ) );

    // buffer to hold the init-string for second-level driver

    HBufC8* dataTransmissionInit = NULL;

    TRAP( r2, ( dataTransmissionInit = HBufC8::NewL( KIscIniLineLength ) ) );

    __ASSERT_ALWAYS( ( KErrNone == r && KErrNone == r2 ),

    	User::Panic( KIscApiPanic, EIscApiMemoryAllocationFailure ) );

    // Read ini-file and load needed drivers.

    TRAP( r, LoadL( *multiplexerInit, *dataTransmissionInit ) );

    if( KErrAlreadyExists == r )

        {

        TRACE_ASSERT_ALWAYS;

        C_TRACE( ( _T( "RIscApi::InitializeModemInterface DRIVERS ERROR" ) ) );

        delete multiplexerInit;

        multiplexerInit = NULL;

        delete dataTransmissionInit;

        dataTransmissionInit = NULL;

        delete cleanup;

        cleanup = NULL;

        TRequestStatus* ptrStatus = &aStatus;

        User::RequestComplete( ptrStatus, r );

        return;

        }

    else

        {

        __ASSERT_ALWAYS( ( KErrNone == r ),

                           User::Panic( KIscApiPanic,EIscApiDriverLoadFail ) );

        }

    // Open control channel

    TInt channel( KIscControlChannel );

    TInt err = DoCreate( KIscDriverName, 

                            TVersion( KMajor, KMinor, KBuild ), 

                            channel,

                            NULL,

                            NULL,

                            EOwnerThread );

    __ASSERT_ALWAYS( KErrNone == err,

                     User::Panic( KIscApiPanic, EIscApiChannelCreateFail ) );

    iChannelNumber = static_cast<TUint16>( channel );

    iOpen = ETrue;

    TPtrC8 multiplexerInitString( multiplexerInit->Des() );

    TPtrC8 dataTransmissionInitString( dataTransmissionInit->Des() );

    TAny* params[ KThreeParams ];

    params[ KFirstParam ] = (TAny*)&aStatus;

    params[ KSecondParam ] = static_cast<TAny*>( &multiplexerInitString );

    params[ KThirdParam ] = static_cast<TAny*>( &dataTransmissionInitString );

    aStatus = KRequestPending;

    //Initialize Data transmission 

    DoSvControl( EIscAsyncInitializeModemInterface, params );

    delete multiplexerInit;

    multiplexerInit = NULL;

    delete dataTransmissionInit;

    dataTransmissionInit = NULL;

    delete cleanup;

    cleanup = NULL;

#ifdef __WINS__

    iInitializing = EFalse;

#endif

    A_TRACE( ( _T( "RIscApi::InitializeModemInterfaceL - return void" ) ) );

    }

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

// RIscApi::InitializeCancel

// Cancel ISC Initialization sequence

// ( other items were commented in a header ).

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

//

EXPORT_C void RIscApi::InitializeCancel()

    {

    A_TRACE( ( _T( "RIscApi::InitializeCancel()" ) ) );

	if( iOpen && iChannelNumber == KIscControlChannel )

		{

		DoControl( EIscCancelAsyncInitialize );			

		}

	else

		{

		// Do nothing if not controlchannel who is handling the initialization.	

		}

    A_TRACE( ( _T( "RIscApi::InitializeCancel - return void" ) ) );

    }

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

// RIscApi::LoadL

// Load required drivers using Isc_config.ini file

// ( other items were commented in a header ).

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

//

void RIscApi::LoadL

        ( 

        const TDesC8& aMultiplexerInit,     // Multiplexer init. 

        const TDesC8& aDataTransmissionInit // Datatransmission init.

        ) const

    {

    C_TRACE( ( _T( "RIscApi::LoadL(0x%x, 0x%x)" ), &aMultiplexerInit,

    											   &aDataTransmissionInit ) );

    TInt err( KErrNone );

    TInt loadStatus( KErrNone );

    TInt pos( KErrNone );

    // Temporary buffers.

    HBufC* driverNameBuf = HBufC::NewLC( KIscIniLineLength );

    HBufC* iniFileLineBuf = HBufC::NewLC( KIscIniLineLength );

    HBufC* initStringBuf = HBufC::NewLC( KIscIniLineLength );

    // Temporary pointers.

    TPtr driverName( driverNameBuf->Des() );

    TPtr initString( initStringBuf->Des() );

    TPtr iniFileLine( iniFileLineBuf->Des() );

    RFs fsSession;

    CleanupClosePushL( fsSession );

    RFile file;

    CleanupClosePushL( file );

    TFileText fileText;

    User::LeaveIfError( fsSession.Connect() );

    User::LeaveIfError( file.Open( fsSession, KIniFile,

    							   EFileStreamText | EFileRead ) );

    fileText.Set( file );

    while( KErrNone == fileText.Read( iniFileLine ) )

        {

        if( KErrNone < iniFileLine.Length() )

            {

            C_TRACE( ( iniFileLine ) );

            pos = KErrNotFound;

            loadStatus = KErrNotFound;

            if ( iniFileLine.Find( KHashSign ) != KErrNotFound )

                {

                pos = KErrNone;

                loadStatus = KErrNone;

                }

            else if ( iniFileLine.Find( KDataTransmissionPdd ) != KErrNotFound )

                {

                C_TRACE( ( _T( "RIscApi::LoadL - datatransmissionpdd" ) ) );

                iniFileLine.Trim();

                pos = InifileLineParser( iniFileLine, driverName );

                if( KErrNotFound != pos )

                    {

                    loadStatus = User::LoadPhysicalDevice( driverName );

                    }

                else

                	{

                	// Do nothing.

                	}

                }          

            else if ( iniFileLine.Find( KDataTransmissionLdd ) != KErrNotFound )

                {

                C_TRACE( ( iniFileLine ) );

                pos = InifileLineParser( iniFileLine, driverName );

                if( KErrNotFound != pos )

                    {

                    DriverNameParser( initString, driverName,

                    				 *&aDataTransmissionInit );

                    loadStatus = User::LoadLogicalDevice( driverName );

                    }

                else

                	{

                	// Do nothing.

                	}

                }

            else if ( iniFileLine.Find( KMultiplexerLdd ) != KErrNotFound )

                {

                C_TRACE( ( iniFileLine ) );

                pos = InifileLineParser( iniFileLine, driverName );

                if( KErrNotFound != pos )

                    {

                    DriverNameParser( initString, driverName,

                    				  *&aMultiplexerInit );

                    loadStatus = User::LoadLogicalDevice( driverName );

                    }

                else

                	{

                	// Do nothing.

                	}

                }

            else if ( iniFileLine.Find( KPdd ) != KErrNotFound )

                {

                C_TRACE( ( _T( "RIscApi::LoadL - pdd" ) ) );

                iniFileLine.Trim();

                pos = InifileLineParser( iniFileLine, driverName );

                if( KErrNotFound != pos )

                    {

                    loadStatus = User::LoadPhysicalDevice( driverName );

                    }

                else

                	{

                	// Do nothing.

                	}

                }

            else if ( iniFileLine.Find( KLdd ) != KErrNotFound )

                {

                RDebug::Print( _L( "RIscApi::LoadL ldd" ) );

                iniFileLine.Trim();

                pos = InifileLineParser( iniFileLine, driverName );

                if( KErrNotFound != pos )

                    {

                    loadStatus = User::LoadLogicalDevice( driverName );

                    }

                else

                	{

                	// Do nothing.

                	}

                }

            __ASSERT_ALWAYS( pos != KErrNotFound,

            				 User::Panic( KIscApiPanic, EIscApiFalseIniFile ) );

            __ASSERT_ALWAYS( KErrAlreadyExists != loadStatus,

            				 User::Leave( loadStatus ) );

            __ASSERT_ALWAYS( KErrNone == loadStatus,

            				 User::Panic( KIscApiPanic, EIscApiDriverLoadFail ) );

            }

        else

        	{

        	C_TRACE( ( _T( "RIscApi::LoadL IniFileLength = KErrNone" ) ) );

        	}

        }

    loadStatus = User::LoadLogicalDevice( KIscDriverLdd );

    err = User::LoadLogicalDevice( KIscDriverExtensionLdd );

    C_TRACE( ( _T( "RIscApi::LoadL drivers iscdriver %d, iscdriverext %d" ),

    			    loadStatus, err ) );

    __ASSERT_ALWAYS( ( KErrNone == loadStatus|| KErrNone == err ),

                       User::Panic( KIscApiPanic, EIscApiDriverLoadFail ) );

    // R-Classes fsSession and file Close-method is called when deleted

    // from CleanupStack.

    CleanupStack::PopAndDestroy( KTwoParams );

    CleanupStack::PopAndDestroy( initStringBuf );

    CleanupStack::PopAndDestroy( iniFileLineBuf );

    CleanupStack::PopAndDestroy( driverNameBuf );

    C_TRACE( ( _T( "RIscApi::LoadL - return void" ) ) );

    }

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

// IscApi::LoadLHelper

// Helps parsing the .ini file.

// ( other items were commented in a header ).

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

//

TInt RIscApi::InifileLineParser

        (

        TDes& aInifileLine,

        TDes& aDriverName 

        ) const

    {

    C_TRACE( ( _T( "RIscApi::InifileLineParser" ) ) );

    TInt position( KErrNotFound );

    position = aInifileLine.Find( KEqualSign );

    if( KErrNotFound != position )

        {

        // Split the string.

        C_TRACE( ( aInifileLine ) );

        aDriverName.Zero();

        aDriverName.Append( aInifileLine.Mid( position + KAddPosition ) );

        aInifileLine.Delete(  KStartPosition, KIscIniLineLength );

        C_TRACE( ( aDriverName ) );

        }

    else

    	{

    	// Do nothing.	

    	}         

    C_TRACE( ( _T( "RIscApi::InifileLineParser return %d" ), position ) );

    return position;

    }

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

// IscApi::LoadLSecondHelper

// Helps parsing the .ini file.

// ( other items were commented in a header ).

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

//    

void RIscApi::DriverNameParser

        (

        TDes& aInitString,

        TDes& aDriverName,

        const TDesC8& aString 

        )const    

    {

    C_TRACE( ( _T( "RIscApi::DriverNameParser" ) ) );

    TInt position = aDriverName.Find( KSemiColon );

    if( KErrNotFound != position )

        {

        C_TRACE( ( aInitString ) );

        // Split the string.

        aInitString.Zero();

        aInitString.Append( aDriverName.Mid( position + KAddPosition ) );

        aDriverName.Delete( position, KIscIniLineLength );

        C_TRACE( ( aDriverName ) );

        TPtr8 tmpPtr( ( static_cast<HBufC8*>( &const_cast<TDesC8&>( aString ) ) )->Des() );

        tmpPtr.Append( aInitString );

        C_TRACE( ( aInitString ) );

        }

    else

    	{

    	// Do nothing.	

    	}         

    C_TRACE( ( _T( "RIscApi::DriverNameParser return " ) ) );

    }

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

// RIscApi::Open

// Open ISC channel asyncronously

// ( other items were commented in a header ).

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

//

EXPORT_C void RIscApi::Open(    

    const TUint16 aChannelNumber,    

    TRequestStatus& aStatus,

    TOwnerType aType,

    const TDesC8* aOpenParams )

    {

    A_TRACE( ( _T( "RIscApi::Open(0x%x, 0x%x, 0x%x, 0x%x) this %x" ),

    			  aChannelNumber, &aStatus, aType, aOpenParams, this ) );

    // In case if async Close() is called but channel is not destructed,

    // release kernel side memory allocations before actual channel opening.

    if( iChannelNumber != KIscFrameReceiverNotFound && iOpen == EFalse )

        {

        Close();

        }

    else

    	{

    	// Do nothing.	

    	}        

#ifdef __WINS__

    // InitializeModemInterface() must be called to load correct drivers.

    // In HW this is done e.g. from EStart 

    RMutex iscapiMutex;

    if ( !iInitializing )

        {

        C_TRACE( ( _T( "RIscApi::Open mutex creation" ) ) );

        TInt createErr( iscapiMutex.CreateGlobal( _L( "ISCAPICONNECT" ) ) );

        if ( createErr == KErrNoMemory )

            {

            C_TRACE( ( _T( "RIscApi::Open mutex creation FAILED" ) ) );

            TRequestStatus* ptrStatus = &aStatus;

            User::RequestComplete( ptrStatus, KErrNoMemory );

            return;

            }

        else if ( createErr )

            {

            TInt openErr( iscapiMutex.OpenGlobal( _L( "ISCAPICONNECT" ) ) );

            if ( openErr )

                {

                C_TRACE( ( _T( "RIscApi::Open mutex open FAILED" ) ) );

                TRequestStatus* ptrStatus = &aStatus;

                User::RequestComplete( ptrStatus, KErrNoMemory );

                return;

                }

			else

				{

				// Do nothing.	

				}    

            }

	    else

	    	{

	    	// Do nothing.	

	    	}            

        iscapiMutex.Wait();

        }

    RDevice handle;

    // If already openend, initialization not needed

    TInt r = handle.Open( KIscDriverName );

    if( r == KErrNotFound && !iInitializing )

        {

        RIscApi temp;

        TRequestStatus status;

        temp.InitializeModemInterface( status );

        iInitializing = EFalse;

        User::WaitForRequest( status );

        r = status.Int();

        temp.Close();

        }

    else

    	{

    	// Do nothing.	

    	}        

    if( !iInitializing )

        {

        iscapiMutex.Signal();

        }

    else

    	{