contentmgmt/referencedrmagent/RefTestAgent/RTAServer/Server/rtadatahandler.cpp
changeset 15 da2ae96f639b
parent 8 35751d3474b7
child 29 ece3df019add
equal deleted inserted replaced
10:afc583cfa176 15:da2ae96f639b
    47 	
    47 	
    48 CRtaDataHandler::~CRtaDataHandler()
    48 CRtaDataHandler::~CRtaDataHandler()
    49 	{
    49 	{
    50 	delete iArchive;
    50 	delete iArchive;
    51 	iFile.Close();
    51 	iFile.Close();
       
    52 #ifdef SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT          
       
    53     delete iWmdrmContentObject;     
       
    54 #endif //SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT 
    52 	}
    55 	}
    53 
    56 
    54 void CRtaDataHandler::ServiceL(const RMessage2& aMessage)
    57 void CRtaDataHandler::ServiceL(const RMessage2& aMessage)
    55 //
    58 //
    56 // Handle a client request.
    59 // Handle a client request.
   103 		GetStringAttributeSetL(aMessage);
   106 		GetStringAttributeSetL(aMessage);
   104 		break;
   107 		break;
   105 	case EDataSetProperty:
   108 	case EDataSetProperty:
   106 	case ENoEnforceDataSetProperty:
   109 	case ENoEnforceDataSetProperty:
   107 		SetPropertyL(aMessage);
   110 		SetPropertyL(aMessage);
   108 		break;		
   111 		break;
       
   112 #ifdef SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT
       
   113     case EReadWMDRMHeaderData:     
       
   114     case ENoEnforceReadWMDRMHeaderData:     
       
   115         ReadWMDRMHeaderL(aMessage);     
       
   116         break;     
       
   117          
       
   118     case EReadWMDRMDataPacket:     
       
   119     case ENoEnforceReadWMDRMDataPacket:     
       
   120         DecryptWMDRMDataPacketL(aMessage);     
       
   121         break;     
       
   122              
       
   123     case EWMDRMGetAttribute:     
       
   124     case ENoEnforceWMDRMGetAttribute:     
       
   125         GetWMDRMAttributeL(aMessage);     
       
   126         break;     
       
   127              
       
   128     case EWMDRMGetAttributeSet:     
       
   129     case ENoEnforceWMDRMGetAttributeSet:     
       
   130         GetWMDRMAttributeSetL(aMessage);     
       
   131         break;     
       
   132          
       
   133     case EWMDRMGetStringAttribute:     
       
   134     case ENoEnforceWMDRMGetStringAttribute:     
       
   135         GetWMDRMStringAttributeL(aMessage);     
       
   136         break;     
       
   137              
       
   138     case EWMDRMGetStringAttributeSet:     
       
   139     case ENoEnforceWMDRMGetStringAttributeSet:     
       
   140         GetWMDRMStringAttributeSetL(aMessage);     
       
   141         break;     
       
   142 #endif //SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT        
   109 	default:
   143 	default:
   110 		CRtaSession::PanicClient(aMessage,EPanicIllegalFunction);
   144 		CRtaSession::PanicClient(aMessage,EPanicIllegalFunction);
   111 		break;
   145 		break;
   112 		}
   146 		}
   113 	}
   147 	}
   325 
   359 
   326 void CRtaDataHandler::SetPropertyL(const RMessage2& /*aMessage*/)
   360 void CRtaDataHandler::SetPropertyL(const RMessage2& /*aMessage*/)
   327 	{	
   361 	{	
   328 	User::Leave(KErrCANotSupported);
   362 	User::Leave(KErrCANotSupported);
   329 	}
   363 	}
       
   364 
       
   365 #ifdef SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT     
       
   366       
       
   367 void CRtaDataHandler::ReadWMDRMHeaderL(const RMessage2& aMessage)     
       
   368     {     
       
   369     HBufC8* headerData = ReadDesC8LC(aMessage, 0);       
       
   370     iWmdrmContentObject = CWmdrmContentParser::NewL(*headerData);     
       
   371          
       
   372     CleanupStack::PopAndDestroy(headerData);     
       
   373     }     
       
   374          
       
   375 void CRtaDataHandler::DecryptWMDRMDataPacketL(const RMessage2& aMessage)     
       
   376     {     
       
   377     HBufC8* inputPacket = ReadDesC8LC(aMessage, 0);     
       
   378          
       
   379     HBufC8* decryptedPacket = ReadDes8LC(aMessage, 1);     
       
   380     TPtr8 decryptedPacketPtr = decryptedPacket->Des();     
       
   381          
       
   382     decryptedPacketPtr.Copy(*inputPacket);     
       
   383          
       
   384     WriteL(aMessage, 1, decryptedPacketPtr);     
       
   385          
       
   386     CleanupStack::PopAndDestroy(2, inputPacket);     
       
   387     }     
       
   388          
       
   389 void CRtaDataHandler::GetWMDRMAttributeL(const RMessage2& aMessage)     
       
   390     {     
       
   391     TInt attribute = aMessage.Int0();     
       
   392     TInt value;     
       
   393     TPckg <TInt> valuePckg(value);               
       
   394     User::LeaveIfError(iWmdrmContentObject->GetAttribute(attribute, value));     
       
   395          
       
   396     WriteL(aMessage, 1, valuePckg);     
       
   397     }     
       
   398          
       
   399 void CRtaDataHandler::GetWMDRMStringAttributeL(const RMessage2& aMessage)     
       
   400     {     
       
   401     TInt attribute = aMessage.Int0();     
       
   402     HBufC* value = ReadDes16LC(aMessage, 1);     
       
   403     TPtr valuePtr = value->Des();     
       
   404          
       
   405     User::LeaveIfError(iWmdrmContentObject->GetStringAttribute(attribute, valuePtr));     
       
   406     WriteL(aMessage, 1, valuePtr);     
       
   407          
       
   408     CleanupStack::PopAndDestroy(value);     
       
   409     }     
       
   410          
       
   411 void CRtaDataHandler::GetWMDRMAttributeSetL(const RMessage2& aMessage)     
       
   412     {     
       
   413     RAttributeSet attributeSet;     
       
   414     CleanupClosePushL(attributeSet);     
       
   415          
       
   416     HBufC8* value = ReadDes8LC(aMessage, 0);     
       
   417     TPtr8 valuePtr = value->Des();     
       
   418     RDesReadStream readStream(valuePtr);     
       
   419     CleanupClosePushL(readStream);     
       
   420          
       
   421     attributeSet.InternalizeL(readStream);     
       
   422     CleanupStack::PopAndDestroy(2, value);     
       
   423          
       
   424     iWmdrmContentObject->GetAttributeSet(attributeSet);     
       
   425       
       
   426     // Write the object out to a buffer, send to client     
       
   427     CBufFlat* buf = CBufFlat::NewL(50);     
       
   428     CleanupStack::PushL(buf);     
       
   429     // create write stream     
       
   430     RBufWriteStream writeStream(*buf);     
       
   431     CleanupClosePushL(writeStream);     
       
   432          
       
   433     // write the directory to the stream     
       
   434     attributeSet.ExternalizeL(writeStream);     
       
   435     CleanupStack::PopAndDestroy(&writeStream);     
       
   436          
       
   437     TPtr8 bufPtr = buf->Ptr(0);     
       
   438     WriteL(aMessage, 0, bufPtr);     
       
   439              
       
   440     CleanupStack::PopAndDestroy(2, &attributeSet); // buf, attributeSet     
       
   441     }     
       
   442          
       
   443 void CRtaDataHandler::GetWMDRMStringAttributeSetL(const RMessage2& aMessage)     
       
   444     {     
       
   445     RStringAttributeSet attributeSet;     
       
   446     CleanupClosePushL(attributeSet);     
       
   447          
       
   448     HBufC8* value = ReadDes8LC(aMessage, 0);     
       
   449     TPtr8 valuePtr = value->Des();     
       
   450     RDesReadStream readStream(valuePtr);     
       
   451     CleanupClosePushL(readStream);     
       
   452          
       
   453     attributeSet.InternalizeL(readStream);     
       
   454     CleanupStack::PopAndDestroy(2, value);     
       
   455          
       
   456     iWmdrmContentObject->GetStringAttributeSet(attributeSet);     
       
   457       
       
   458     // Write the object out to a buffer, send to client     
       
   459     CBufFlat* buf = CBufFlat::NewL(50);     
       
   460     CleanupStack::PushL(buf);     
       
   461     // create write stream     
       
   462     RBufWriteStream writeStream(*buf);     
       
   463     CleanupClosePushL(writeStream);     
       
   464          
       
   465     // write the directory to the stream     
       
   466     attributeSet.ExternalizeL(writeStream);     
       
   467     CleanupStack::PopAndDestroy(&writeStream);     
       
   468          
       
   469     TPtr8 bufPtr = buf->Ptr(0);     
       
   470     WriteL(aMessage, 0, bufPtr);     
       
   471              
       
   472     CleanupStack::PopAndDestroy(2, &attributeSet); // buf, attributeSet     
       
   473     }        
       
   474 #endif //SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT