/*
* Copyright (c) 2008 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 the WMDRM DLA Parser
*
*/


// INCLUDE FILES
#include <xml/xmlframeworkconstants.h>
#include "wmdrmdlaparser.h"

#define _LOGGING_FILE L"wmdrmdla.txt"
#include "logfn.h"

// CONSTANTS
_LIT8( KLaInfoTag8, "lainfo" );
_LIT8( KTIDTag8, "tid" );
_LIT8( KContentUrlTag8, "contenturl" );

// ----------------------------------------------------------------------------
// CWmDrmDlaParser::NewL
// ----------------------------------------------------------------------------
//
CWmDrmDlaParser* CWmDrmDlaParser::NewL()
    {
    LOGFN( "CWmDrmDlaParser::NewL" );
    CWmDrmDlaParser* self = new (ELeave) CWmDrmDlaParser();
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// ----------------------------------------------------------------------------
// CWmDrmDlaParser::CWmDrmDlaParser
// ----------------------------------------------------------------------------
//
CWmDrmDlaParser::CWmDrmDlaParser()
    {
    LOGFN( "CWmDrmDlaParser::CWmDrmDlaParser" );
    }

// ----------------------------------------------------------------------------
// CWmDrmDlaParser::~CWmDrmDlaParser
// ----------------------------------------------------------------------------
//
CWmDrmDlaParser::~CWmDrmDlaParser()
    {
    LOGFN( "CWmDrmDlaParser::~CWmDrmDlaParser" );
    delete iParser;
    delete iBuffer;
    }

// ----------------------------------------------------------------------------
// CWmDrmDlaParser::ConstructL
// ----------------------------------------------------------------------------
//
void CWmDrmDlaParser::ConstructL()
    {
    LOGFN( "CWmDrmDlaParser::ConstructL" );
    // Mime type of the parsed document
    _LIT8( KXmlMimeType, "text/xml" );
    // Construct the parser object
    iParser = Xml::CParser::NewL( KXmlMimeType, *this );
    }

// ----------------------------------------------------------------------------
// CWmDrmDlaParser::ProcessLicenseResponse
// ----------------------------------------------------------------------------
//
TInt CWmDrmDlaParser::ProcessLicenseResponse(
    const TDesC8& aLicenseResponse,
    HBufC8*& aTID,
    HBufC8*& aContentURL)
    {
    TInt error = KErrNone;
    
    LOGFNR( "CWmDrmDlaParser::ProcessLicenseResponse", error );
    
    // Find beginning of XML document ('<')
    TInt pos = aLicenseResponse.Locate( '<' );
    if ( pos != KErrNotFound )
      {
      iContentUrl = &aContentURL;
      iTID = &aTID;
      iErrorCode = KErrNone;
      TPtrC8 ptrUrl = aLicenseResponse.Mid( pos );
      TRAP( error, Xml::ParseL( *iParser, ptrUrl ) );
      if ( !error )
        {
        error = iErrorCode;
        }

      iTID = NULL;
      iContentUrl = NULL;

      delete iServerUrl;
      iServerUrl = NULL;
      }
    else
      {
      error = KErrCorrupt;
      }
    return error;
    }

// ----------------------------------------------------------------------------
// CWmDrmDlaParser::GetLicenseServerURLFromDRMHeader
// ----------------------------------------------------------------------------
//
TInt CWmDrmDlaParser::GetLicenseServerURLFromDRMHeader(
    const TDesC8& aDrmHeader,
    HBufC8*& aServerURL )
    {
    TInt error( KErrNone );
    
    LOGFNR( "CWmDrmDlaParser::GetLicenseServerURLFromDRMHeader", error );
    
    // Find beginning of XML document ('<')
    TInt pos = aDrmHeader.Locate( '<' );
    if ( pos != KErrNotFound )
        {
        iServerUrl = &aServerURL;
        iErrorCode = KErrNone;
        TPtrC8 ptrUrl = aDrmHeader.Mid( pos );
        TRAP( error, Xml::ParseL( *iParser, ptrUrl ) );
        if ( !error )
            {
            error = iErrorCode;
            }

        iServerUrl = NULL;

        delete iTID;
        iTID = NULL;

        delete iContentUrl;
        iContentUrl = NULL;
        }
    else
        {
        error = KErrCorrupt;
        }

    return error;
    }

// ----------------------------------------------------------------------------
// CWmDrmDlaParser::OnStartDocumentL
// From MContentHandler
// ----------------------------------------------------------------------------
//
void CWmDrmDlaParser::OnStartDocumentL(
    const Xml::RDocumentParameters& /*aDocParam*/,
    TInt /*aErrorCode*/ )
    {
    }

// ----------------------------------------------------------------------------
// CWmDrmDlaParser::OnEndDocumentL
// From MContentHandler
// ----------------------------------------------------------------------------
//
void CWmDrmDlaParser::OnEndDocumentL( TInt /*aErrorCode*/ )
    {
    }

// ----------------------------------------------------------------------------
// CWmDrmDlaParser::OnStartElementL
// From MContentHandler
// ----------------------------------------------------------------------------
//
void CWmDrmDlaParser::OnStartElementL(
    const Xml::RTagInfo& /*aElement*/,
    const Xml::RAttributeArray& /*aAttributes*/,
    TInt /*aErrorCode*/ )
    {
    }

// ----------------------------------------------------------------------------
// CWmDrmDlaParser::OnEndElementL
// From MContentHandler
// ----------------------------------------------------------------------------
//
void CWmDrmDlaParser::OnEndElementL(
    const Xml::RTagInfo& aElement,
    TInt aErrorCode)
    {
    User::LeaveIfError( aErrorCode );
    if ( !aElement.LocalName().DesC().CompareF( KLaInfoTag8 ) )
        {
        *iServerUrl = iBuffer;
        iBuffer = NULL;
        }
    else if ( !aElement.LocalName().DesC().CompareF( KTIDTag8 ) )
        {
        *iTID = iBuffer;
        iBuffer = NULL;
        }
    else if ( !aElement.LocalName().DesC().CompareF( KContentUrlTag8 ) )
        {
        *iContentUrl = iBuffer;
        iBuffer = NULL;
        }
    else
        {
        delete iBuffer;
        iBuffer = NULL;
        }
    }

// ----------------------------------------------------------------------------
// CWmDrmDlaParser::OnContentL
// From MContentHandler
// ----------------------------------------------------------------------------
//
void CWmDrmDlaParser::OnContentL( const TDesC8& aBytes, TInt /*aErrorCode*/ )
    {
    if ( !iBuffer )
        {
        iBuffer = aBytes.AllocL();
        }
    else
        {
        iBuffer = iBuffer->ReAllocL( iBuffer->Length() + aBytes.Length() );
        iBuffer->Des().Append( aBytes );
        }
 
   }

// ----------------------------------------------------------------------------
// CWmDrmDlaParser::OnStartPrefixMappingL
// From MContentHandler
// ----------------------------------------------------------------------------
//
void CWmDrmDlaParser::OnStartPrefixMappingL(
    const RString& /*aPrefix*/,
    const RString& /*aUri*/,
    TInt /*aErrorCode*/ )
    {
    }

// ----------------------------------------------------------------------------
// CWmDrmDlaParser::OnEndPrefixMappingL
// From MContentHandler
// ----------------------------------------------------------------------------
//
void CWmDrmDlaParser::OnEndPrefixMappingL(
    const RString& /*aPrefix*/,
    TInt /*aErrorCode*/ )
    {
    }

// ----------------------------------------------------------------------------
// CWmDrmDlaParser::OnIgnorableWhiteSpaceL
// From MContentHandler
// ----------------------------------------------------------------------------
//
void CWmDrmDlaParser::OnIgnorableWhiteSpaceL(
    const TDesC8& /*aBytes*/,
    TInt /*aErrorCode*/ )
    {
    }

// ----------------------------------------------------------------------------
// CWmDrmDlaParser::OnSkippedEntityL
// From MContentHandler
// ----------------------------------------------------------------------------
//
void CWmDrmDlaParser::OnSkippedEntityL(
    const RString& /*aName*/,
    TInt /*aErrorCode*/ )
    {
    }

// ----------------------------------------------------------------------------
// CWmDrmDlaParser::OnProcessingInstructionL
// From MContentHandler
// ----------------------------------------------------------------------------
//
void CWmDrmDlaParser::OnProcessingInstructionL(
    const TDesC8& /*aTarget*/,
    const TDesC8& /*aData*/,
    TInt /*aErrorCode*/ )
    {
    }

// ----------------------------------------------------------------------------
// CWmDrmDlaParser::OnError
// From MContentHandler
// ----------------------------------------------------------------------------
//
void CWmDrmDlaParser::OnError( TInt aErrorCode )
    {
    iErrorCode = aErrorCode;
    }

// ----------------------------------------------------------------------------
// CWmDrmDlaParser::GetExtendedInterface
// From MContentHandler
// ----------------------------------------------------------------------------
//
TAny* CWmDrmDlaParser::GetExtendedInterface( const TInt32 /* aUid */ )
    {
    return NULL;
    }