/*

* 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:  Handles the persistance of Bootstrap settings

*

*/

//  INCLUDE FILES

#include "CWPBootstrap.h"

#include <badesca.h>

#include <uri16.h>

#include <CWPCharacteristic.h>

#include <CWPParameter.h>

#include <CWPEngine.h>

#include "CWPPushMessage.h"

#include "MWPContextManager.h"

// CONSTANTS

const TInt KProxiesGranularity = 3;

const TInt KInitialHBufCSize = 1;

const TInt KProvURLMaxLength = 50;

_LIT( KHttp, "http://" );

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

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

// CWPBootstrap::CWPBootstrap

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

// might leave.

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

//

CWPBootstrap::CWPBootstrap( const TDesC& aIMSI )

                        : iIMSI( aIMSI )

    {

    }

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

// CWPBootstrap::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CWPBootstrap::ConstructL()

    {

    iProxies = new(ELeave) CDesC16ArrayFlat( KProxiesGranularity );

    iTPS = HBufC::NewL( KInitialHBufCSize );

    iName = HBufC::NewL( KInitialHBufCSize );

    }

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

// CWPCharacteristic::NewL

// Two-phased constructor.

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

//

EXPORT_C CWPBootstrap* CWPBootstrap::NewL( const TDesC& aIMSI )

    {

    CWPBootstrap* self = NewLC( aIMSI );

    CleanupStack::Pop();

    return self;

    }

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

// CWPCharacteristic::NewLC

// Two-phased constructor.

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

//

