/*

* Copyright (c) 2003 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:   CXcapHttpAuthManager

*

*/

// INCLUDE FILES

#include <hash.h>

#include <e32math.h>

#include "XcapHttpRequest.h"

#include "XcapHttpTransport.h"

#include "XcapHttpAuthManager.h"

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

// CXcapHttpAuthManager::CXcapHttpAuthManager

// 

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

//

CXcapHttpAuthManager::CXcapHttpAuthManager( RHTTPSession& aHttpSession,

                                            CXcapHttpTransport& aTransportMain ) :

                                            iNonceCount( 1 ),

                                            iAuthorized( EFalse ),

                                            iHttpSession( aHttpSession ),

                                            iTransportMain( aTransportMain ),

                                            iStringPool( aHttpSession.StringPool() )

    { 

    }

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

// CXcapHttpAuthManager::NewL

// 

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

//

CXcapHttpAuthManager* CXcapHttpAuthManager::NewL( RHTTPSession& aHttpSession,

                                                  CXcapHttpTransport& aTransportMain,

                                                  const TXdmCredentials& aDigestCredentials )

    {

    CXcapHttpAuthManager* self = new ( ELeave ) CXcapHttpAuthManager( aHttpSession, aTransportMain );

    CleanupStack::PushL( self );

    self->ConstructL( aDigestCredentials );

    CleanupStack::Pop();  //self

    return self;

    }

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

// CXcapHttpAuthManager::~CXcapHttpAuthManager

// 

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

//

CXcapHttpAuthManager::~CXcapHttpAuthManager()

    {

    #ifdef _DEBUG

        iTransportMain.WriteToLog( _L8( "CXcapHttpAuthManager::~CXcapHttpAuthManager()" ) );

    #endif

    delete iMD5;

    delete iRealm;

    delete iOpaque;

    delete iDomain;

    delete iQopString;

    delete iAlgorithm;

    delete iServerNonce;

    }

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

// CXcapHttpAuthManager::ConstructL

// 

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

//

void CXcapHttpAuthManager::ConstructL( const TXdmCredentials& aDigestCredentials )

    {

    iMD5 = CMD5::NewL();

    iUserName.Copy( aDigestCredentials.iUserName );

    iPassword.Copy( aDigestCredentials.iPassword );

    } 

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

// CXcapHttpAuthManager::SetAuthorized

// 

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

//

void CXcapHttpAuthManager::SetAuthorized( TBool aAuthorized )

    {

    iAuthorized = aAuthorized;

    } 

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

// CXcapHttpAuthManager::IsAuthorized

// 

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

//

TBool CXcapHttpAuthManager::IsAuthorized() const

    {

    return iAuthorized;

    }

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

// CXcapHttpAuthManager::AuthorizationL

// 

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

//

