// Copyright (c) 1997-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:
//
#include <baksrv.h>
#include "Baksrvs.h"
#include <babackup.h>
#include <bafl/backup_std.h>
#include <basched.h>
#include <bsul/clientmessage.h>
#include "patchdata.h"
extern const BSUL::TClientMessageServerData KServerData;
const TInt KBakServMaxOperationTimerLoops = 3; // Number of iterations for base operation timer
_LIT(KPanic,"BackupServer");
//
// RMessage::Panic() also completes the message. This is:
// (a) important for efficient cleanup within the kernel
// (b) a problem if the message is completed a second time
//
void PanicClient(const RMessagePtr2& aMessage, TInt aPanic)
{
aMessage.Panic(KPanic,aPanic);
}
//
// class CShutdownServer
//
NONSHARABLE_CLASS(CShutdownServer) : public CTimer
{
enum {KMyShutdownDelay=0x2000000}; // approx 2s
public:
inline CShutdownServer();
inline void ConstructL();
inline void Start();
private:
void RunL();
};
inline CShutdownServer::CShutdownServer()
:CTimer(-1)
{
CActiveScheduler::Add(this);
}
inline void CShutdownServer::ConstructL()
{
CTimer::ConstructL();
}
inline void CShutdownServer::Start()
{
After(KMyShutdownDelay);
}
//
// Initiate server exit when the timer expires
//
void CShutdownServer::RunL()
{
CActiveScheduler::Stop();
}
//
// class CBaServBackupScheduler
//
EXPORT_C CBaServBackupScheduler::CBaServBackupScheduler()
{
}
EXPORT_C CBaServBackupScheduler::~CBaServBackupScheduler()
{
}
/**
*
* Set the error handler to aErrorHandler to the current scheduler.
*
* @param "CBaServBackupSession* aErrorHandler"
* The handler session.
*/
EXPORT_C void CBaServBackupScheduler::SetErrorHandler(CBaServBackupSession* aErrorHandler)
{
iErrorHandler=aErrorHandler;
}
/**
*
* Handles the error aError.
*
* @param "TInt aError"
* The error.
*/
EXPORT_C void CBaServBackupScheduler::Error(TInt aError) const
{
if (iErrorHandler)
{
iErrorHandler->HandleError(aError);
}
else if (aError!=KLeaveWithoutAlert)
{
// Handling the in this way implies that ServiceL should not leave.
CActiveScheduler::Error(aError);
}
}
/**
Class CBaServBackupSession::CReRegistrationTimer
*/
NONSHARABLE_CLASS(CBaServBackupSession::CReRegistrationTimer) : public CPeriodic
{
public:
static CReRegistrationTimer* NewL(TInt aPriority);
static TInt ReRegistrationTimerCallBack(TAny* aPtr);
protected:
TInt RunError(TInt aError);
private:
CReRegistrationTimer(TInt aPriority);
void HandleReRegistrationTimerCallBack();
public:
CBaBackupServer* iBackupServer;
};
/**
Class CBaBackupServer::CBaServCloseAllOperationTimer
*/
NONSHARABLE_CLASS(CBaBackupServer::CBaServCloseAllOperationTimer): public CPeriodic
{
public:
static CBaServCloseAllOperationTimer* NewL(CBaBackupServer* aBackupServer);
void ConstructL(CBaBackupServer* aBackupServer);
~CBaServCloseAllOperationTimer();
void SetMessage(const RMessagePtr2& aPtr);
RMessagePtr2 Message();
TInt GetOperationCount();
void SetOperationCount(TInt aCount);
static TInt OperationTimerCallBack(TAny* aPtr);
protected:
TInt RunError(TInt aError);
private:
void HandleOperationTimerCallBack();
CBaServCloseAllOperationTimer();
private:
RMessagePtr2 iCloseAllFilesMessage;
TInt16 iOperationCount;
CBaBackupServer* iBackupServer;
};
//
// class CBaBackupServer
//
/**
*
* Returns a pointer to <code>CBaBackupServer</code> object.
*
* @return "CBaBackupServer"
* A newly-constructed backup server object.
*/
EXPORT_C CBaBackupServer* CBaBackupServer::NewL()
{ // static
CBaBackupServer* self=new(ELeave) CBaBackupServer(CActive::EPriorityStandard);
return self;
}
/**
*
* Constructor.
*
* @param "TInt aPriority"
* The active object priority.
*/
EXPORT_C CBaBackupServer::CBaBackupServer(TInt aPriority)
: CServer2(aPriority)
{}
/**
*
* Destructor.
*
*/
EXPORT_C CBaBackupServer::~CBaBackupServer()
{
TDblQueIter<CSession2> iter(iSessionIter);
iter.SetToFirst();
for (CSession2* session=iter++; session!=NULL; session=iter++)
{
delete session;
}
delete iShutdown;
delete iExtension;
delete iCloseAllFilesOperationTimer;
}
/**
*
* Completes the server construction by adding the server to the active scheduler and creating
* a <code>CShutdownServer</code> object.
*
*/
EXPORT_C void CBaBackupServer::ConstructL()
{
StartL(__BACKUP_SERVER_NAME_V2);
iExtension = new(ELeave) CBaBackupServerExt();
iShutdown = new (ELeave) CShutdownServer;
iShutdown->ConstructL();
// ensure that the server still exits even if the 1st client fails to connect
iShutdown->Start();
iRegisteredFilesCount = 0;
iCloseAllFilesOperationTimer = CBaBackupServer::CBaServCloseAllOperationTimer::NewL(this);
iCloseAllOperationRunning = EFalse;
//initialise the client message framework
BSUL::CClientMessage::InitialiseFrameworkL(KServerData);
}
/**
*
* Sets the server to be busy with the aUniqueClientId client.
*
* @param "TUint32 aUniqueClientId"
* A unique client identifier.
*/
EXPORT_C void CBaBackupServer::SetBusy(TUint32 aUniqueClientId)
{
iExtension->iUniqueBusyClientId=aUniqueClientId;
}
/**
*
* Returns <code>ETrue</code> if the client using the server is not the one identified by aUniqueClientId
* oterwise <code>EFalse</code>
*
* @param "TUint32 aUniqueClientId"
* A unique client identifier.
*/
EXPORT_C TBool CBaBackupServer::IsOtherClientBusy(TUint32 aUniqueClientId) const
{
return (iExtension->iUniqueBusyClientId!=0 && iExtension->iUniqueBusyClientId!=aUniqueClientId);
}
/**
*
* Returns <code>ETrue</code> if the client using the server corresponds has aUniqueClientId as unique id
* oterwise <code>EFalse</code>
*
* @param "TUint32 aUniqueClientId"
* A unique client identifier id.
*/
EXPORT_C TBool CBaBackupServer::IsClientBusy(TUint32 aUniqueClientId) const
{
return ((iExtension->iUniqueBusyClientId==aUniqueClientId) ||
((iExtension->iCachedBusyClientId != 0) && (iExtension->iCachedBusyClientId == aUniqueClientId)));
}
/**
*
* Handles the closing of all files by signaling the new file lock flag, aFlag, to all client.
*
* @param "MBackupObserver::TFileLockFlags aFlag"
* A file lock flag.
*/
EXPORT_C void CBaBackupServer::CloseAllFilesL(MBackupObserver::TFileLockFlags aFlag)
{
// Set the close all operation flag and the reregistration counter to zero
iCloseAllOperationRunning = ETrue;
iSessionLockReRegistrationCount = 0;
// cleanup that calls RestartAll if required
TDblQueIter<CSession2> iter(iSessionIter);
iter.SetToFirst();
for (CSession2* session=iter++; session!=NULL; session=iter++)
{
static_cast<CBaServBackupSession*>(session)->SignalReleaseAllFileLocksL(aFlag);
}
}
/**
*
* Signals to all clients of getting the lock of their respective files.
*
*/
EXPORT_C void CBaBackupServer::RestartAll()
{
TDblQueIter<CSession2> iter(iSessionIter);
iter.SetToFirst();
for (CSession2* session=iter++; session!=NULL; session=iter++)
{
static_cast<CBaServBackupSession*>(session)->SignalRetakeAllFileLocks();
}
}
/**
*
* Allows any subclass of <code>CBaBackupServer</code> of completing the closing of files.
* The server will lose the ownership of aClosedFiles object, which implies it is up to this virtual
* function to deal with it in order to avoid a memory leak.
*
* @param "CArrayFix<CBaServBackupSession::TClosedFile>* aClosedFiles"
* An array of closed files.
*/
EXPORT_C void CBaBackupServer::CompleteClosingFiles(CArrayFix<CBaServBackupSession::TClosedFile>* aClosedFiles)
{
delete aClosedFiles;
}
/**
*
* Allows application framework backup code to check if all registerd files have beem updated
*
*/
EXPORT_C TBool CBaBackupServer::HaveAllCloseAllFilesClientsReRegistered()
{
return((iRegisteredFilesCount == iSessionLockReRegistrationCount) ? ETrue : EFalse);
}
void CBaBackupServer::CloseFileL(MBackupObserver::TFileLockFlags aFlag,const TDesC& aFileName)
{
TDblQueIter<CSession2> iter(iSessionIter);
iter.SetToFirst();
for (CSession2* session=iter++; session!=NULL; session=iter++)
{
static_cast<CBaServBackupSession*>(session)->SignalReleaseFileLockL(aFlag,aFileName);
}
}
void CBaBackupServer::RestartFile(const TDesC& aFileName)
{
TDblQueIter<CSession2> iter(iSessionIter);
iter.SetToFirst();
for (CSession2* session=iter++; session!=NULL; session=iter++)
{
static_cast<CBaServBackupSession*>(session)->SignalRetakeFileLocks(aFileName);
}
}
/**
*
* Creates a server-side client <code>CBaServBackupSession</code> session object by checking first if
* the version of the server is compatible with the client.
*
* @param "const TVersion &aVersion"
* Version information supplied by the client.
*/
EXPORT_C CSession2* CBaBackupServer::NewSessionL(const TVersion &aVersion, const RMessage2& /*aMessage*/) const
{
TVersion ver(KBakServMajorVN,KBakServMinorVN,KBakServBuildVN);
if (!User::QueryVersionSupported(ver,aVersion))
User::Leave(KErrNotSupported);
//
return CBaServBackupSession::NewL();
}
/**
*
* Signals to all clients the aBackupOperationAttributes.
*
* @param "const TBackupOperationAttributes& aBackupOperationAttributes"
* Backup operation attributes.
*/
EXPORT_C void CBaBackupServer::SignalBackupOperation(const TBackupOperationAttributes& aBackupOperationAttributes)
{
TDblQueIter<CSession2> iter(iSessionIter);
iter.SetToFirst();
for (CSession2* session=iter++; session!=NULL; session=iter++)
{
static_cast<CBaServBackupSession*>(session)->SignalBackupOperation(aBackupOperationAttributes);
}
// Cache session id if starting backup
if (aBackupOperationAttributes.iOperation == MBackupOperationObserver::EStart)
iExtension->iCachedBusyClientId = iExtension->iUniqueBusyClientId;
}
void CBaBackupServer::AddSession()
{
iShutdown->Cancel();
++iSessionCount;
}
void CBaBackupServer::DropSession()
{
if (--iSessionCount==0)
{
iShutdown->Start();
}
}
/*
* Check to see if a CloseAll opertation is in progress
*
*/
TBool CBaBackupServer::IsCloseAllOperationRunning()
{
return iCloseAllOperationRunning;
}
/*
* Set value of IsCloseAllOperationRunning
*
*/
EXPORT_C void CBaBackupServer::SetCloseAllOperationRunningState(TBool aRunning)
{
iCloseAllOperationRunning = aRunning;
}
/**
*
* This timer will only be created in cases of no derived backup server
*
*/
void CBaBackupServer::StartCloseAllFilesOperationTimer(const RMessagePtr2& aPtr)
{
// Store the CloseAll message in case we need to Complete on a timeout
iCloseAllFilesOperationTimer->SetMessage(aPtr);
// If hardware use patchable constant if not default to 3 seconds
iCloseAllFilesOperationTimer->Start(KBaBackupCloseallFilesTimeout, KBaBackupCloseallFilesTimeout, TCallBack(CBaBackupServer::CBaServCloseAllOperationTimer::OperationTimerCallBack, iCloseAllFilesOperationTimer));
}
/**
* Handle an error from CBaServBackupSession::ServiceL()
* A bad descriptor error implies a badly programmed client, so panic it;
* otherwise report the error to the client
*
* @param "TInt aError"
* The error.
*/
EXPORT_C TInt CBaBackupServer::RunError(TInt aError)
{
if (aError==KErrBadDescriptor)
{
PanicClient(Message(), EBufferOverflow);
}
else
{
Message().Complete(aError);
}
//
// The leave will result in an early return from CServer::RunL(), skipping
// the call to request another message. So do that now in order to keep the
// server running.
ReStart();
return KErrNone; // handled the error fully
}
//
// class CBaBackupServer::CBaServCloseAllOperationTimer
//
/**
@internalComponent
*/
CBaBackupServer::CBaServCloseAllOperationTimer* CBaBackupServer::CBaServCloseAllOperationTimer::NewL(CBaBackupServer* aBackupServer)
{ // static
CBaBackupServer::CBaServCloseAllOperationTimer* self=new(ELeave) CBaBackupServer::CBaServCloseAllOperationTimer();
CleanupStack::PushL(self);
self->ConstructL(aBackupServer);
CleanupStack::Pop(); // self
CActiveScheduler::Add(self);
return self;
}
/**
@internalComponent
*/
void CBaBackupServer::CBaServCloseAllOperationTimer::ConstructL(CBaBackupServer* aBackupServer)
{
CTimer::ConstructL();
iBackupServer = aBackupServer;
iOperationCount = 0;
}
/**
@internalComponent
*/
TInt CBaBackupServer::CBaServCloseAllOperationTimer::GetOperationCount()
{
return iOperationCount;
}
/**
@internalComponent
*/
void CBaBackupServer::CBaServCloseAllOperationTimer::SetOperationCount(TInt aCount)
{
iOperationCount = aCount;
}
/**
@internalComponent
*/
TInt CBaBackupServer::CBaServCloseAllOperationTimer::RunError(TInt aError)
{
if (aError==KLeaveWithoutAlert)
{
return KErrNone;
}
return aError;
}
/**
@internalComponent
*/
CBaBackupServer::CBaServCloseAllOperationTimer::CBaServCloseAllOperationTimer()
: CPeriodic(CActive::EPriorityStandard)
{ ; }
/**
@internalComponent
*/
CBaBackupServer::CBaServCloseAllOperationTimer::~CBaServCloseAllOperationTimer()
{
if (IsActive())
Cancel();
}
/**
@internalComponent
*/
void CBaBackupServer::CBaServCloseAllOperationTimer::SetMessage(const RMessagePtr2& aPtr)
{
iCloseAllFilesMessage = aPtr;
}
/**
@internalComponent
*/
RMessagePtr2 CBaBackupServer::CBaServCloseAllOperationTimer::Message()
{
return iCloseAllFilesMessage;
}
/**
@internalComponent
*/
TInt CBaBackupServer::CBaServCloseAllOperationTimer::OperationTimerCallBack(TAny* aPtr)
{ // static
TRAP_IGNORE(REINTERPRET_CAST(CBaBackupServer::CBaServCloseAllOperationTimer*,aPtr)->HandleOperationTimerCallBack());
return 0;
}
/**
@internalComponent
*/
void CBaBackupServer::CBaServCloseAllOperationTimer::HandleOperationTimerCallBack()
{
TBool finished = iBackupServer->HaveAllCloseAllFilesClientsReRegistered();
TInt retCode;
if (finished || (iOperationCount == KBakServMaxOperationTimerLoops))
{
if (finished)
{
retCode = KErrNone;
}
else
{
retCode = KErrLocked;
}
// One way or another CloseAll is finished at this point
iBackupServer->SetCloseAllOperationRunningState(EFalse);
iCloseAllFilesMessage.Complete(retCode);
Cancel();
}
else
{
iOperationCount++;
if (IsActive())
{
Cancel();
// If hardware use patchable constant if not default to 3 seconds
Start(KBaBackupCloseallFilesTimeout, KBaBackupCloseallFilesTimeout, TCallBack(CBaBackupServer::CBaServCloseAllOperationTimer::OperationTimerCallBack,this));
}
}
}
//
// class CBaServBackupMessageQueue
//
inline CBaServBackupMessageQueue::TQueueItem::TQueueItem(HBufC* aFileName,TInt aOperation)
: iFileName(aFileName), iOperation(aOperation)
{}
CBaServBackupMessageQueue* CBaServBackupMessageQueue::NewL()
{ // static
CBaServBackupMessageQueue* self=new(ELeave) CBaServBackupMessageQueue();
return self;
}
CBaServBackupMessageQueue::~CBaServBackupMessageQueue()
{
const TInt count=iQueue.Count();
for (TInt ii=0;ii<count;ii++)
{
delete iQueue[ii].iFileName;
}
iQueue.Reset();
iQueue.Close();
}
void CBaServBackupMessageQueue::AddItemL(const TDesC& aFileName,MBackupObserver::TFileLockFlags aFlag)
{
const TInt count=iQueue.Count();
for (TInt ii=0;ii<count;ii++)
{
TQueueItem& item=iQueue[ii];
if(aFileName.MatchF(*item.iFileName) == KErrNone)
{
if (item.iOperation==MBackupObserver::EReleaseLockReadOnly && aFlag==MBackupObserver::EReleaseLockNoAccess)
{
item.iOperation=MBackupObserver::EReleaseLockNoAccess;
}
else if (item.iOperation!=MBackupObserver::EReleaseLockNoAccess)
{
HBufC* file=aFileName.AllocLC();
TQueueItem item(file,aFlag);
User::LeaveIfError(iQueue.Insert(item,ii));
CleanupStack::Pop(); // file
}
return;
}
}
HBufC* file=aFileName.AllocLC();
HBufC* copy=aFileName.AllocLC();
TQueueItem item(file,aFlag);
User::LeaveIfError(iQueue.Append(item));
item=TQueueItem(copy,-1);
const TInt err=iQueue.Append(item);
if (err!=KErrNone)
{
iQueue.Remove(iQueue.Count()-1);
User::Leave(err);
}
CleanupStack::Pop(2); // copy, file
}
void CBaServBackupMessageQueue::AddItem(const TDesC& aFileName)
{
const TInt count=iQueue.Count();
for (TInt ii=0;ii<count;ii++)
{
TQueueItem& item=iQueue[ii];
if (aFileName.MatchF(*item.iFileName) == KErrNone && item.iOperation==-1)
{
item.iOperation=0;
break;
}
}
}
TBool CBaServBackupMessageQueue::IsEmpty() const
{
return HeadIndex()==KErrNotFound;
}
void CBaServBackupMessageQueue::RemoveHead()
{
const TInt index=HeadIndex();
if (index!=KErrNotFound)
{
delete iQueue[index].iFileName;
iQueue.Remove(index);
iQueue.Compress();
}
}
void CBaServBackupMessageQueue::RemoveItem(const TDesC& aFileName)
{
const TInt count=iQueue.Count();
for (TInt ii=count-1;ii>=0;ii--)
{
const TQueueItem& item=iQueue[ii];
if (aFileName.MatchF(*item.iFileName) == KErrNone)
{
delete item.iFileName;
iQueue.Remove(ii);
iQueue.Compress();
}
}
}
void CBaServBackupMessageQueue::GetHead(TDes& aFileName,MBackupObserver::TFileLockFlags& aFlag) const
{
aFileName.Zero();
const TInt index=HeadIndex();
if (index!=KErrNotFound)
{
const TQueueItem& item=iQueue[index];
aFileName=item.iFileName->Des();
aFlag=(MBackupObserver::TFileLockFlags)item.iOperation;
}
}
TInt CBaServBackupMessageQueue::HeadIndex() const
{
TInt index=KErrNotFound;
const TInt count=iQueue.Count();
for (TInt ii=0;ii<count;ii++)
{
const TQueueItem& item=iQueue[ii];
if (item.iOperation!=ENoOp)
{
index=ii;
break;
}
}
return index;
}
//
// class CBaServBackupSession
//
CBaServBackupSession* CBaServBackupSession::NewL()
{ // static
CBaServBackupSession* self=new(ELeave) CBaServBackupSession();
CleanupStack::PushL(self);
self->ConstructL();
CleanupStack::Pop(); // self
return self;
}
/**
*
* Constructor.
*
* @param "RThread aClient"
* The client thread for which this server-side client session is being constructed.
*/
EXPORT_C CBaServBackupSession::CBaServBackupSession()
: CSession2()
{
iUniqueClientId = (TUint32)this;
}
/**
*
* Destructor.
*
*/
EXPORT_C CBaServBackupSession::~CBaServBackupSession()
{
CBaBackupServer* server=BackupServer();
if (server->IsClientBusy(iUniqueClientId))
{
RestartAll();
if (server->IsBackupOperationRunning())
{
TBackupOperationAttributes backupOpAtt(MBackupObserver::ETakeLock, MBackupOperationObserver::EAbort);
server->SignalBackupOperation(backupOpAtt);
server->SetBackupOperationRunning(EFalse);
}
server->SetBusy(0);
}
if (iFileLockObservers)
{
server->DecrementRegisteredFilesCount(iFileLockObservers->Count());
}
delete iClosedFiles;
delete iFileLockObservers;
delete iReleasedFiles;
delete iMessageQueue;
delete iReRegistrationTimer;
iReRegistrationTimer = 0;
server->DropSession();
}
/**
*
* Completes the session construction by creating a <code>CBaServBackupMessageQueue</code> object.
*
*/
EXPORT_C void CBaServBackupSession::ConstructL()
{
iMessageQueue=CBaServBackupMessageQueue::NewL();
// Cannot set iBackupServer in CReRegistrationTimer at this point but must be done before call to Start
iReRegistrationTimer=CBaServBackupSession::CReRegistrationTimer::NewL(CActive::EPriorityStandard);
}
/**
*
* Completes the construction of this <code>CBaServBackupSession</code> session by just doing a base call class.
* It also notify the server that a new session has been created.
*
* @param "const CServer& aServer"
* The server active object which is responsible for this session
*/
EXPORT_C void CBaServBackupSession::CreateL()
{
BackupServer()->AddSession();
}
void CBaServBackupSession::SignalReleaseAllFileLocksL(MBackupObserver::TFileLockFlags aFlag)
{
CBaBackupServer* server=BackupServer();
if (iFileLockObservers)
{
const TInt count=iFileLockObservers->Count();
for (TInt ii=0;ii<count;ii++)
{
TFileName name=(*iFileLockObservers)[ii];
server->CloseFileL(aFlag,name);
}
}
}
void CBaServBackupSession::SignalRetakeAllFileLocks()
{
// CBaBackupServer* server=BackupServer();
if (iReleasedFiles)
{
const TInt count=iReleasedFiles->Count();
for (TInt ii=count-1;ii>=0;ii--)
{
TFileName name=(*iReleasedFiles)[ii];
// server->RestartFile(name);
SignalRetakeFileLocks(name);
}
}
}
LOCAL_C void CleanupCloseFail(TAny* aPtr)
{
CDesCArray* array=REINTERPRET_CAST(CDesCArray*,aPtr);
array->Delete(array->Count()-1);
}
void CBaServBackupSession::SignalReleaseFileLockL(MBackupObserver::TFileLockFlags aFlag,const TDesC& aFileName)
{
TInt pos;
if (iFileLockObservers && iFileLockObservers->Find(aFileName,pos)==KErrNone)
{
if (iReleasedFiles==NULL)
{
iReleasedFiles=new(ELeave) CDesCArraySeg(1);
}
const TBool addedReleasedFile=iReleasedFiles->Find(aFileName,pos)!=KErrNone;
if (addedReleasedFile)
{
iReleasedFiles->AppendL(aFileName);
CleanupStack::PushL(TCleanupItem(CleanupCloseFail,iReleasedFiles));
}
iMessageQueue->AddItemL(aFileName,aFlag);
if (!iNotificationPullMsg.IsNull())
{
iNotificationPullMsg.Complete(KErrNone);
// Okay - if this is part of a CloseAll operation we need to kick off a ReRegistration timer
if (BackupServer()->IsCloseAllOperationRunning())
{
// Set backup server for the timer
iReRegistrationTimer->iBackupServer = BackupServer();
// If hardware use patchable constant if not default to 3 seconds
iReRegistrationTimer->Start(KBaBackupFileLockReRegistrationTimeout, KBaBackupFileLockReRegistrationTimeout, TCallBack(CBaServBackupSession::CReRegistrationTimer::ReRegistrationTimerCallBack, iReRegistrationTimer));
}
}
if (addedReleasedFile)
{
CleanupStack::Pop(); // CleanupCloseFail
}
}
}
void CBaServBackupSession::SignalRetakeFileLocks(const TDesC& aFileName)
{
if (iReleasedFiles)
{
const TInt count=iReleasedFiles->Count();
for (TInt ii=count-1;ii>=0;ii--)
{
TFileName name=(*iReleasedFiles)[ii];
if (name.MatchF(aFileName)==0)
{
iMessageQueue->AddItem(aFileName);
if (!iNotificationPullMsg.IsNull())
{
iNotificationPullMsg.Complete(KErrNone);
}
iReleasedFiles->Delete(ii);
}
}
if (iReleasedFiles->Count()==0)
{
delete iReleasedFiles;
iReleasedFiles=NULL;
if (iClosedFiles==NULL && BackupServer()->IsClientBusy(iUniqueClientId))
{
BackupServer()->SetBusy(0);
}
}
}
}
/**
*
* Allows the session to handle the error.
*
* @param "TInt aError"
* The error.
*/
EXPORT_C void CBaServBackupSession::HandleError(TInt aError)
{
if (aError==KLeaveWithoutAlert)
{
CBaServBackupScheduler::Current()->SetErrorHandler(NULL);
}
}
void CBaServBackupSession::DoServiceL(TCompletionType& aCompleteType)
{
switch (iClientMessage->Function())
{
case EBakOpCodeEventReady:
{
HandleEventReadyL();
aCompleteType = ECompleteAsync;
}
break;
case EBakOpCodeStopNotifications:
{
StopNotifications();
}
break;
case EBakOpCodeGetEvent:
GetEventL();
break;
case EBakOpCodeCloseAllFiles:
{
aCompleteType = CloseAllFilesL(iClientMessage->Message());
}
break;
case EBakOpCodeRestartAll:
RestartAll();
break;
case EBakOpCodeCloseFile:
CloseFileL();
break;
case EBakOpCodeRestartFile:
RestartFileL();
break;
case EBakOpCodeNotifyLockChange:
NotifyLockChangeL();
break;
case EBakOpCodeNotifyLockChangeCancel:
NotifyLockChangeCancelL();
break;
case EBakOpCodeNotifyBackupOperation:
NotifyBackupOperationL();
break;
case EBakOpCodeCancelOutstandingBackupOperationEvent:
{
iBackupOperationObserverPresent = EFalse;
if (!iBackupOperationMessagePtr.IsNull())
{
GetBackupOperationEventL(iBackupOperationMessagePtr);
iBackupOperationMessagePtr.Complete(KErrCancel);
}
}
break;
case EBakOpCodeGetBackupOperationState:
GetBackupOperationStateL();
break;
case EBakOpCodeBackupOperationEventReady:
BackupOperationEventReadyL();
aCompleteType = ECompleteAsync;
break;
case EBakOpCodeGetBackupOperationEvent:
GetBackupOperationEventL(iClientMessage->Message());
break;
case EBakOpCodeSetBackupOperationObserverIsPresent:
{
iBackupOperationObserverPresent = iClientMessage->GetIntL(0);
}
break;
default:
User::Leave(KErrNotSupported);
break;
}
}
/**
*
* Handles the servicing of client requests passed to the backup server.
*
* @param "const RMessage& aMessage"
* The message containing the client request.
*/
EXPORT_C void CBaServBackupSession::ServiceL(const RMessage2& aMessage)
{
TCompletionType completionType = ECompleteSync;
BSUL::CClientMessage* clientMessage = 0;
clientMessage = BSUL::CClientMessage::NewL(aMessage);
//Push iClientMessage onto the cleanupstack. Although an instance variable,
//the lifetime of the object is contained to this function so it needs to
//be pushed and popped here as it is not deleted in the destructor
CleanupStack::PushL(clientMessage);
//Validate the message
TRAPD(error, clientMessage->ValidateL());
iClientMessage = clientMessage;
if(error == KErrNone)
{
TRAP(error, DoServiceL(completionType));
}
if(completionType == ECompleteSync)
{
if (error==KLeaveWithoutAlert)
{
CBaServBackupScheduler::Current()->SetErrorHandler(NULL);
}
else
{
iClientMessage->CompleteRequestL(error);
}
}
//Pop and destroy message
CleanupStack::PopAndDestroy(clientMessage);
clientMessage = NULL;
iClientMessage = NULL;
}
void CBaServBackupSession::HandleEventReadyL()
{
if (iReRegistrationTimer->IsActive())
{ // If timer is still active (ie not timed out) we need to increment the counter and cancel the timer
BackupServer()->IncrementFilesReRegistrationCount();
iReRegistrationTimer->Cancel();
}
// else timer is already inactive because it's expired
if (iMessageQueue->IsEmpty())
{
iNotificationPullMsg = iClientMessage->Message();
}
else
{
iClientMessage->CompleteRequestL(KErrNone);
}
}
const TInt KEventFileNameOffset=1;
void CBaServBackupSession::GetEventL()
{
TFileName fileName;
MBackupObserver::TFileLockFlags fileFlag;
if(!iMessageQueue->IsEmpty())
{
iMessageQueue->GetHead(fileName,fileFlag);
TBuf<KEventFileNameOffset> num;
num.Num((TInt)fileFlag);
iClientMessage->WriteL(0,num,0);
iClientMessage->WriteL(0,fileName,KEventFileNameOffset);
iMessageQueue->RemoveHead();
}
else
{
iClientMessage->PanicClient(KPanic,ENoEventToFetch);
User::Leave(KLeaveWithoutAlert);
}
}
void CBaServBackupSession::CleanupCloseAllFiles(TAny* aPtr)
{ // static
CBaServBackupSession* self=REINTERPRET_CAST(CBaServBackupSession*,aPtr);
delete self->iClosedFiles;
self->iClosedFiles=NULL;
self->BackupServer()->RestartAll();
}
/**
Asks the server to close all files. This function may leave in case the server is busy.
If the requesting client is the current busy client and it has already requested CloseAll,
this request will be ignored.
@param aMessage The reference to the message containing the client request: file lock.
@leave KErrServerBusy if the requesting client is not the busy client. Plus other system-wide
errors.
*/
EXPORT_C TCompletionType CBaServBackupSession::CloseAllFilesL(const RMessage2& aMessage)
{
// Raise file lock notifications
TRAPD(err,DoCloseAllFilesL(aMessage));
if (err == KErrNone)
{
// Start timer to check all file locks re-registered before completing message
BackupServer()->StartCloseAllFilesOperationTimer(aMessage);
}
else
{
// If the error is that the same client has already requested CloseAll, ignore this request
// If not this error, recover the CloseAllOperationRunningState flag and leave with the error.
if (err != KErrAlreadyExists)
{
BackupServer()->SetCloseAllOperationRunningState(EFalse);
User::Leave(err);
}
}
return ECompleteAsync;
}
void CBaBackupServer::IncrementRegisteredFilesCount()
{
iRegisteredFilesCount++;
}
void CBaBackupServer::DecrementRegisteredFilesCount(TInt aNumberFiles)
{
iRegisteredFilesCount = iRegisteredFilesCount - aNumberFiles;
}
void CBaBackupServer::IncrementFilesReRegistrationCount()
{
iSessionLockReRegistrationCount++;
}
/**
Function called by both base and derived backup sessions in order to start asynchronous
file lock notifications.
The requesting client is set to the current busy client.
@leave KErrServerBusy if the requesting client is not the current busy client or the server
is under CloseAll operation. KErrAlreadyExists if the same client has sent CloseAll request.
Plus other system-wide errors.
*/
EXPORT_C TCompletionType CBaServBackupSession::DoCloseAllFilesL(const RMessage2& /*aMessage*/)
{
CBaBackupServer* server=BackupServer();
if (server->IsOtherClientBusy(iUniqueClientId))
{
User::Leave(KErrServerBusy);
}
if (BackupServer()->IsCloseAllOperationRunning())
{
User::Leave(KErrAlreadyExists);
}
CleanupStack::PushL(TCleanupItem(CleanupCloseAllFiles,this));
if (iClosedFiles)
{
delete iClosedFiles;
iClosedFiles=NULL;
}
server->SetBusy(iUniqueClientId);
MBackupObserver::TFileLockFlags fileFlag=
(MBackupObserver::TFileLockFlags)iClientMessage->GetIntL(0);
server->CloseAllFilesL(fileFlag);
iClosedFiles=new(ELeave) CArrayFixSeg<CBaServBackupSession::TClosedFile>(1);
CBaServBackupScheduler::Current()->SetErrorHandler(this);
CleanupStack::Pop(); // CleanupCloseAllFiles
return ECompleteAsync;
}
/**
*
* Asks the server to signal all clients of getting the lock of their respective files.
*
*/
EXPORT_C void CBaServBackupSession::RestartAll()
{
CBaBackupServer* server=BackupServer();
if (server->IsClientBusy(iUniqueClientId))
{
DoRestartAll();
}
}
void CBaServBackupSession::DoRestartAll()
{
CBaBackupServer* server=BackupServer();
server->RestartAll();
delete iReleasedFiles;
iReleasedFiles=NULL;
if (iClosedFiles)
{
CArrayFix<CBaServBackupSession::TClosedFile>* closedFiles=iClosedFiles;
iClosedFiles=NULL;
server->CompleteClosingFiles(closedFiles); // takes ownership of closedFiles immediately
}
}
/**
Handle the client's request to close a file.
The request will be ignored if the requesting client the current busy client and the server is
under CloseAll operation.
@leave KErrServerBusy if the server is busy with the other client, plus other system-wide errors.
*/
void CBaServBackupSession::CloseFileL()
{
CBaBackupServer* server=BackupServer();
if (server->IsOtherClientBusy(iUniqueClientId))
{
User::Leave(KErrServerBusy);
}
if (! server->IsCloseAllOperationRunning())
{
MBackupObserver::TFileLockFlags flag=
static_cast<MBackupObserver::TFileLockFlags>(iClientMessage->GetIntL(2));
TFileName fileName;
GetFileNameL(fileName);
server->SetBusy(iUniqueClientId);
server->CloseFileL(flag,fileName);
}
}
void CBaServBackupSession::RestartFileL()
{
TFileName fileName;
GetFileNameL(fileName);
BackupServer()->RestartFile(fileName);
}
/**
Handles the client's request of notification of a file lock change.
@leave KErrServerBusy if the server is under CloseAll operation, KLeaveWithoutAlert if the requested
file has been registered. Plus other system-wide errors.
*/
void CBaServBackupSession::NotifyLockChangeL()
{
if(BackupServer()->IsCloseAllOperationRunning())
{
User::Leave(KErrServerBusy);
}
TFileName fileName;
GetFileNameL(fileName);
if (iFileLockObservers==NULL)
{
iFileLockObservers=new(ELeave) CDesCArraySeg(1);
}
else
{
TInt pos;
if(iFileLockObservers->Find(fileName,pos)== KErrNone)
{
iClientMessage->PanicClient(KPanic,EReqAlreadyOutstanding);
User::Leave(KLeaveWithoutAlert);
}
}
iFileLockObservers->AppendL(fileName);
BackupServer()->IncrementRegisteredFilesCount();
}
LOCAL_C void RemoveFileName(CDesCArray& aArray,const TDesC& aFileName)
{
TInt pos;
if (aArray.Find(aFileName,pos)==KErrNone)
{
aArray.Delete(pos);
}
}
void CBaServBackupSession::NotifyLockChangeCancelL()
{
TFileName fileName;
GetFileNameL(fileName);
if (iFileLockObservers)
{
RemoveFileName(*iFileLockObservers,fileName);
BackupServer()->DecrementRegisteredFilesCount();
}
if (iReleasedFiles)
{
RemoveFileName(*iReleasedFiles,fileName);
}
iMessageQueue->RemoveItem(fileName);
}
void CBaServBackupSession::GetFileNameL(TDes& aFileName)
{
//The verification of this parameter has already been handled
//by the CClientMessage class so we can safely read the value
iClientMessage->ReadL(1,aFileName);
}
void CBaServBackupSession::GetBackupOperationEventL(const RMessagePtr2& aPtr)
{
TPckg<TBackupOperationAttributes> backupOpAttPkg(iBackupOperationAttributes);
aPtr.WriteL(0, backupOpAttPkg);
}
void CBaServBackupSession::BackupOperationEventReadyL()
{
if (iBackupOperationObserverPresent)
{
iBackupOperationMessagePtr = iClientMessage->Message();
}
else
{
iClientMessage->CompleteRequestL(KErrNone);
}
}
void CBaServBackupSession::NotifyBackupOperationL()
{
CBaBackupServer* server=BackupServer();
if (server->CBaBackupServer::IsOtherClientBusy(iUniqueClientId))
{
User::Leave(KErrServerBusy);
}
TPckg<TBackupOperationAttributes> backupOpAttPkg(iBackupOperationAttributes);
iClientMessage->ReadL(0,backupOpAttPkg);
const TBool backupOperationRunning = ((iBackupOperationAttributes.iOperation==MBackupOperationObserver::EStart) ? ETrue : EFalse);
server->SetBackupOperationRunning(backupOperationRunning);
server->SetBusy(backupOperationRunning ? iUniqueClientId : 0);
server->SignalBackupOperation(iBackupOperationAttributes);
if (!iBackupOperationMessagePtr.IsNull())
{
GetBackupOperationEventL(iBackupOperationMessagePtr);
iBackupOperationMessagePtr.Complete(KErrCancel);
}
}
void CBaServBackupSession::GetBackupOperationStateL()
{
const TBool isRunning = BackupServer()->IsBackupOperationRunning();
TPckgC<TBool> pkgObs(isRunning);
iClientMessage->WriteL(0, pkgObs);
}
void CBaServBackupSession::SignalBackupOperation(const TBackupOperationAttributes& aBackupOperationAttributes)
{
iBackupOperationAttributes = aBackupOperationAttributes;
if (!iBackupOperationMessagePtr.IsNull())
{
TRAPD(err,GetBackupOperationEventL(iBackupOperationMessagePtr));
iBackupOperationMessagePtr.Complete(err);
}
}
void CBaServBackupSession::StopNotifications()
{
if(!iNotificationPullMsg.IsNull())
{// complete the registration message
iNotificationPullMsg.Complete(KErrNone);
}
}
/**
@internalComponent
*/
CBaServBackupSession::CReRegistrationTimer* CBaServBackupSession::CReRegistrationTimer::NewL(TInt aPriority)
{ // static
CBaServBackupSession::CReRegistrationTimer* self=new(ELeave) CBaServBackupSession::CReRegistrationTimer(aPriority);
CleanupStack::PushL(self);
self->ConstructL();
CleanupStack::Pop(); // self
CActiveScheduler::Add(self);
return self;
}
/**
@internalComponent
*/
TInt CBaServBackupSession::CReRegistrationTimer::RunError(TInt aError)
{
if (aError==KLeaveWithoutAlert)
{
return KErrNone;
}
return aError;
}
/**
@internalComponent
*/
CBaServBackupSession::CReRegistrationTimer::CReRegistrationTimer(TInt aPriority)
: CPeriodic(aPriority)
{ }
/**
@internalComponent
*/
TInt CBaServBackupSession::CReRegistrationTimer::ReRegistrationTimerCallBack(TAny* aPtr)
{ // static
TRAP_IGNORE(REINTERPRET_CAST(CBaServBackupSession::CReRegistrationTimer*,aPtr)->HandleReRegistrationTimerCallBack());
return 0;
}
/**
@internalComponent
*/
void CBaServBackupSession::CReRegistrationTimer::HandleReRegistrationTimerCallBack()
{
iBackupServer->IncrementFilesReRegistrationCount();
if (IsActive())
{
Cancel();
}
}