CWPBootstrap* CWPBootstrap::NewLC( const TDesC& aIMSI )

    {

    CWPBootstrap* self = new( ELeave ) CWPBootstrap(aIMSI);

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// Destructor

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

CWPBootstrap::~CWPBootstrap()

    {

    delete iProxies;

    delete iTPS;

    delete iName;

    }

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

// CWPBootstrap::SaveL

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

//

void CWPBootstrap::SaveL( CWPEngine& aEngine )

    {

    aEngine.CreateContextL( *iName, *iTPS, *iProxies );

    }

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

// CWPBootstrap::LoadL

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

//

void CWPBootstrap::LoadL( CWPEngine& aEngine )

    {

    // Check if the saved settings apply to the current home network

    if( !aEngine.ContextExistsL( *iTPS ) )

        {

        iLoaded = EFalse;

        }

    else

        {

        // Find TPS

        TUint32 tps( aEngine.ContextL( *iTPS ) );

        CDesCArray* proxies = aEngine.ContextProxiesL( tps );

        CleanupStack::PushL( proxies );

        HBufC* name = aEngine.ContextNameL( tps );

        CleanupStack::Pop(); // proxies

        delete iProxies;

        iProxies = proxies;

        delete iName;

        iName = name;

        iLoaded = ETrue;

        }

    }

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

// CWPBootstrap::BootstrapL

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

//

EXPORT_C CWPBootstrap::TBootstrapResult CWPBootstrap::BootstrapL( 

                                                    CWPPushMessage& aMessage,

                                                    CWPEngine& aEngine,

                                                    const TDesC& aPIN )

    {

    aEngine.AcceptL( *this );

    TBootstrapResult result( ENoBootstrap );

    if( !aMessage.Authenticated() )

        {

        result = DoAuthenticateL( aMessage, aPIN, aEngine );

        }

    else  if( iTPS->Length() > 0 )

        {

        result = DoBootstrapL( aEngine );

        }

    // Set TPS as the sender to later locate the correct configuration context

    if( result == ESucceeded )

        {

        HBufC8* orig = HBufC8::NewLC( iTPS->Length() );

        orig->Des().Copy( *iTPS );

        aMessage.SetOriginatorL( *orig );

        CleanupStack::PopAndDestroy(); // orig

        }

    return result;

    }

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

// CWPBootstrap::TPS

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

//

EXPORT_C const TDesC& CWPBootstrap::TPS() const

    {

    return *iTPS;

    }

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

// CWPBootstrap::DoBootstrapL

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

//

CWPBootstrap::TBootstrapResult CWPBootstrap::DoAuthenticateL( 

                                                    CWPPushMessage& aMessage,

                                                    const TDesC& aPIN,

                                                    CWPEngine& aEngine )

    {

    TBootstrapResult result( ENoBootstrap );

    TInt authResult( aMessage.AuthenticateL( iIMSI, aPIN ) );

    switch( authResult )

        {

        case KWPAuthResultAuthenticated:

            {

            if( iTPS->Length() > 0 )

                {

                result = DoBootstrapL( aEngine );

                }

            aMessage.SetAuthenticated( ETrue );

            break;

            }

        case KWPAuthResultPinRequired:

            {

            result = EPinRequired;

            break;

            }

        case KWPAuthResultAuthenticationFailed:

            {

            result = EAuthenticationFailed;

            break;

            }

        case KWPAuthResultNoAuthentication:

            {

            if( iTPS->Length() > 0 )

                {

                result = ENotAuthenticated;

                }

            else

                {

                result = ENoBootstrap;

                }

            break;

            }

        default:

            {

            break;

            }

        }

    return result;

    }

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

// CWPBootstrap::DoBootstrapL

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

//

CWPBootstrap::TBootstrapResult CWPBootstrap::DoBootstrapL( CWPEngine& aEngine )

    {

    TBootstrapResult result( ESucceeded );

    LoadL( aEngine );

    if( !iLoaded )

        {

        TRAPD( err, SaveL( aEngine ) );

        if( err == KErrNone )

            {

            result = ESucceeded;

            }

        else if( err == KErrAlreadyExists )

            {

            result = EBootstrapExists;

            }

        else

            {

            User::LeaveIfError( err );

            }

        }

    else

        {

        result = EBootstrapExists;

        }

    return result;

    }

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

// CWPBootstrap::VisitL

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

//

void CWPBootstrap::VisitL( CWPCharacteristic& aCharacteristic )

    {

    TInt prevChar = iCurrentChar;

    iCurrentChar = aCharacteristic.Type();

    switch( aCharacteristic.Type() )

        {

        case KWPBootstrap:

            /* FALLTHROUGH */

        case KWPPxLogical:

            /* FALLTHROUGH */

        case KWPPxPhysical:

            {

            aCharacteristic.AcceptL( *this );

            break;

            }

        default:

            {

            break;

            }

        }

    iCurrentChar = prevChar;

    }

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

// CWPBootstrap::VisitL

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

//

void CWPBootstrap::VisitL( CWPParameter& aParameter )

    {

    TPtrC value( aParameter.Value() );

    TPtrC http( KHttp );

    switch( aParameter.ID() )

        {

        case EWPParameterProvURL:

            {

            TInt ProvURLLength = value.Length();

            if( ProvURLLength <= KProvURLMaxLength && iCurrentChar == KWPBootstrap && iTPS->Length() == 0 )

                {

                HBufC* buf = HBufC::NewLC( ProvURLLength + http.Length() );

                TPtr ptr( buf->Des() );

                ptr.Copy( value );

                if( ptr.Left( http.Length() ).CompareF( http ) != 0 )

                    {

                    ptr.Insert( 0, http );

                    }

                TUriParser16 uri;

                if( uri.Parse( ptr ) == KErrNone && uri.IsPresent(EUriHost) )

                    {

                    HBufC* provUrl = uri.Extract(EUriHost).AllocL();

                    delete iTPS;

                    iTPS = provUrl;

                    }

                CleanupStack::PopAndDestroy(); // buf

                }

            break;

            }

        case EWPParameterName:

            {

            if( iCurrentChar == KWPBootstrap && iName->Length() == 0 )

                {

                delete iName;

                iName = NULL;

                TInt length = aParameter.Value().Length();

                if( length >= 50 ) 

                {

                TPtrC ptr = aParameter.Value().Left( 50 );

                iName = ptr.AllocL();

                }

				else

				{

					iName = aParameter.Value().AllocL();

				}

                }

            break;

            }

        case EWPParameterPxAddr:

            {

            TInt pos;

            if( iCurrentChar == KWPPxPhysical 

                && iProxies->Find( aParameter.Value(), pos ) != 0)

                {

                iProxies->AppendL( aParameter.Value() );

                }

            break;

            }

        default:

            break;

        }

    }

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

// CWPBootstrap::VisitL

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

//

void CWPBootstrap::VisitLinkL( CWPCharacteristic& aLink )

    {

    if( aLink.Type() == KWPPxLogical )

        {

        TInt prevChar = iCurrentChar;

        iCurrentChar = KWPPxLogical;

        aLink.AcceptL( *this );

        iCurrentChar = prevChar;

        }

    }

//  End of File