HBufC8* CXcapHttpAuthManager::AuthorizationL( CXcapHttpRequest& aHttpRequest )

    {

    #ifdef _DEBUG

        iTransportMain.WriteToLog( _L8( "CXcapHttpAuthManager::AuthorizationL()" ) );

    #endif

    if( !iUnauthReceived )

        return NULL;

    TInt bufPtr = 0;

    HBufC8* ret = NULL;

    THTTPHdrVal requestUri;

    //All these strings should have been defined - except for

    //"opaque", maybe - in the WWW-Authentication header that

    //the server sent. In case some of them were not, let's just

    //keep going as if they were there, but were empty. The request

    //will then fail & be completed in the next MHFRunL() call. 

    TPtrC8 realm( iRealm ? iRealm->Des() : TPtrC8() );

    TPtrC8 qop( iQopString ? iQopString->Des() : TPtrC8() );

    TPtrC8 opaque( iOpaque ? iOpaque->Des() : TPtrC8() );

    TPtrC8 nonce( iServerNonce ? iServerNonce->Des() : TPtrC8() );

    TPtrC8 uri( aHttpRequest.RelativeUri() );

    TBuf8<8> nonceCount;

    nonceCount.AppendFormat( _L8( "%08x" ), iNonceCount );   

    CBufFlat* buffer = CBufFlat::NewL( 128 );

    CleanupStack::PushL( buffer ); 

    buffer->InsertL( bufPtr, KAuthHeaderStart );

    bufPtr = bufPtr + KAuthHeaderStart().Length();

    buffer->InsertL( bufPtr, iUserName );

    bufPtr = bufPtr + iUserName.Length();    

    buffer->InsertL( bufPtr, KAuthHeaderParamEndQ );

    bufPtr = bufPtr + KAuthHeaderParamEndQ().Length();    

    buffer->InsertL( bufPtr, KAuthHeaderRealm );

    bufPtr = bufPtr + KAuthHeaderRealm().Length();

    buffer->InsertL( bufPtr, realm );

    bufPtr = bufPtr + realm.Length();

    buffer->InsertL( bufPtr, KAuthHeaderParamEndQ );

    bufPtr = bufPtr + KAuthHeaderParamEndQ().Length();   

    buffer->InsertL( bufPtr, KAuthHeaderNonce );

    bufPtr = bufPtr + KAuthHeaderNonce().Length();

    buffer->InsertL( bufPtr, nonce );

    bufPtr = bufPtr + nonce.Length();

    buffer->InsertL( bufPtr, KAuthHeaderParamEndQ );

    bufPtr = bufPtr + KAuthHeaderParamEndQ().Length(); 

    buffer->InsertL( bufPtr, KAuthHeaderUri );

    bufPtr = bufPtr + KAuthHeaderUri().Length();

    buffer->InsertL( bufPtr, uri );

    bufPtr = bufPtr + uri.Length();

    buffer->InsertL( bufPtr, KAuthHeaderParamEndQ );

    bufPtr = bufPtr + KAuthHeaderParamEndQ().Length();

    buffer->InsertL( bufPtr, KAuthHeaderQop );

    bufPtr = bufPtr + KAuthHeaderQop().Length();

    buffer->InsertL( bufPtr, qop );

    bufPtr = bufPtr + qop.Length();

    buffer->InsertL( bufPtr, KAuthHeaderParamEnd );

    bufPtr = bufPtr + KAuthHeaderParamEnd().Length();

    buffer->InsertL( bufPtr, KAuthHeaderNonceCount );

    bufPtr = bufPtr + KAuthHeaderNonceCount().Length();

    buffer->InsertL( bufPtr, nonceCount );

    bufPtr = bufPtr + nonceCount.Length();

    buffer->InsertL( bufPtr, KAuthHeaderParamEnd );

    bufPtr = bufPtr + KAuthHeaderParamEnd().Length();

    buffer->InsertL( bufPtr, KAuthHeaderCNonce );

    bufPtr = bufPtr + KAuthHeaderCNonce().Length();

    buffer->InsertL( bufPtr, iClientNonce );

    bufPtr = bufPtr + iClientNonce.Length();

    buffer->InsertL( bufPtr, KAuthHeaderParamEndQ );

    bufPtr = bufPtr + KAuthHeaderParamEndQ().Length();    

    buffer->InsertL( bufPtr, KAuthHeaderResponse );

    bufPtr = bufPtr + KAuthHeaderResponse().Length();  

    TPtrC8 respDigest( RequestDigestLC( aHttpRequest )->Des() );

    buffer->InsertL( bufPtr, respDigest );

    bufPtr = bufPtr + respDigest.Length(); 

    CleanupStack::PopAndDestroy();  //RequestDigestLC()

    buffer->InsertL( bufPtr, KAuthHeaderParamEndQ );

    bufPtr = bufPtr + KAuthHeaderParamEndQ().Length();

    if( opaque.Length() > 0 )

        {

        buffer->InsertL( bufPtr, KAuthHeaderOpaque );

        bufPtr = bufPtr + KAuthHeaderOpaque().Length();

        buffer->InsertL( bufPtr, opaque );

        bufPtr = bufPtr + opaque.Length();

        buffer->InsertL( bufPtr, KAuthHeaderParamQuote );

        }

    ret = HBufC8::NewL( buffer->Size() );

    ret->Des().Copy( buffer->Ptr( 0 ) );

    buffer->Reset();

    iNonceCount++;

    CleanupStack::PopAndDestroy();  //buffer

    return ret;

    }

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

