/*

* 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:  WPAdapterUtil is a utility class for reading resource strings.

*

*/

// INCLUDE FILES

#include <e32base.h>

#include <f32file.h>

#include <barsc.h>

#include <bautils.h>

#include <uri16.h>

#include "CWPCharacteristic.h"

#include "WPAdapterUtil.h"

#include "TWPFindAccesspoint.h"

#include <data_caging_path_literals.hrh>

#include "CWPInternetAPDB.h"

#include "ProvisioningDebug.h"

#include <cmmanager.h>

#include <cmmanagerext.h>

#include <cmconnectionmethod.h>

#include <cmconnectionmethodext.h>

#include <cmdestination.h>

#include <cmdestinationext.h>

#include <cmmanagerdef.h>

#include "ProvisioningInternalCRKeys.h"

#include <centralrepository.h>

// LOCAL FUNCTION PROTOTYPES

typedef TBool (*TParseFunc)( TLex& aLex );

LOCAL_C TBool DoOrReverse( TParseFunc aFunc, TLex& aLex );

LOCAL_C TBool Star( TParseFunc aFunc, TLex& aLex );

LOCAL_C TBool CheckIPv6Hex4( TLex& aLex );

LOCAL_C TBool CheckIPv6ColonHex4( TLex& aLex );

LOCAL_C TBool CheckIPv6HexSeq( TLex& aLex );

LOCAL_C TBool CheckIPv6HexPart( TLex& aLex );

LOCAL_C TBool CheckIPv4AddressPart( TLex& aLex );

LOCAL_C TBool CheckIPv4Address( TLex& aLex );

LOCAL_C TBool CheckIPv6Address( TLex& aLex );

//Local functions for Internet Parameter handling

//Get Cenrep key (Operator value)

LOCAL_C void GetCenrepKeyL(TDes8& aValue);

//Get Access Point ID from Database of Internet connection Methods

//or from Internet SNAP

LOCAL_C TUint GetAPIDFromDBorSNAPL(TDesC& aOrig);

//Get the Latest Access Point ID from Internet SNAP

LOCAL_C TUint GetInternetSnapLatestAPIDL(RCmDestinationExt& InternetDestination);

// Get the destination of purpose Internet

LOCAL_C void GetInternetSnapDestinationL(RCmManagerExt& aCmManager, RCmDestinationExt& InternetDestination);

// Set the Internet Access point in Internet SNAP and 

// Database of Internet connection Methods

LOCAL_C void SetAPtoDBandSNAPL(const TUint aAPID, const TDesC& aOriginator);

using namespace CMManager;

/// Default resource file suffix

_LIT( KResourceFileSuffix, ".rsc" );

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

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

// WPAdapterUtil::AccesspointL

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

//

EXPORT_C CWPCharacteristic* WPAdapterUtil::AccesspointL( 

                                            CWPCharacteristic& aCharacteristic )

    {

    TWPFindAccesspoint finder;

    aCharacteristic.AcceptL( finder );

    return finder.iNapDef;

    }

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

// WPAdapterUtil::ReadHBufCL

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

//

EXPORT_C HBufC* WPAdapterUtil::ReadHBufCL( const TDesC& aDllPath, 

                                           const TDesC& aAdapterName,

                                           TInt aResourceId )

    {

    // Open a file server session

    RFs fs;

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

    CleanupClosePushL(fs);

    // Open the resource file

    RResourceFile resourceFile;

    FindAndOpenResourceFileLC(fs, aDllPath, aAdapterName, resourceFile);

    TResourceReader resReader;

    resReader.SetBuffer( resourceFile.AllocReadLC( aResourceId ) );

    HBufC* text = resReader.ReadHBufCL();

    CleanupStack::PopAndDestroy(3); // resourceFile, fs, aResourceId

    return text;

    }

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

// WPAdapterUtil::FindAndOpenResourceFileLC

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

//

void WPAdapterUtil::FindAndOpenResourceFileLC( RFs& aFs, 

                                               const TDesC& aDllPath, 

                                               const TDesC& aAdapterName, 

                                               RResourceFile& aResFile )

    {

    // Get the drive from DLL file name

    TFileName fileName( aDllPath.Left( KMaxFileName ) );

    TParsePtrC parse( fileName );

    fileName = parse.Drive();

    fileName.Append( KDC_RESOURCE_FILES_DIR );

    fileName.Append( aAdapterName );

    fileName.Append( KResourceFileSuffix );

    // Retrieve the correct suffix

    BaflUtils::NearestLanguageFile( aFs, fileName );

    // Open the file

    aResFile.OpenL( aFs, fileName );

    CleanupClosePushL( aResFile );

    }

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

// WPAdapterUtil::CheckURI

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

//

EXPORT_C TBool WPAdapterUtil::CheckURI( const TDesC& aUrl )

    {

    TUriParser16 uriParser;

    TInt err = uriParser.Parse( aUrl );

    return err == KErrNone 

        && uriParser.IsPresent(EUriScheme)

        && uriParser.IsPresent(EUriHost);

    }

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

