contentmgmt/referencedrmagent/RefTestAgent/RTAServer/Server/rtamanagerhandler.cpp
/*
* Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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:
* SisRegistry - server session implementation
*
*/
/**
@file
@test
@internalComponent
*/
#include <s32mem.h>
#include <f32file.h>
#include <s32file.h>
#include <caf/virtualpath.h>
#include "rtamanagerhandler.h"
#include "RTAsession.h"
#include "RTAserver.h"
#include "rightsobject.h"
#include "rtaArchive.h"
#include "drmfilecontent.h"
#include "drmfiles.h"
using namespace ReferenceTestAgent;
using namespace ContentAccess;
//This structure is used to pass empty lists to the GetDir method.
class CDirectoryStruct : public CBase
{
public:
~CDirectoryStruct();
public:
CDir* entryList;
CDir* dirList;
};
CDirectoryStruct::~CDirectoryStruct()
{
delete entryList;
delete dirList;
}
CRtaManagerHandler* CRtaManagerHandler::NewL(const CSession2& aSession)
{
CRtaManagerHandler* self = new (ELeave) CRtaManagerHandler(aSession);
return self;
}
CRtaManagerHandler::CRtaManagerHandler(const CSession2& aSession) : CRtaMessageHandler(aSession)
{
}
CRtaManagerHandler::~CRtaManagerHandler()
{
delete iArchive;
iFile.Close();
#ifdef SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT
delete iWmdrmContentObject;
#endif //SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT
}
void CRtaManagerHandler::ServiceL(const RMessage2& aMessage)
//
// Handle a client request.
{
switch (aMessage.Function())
{
// RRtaManager functions
case EManagerDeleteFile:
case ENoEnforceManagerDeleteFile:
DeleteFileL(aMessage);
break;
case EManagerCopyFile:
case ENoEnforceManagerCopyFile:
CopyFileL(aMessage);
break;
case EManagerCopyFileHandle:
case ENoEnforceManagerCopyFileHandle:
CopyFileHandleL(aMessage);
break;
case EManagerRenameFile:
case ENoEnforceManagerRenameFile:
RenameFileL(aMessage);
break;
case EManagerMkDir:
case ENoEnforceManagerMkDir:
MkDirL(aMessage);
break;
case EManagerMkDirAll:
case ENoEnforceManagerMkDirAll:
MkDirAllL(aMessage);
break;
case EManagerRenameDir:
case ENoEnforceManagerRenameDir:
DeleteFileL(aMessage);
break;
case EManagerRemoveDir:
case ENoEnforceManagerRemoveDir:
RmDirL(aMessage);
break;
case EManagerGetDir1:
case ENoEnforceManagerGetDir1:
GetDir1L(aMessage);
break;
case EManagerGetDir2:
case ENoEnforceManagerGetDir2:
GetDir2L(aMessage);
break;
case EManagerGetDir3:
case ENoEnforceManagerGetDir3:
GetDir3L(aMessage);
break;
case EManagerGetAttribute:
case EManagerGetAttributeByFileHandle:
case ENoEnforceManagerGetAttribute:
GetAttributeL(aMessage);
break;
case EManagerGetAttributeSet:
case EManagerGetAttributeSetByFileHandle:
case ENoEnforceManagerGetAttributeSet:
GetAttributeSetL(aMessage);
break;
case EManagerGetStringAttribute:
case EManagerGetStringAttributeByFileHandle:
case ENoEnforceManagerGetStringAttribute:
GetStringAttributeL(aMessage);
break;
case EManagerGetStringAttributeSet:
case EManagerGetStringAttributeSetByFileHandle:
case ENoEnforceManagerGetStringAttributeSet:
GetStringAttributeSetL(aMessage);
break;
case EManagerNotifyStatusChange:
case ENoEnforceManagerNotifyStatusChange:
NotifyStatusChangeL(aMessage);
break;
case EManagerCancelNotifyStatusChange:
case ENoEnforceManagerCancelNotifyStatusChange:
CancelNotifyStatusChangeL(aMessage);
break;
case EManagerAgentSpecificCommand:
case ENoEnforceManagerAgentSpecificCommand:
AgentSpecificCommandL(aMessage);
break;
case EManagerSetProperty:
case ENoEnforceManagerSetProperty:
SetPropertyL(aMessage);
break;
case EManagerDisplayInfo:
case ENoEnforceManagerDisplayInfo:
DisplayInfoL(aMessage);
break;
case EManagerDisplayInfo1:
case ENoEnforceManagerDisplayInfo1:
DisplayInfo1L(aMessage);
break;
case EManagerDisplayManagementInfo:
case ENoEnforceManagerDisplayManagementInfo:
DisplayManagementInfoL(aMessage);
break;
#ifdef SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT
case EWMDRMGetAttribute:
case ENoEnforceWMDRMGetAttribute:
GetWMDRMAttributeL(aMessage);
break;
case EWMDRMGetAttributeSet:
case ENoEnforceWMDRMGetAttributeSet:
GetWMDRMAttributeSetL(aMessage);
break;
case EWMDRMGetStringAttribute:
case ENoEnforceWMDRMGetStringAttribute:
GetWMDRMStringAttributeL(aMessage);
break;
case EWMDRMGetStringAttributeSet:
case ENoEnforceWMDRMGetStringAttributeSet:
GetWMDRMStringAttributeSetL(aMessage);
break;
#endif //SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT
default:
CRtaSession::PanicClient(aMessage,EPanicIllegalFunction);
break;
}
}
void CRtaManagerHandler::DeleteFileL(const RMessage2& aMessage)
{
_LIT(KSystemDrive, "C:"); // not always c but close enough for test/ref
const TInt KPrivatePathLen = 32;
TBuf<KPrivatePathLen> myDataCage;
User::LeaveIfError(Server().Fs().PrivatePath(myDataCage));
myDataCage.Insert(0, KSystemDrive);
HBufC16* buffer = ReadDesC16LC(aMessage,0);
if (buffer->FindF(myDataCage) == KErrNotFound)
{
User::Leave(KErrArgument);
}
User::LeaveIfError(Server().Fs().Delete(*buffer));
CleanupStack::PopAndDestroy(buffer);
}
void CRtaManagerHandler::CopyFileL(const RMessage2& aMessage)
{
// Read source and destination
HBufC16* source = ReadDesC16LC(aMessage,0);
HBufC16* destination= ReadDesC16LC(aMessage,1);
// Attempt to copy the files
CFileMan* fileMan = CFileMan::NewL(Server().Fs());
CleanupStack::PushL(fileMan);
User::LeaveIfError(fileMan->Copy(*source, *destination, EFalse));
CleanupStack::PopAndDestroy(3, source); // fileman, destination, source
}
void CRtaManagerHandler::CopyFileHandleL(const RMessage2& aMessage)
{
RFile file;
// Read source and destination
User::LeaveIfError(file.AdoptFromClient(aMessage,0,1));
CleanupClosePushL(file);
HBufC16* destination= ReadDesC16LC(aMessage,2);
// Attempt to copy the files
CFileMan* fileMan = CFileMan::NewL(Server().Fs());
CleanupStack::PushL(fileMan);
User::LeaveIfError(fileMan->Copy(file, *destination));
CleanupStack::PopAndDestroy(3); // fileman, destination, file
}
void CRtaManagerHandler::RenameFileL(const RMessage2& aMessage)
{
// Read source and destination
HBufC16* source = ReadDesC16LC(aMessage,0);
HBufC16* destination= ReadDesC16LC(aMessage,1);
// Attempt to rename the file
User::LeaveIfError(Server().Fs().Rename(*source, *destination));
CleanupStack::PopAndDestroy(2, source); // destination, source
}
void CRtaManagerHandler::MkDirL(const RMessage2& aMessage)
{
// Read path
HBufC16* path = ReadDesC16LC(aMessage,0);
// Attempt to create the directory
User::LeaveIfError(Server().Fs().MkDir(*path));
CleanupStack::PopAndDestroy(path);
}
void CRtaManagerHandler::MkDirAllL(const RMessage2& aMessage)
{
// Read path
HBufC16* path = ReadDesC16LC(aMessage,0);
// Attempt to create the directory
User::LeaveIfError(Server().Fs().MkDirAll(*path));
CleanupStack::PopAndDestroy(path);
}
void CRtaManagerHandler::RenameDirL(const RMessage2& aMessage)
{
// Read oldPath, newPath
HBufC16* oldPath = ReadDesC16LC(aMessage,0);
HBufC16* newPath = ReadDesC16LC(aMessage,1);
// Attempt to rename the directory
User::LeaveIfError(Server().Fs().Rename(*oldPath, *newPath));
CleanupStack::PopAndDestroy(2, oldPath); // newPath, oldPath
}
void CRtaManagerHandler::RmDirL(const RMessage2& aMessage)
{
// Read path
HBufC16* path = ReadDesC16LC(aMessage,0);
// Attempt to remove the directory
User::LeaveIfError(Server().Fs().RmDir(*path));
CleanupStack::PopAndDestroy(path);
}
void CRtaManagerHandler::GetDir1L(const RMessage2& aMessage)
{
// read path
HBufC* name = ReadDesC16LC(aMessage,0);
// read entry attribute mask
TUint entryAttMask;
TPckg<TUint> entryAttMaskPckg(entryAttMask);
aMessage.Read(1, entryAttMaskPckg);
// read entry sort key
TUint entrySortKey;
TPckg<TUint> entrySortKeyPckg(entrySortKey);
aMessage.Read(2, entrySortKeyPckg);
// Get Dir
CDir* entryList = NULL;
User::LeaveIfError(Server().Fs().GetDir(*name, entryAttMask, entrySortKey, entryList));
CleanupStack::PushL(entryList);
// Write results to the client
WriteCDirToMessageL(aMessage, 3, *entryList);
CleanupStack::PopAndDestroy(2, name); // entryList, name
}
void CRtaManagerHandler::GetDir2L(const RMessage2& aMessage)
{
// read path
HBufC* name = ReadDesC16LC(aMessage,0);
// read entry attribute mask
TUint entryAttMask;
TPckg<TUint> entryAttMaskPckg(entryAttMask);
aMessage.Read(1, entryAttMaskPckg);
// read entry sort key, packaged beside entryAttMask in the same parameter
TUint entrySortKey;
TPckg<TUint> entrySortKeyPckg(entrySortKey);
aMessage.Read(1, entrySortKeyPckg, entryAttMaskPckg.MaxLength());
CDirectoryStruct* dirstruct = new (ELeave) CDirectoryStruct;
CleanupStack::PushL(dirstruct);
User::LeaveIfError(Server().Fs().GetDir(*name, entryAttMask, entrySortKey, dirstruct->entryList, dirstruct->dirList));
// copy data across into CDirStreamable
WriteCDirToMessageL(aMessage, 2, *dirstruct->entryList);
WriteCDirToMessageL(aMessage, 3, *dirstruct->dirList);
CleanupStack::PopAndDestroy(2, name); // dirstruct, name
}
void CRtaManagerHandler::GetDir3L(const RMessage2& aMessage)
{
// read path
HBufC* name = ReadDesC16LC(aMessage,0);
// read entry Uid
TUidType entryUid;
TPckg<TUidType> entryUidPckg(entryUid);
aMessage.Read(1, entryUidPckg);
// read entry sort key, packaged beside entryAttMask in the same parameter
TUint entrySortKey;
TPckg<TUint> entrySortKeyPckg(entrySortKey);
aMessage.Read(2, entrySortKeyPckg);
CDir* fileList = NULL;
User::LeaveIfError(Server().Fs().GetDir(*name, entryUid, entrySortKey, fileList));
// copy data across into CDirStreamable
CleanupStack::PushL(fileList);
WriteCDirToMessageL(aMessage, 3, *fileList);
CleanupStack::PopAndDestroy(2, name); // fileList, name
}
void CRtaManagerHandler::GetAttributeL(const RMessage2& aMessage)
{
// open the content object specified in parameter 0,1 either using virtual path or file handle
OpenContentObjectL(aMessage, 0, 1);
TAttributePckg pckgObject;
TPckg <TAttributePckg> pckgData(pckgObject);
aMessage.ReadL(2, pckgData);
User::LeaveIfError(iContentObject->GetAttribute(pckgData().iAttribute, pckgData().iValue));
WriteL(aMessage, 2, pckgData);
}
void CRtaManagerHandler::GetAttributeSetL(const RMessage2& aMessage)
{
// open the content object specified in parameter 0,1 either using virtual path or file handle
OpenContentObjectL(aMessage, 0, 1);
RAttributeSet attributeSet;
CleanupClosePushL(attributeSet);
HBufC8* value = ReadDes8LC(aMessage, 2);
TPtr8 valuePtr = value->Des();
RDesReadStream readStream(valuePtr);
attributeSet.InternalizeL(readStream);
CleanupStack::PopAndDestroy(value);
iContentObject->GetAttributeSet(attributeSet);
// Write the object out to a buffer, send to client
CBufFlat* buf = CBufFlat::NewL(50);
CleanupStack::PushL(buf);
// create write stream
RBufWriteStream writeStream(*buf);
// write the directory to the stream
attributeSet.ExternalizeL(writeStream);
TPtr8 bufPtr = buf->Ptr(0);
WriteL(aMessage, 2, bufPtr);
CleanupStack::PopAndDestroy(2, &attributeSet); // buf, attributeSet
}
void CRtaManagerHandler::GetStringAttributeL(const RMessage2& aMessage)
{
// open the content object specified in parameter 0,1 either using virtual path or file handle
OpenContentObjectL(aMessage, 0, 1);
TStringAttributePckg pckgObject;
TPckg<TStringAttributePckg> pckgData(pckgObject);
aMessage.ReadL(2, pckgData);
User::LeaveIfError(iContentObject->GetStringAttribute(pckgData().iAttribute, pckgData().iValue));
WriteL(aMessage, 2, pckgData);
}
void CRtaManagerHandler::GetStringAttributeSetL(const RMessage2& aMessage)
{
// open the content object specified in parameter 0,1 either using virtual path or file handle
OpenContentObjectL(aMessage, 0, 1);
RStringAttributeSet attributeSet;
CleanupClosePushL(attributeSet);
HBufC8* value = ReadDes8LC(aMessage, 2);
TPtr8 valuePtr = value->Des();
RDesReadStream readStream(valuePtr);
attributeSet.InternalizeL(readStream);
CleanupStack::PopAndDestroy(value);
iContentObject->GetStringAttributeSet(attributeSet);
// Write the object out to a buffer, send to client
CBufFlat* buf = CBufFlat::NewL(50);
CleanupStack::PushL(buf);
// create write stream
RBufWriteStream writeStream(*buf);
// write the directory to the stream
attributeSet.ExternalizeL(writeStream);
TPtr8 bufPtr = buf->Ptr(0);
WriteL(aMessage, 2, bufPtr);
CleanupStack::PopAndDestroy(2, &attributeSet); // buf, attributeSet
}
void CRtaManagerHandler::NotifyStatusChangeL(const RMessage2& /*aMessage*/)
{
User::Leave(KErrCANotSupported);
// Server().NotifyStatusChange(aVirtualPath)
}
void CRtaManagerHandler::CancelNotifyStatusChangeL(const RMessage2& /*aMessage*/)
{
User::Leave(KErrCANotSupported);
// Server().CancelNotifyStatusChange(aVirtualPath)
}
void CRtaManagerHandler::WriteCDirToMessageL(const RMessage2& aMessage, TInt aParam, CDir& aDir)
{
// Create a CDirStreamable from the directory
CDirStreamable* dirStreamable = CDirStreamable::NewL(aDir);
CleanupStack::PushL(dirStreamable);
// Write the object out to a buffer, send to client
CBufFlat* buf = CBufFlat::NewL(50);
CleanupStack::PushL(buf);
// create write stream
RBufWriteStream writeStream(*buf);
// write the directory to the stream
dirStreamable->ExternalizeL(writeStream);
TPtr8 bufPtr = buf->Ptr(0);
WriteL(aMessage, aParam, bufPtr);
CleanupStack::PopAndDestroy(2, dirStreamable); // buf, dirStreamable
}
void CRtaManagerHandler::OpenContentObjectL(const RMessage2& aMessage, TInt aUriOrFileSession, TInt aUniqueIdOrFileHandle)
{
// close any existing content object
delete iArchive;
iArchive = NULL;
iFile.Close();
switch(aMessage.Function())
{
case EManagerGetAttribute:
case EManagerGetAttributeSet:
case EManagerGetStringAttribute:
case EManagerGetStringAttributeSet:
{
_LIT(KPipe,"|" );
HBufC* uri = ReadDesC16LC(aMessage, aUriOrFileSession);
//If uri concatenated with uid remove uid.
TInt positionFound = uri->Find(KPipe);
if(positionFound!= KErrNotFound)
{
*uri = uri->Left(positionFound);
}
User::LeaveIfError(iFile.Open(Server().Fs(),*uri, EFileShareReadersOnly | EFileRead | EFileStream));
CleanupStack::PopAndDestroy(uri); // uri
break;
}
case EManagerGetAttributeByFileHandle:
case EManagerGetAttributeSetByFileHandle:
case EManagerGetStringAttributeByFileHandle:
case EManagerGetStringAttributeSetByFileHandle:
{
User::LeaveIfError(iFile.AdoptFromClient(aMessage, aUriOrFileSession, aUniqueIdOrFileHandle));
aUniqueIdOrFileHandle =3; // position of the uniqueId in message.
break;
}
}
iArchive = CRefTestAgentArchive::NewL(iFile);
HBufC* uniqueId = ReadDesC16LC(aMessage, aUniqueIdOrFileHandle);
iContentObject = &iArchive->DrmFilesL().FindL(*uniqueId);
CleanupStack::PopAndDestroy(uniqueId); // uniqueId
}
void CRtaManagerHandler::SetPropertyL(const RMessage2& /*aMessage*/)
{
User::Leave(KErrCANotSupported);
}
void CRtaManagerHandler::DisplayInfoL(const RMessage2& /*aMessage*/)
{
User::Leave(KErrCANotSupported);
}
void CRtaManagerHandler::DisplayInfo1L(const RMessage2& /*aMessage*/)
{
User::Leave(KErrCANotSupported);
}
void CRtaManagerHandler::AgentSpecificCommandL(const RMessage2& /*aMessage*/)
{
User::Leave(KErrCANotSupported);
}
void CRtaManagerHandler::AgentSpecificCommandAsyncL(const RMessage2& /*aMessage*/)
{
User::Leave(KErrCANotSupported);
}
void CRtaManagerHandler::DisplayManagementInfoL(const RMessage2& /*aMessage*/)
{
User::Leave(KErrCANotSupported);
}
#ifdef SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT
void CRtaManagerHandler::OpenWmdrmContentObjectL(const RMessage2& aMessage, TInt aHeaderParameter)
{
HBufC8* headerData = ReadDesC8LC(aMessage, aHeaderParameter);
iWmdrmContentObject = CWmdrmContentParser::NewL(*headerData);
CleanupStack::PopAndDestroy(headerData);
}
void CRtaManagerHandler::GetWMDRMAttributeL(const RMessage2& aMessage)
{
OpenWmdrmContentObjectL(aMessage, 0);
TInt attribute = aMessage.Int1();
TInt value;
TPckg<TInt> valuePckg(value);
User::LeaveIfError(iWmdrmContentObject->GetAttribute(attribute, value));
WriteL(aMessage, 2, valuePckg);
}
void CRtaManagerHandler::GetWMDRMStringAttributeL(const RMessage2& aMessage)
{
OpenWmdrmContentObjectL(aMessage, 0);
TInt attribute = aMessage.Int1();
HBufC* value = ReadDes16LC(aMessage, 2);
TPtr valuePtr = value->Des();
User::LeaveIfError(iWmdrmContentObject->GetStringAttribute(attribute, valuePtr));
WriteL(aMessage, 2, valuePtr);
CleanupStack::PopAndDestroy(value);
}
void CRtaManagerHandler::GetWMDRMAttributeSetL(const RMessage2& aMessage)
{
OpenWmdrmContentObjectL(aMessage, 0);
RAttributeSet attributeSet;
CleanupClosePushL(attributeSet);
HBufC8* value = ReadDes8LC(aMessage, 1);
TPtr8 valuePtr = value->Des();
RDesReadStream readStream(valuePtr);
CleanupClosePushL(readStream);
attributeSet.InternalizeL(readStream);
CleanupStack::PopAndDestroy(2, value);
iWmdrmContentObject->GetAttributeSet(attributeSet);
// Write the object out to a buffer, send to client
CBufFlat* buf = CBufFlat::NewL(50);
CleanupStack::PushL(buf);
// create write stream
RBufWriteStream writeStream(*buf);
CleanupClosePushL(writeStream);
// write the directory to the stream
attributeSet.ExternalizeL(writeStream);
CleanupStack::PopAndDestroy(&writeStream);
TPtr8 bufPtr = buf->Ptr(0);
WriteL(aMessage, 1, bufPtr);
CleanupStack::PopAndDestroy(2, &attributeSet); // buf, attributeSet
}
void CRtaManagerHandler::GetWMDRMStringAttributeSetL(const RMessage2& aMessage)
{
OpenWmdrmContentObjectL(aMessage, 0);
RStringAttributeSet attributeSet;
CleanupClosePushL(attributeSet);
HBufC8* value = ReadDes8LC(aMessage, 1);
TPtr8 valuePtr = value->Des();
RDesReadStream readStream(valuePtr);
CleanupClosePushL(readStream);
attributeSet.InternalizeL(readStream);
CleanupStack::PopAndDestroy(2, value);
iWmdrmContentObject->GetStringAttributeSetL(attributeSet);
// Write the object out to a buffer, send to client
CBufFlat* buf = CBufFlat::NewL(50);
CleanupStack::PushL(buf);
// create write stream
RBufWriteStream writeStream(*buf);
CleanupClosePushL(writeStream);
// write the directory to the stream
attributeSet.ExternalizeL(writeStream);
CleanupStack::PopAndDestroy(&writeStream);
TPtr8 bufPtr = buf->Ptr(0);
WriteL(aMessage, 1, bufPtr);
CleanupStack::PopAndDestroy(2, &attributeSet); // buf, attributeSet
}
#endif //SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT