Mercurial Mercurial > oss > FCL > sf > mw > drm / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
omadrm/drmengine/agentv2/src/Oma2AgentAttributes.cpp
changeset 87 c938d010410d
parent 84 b09186059647
equal deleted inserted replaced
84:b09186059647 87:c938d010410d 
     1 /*
 
     1 /*
 
     2 * Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
 
     2 * Copyright (c) 2005-2010 Nokia Corporation and/or its subsidiary(-ies).
 
     3 * All rights reserved.
 
     3 * All rights reserved.
 
     4 * This component and the accompanying materials are made available
 
     4 * This component and the accompanying materials are made available
 
     5 * under the terms of "Eclipse Public License v1.0"
 
     5 * under the terms of "Eclipse Public License v1.0"
 
     6 * which accompanies this distribution, and is available
 
     6 * which accompanies this distribution, and is available
 
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 
   344     TInt value = KErrCANotSupported;
 
   344     TInt value = KErrCANotSupported;
 
   345     COma2Dcf* dcf2 = NULL;
 
   345     COma2Dcf* dcf2 = NULL;
 
   346     TBool protection = ETrue;
 
   346     TBool protection = ETrue;
 
   347     HBufC8* buffer;
 
   347     HBufC8* buffer;
 
   348     TInt traperror = KErrNone;
 
   348     TInt traperror = KErrNone;
 
       
   349     TInt ret = KErrNone;
 
   349 
   350 
   350     if (aDcfFile.iVersion == 2)
 
   351     if (aDcfFile.iVersion == 2)
 
   351         {
 
   352         {
 
   352         dcf2 = static_cast<COma2Dcf*>(&aDcfFile);
 
   353         dcf2 = static_cast<COma2Dcf*>(&aDcfFile);
 
   353         if (dcf2->iEncryptionMethod == EMethodNULL)
 
   354         if (dcf2->iEncryptionMethod == EMethodNULL)
 
   723                     }
 
   724                     }
 
   724                 break;
 
   725                 break;
 
   725             case ERightsNone:
 
   726             case ERightsNone:
 
   726                 if (aRightsClient == NULL)
 
   727                 if (aRightsClient == NULL)
 
   727                     {
 
   728                     {
 
   728                     value = client.Connect();
 
   729                     ret = client.Connect();
 
   729                     if (value != KErrCANoRights)
 
   730                     if (ret != KErrNone)
 
   730                         {
 
   731                         {
 
       
   732                         value = ret;
 
   731                         break;
 
   733                         break;
 
   732                         }
 
   734                         }
 
   733                     TUint32 reason = 0;
 
   735                     TUint32 reason = 0;
 
   734                     value = client.CheckRights(EPeek, *aDcfFile.iContentID, reason);
 
   736                     value = EFalse;
 
   735                     if(value == KErrCANoRights  || KErrCANoPermission)
 
   737                     ret = client.CheckRights(EPeek, *aDcfFile.iContentID, reason);
 
       
   738                     if(ret == KErrCANoRights  || ret == KErrCANoPermission)
 
   736                         {
 
   739                         {
 
   737                         value = ETrue;
 
   740                         value = ETrue;
 
   738                         }
 
   741                         }
 
   739                     client.Close();
 
   742                     client.Close();
 
   740                     }
 
   743                     }
 
   741                 else
 
   744                 else
 
   742                     {
 
   745                     {
 
   743                     TUint32 reason = 0;
 
   746                     TUint32 reason = 0;
 
   744                     value = aRightsClient->CheckRights(EPeek, *aDcfFile.iContentID, reason);
 
   747                     value = EFalse;
 
   745                     if(value == KErrCANoRights  || KErrCANoPermission)
 
   748                     ret = aRightsClient->CheckRights(EPeek, *aDcfFile.iContentID, reason);
 
       
   749                     if(ret == KErrCANoRights  || ret == KErrCANoPermission)
 
   746                         {
 
   750                         {
 
   747                         value = ETrue;
 
   751                         value = ETrue;
 
   748                         }
 
   752                         }
 
   749                     }
 
   753                     }
 
   750                 break;
 
   754                 break;
 
   751             case ERightsHaveExpired:
 
   755             case ERightsHaveExpired:
 
   752                 if (aRightsClient == NULL)
 
   756                 if (aRightsClient == NULL)
 
   753                     {
 
   757                     {
 
   754                     value = client.Connect();
 
   758                     ret = client.Connect();
 
   755                     if (value != KErrNone)
 
   759                     if (ret != KErrNone)
 
   756                         {
 
   760                         {
 
       
   761                         value = ret;
 
   757                         break;
 
   762                         break;
 
   758                         }
 
   763                         }
 
   759                     value = ETrue;
 
   764                     value = ETrue;
 
   760                     TUint32 reason = 0;
 
   765                     TUint32 reason = 0;
 
   761                     value = client.CheckRights(EPlay, *aDcfFile.iContentID, reason);
 
   766                     ret = client.CheckRights(EPlay, *aDcfFile.iContentID, reason);
 
   762                     if(value != KErrCANoRights  || KErrCANoPermission)
 
   767                     if(ret != KErrCANoRights && ret != KErrCANoPermission)
 
   763                         {
 
   768                         {
 
   764                         value = EFalse;
 
   769                         value = EFalse;
 
   765                         }
 
   770                         }
 
   766                     value = client.CheckRights(EView, *aDcfFile.iContentID, reason);
 
   771                     if(value)
 
   767                     if(value != KErrCANoRights  || KErrCANoPermission)
 
   772                         { 
   768                         {
 
   773                         ret = client.CheckRights(EView, *aDcfFile.iContentID, reason);
 
   769                         value = EFalse;
 
   774                         if(ret != KErrCANoRights && ret != KErrCANoPermission)
 
   770                         }
 
   775                             {
 
   771                     value = client.CheckRights(EExecute, *aDcfFile.iContentID, reason);
 
   776                             value = EFalse;
 
   772                     if(value != KErrCANoRights  || KErrCANoPermission)
 
   777                             }
 
   773                         {
 
   778                         }
 
   774                         value = EFalse;
 
   779                     if(value)
 
   775                         }
 
   780                         {
 
   776                     value = client.CheckRights(EPrint, *aDcfFile.iContentID, reason);
 
   781                         ret = client.CheckRights(EExecute, *aDcfFile.iContentID, reason);
 
   777                     if(value != KErrCANoRights  || KErrCANoPermission)
 
   782                         if(ret != KErrCANoRights && ret != KErrCANoPermission)
 
   778                         {
 
   783                             {
 
   779                         value = EFalse;
 
   784                             value = EFalse;
 
       
   785                             }
 
       
   786                         }
 
       
   787                     if(value)
 
       
   788                         {
 
       
   789                         ret = client.CheckRights(EPrint, *aDcfFile.iContentID, reason);
 
       
   790                         if(ret != KErrCANoRights && ret != KErrCANoPermission)
 
       
   791                             {
 
       
   792                             value = EFalse;
 
       
   793                             }
 
   780                         }
 
   794                         }
 
   781                     client.Close();
 
   795                     client.Close();
 
   782                     }
 
   796                     }
 
   783                 else
 
   797                 else
 
   784                     {
 
   798                     {
 
   785                     value = ETrue;
 
   799                     value = ETrue;
 
   786                     TUint32 reason = 0;
 
   800                     TUint32 reason = 0;
 
   787                     value = aRightsClient->CheckRights(EPlay, *aDcfFile.iContentID, reason);
 
   801                     ret = aRightsClient->CheckRights(EPlay, *aDcfFile.iContentID, reason);
 
   788                     if(value != KErrCANoRights  || KErrCANoPermission)
 
   802                     if(ret != KErrCANoRights && ret != KErrCANoPermission)
 
   789                         {
 
   803                         {
 
   790                         value = EFalse;
 
   804                         value = EFalse;
 
   791                         }
 
   805                         }
 
   792                     value = aRightsClient->CheckRights(EView, *aDcfFile.iContentID, reason);
 
   806                     if(value)
 
   793                     if(value != KErrCANoRights  || KErrCANoPermission)
 
   807                         {
 
   794                         {
 
   808                         ret = aRightsClient->CheckRights(EView, *aDcfFile.iContentID, reason);
 
   795                         value = EFalse;
 
   809                         if(ret != KErrCANoRights && ret != KErrCANoPermission)
 
   796                         }
 
   810                             {
 
   797                     value = aRightsClient->CheckRights(EExecute, *aDcfFile.iContentID, reason);
 
   811                             value = EFalse;
 
   798                     if(value != KErrCANoRights  || KErrCANoPermission)
 
   812                             }
 
   799                         {
 
   813                         }
 
   800                         value = EFalse;
 
   814                     if(value)
 
   801                         }
 
   815                         {
 
   802                     value = aRightsClient->CheckRights(EPrint, *aDcfFile.iContentID, reason);
 
   816                         ret = aRightsClient->CheckRights(EExecute, *aDcfFile.iContentID, reason);
 
   803                     if(value != KErrCANoRights  || KErrCANoPermission)
 
   817                         if(ret != KErrCANoRights && ret != KErrCANoPermission)
 
   804                         {
 
   818                             {
 
   805                         value = EFalse;
 
   819                             value = EFalse;
 
   806                         }
 
   820                             }
 
   807 
   821                         }
 
       
   822                     if(value)
 
       
   823                         {
 
       
   824                         ret = aRightsClient->CheckRights(EPrint, *aDcfFile.iContentID, reason);
 
       
   825                         if(ret != KErrCANoRights && ret != KErrCANoPermission)
 
       
   826                             {
 
       
   827                             value = EFalse;
 
       
   828                             }
 
       
   829                         }
 
   808                     }
 
   830                     }
 
   809                 break;
 
   831                 break;
 
   810             default:
 
   832             default:
 
   811                 value = KErrCANotSupported;
 
   833                 value = KErrCANotSupported;
 
   812                 break;
 
   834                 break;
 
   852     TDes& aValue,
 
   874     TDes& aValue,
 
   853     const TVirtualPathPtr& aVirtualPath,
 
   875     const TVirtualPathPtr& aVirtualPath,
 
   854     RDRMRightsClient* aRightsClient)
 
   876     RDRMRightsClient* aRightsClient)
 
   855     {
 
   877     {
 
   856     TInt err = KErrCANotSupported;
 
   878     TInt err = KErrCANotSupported;
 
   857     TInt ret = KErrNone;
 
       
   858     HBufC* b = NULL;
 
   879     HBufC* b = NULL;
 
   859     COma1Dcf* dcf1 = NULL;
 
   880     COma1Dcf* dcf1 = NULL;
 
   860     COma2Dcf* dcf2 = NULL;
 
   881     COma2Dcf* dcf2 = NULL;
 
   861     TPtrC8 ptr(NULL, 0);
 
   882     TPtrC8 ptr(NULL, 0);
 
   862     TPtr ptr16(NULL, 0, 0);
 
   883     TPtr ptr16(NULL, 0, 0);
FCL/sf/mw/drm