/*

* Copyright (c) 2005-2009 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:  Access to content and data attributes

*

*/

// Includes

#include <apgcli.h>

#include <f32file.h>

#include <charconv.h>

#include <caf/caf.h>

#include <caf/cafplatform.h>

#include <caf/attributeset.h>

#include <caf/stringattributeset.h>

#include <caf/virtualpath.h>

#include <caf/caferr.h>

#include <utf.h>

#include <drmagents.h>

#include <featmgr.h>

#include "Oma2Agent.h"

#include "Oma2AgentAttributes.h"

#include "Oma1Dcf.h"

#include "oma2dcf.h"

#include "DRMRightsClient.h"

#include "DRMProtectedRoParser.h"

using namespace ContentAccess;

// LOCAL FUNCTION PROTOTYPES

LOCAL_C HBufC* CollectEmbeddedRosL(

    COma2Dcf* aDcf);

LOCAL_C HBufC* GetDomainRiUrlL(

    COma2Dcf* aDcf);

LOCAL_C HBufC* GetDomainIdL(

    COma2Dcf* aDcf);

LOCAL_C HBufC* GetDomainRiIdL(

    COma2Dcf* aDcf);

LOCAL_C TInt CheckIntentL(

    const TDesC8& aContentId,

    TIntent aIntent,

    RDRMRightsClient* aRightsClient);

LOCAL_C TInt GetEstimatedArrivalTime(

    const TDesC8& aContentId,

    RDRMRightsClient* aRightsClient);

LOCAL_C TInt GetContentName(

    const TDesC8& aContentId,

    HBufC*& aContentName,

    RDRMRightsClient* aRightsClient );

// LOCAL CONSTANTS

_LIT16(KOma1DcfContentType16, "application/vnd.oma.drm.content");

_LIT16(KOma2DcfContentType16, "application/vnd.oma.drm.dcf");

const TInt KMaxAlbumTrack = 3;

const TInt KMaxRecordingYear = 6;

const TInt KAllowAllDefined =  

    DRM::EDrmAllowAudioAnalog |

    DRM::EDrmAllowAudioFmTransmitter |

    DRM::EDrmAllowAudioBluetooth |

    DRM::EDrmAllowAudioUplink |

    DRM::EDrmAllowVideoAnalog |

    DRM::EDrmAllowVideoMacroVision |

    DRM::EDrmAllowAudioUsb |   

    DRM::EDrmAllowAudioHdmiHdcpRequired |

    DRM::EDrmAllowAudioHdmi |

    DRM::EDrmAllowVideoHDMI  |

    DRM::EDrmAllowVideoHdmiHdcpRequested |

    DRM::EDrmAllowVideoHdmiHdcpRequired;

// ============================= LOCAL FUNCTIONS ===============================

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

// CollectEmbeddedRosL

// Concatenate all rights objects embedded in a DCF into one buffer

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

//

LOCAL_C HBufC* CollectEmbeddedRosL(

    COma2Dcf* aDcf)

    {

    HBufC* r = NULL;

    HBufC* ro = NULL;

    TPtr ptr(NULL, 0);

    TInt i;

    TInt n;

    if (aDcf != NULL && aDcf->iRightsObjects.Count() > 0)

        {

        n = 0;

        for (i = 0; i < aDcf->iRightsObjects.Count(); i++)

            {

            n += aDcf->iRightsObjects[i]->Length();

            }

        r = HBufC::NewLC(n);

        ptr.Set(r->Des());

        for (i = 0; i < aDcf->iRightsObjects.Count(); i++)

            {

            ro = CnvUtfConverter::ConvertToUnicodeFromUtf8L(

                *aDcf->iRightsObjects[i]);

            ptr.Append(*ro);

            delete ro;

            }

        CleanupStack::Pop(r);

        }

    return r;

    }

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

// GetDomainRiUrlL

// Returns the RI URL from the last embedded domain RO, to be used for

// automatically joining a domain

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

//

LOCAL_C HBufC* GetDomainRiUrlL(

    COma2Dcf* aDcf)

    {

    HBufC8* url = NULL;

    HBufC* r = NULL;

    CDrmProtectedRoParser* parser = NULL;

    if (aDcf != NULL && aDcf->iRightsObjects.Count() > 0)

        {

        parser = CDrmProtectedRoParser::NewL();

        CleanupStack::PushL(parser);

        url = parser->GetRiUrlL(*aDcf->iRightsObjects[ 0 ]);

        if (url != NULL)

            {

            CleanupStack::PushL(url);

            r = CnvUtfConverter::ConvertToUnicodeFromUtf8L(*url);

            CleanupStack::PopAndDestroy(); // url

            }

        CleanupStack::PopAndDestroy(); // parser

        }

    return r;

    }

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

