genericservices/httputils/Test/Integration/TestFileUriSuite/TestFileUriServer.cpp
Reapply fix for EXPORT_C problem in backend.dll, which got lost in the merge - bug 2971
// 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 "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:
//
/**
@file
@internalTechnology
*/
// System Include
#include <escapeutils.h>
// User Includes
#include "TestFileUriServer.h"
#include "TestCreateFileStep.h"
#include "TestGetFileNameFromUriStep.h"
#include "TestGenerateFileUriStep.h"
#include "TestDeleteFileStep.h"
#include "TestForAllFilesStep.h"
// The system-wide unique name for the test-server
_LIT(KServerName, "TestFileUriServer");
TBuf<KMaxDrives> CTestFileUriServer::iRemovableDrives(KNullDesC);
/**
Static factory constructor. Creates and returns instance of the test server
@return A pointer to the newly created CTestFileUriServer object
*/
CTestFileUriServer* CTestFileUriServer::NewL()
{
// Construct the server
CTestFileUriServer* server = new(ELeave) CTestFileUriServer();
CleanupStack::PushL(server);
// CServer base class call
// Name the server using the system-wide unique string
// Clients use this to create server sessions.
server->StartL(KServerName);
CleanupStack::Pop(server);
return server;
}
#if (!defined EKA2)
/**
Creates the Active Scheduler, then creates the test-server, synchronises the
thread with the client and then enters the active scheduler.
This is EKA1 version of MainL(). Uses sempahore to sync with client
as Rendezvous calls are not available
*/
LOCAL_C void MainL()
{
// Create and install the active scheduler.
CActiveScheduler* sched = NULL;
sched = new(ELeave) CActiveScheduler;
CleanupStack::PushL(sched);
CActiveScheduler::Install(sched);
// Create the server inside trap harness
CTestFileUriServer *server = NULL;
TRAPD(err, server = CTestFileUriServer::NewL());
if (!err)
{
CleanupStack::PushL(server);
RSemaphore sem;
// The client API of TestExecute will already have created the
// semaphore and will be waiting on it.
User::LeaveIfError(sem.OpenGlobal(KServerName));
CleanupStack::Pop(server);
// Signal the client
sem.Signal();
sem.Close();
// Enter the active scheduler
sched->Start();
}
CleanupStack::Pop(sched);
delete server;
delete sched;
}
#else
/**
EKA2 version of MainL()
Uses the new Rendezvous call isntead of the older semaphore.
*/
LOCAL_C void MainL()
{
// For platform security
#if (defined __DATA_CAGING__)
RProcess().DataCaging(RProcess::EDataCagingOn);
RProcess().SecureApi(RProcess::ESecureApiOn);
#endif
CActiveScheduler* sched = NULL;
sched = new(ELeave) CActiveScheduler;
CActiveScheduler::Install(sched);
CTestFileUriServer* server = NULL;
// Create the test-server
TRAPD(err, server = CTestFileUriServer::NewL());
if(!err)
{
// Sync with the client and enter the active scheduler
RProcess::Rendezvous(KErrNone);
sched->Start();
}
delete server;
delete sched;
}
#endif // #if (!defined EKA2)
#if (defined __WINS__ && !defined EKA2)
/**
DLL entry-point for EKA1 emulator builds.
*/
GLDEF_C TInt E32Dll(enum TDllReason /*aDllReason*/)
{
return KErrNone;
}
#else
/**
Exe entry point code, for EKA1 hardware and EKA2 builds.
*/
GLDEF_C TInt E32Main()
{
__UHEAP_MARK;
CTrapCleanup *cleanup = CTrapCleanup::New();
if (cleanup == NULL)
{
return KErrNoMemory;
}
TInt err = KErrNone;
TRAP(err, MainL());
delete cleanup;
__UHEAP_MARKEND;
return KErrNone;
}
#endif // #if (defined __WINS__ && !defined EKA2)
#if (defined __WINS__ && !defined EKA2)
/**
For EKA1 emulator builds. This function is called when the thread is first
resumed. Has the standard thread entry siganture.
*/
TInt ThreadFunc (TAny* /*aParam*/)
{
__UHEAP_MARK;
CTrapCleanup* cleanup = CTrapCleanup::New();
if (cleanup == NULL)
{
return KErrNoMemory;
}
TInt err = KErrNone;
TRAP(err, MainL());
delete cleanup;
__UHEAP_MARKEND;
return KErrNone;
}
/**
For EKA1 emulator builds. Creates and starts a thread for the server to run.
*/
EXPORT_C TInt NewServer()
{
_LIT(KThread, "Thread");
RThread thread;
// Name the thread as "<Server-Name>Thread" making it hopefully unique
TBuf<KMaxTestExecuteNameLength> threadName(KServerName);
threadName.Append(KThread);
const TInt KMaxHeapSize = 0x1000000;
// Create the thread
TInt err = thread.Create(threadName, ThreadFunc, KDefaultStackSize,
KMinHeapSize, KMaxHeapSize, NULL, EOwnerProcess);
if (err != KErrNone)
{
return err;
}
// Start the thread -> effectively calls ThreadFunc
thread.Resume();
thread.Close();
return KErrNone;
}
#endif // #if (defined __WINS__ && !defined EKA2)
/**
Base class pure virtual
@return - Instance of the test step
*/
CTestStep* CTestFileUriServer::CreateTestStep(const TDesC& aStepName)
{
CTestStep *testStep = NULL;
if (aStepName == KTestCreateFileStep)
{
testStep = new (ELeave) CTestCreateFileStep;
}
else if (aStepName == KTestGetFileNameFromUriStep)
{
testStep = new (ELeave) CTestGetFileNameFromUriStep;
}
else if (aStepName == KTestGenerateFileUriStep)
{
testStep = new (ELeave) CTestGenerateFileUriStep;
}
else if (aStepName == KTestDeleteFileStep)
{
testStep = new (ELeave) CTestDeleteFileStep;
}
else if (aStepName == KTestForAllFilesStep)
{
testStep = new (ELeave) CTestForAllFilesStep();
}
return testStep;
}
/**
Returns the equivalent drive number of a drive
*/
void CTestFileUriServer::GetDriveNumber(const TDesC& aDrive, TDriveNumber& aDriveNum)
{
TBuf<1> driveLetter(aDrive.Left(1));
driveLetter.LowerCase();
aDriveNum = static_cast <TDriveNumber> (driveLetter[0] - KLetterA);
}
/**
Checks whether a specific drive is a removable drive
*/
TInt CTestFileUriServer::IsRemovableDrive(const TDriveNumber& aDriveNum, TBool& aResult)
{
TInt err = KErrNone;
TDriveInfo driveInfo;
RFs fs;
aResult = EFalse;
err = fs.Connect();
if(err == KErrNone)
{
err = fs.Drive(driveInfo, aDriveNum);
if (err == KErrNone && driveInfo.iDriveAtt & KDriveAttRemovable)
{
aResult = ETrue;
}
fs.Close();
}
return err;
}
/**
Replaces the drive placeholder <drive> with the actual drive
*/
HBufC16* CTestFileUriServer::CheckAndFillDriveNameL(const TPtrC& aFileUri, const TPtrC& aDrive)
{
HBufC16* expectedUriWithDrive = aFileUri.AllocL();
TInt placeHolderPos = aFileUri.Find(KDrivePlaceHolder);
if(placeHolderPos >= KErrNone)
{
if(aDrive == KExtMedia)
{// Create a descriptor that is big enough
// Just in case ReAllocL leaves
CleanupStack::PushL(expectedUriWithDrive);
expectedUriWithDrive = expectedUriWithDrive->ReAllocL(aFileUri.Length() + (KExtMedia().Length() - KDrivePlaceHolder().Length()));
CleanupStack::Pop(); // expectedUriWithDrive
}
expectedUriWithDrive->Des().Replace(placeHolderPos, KDrivePlaceHolder().Length(), aDrive);
}
return expectedUriWithDrive;
}
/**
Private function used to find the remobale drives and populate iRemovableDrives
*/
TInt CTestFileUriServer::PopulateRemovableDrivesBuf(const RFs& aFs)
{
TInt err = KErrNone;
TDriveInfo driveInfo;
TInt driveNum;
for (driveNum = EDriveA; driveNum <= EDriveZ; driveNum++)
{
// Populate iRemovableDrives with all removable drives in alphabetical order
err = aFs.Drive(driveInfo, driveNum);
if (err == KErrNone && (driveInfo.iDriveAtt & KDriveAttRemovable))
{
iRemovableDrives.Append(TInt16('a' + driveNum));
}
}
return err;
}
/**
Searches whether a file with same name and path exists in any other removable drive
*/
TInt CTestFileUriServer::FirstRemovableDriveWithSameFileName(const TDesC& aFileName, TBuf<1>& aCorrectDrive)
{
aCorrectDrive = aFileName.Left(1);
TInt err = KErrNone;
RFs fs;
if((err = fs.Connect()) != KErrNone)
{
return err;
}
if(iRemovableDrives == KNullDesC)
{
if((err = PopulateRemovableDrivesBuf(fs)) != KErrNone)
{
return err;
}
}
TInt index;
HBufC* tempFileName = NULL;
if((tempFileName = aFileName.Alloc()) == NULL)
{
return KErrGeneral;
}
for(index = 0; index < iRemovableDrives.Length(); ++index)
{
TUint attValue;
// change the drive in the filename and check whether such a file exists
tempFileName->Des()[0] = iRemovableDrives[index];
err = fs.Att(tempFileName->Des(), attValue);
if(err == KErrNone)
{
aCorrectDrive[0] = iRemovableDrives[index];
break;
}
}
if(index >= iRemovableDrives.Length())
{// File not found on any removable drive
aCorrectDrive = KNullDesC;
}
delete tempFileName;
fs.Close();
return KErrNone;
}
/**
Obtains the private directory of the application and appends it along with the
relative filename and drive to create the fully qualified filename
*/
TInt CTestFileUriServer::CreateFullyQualifiedName(const TPtrC& aRelativeName, const TPtrC& aDrive, TFileName& aFullyQualifiedName)
{
RFs fs;
TInt err = fs.Connect();
if(err != KErrNone)
{
return err;
}
// Get private dir name
err = fs.PrivatePath(aFullyQualifiedName);
fs.Close();
if(err != KErrNone)
{
return err;
}
// Construct fully-qualified filename
aFullyQualifiedName.Insert(0, KDriveSeparator);
aFullyQualifiedName.Insert(0, aDrive);
TInt position = 0;
// If backslash already exists dont include again
if(aRelativeName.Left(1) == KBackSlash)
{
++position;
}
aFullyQualifiedName.Append(aRelativeName.Right(aRelativeName.Length() - position));
return KErrNone;
}