// CXcapHttpAuthManager::ConsumeAuthInfoParamL

// 

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

//

TBool CXcapHttpAuthManager::ConsumeAuthInfoParamL( TAuthInfoParam aName, const TDesC8& aValue )

    {

    //For the time being, always return ETrue

    TBool ret = ETrue;

    TInt length = aValue.Length();

    TPtr8 value( CONST_CAST( TUint8*, aValue.Ptr() ), length, length );

    Unquote( value );

    #ifdef _DEBUG

        TPtrC8 name( KAuthInfoParamArray[aName] );

        iTransportMain.WriteToLog( _L8( "CXcapHttpAuthManager::ConsumeAuthInfoParamL()" ) );

        iTransportMain.WriteToLog( _L8( "  Name:   %S" ), &name );

        iTransportMain.WriteToLog( _L8( "  Value:  %S" ), &value );

    #endif

    switch( aName )

        {                                              

        case ENfoNextnonce:

            {

            SetNextNonceL( value );

            #ifdef _DEBUG

                TPtrC8 nonce( iServerNonce->Des() );

                iTransportMain.WriteToLog( _L8( "  -> Nonce set to %S" ), &nonce );

            #endif

            }

            break;

        case ENfoRspauth:

            /* TODO */

            break;

        case ENfoCnonce:

            #ifdef _DEBUG

                iTransportMain.WriteToLog( _L8( "  -> Current cnonce %S" ), &iClientNonce );

            #endif

            break;

            //ret = value.Compare( iClientNonce ) == 0;

        case ENfoNc:

            {

            TBuf8<8> nonceCount;

            nonceCount.AppendFormat( _L8( "%08x" ), iNonceCount );

            #ifdef _DEBUG

                iTransportMain.WriteToLog( _L8( "  -> Current nonce count %S" ), &nonceCount );

            #endif

            //ret = nonceCount.Compare( value ) == 0;

            break;

            }

        case ENfoQop:

            ret = ETrue;

            break;

        default:

            ret = ETrue;

            break;

        }

    return ret;

    }

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

// CXcapHttpAuthManager::GenerateClientNonce

// 

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

//

void CXcapHttpAuthManager::SetNextNonceL( const TDesC8& aNextnonce )

    {

    delete iServerNonce;

    iServerNonce = NULL;

    iServerNonce = aNextnonce.AllocL();

    }

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

// CXcapHttpAuthManager::Unquote

// 

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

//

void CXcapHttpAuthManager::Unquote( TPtr8& aParamValue )

    {

    TInt index = aParamValue.Locate( '"' );

    while( index >= 0 )

        {

        aParamValue.Delete( index, 1 );

        index = aParamValue.Locate( '\"');

        }

    }

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

// CXcapHttpAuthManager::RequestDigestLC

// 

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

//

HBufC8* CXcapHttpAuthManager::RequestDigestLC( CXcapHttpRequest& aHttpRequest )

    {

    #ifdef _DEBUG

        iTransportMain.WriteToLog( _L8( "CXcapHttpAuthManager::RequestDigestLC()" ) );

    #endif

    HBufC8* ret = NULL;

    TPtrC8 nonce( iServerNonce->Des() );

    if( iQop == EXcapAuth || iQop == EXcapAuthInt )

        {

        TBuf8<8> nonceCount;

        TBuf8<KXcapHashLength> hashBush;

        nonceCount.AppendFormat( _L8( "%08x" ), iNonceCount );

        TPtrC8 nonce( iServerNonce->Des() );

        TPtrC8 qop( iQop == EXcapAuth ? _L8( "auth" ) : _L8( "auth-int" ) );

        HBufC8* stringToHash = HBufC8::NewLC( nonce.Length() + qop.Length() +

                                              3 * KXcapHashLength + 8 + 5 );

        TPtr8 desc( stringToHash->Des() );

        ConstructHA1L( desc );

        desc.Append( ':' );

        desc.Append( nonce );

        desc.Append( ':' );

        desc.Append( nonceCount );

        desc.Append( ':' );

        desc.Append( iClientNonce );

        desc.Append(':');

        desc.Append( qop );

        desc.Append(':');

        ConstructHA2L( hashBush, aHttpRequest );

        desc.Append( hashBush ); 

        hashBush.Zero();		

        ret = HBufC8::NewL( KXcapHashLength );

        Hash( *stringToHash, hashBush );

        ret->Des().Copy( hashBush );

        CleanupStack::PopAndDestroy();  //stringToHash

        CleanupStack::PushL( ret );

        }

    else

        {

        /*

        * This case is for compatibility with RFC 2069:

        * request-digest = <"> < KD ( H(A1), unq(nonce-value) ":" H(A2) ) > <">

        */

        #ifdef _DEBUG

            iTransportMain.WriteToLog( _L8( "  Qop not defined, ignore" ) );

        #endif

        }

    return ret;

    }

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

// CXcapHttpAuthManager::GenerateClientNonce

// 

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

//

void CXcapHttpAuthManager::GenerateClientNonce()

    {

    TTime time;

    TBuf8<33> key;

    time.UniversalTime();

    TInt64 randomNumber = Math::Rand( iSeed );

    randomNumber <<= 32;

    randomNumber += Math::Rand( iSeed );

    key.Zero();

    key.AppendNum( time.Int64(), EHex );

    key.Append( _L8( ":" ) );

    key.AppendNum( randomNumber, EHex );

    Hash( key, iClientNonce );

    }

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

// CXcapHttpAuthManager::Hash

// 

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

//

void CXcapHttpAuthManager::Hash( const TDesC8& aMessage, TDes8& aHash )

    {

    TBuf8<2> buf;

    aHash.Zero();

    iMD5->Reset();

    TPtrC8 hash = iMD5->Hash( aMessage );

    _LIT8( formatStr, "%02x" );

    for( TInt i = 0;i < KXcapRawHashLength;i++ )

        {

        buf.Zero();

        buf.Format( formatStr, hash[i] );

        aHash.Append( buf );

        }

    }

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

// CXcapHttpAuthManager::ParseQopL

// 

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

//

void CXcapHttpAuthManager::ParseQopL( const TDesC8& aQopString )

    {

    _LIT8( KXcapAuthInt, "auth-int" );

    iQop = aQopString.FindF( KXcapAuthInt ) == 0 ? EXcapAuthInt : EXcapAuth;

    delete iQopString;

    iQopString = NULL;

    iQopString = HBufC8::NewL( 8 );

    iQopString->Des().Copy( iQop == EXcapAuth ? _L8( "auth" ) : _L8( "auth-int" )  );

    #ifdef _DEBUG

        TPtrC8 qop( iQopString->Des() );

        iTransportMain.WriteToLog( _L8( "  Qop:         %S" ), &qop );

    #endif

    GenerateClientNonce();

    iNonceCount = 1;    

    }

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

// CXcapHttpAuthManager::ParseHeaderL

// 

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

//