// GetDomainRiIdL

// Returns the RI ID from the last embedded domain RO, to be used for

// automatically joining a domain

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

//

LOCAL_C HBufC* GetDomainRiIdL(

    COma2Dcf* aDcf)

    {

    HBufC8* id = NULL;

    HBufC* r = NULL;

    CDrmProtectedRoParser* parser = NULL;

    TInt i;

    TPtr ptr(NULL, 0);

    if (aDcf != NULL && aDcf->iRightsObjects.Count() > 0)

        {

        parser = CDrmProtectedRoParser::NewL();

        CleanupStack::PushL(parser);

        id = parser->GetRiIdL(*aDcf->iRightsObjects[ 0 ]);

        if (id != NULL)

            {

            CleanupStack::PushL(id);

            r = HBufC::NewL(id->Length() * 2);

            ptr.Set(r->Des());

            for (i = 0; i < id->Length(); i++)

                {

                ptr.Append((*id)[i]);

                }

            CleanupStack::PopAndDestroy(); // url

            }

        CleanupStack::PopAndDestroy(); // parser

        }

    return r;

    }

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

// GetDomainIdL

// Returns the domain ID from the last embedded domain RO, to be used for

// automatically joining a domain

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

//

LOCAL_C HBufC* GetDomainIdL(

    COma2Dcf* aDcf)

    {

    HBufC8* id = NULL;

    HBufC* r = NULL;

    CDrmProtectedRoParser* parser = NULL;

    if (aDcf != NULL && aDcf->iRightsObjects.Count() > 0)

        {

        parser = CDrmProtectedRoParser::NewL();

        CleanupStack::PushL(parser);

        id = parser->GetDomainIdL(*aDcf->iRightsObjects[ 0 ]);

        if (id != NULL)

            {

            CleanupStack::PushL(id);

            r = CnvUtfConverter::ConvertToUnicodeFromUtf8L(*id);

            CleanupStack::PopAndDestroy(); // id

            }

        CleanupStack::PopAndDestroy(); // parser

        }

    return r;

    }

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

// CheckIntentL

// Check the intent for a content ID via the rights server

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

//

LOCAL_C TInt CheckIntentL(

    const TDesC8& aContentId,

    TIntent aIntent,

    RDRMRightsClient* aRightsClient)

    {

    RDRMRightsClient client;

    TInt r;

    TBool retVal = EFalse;

    TUint32 reason = 0;

    if (aRightsClient == NULL)

        {

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

        r = client.CheckRights(aIntent, aContentId, reason);

        client.Close();

        }

    else

        {

        r = aRightsClient->CheckRights(aIntent, aContentId, reason);

        }

    // If the rights exist return ETrue

    if( r == KErrNone )

        {

        retVal = ETrue;

        }

    return retVal;

    }

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

// GetEstimatedArrivalTime

// Get the estimated arrival time for the rights (value of the

// X-OMA-Separate-Delivery header)

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

//

LOCAL_C TInt GetEstimatedArrivalTime(

    const TDesC8& aContentId,

    RDRMRightsClient* aRightsClient)

    {

    RDRMRightsClient client;

    TInt r;

    TTimeIntervalSeconds n;

    if (aRightsClient == NULL)

        {

        r = client.Connect();

        if (r != KErrNone)

            {

            return r;

            }

        r = client.GetEstimatedArrival(aContentId, n);

        client.Close();

        }

    else

        {

        r = aRightsClient->GetEstimatedArrival(aContentId, n);

        }

    if (r == KErrNone)

        {

        r = n.Int();

        // -1 is the special case when the arrival time has passed,

        // the first caller gets the KErrCAPendingRights meaning

        // the rights are still pending

        if( r == -1 )

            {

            r = KErrCAPendingRights;

            }

        }

    return r;

    }

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

// GetContentName

// Get the content name stored into the rights database

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

//

LOCAL_C TInt GetContentName(

    const TDesC8& aContentId,

    HBufC*& aContentName,

    RDRMRightsClient* aRightsClient )

    {

    RDRMRightsClient client;

    TInt r;

    if (aRightsClient == NULL)

        {

        r = client.Connect();

        if( !r )

            {

            r = client.GetName(aContentId, aContentName);

            }

        client.Close();

        }

    else

        {

        r = aRightsClient->GetName(aContentId, aContentName);

        }

    return r;

    };

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

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

// TOma2AgentAttributes::

//

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

//

TInt TOma2AgentAttributes::GetAttribute(

    CDcfCommon& aDcfFile,

    TInt aAttribute,

    const TVirtualPathPtr& aVirtualPath,

    RDRMRightsClient* aRightsClient)

    {

    RDRMRightsClient client;

    TInt value = KErrCANotSupported;

    COma2Dcf* dcf2 = NULL;

    TBool protection = ETrue;

    HBufC8* buffer;

    TInt traperror = KErrNone;

    if (aDcfFile.iVersion == 2)

        {

        dcf2 = static_cast<COma2Dcf*>(&aDcfFile);

        if (dcf2->iEncryptionMethod == EMethodNULL)

            {

            protection = EFalse;

            }

        }

    if(aVirtualPath.UniqueId().Length() == 0)

        {

        // The DCF file itself

        switch(aAttribute)

            {

            case DRM::EDrmAgentUid:

                value = DRM::EDrmOmaAgent;

                break;

            case EIsProtected:

                value = EFalse;

                break;

            case EIsForwardable:

                value = ETrue;

                break;

            case EIsModifyable:

                value = EFalse;

                break;

            case EIsCopyable:

                value = ETrue;

                break;

            case EContentCDataInUse:

                value = KErrCANotSupported;

                break;

            case ECopyPaste:

                value = ETrue;

                break;

            case ECanMove:

                value = ETrue;

                break;

            case ECanRename:

                value = ETrue;

                break;

            case EFileType:

            case DRM::EDrmFileType:

                value = aDcfFile.iVersion;

                break;

            case ESilentRightsType:

                value = 0;

                break;

            case EDeliveryMethod:

                if (aDcfFile.iVersion == 2)

                    {

                    value = EOmaDrm2;

                    }

                else

                    {

                    if (aDcfFile.iContentID->Left(4).Compare(_L8("flk:")) == 0)

                        {

                        if (aRightsClient == NULL)

                            {

                            value = client.Connect();

                            if (value != KErrNone)

                                {

                                break;

                                }

                            if (client.ForwardLockURI(buffer) == KErrNone &&

                                buffer != NULL)

                                {

                                if (aDcfFile.iContentID->Compare(*buffer) == 0)

                                    {

                                    value = EOmaDrm1ForwardLock;

                                    }

                                else

                                    {

                                    value = EOmaDrm1CombinedDelivery;

                                    }

                                delete buffer;

                                }

                            else

                                {

                                value = KErrGeneral;

                                }

                            client.Close();

                            break;

                            }

                        else

                            {

                            if (aRightsClient->ForwardLockURI(buffer) == KErrNone &&

                            buffer != NULL)

                                {

                                if (aDcfFile.iContentID->Compare(*buffer) == 0)

                                    {

                                    value = EOmaDrm1ForwardLock;

                                    }

                                else

                                    {

                                    value = EOmaDrm1CombinedDelivery;

                                    }

                                delete buffer;

                                }

                            else

                                {

                                value = KErrGeneral;

                                }

                            }

                        }

                    else if (aDcfFile.iContentID->Left(4).Compare(_L8("ldf:")) == 0)

                        {

                        value = EOmaDrm1LocalDataFile;

                        }

                    else

                        {

                        value = EOmaDrm1SeparateDelivery;

                        }

                    }

                break;

            case DRM::EDrmAllowedOutputs:

                if( dcf2 )

                    {

                    }

                else

                    {

                    value = KAllowAllDefined;

                    }

                break;

            default:

                value = KErrCANotSupported;

                break;

            }

        }

    else

        {

        switch(aAttribute)

            {

            case DRM::EDrmAgentUid:

                value = DRM::EDrmOmaAgent;

                break;

            case EIsProtected:

                value = protection;

                break;

            case EIsForwardable:

                if ((aDcfFile.iContentID->Left(4).Compare(_L8("flk:")) == 0)

                    ||

                    (aDcfFile.iContentID->Left(4).Compare(_L8("ldf:")) == 0))

                    {

                    value = EFalse;

                    }

                else

                    {

                    if (aDcfFile.iRightsIssuerURL == NULL )

                        {

                        value = EFalse;

                        }

                     else

                        {

                        value = ETrue;

                        }

                    }

                break;

            case EIsModifyable:

                value = protection ? EFalse : ETrue;

                break;

            case EIsCopyable:

                value = protection ? EFalse : ETrue;

                break;

            case ECanPlay:

                if (!protection)

                    {

                    value = ETrue;