// WPAdapterUtil::CheckIPv4

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

//

EXPORT_C TBool WPAdapterUtil::CheckIPv4( const TDesC& aIP )

    {

    /*

    * ABNF

    * IPv4address = 1*3DIGIT "." 1*3DIGIT "." 1*3DIGIT "." 1*3DIGIT

    */

    TLex lex( aIP );

    return CheckIPv4Address( lex );

    }

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

// WPAdapterUtil::CheckIPv6

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

//

EXPORT_C TBool WPAdapterUtil::CheckIPv6( const TDesC& aIP )

    {

    /*

    * ABNF from RFC2373

    * IPv6address = hexpart [ ":" IPv4address ]

    * IPv4address = 1*3DIGIT "." 1*3DIGIT "." 1*3DIGIT "." 1*3DIGIT

    *

    * IPv6prefix  = hexpart "/" 1*2DIGIT

    *

    * hexpart = hexseq | hexseq "::" [ hexseq ] | "::" [ hexseq ]

    * hexseq  = hex4 *( ":" hex4)

    * hex4    = 1*4HEXDIG

    */

    TLex lex( aIP );

    TLex lexipv4( aIP );

    if(!CheckIPv4Address( lexipv4 ))

		return CheckIPv6Address( lex );

		else

    return EFalse;

    }

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

// CheckIPv6Address()

// IPv6address = hexpart [ ":" IPv4address ]

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

//

LOCAL_C TBool CheckIPv6Address( TLex& aLex )

    {

    TBool result( CheckIPv6HexPart( aLex ) );

    if( aLex.Peek() == '.' )

        {

        while( aLex.Peek() != ':' && aLex.Offset() > 0 )

            {

            aLex.UnGet();

            }

        aLex.Inc();

        result = CheckIPv4Address( aLex );

        }

    return result && aLex.Eos();

    }

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

// CheckIPv4Address()

// IPv4address = 1*3DIGIT "." 1*3DIGIT "." 1*3DIGIT "." 1*3DIGIT

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

//

LOCAL_C TBool CheckIPv4Address( TLex& aLex )

    {

    return CheckIPv4AddressPart( aLex ) 

        && aLex.Get() == '.'

        && CheckIPv4AddressPart( aLex ) 

        && aLex.Get() == '.'

        && CheckIPv4AddressPart( aLex ) 

        && aLex.Get() == '.'

        && CheckIPv4AddressPart( aLex ) && aLex.Get() == '\0' ;

    }

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

// CheckIPv4AddressPart()

// 1*3DIGIT

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

//

LOCAL_C TBool CheckIPv4AddressPart( TLex& aLex )

    {

    TBool result( aLex.Peek().IsDigit() );

    aLex.Inc();

    if( aLex.Peek().IsDigit() )

        {

        aLex.Inc();

        if( aLex.Peek().IsDigit() )

            {

            aLex.Inc();

            }

        }

    return result;

    }

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

// CheckIPv6HexPart()

// hexpart = hexseq | hexseq "::" [ hexseq ] | "::" [ hexseq ]

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

//

LOCAL_C TBool CheckIPv6HexPart( TLex& aLex )

    {

    TBool hexSeq( DoOrReverse( CheckIPv6HexSeq, aLex ) );

    TBool doubleSemiColon( EFalse );

    if( aLex.Peek() == ':' )

        {

        aLex.Inc();

        if( aLex.Get() == ':' )

            {

            doubleSemiColon = ETrue;

            DoOrReverse( CheckIPv6HexSeq, aLex );

            }

        }

    return hexSeq || doubleSemiColon;

    }

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

// CheckIPv6HexSeq()

// hexseq  = hex4 *( ":" hex4)

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

//

LOCAL_C TBool CheckIPv6HexSeq( TLex& aLex )

    {

    TBool result( CheckIPv6Hex4( aLex ) );

    if( result )

        {

        Star( CheckIPv6ColonHex4, aLex );

        }

    return result;

    }

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

// CheckIPv6ColonHex4()

// ":" hex4

// Used as a helper to give to Star()

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

//

LOCAL_C TBool CheckIPv6ColonHex4( TLex& aLex )

    {

    return aLex.Get() == ':'

        && CheckIPv6Hex4( aLex );

    }

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

// CheckIPv6Hex4()

// hex4    = 1*4HEXDIG

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

//

LOCAL_C TBool CheckIPv6Hex4( TLex& aLex )

    {

    _LIT( KHexDigits, "0123456789ABCDEF" );

    TPtrC hexDigits( KHexDigits );

    TBool foundOne( EFalse );

    while( hexDigits.LocateF( aLex.Peek() ) != KErrNotFound )

        {

        foundOne = ETrue;

        aLex.Inc();

        }

    return foundOne;

    }

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

// DoOrReverse()

// Calls aFunc. If it fails, the lexer is returned to 

// the state before calling DoOrReverse().

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

//

LOCAL_C TBool DoOrReverse( TParseFunc aFunc, TLex& aLex )

    {

    TLexMark mark;

    aLex.Mark( mark );

    if( (*aFunc)(aLex) )

        {

        return ETrue;

        }

    else

        {

        aLex.UnGetToMark( mark );

        return EFalse;

        }

    }

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

// Star()

// Calls aFunc repeatedly until aFunc returns EFalse.

// The lexer is left to the state where it was after

// the last succesful aFunc call. Returns ETrue if

// at least one call to aFunc succeeded.

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

//

LOCAL_C TBool Star( TParseFunc aFunc, TLex& aLex )

    {

    TBool hasMore( ETrue );

    TBool hasOne( EFalse );

    while( hasMore )

        {

        if( DoOrReverse( aFunc, aLex ) )

            {

            hasOne = ETrue; 

            }

        else

            {

            hasMore = EFalse;

            }

        }

    return hasOne;

    }

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

// WPAdapterUtil::SetAPDetailsL

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

EXPORT_C void WPAdapterUtil::SetAPDetailsL(TUint aAPId)

    {

    FLOG( _L( "[WPAdapterUtil] WPAdapterUtil::SetAPDetailsL:" ) );

    TBuf8<KOriginatorMaxLength> Orig;

    //Get Originator from the Cenrep Key

    GetCenrepKeyL(Orig);

    //Convert to TBuf

    TBuf<KOriginatorMaxLength> Orig1;

    Orig1.Copy(Orig);

    User::LeaveIfError(ERROR);

    //Set AP to SNAP and DB

    User::LeaveIfError(err);

    FLOG( _L( "[Provisioning] WPAdapterUtil::SetAPDetailsL: done" ) );

    }

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

// WPAdapterUtil::GetAPIDL

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

EXPORT_C TUint WPAdapterUtil::GetAPIDL()

    {

    FLOG( _L( "[Provisioning] WPAdapterUtil::GetAPIDL:" ) );

    TBuf8<KOriginatorMaxLength> Orig;

    //Get Originator from the P&S Key

    GetCenrepKeyL(Orig);

    //Convert to TBuf

    TBuf<KOriginatorMaxLength> Orig1;

    Orig1.Copy(Orig);

    TUint apid;

    //Get the APID from DB or SNAP

    apid = GetAPIDFromDBorSNAPL(Orig1);

    FLOG( _L( "[Provisioning] WPAdapterUtil::GetAPIDL:done" ) );

    return apid;

    }

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

//GetCenrepKeyL

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

//	

LOCAL_C void GetCenrepKeyL(TDes8& aValue)

    {

    FLOG( _L( "[Provisioning] WPAdapterUtil GetCenrepKeyL" ) );

    CRepository* rep = NULL;

    TInt errorStatus = KErrNone;

    TRAPD( errVal, rep = CRepository::NewL(KCRUidOMAProvisioningLV));

    if(errVal == KErrNone)

        {

        errorStatus = rep->Get( KOMAProvOriginatorContent ,aValue );

        }

    else

        {

        errorStatus = errVal;

        }

    if(rep)

        {

        delete rep;

        }

    if(errorStatus != KErrNone )

        {

        User::Leave(errorStatus);

        }

    FLOG( _L( "[Provisioning] WPAdapterUtil GetCenrepKeyL: done" ) );

    }

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

// GetAPIDFromDBorSNAPL

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

// 

LOCAL_C TUint GetAPIDFromDBorSNAPL(TDesC& aOrig)

    {

    FLOG( _L( "[Provisioning] WPAdapterUtil GetAPIDFromDBorSNAPL" ) );

    RArray<TAccessPointItem> AccessPointItem;

    RArray<TAccessPointItem> AccessPointItem2;

    CWPInternetAPDB *db = CWPInternetAPDB::NewLC();

    RCmConnectionMethodExt connection;

    RCmManagerExt cmManager;

    cmManager.OpenL();

    CleanupClosePushL( cmManager );

    if (aOrig.Length())

        {

        //Read the Accesspoint data from DB, for the same originator

        db->ReadDbItemsForOrigL(AccessPointItem, aOrig);

        }

    //Read the Accesspoint data from DB, for all originators

    db->ReadDbItemsL(AccessPointItem2);

    TInt APOrigCount = AccessPointItem.Count();

    TInt APCount = AccessPointItem2.Count();

    //Valid APID of same originator

    TBool APIDofSameOrig = EFalse;

    //Valid APID of same originator

    TBool APIDofOtherOrig = EFalse;

    //HBufC *AccessPointName = NULL;

    TUint apid = 0;

    TUint apid1;

    if (APOrigCount)

        {

        TInt i;

        for ( i = APOrigCount - 1; i >= 0; i-- )

            {

            apid1 = AccessPointItem[i].iAPID;

            TRAPD(err, connection = cmManager.ConnectionMethodL(apid1));

            if (err == KErrNone)

                {

                CleanupClosePushL( connection );

                if (AccessPointItem[i].iBearerType == connection.GetIntAttributeL(ECmBearerType))

                    {

                    //Valid access point of same originator is found

                    APIDofSameOrig = ETrue;

                    apid = apid1;

                    CleanupStack::PopAndDestroy();

                    break;

                    }