TBool CXcapHttpAuthManager::ParseHeaderL( RHTTPTransaction& aTransaction, TInt aAuthType )

    {

    #ifdef _DEBUG

        iTransportMain.WriteToLog( _L8( "CXcapHttpAuthManager::ParseHeaderL()" ) );

    #endif

    TBool ret = EFalse;

    THTTPHdrVal fieldVal;

    RHTTPHeaders headers = aTransaction.Response().GetHeaderCollection();

    RStringF auth = aAuthType == KAuthTypeNormal ? 

        iStringPool.StringF( HTTP::EWWWAuthenticate, RHTTPSession::GetTable() ) :

        iStringPool.StringF( HTTP::EProxyAuthenticate, RHTTPSession::GetTable() );

    headers.GetField( auth, 0, fieldVal );

    if( fieldVal.StrF() == iStringPool.StringF( HTTP::EDigest, RHTTPSession::GetTable() ) )

        {

        ret = ETrue;

        TInt error = headers.GetParam( auth, iStringPool.StringF( HTTP::ERealm, RHTTPSession::GetTable() ), fieldVal );

        if( KErrNone == error )

            {

            delete iRealm;

            iRealm = NULL;

            iRealm = fieldVal.Str().DesC().AllocL();

            #ifdef _DEBUG

                TPtrC8 realm( fieldVal.Str().DesC() );

                iTransportMain.WriteToLog( _L8( "  Realm:       %S" ), &realm );

            #endif

            }

        //In a proper WWW-Authentication request there SHOULD have been 

        //a qop value. In case there was not, call the whole thing off

        error = headers.GetParam( auth, iStringPool.StringF( HTTP::EQop, RHTTPSession::GetTable() ), fieldVal );

        if( KErrNone == error )

            ParseQopL( fieldVal.Str().DesC() );

        else

            {

            delete iQopString;

            iQopString = NULL;

            ret = EFalse;

            }

        error = headers.GetParam( auth, iStringPool.StringF( HTTP::ENonce, RHTTPSession::GetTable() ), fieldVal );

        if( ret && KErrNone == error )

            {

            SetNextNonceL( fieldVal.Str().DesC() );

            #ifdef _DEBUG

                TPtrC8 nonce( iServerNonce->Des() );

                iTransportMain.WriteToLog( _L8( "  Nonce:       %S" ), &nonce );

            #endif

            }

        error = headers.GetParam( auth, iStringPool.StringF( HTTP::EOpaque, RHTTPSession::GetTable() ), fieldVal );

        if( ret && KErrNone == error )

            {

            delete iOpaque;

            iOpaque = NULL;

            iOpaque = fieldVal.Str().DesC().AllocL();

            #ifdef _DEBUG

                TPtrC8 opaque( iOpaque->Des() );

                iTransportMain.WriteToLog( _L8( "  Opaque:      %S" ), &opaque );

            #endif

            }

        error = headers.GetParam( auth, iStringPool.StringF( HTTP::EStale, RHTTPSession::GetTable() ), fieldVal );

        if( ret && KErrNone == error )

            {

            #ifdef _DEBUG

                TPtrC8 stale( fieldVal.Str().DesC() );

                iTransportMain.WriteToLog( _L8( "  Stale:       %S" ), &stale );

            #endif

            }

        error = headers.GetParam( auth, iStringPool.StringF( HTTP::EDomain, RHTTPSession::GetTable() ), fieldVal );

        if( ret && KErrNone == error )

            {

            delete iDomain;

            iDomain = NULL;

            iDomain = fieldVal.Str().DesC().AllocL();

            #ifdef _DEBUG

                TPtrC8 domain( iDomain->Des() );

                iTransportMain.WriteToLog( _L8( "  Domain:       %S" ), &domain );

            #endif

            }

        error = headers.GetParam( auth, iStringPool.StringF( HTTP::EAlgorithm, RHTTPSession::GetTable() ), fieldVal );

        if( ret && KErrNone == error )

            {

            delete iAlgorithm;

            iAlgorithm = NULL;

            iAlgorithm = fieldVal.Str().DesC().AllocL();

            #ifdef _DEBUG

                TPtrC8 algorithm( iAlgorithm->Des() );

                iTransportMain.WriteToLog( _L8( "  Algorithm:   %S" ), &algorithm );

            #endif

            }

        }

    iUnauthReceived = ETrue;

    return ret;

    }

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

// CXcapHttpAuthManager::ConstructHA1L

// 

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

//

void CXcapHttpAuthManager::ConstructHA1L( TDes8& aResult )

    {

    #ifdef _DEBUG

        iTransportMain.WriteToLog( _L8( "CXcapHttpAuthManager::ConstructHA1L()" ) );

    #endif

    HBufC8* buffer = HBufC8::NewLC( iUserName.Length() +

                     iPassword.Length() + iRealm->Des().Length() + 2 ); 

    TPtr8 desc( buffer->Des() );

    desc.Copy( iUserName );

    desc.Append(':');

    desc.Append( iRealm->Des() );

    desc.Append(':');

    desc.Append( iPassword );

    Hash( *buffer, aResult );

    CleanupStack::PopAndDestroy();  //buffer	

    }

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

// CXcapHttpAuthManager::ConstructHA2L

// 

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

//