// Copyright (c) 2002-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:

 //

 #include "sf_std.h"

 #include "e32cmn.h"

 #ifdef SYMBIAN_F32_ENHANCED_CHANGE_NOTIFICATION	

 #include "sf_notifier.h"

 #endif

 GLREF_C CProxyDriveFactory* GetExtension(const TDesC& aName);

 GLREF_C CExtProxyDriveFactory* GetProxyDriveFactory(const TDesC& aName);

 TBusLocalDrive LocalDrives::iLocalDrives[KMaxLocalDrives];			

 TInt LocalDrives::iMapping[KMaxDrives];

 TInt LocalDrives::iReverseMapping[KMaxLocalDrives];

 TBool LocalDrives::iMappingSet;

 LocalDrives::TSocketDesc LocalDrives::iSocketDescs[KMaxPBusSockets];

 CExtProxyDrive*  LocalDrives::iProxyDriveMapping[KMaxProxyDrives];

 TBool LocalDrives::iIsMultiSlotDrive[KMaxDrives];

 const TInt KInvalidSocketNumber = -1;

 void LocalDrives::Initialise()

 //

 //

 //

 	{	

 	iMappingSet = EFalse;

 	TInt i;

 	Mem::FillZ((TAny*)iProxyDriveMapping,sizeof(CExtProxyDriveFactory*)*KMaxProxyDrives);

 	// initialise mapping from drive number to local drive

 	for(i=0;i<KMaxDrives;i++)

 		{

 		iMapping[i] = KDriveInvalid;

 		iIsMultiSlotDrive[i] = EFalse;

 		}

 	// initialise reverse mapping from local drive to drive.

 	for(i=0;i<KMaxLocalDrives;i++)

 		{

 		iReverseMapping[i] = KDriveInvalid;

 		}

 	// initialise mapping from socket number to drive numbers

 	for(i=0;i<KMaxPBusSockets;++i)

 		{

 		TSocketDesc& socketDesc = iSocketDescs[i];

 		socketDesc.iMediaType = EInvalidMedia;

 		socketDesc.iControllerRelativeSocket = KInvalidSocketNumber;

 		for(TInt j=0;j<KMaxDrivesPerSocket;++j)

 			socketDesc.iDriveNumbers[j]=KDriveInvalid;

 		}

 	}

 // Searches for a local socket which matches the media type and 

 // controller relative socket number. 

 // If none is found then this function returns a new socket number.

 // If no more free sockets available, returns KErrNoMemory

 TInt LocalDrives::GetLocalSocket(TInt aControllerRelativeSocket, TMediaDevice aMediaType)

 	{

 	TInt i;

 	TSocketDesc* socketDesc = NULL;

 	for (i=0; i<KMaxPBusSockets; i++)

 		{

 		socketDesc = &iSocketDescs[i];

 		TMediaDevice mediaType = socketDesc->iMediaType;

 		if (mediaType == aMediaType && socketDesc->iControllerRelativeSocket == aControllerRelativeSocket)

 			return i;

 		if (mediaType == EInvalidMedia)	// socket unassigned ?

 			break;

 		}

 	if (i == KMaxPBusSockets)

 		return KErrNoMemory;

 	// assign a new local socket for this controller relative socket number & media type

 	socketDesc->iMediaType = aMediaType;

 	socketDesc->iControllerRelativeSocket = aControllerRelativeSocket;

 	return i;

 	}

 TBusLocalDrive& LocalDrives::GetLocalDrive(TInt aDrive)

 //

 // Export localdrives

 //

 	{

 	__ASSERT_DEBUG(aDrive>=0 && aDrive<KMaxDrives,Fault(EGetLocalDrive1));

 	__ASSERT_DEBUG(iMapping[aDrive]!=KDriveInvalid &&  iMapping[aDrive]<KMaxLocalDrives,Fault(EGetLocalDrive2));

 	return(iLocalDrives[iMapping[aDrive]]);

 	}

 TInt LocalDrives::GetLocalDriveNumber(TBusLocalDrive* aLocDrv)

 //

 // Get the local drive number for the local drive object passed in

 //

 	{

 	for(TInt i=0;i<KMaxLocalDrives;++i)

 		if(&iLocalDrives[i]==aLocDrv)

 			return(i);

 	return(KDriveInvalid);

 	}

 CExtProxyDrive* LocalDrives::GetProxyDrive(TInt aDrive)

 	{

 	__ASSERT_DEBUG(aDrive>=0 && aDrive<KMaxDrives,Fault(EGetProxyDriveMapping1));

 	__ASSERT_DEBUG(iMapping[aDrive]!=KDriveInvalid &&  iMapping[aDrive]>=KMaxLocalDrives && iMapping[aDrive]<KMaxDrives,Fault(EGetProxyDriveMapping1));

 	return iProxyDriveMapping[iMapping[aDrive]-KMaxLocalDrives];

 	}

 LOCAL_C TBool DriveNumberIsInRange(TInt aDrive)

 	{

 	return((aDrive>=0) && (aDrive<KMaxDrives));

 	}

 TBool LocalDrives::IsValidDriveMapping(TInt aDrive)

 //

 //  Is the drive number to local drive mapping valid?

 //

 	{

 	__ASSERT_DEBUG(DriveNumberIsInRange(aDrive),Fault(EIsValidDriveMapping));

 	return(iMapping[aDrive]!=KDriveInvalid);

 	}

 TInt LocalDrives::DriveNumberToLocalDriveNumber(TInt aDrive)

 //

 // Get the mapping from drive number to local drive

 //

 	{

 	return(iMapping[aDrive]);

 	}

 TInt LocalDrives::SetDriveMappingL(CFsRequest* aRequest)

 //

 //

 //

 	{

 	__PRINT(_L("LocalDrives::SetDriveMappingL()"));

 	if (iMappingSet)

 		return(KErrAccessDenied);

 	TLocalDriveMappingInfoBuf mBuf;

 	mBuf.FillZ();

 	aRequest->ReadL(KMsgPtr0,mBuf);

 	TLocalDriveMappingInfo& ldmi=mBuf();

 	if (ldmi.iOperation==TLocalDriveMappingInfo::ESwapIntMappingAndSet)

 		{

 		// Only the 1st two entries of the mapping table are valid - holding the drive numbers to be swapped 

 		TInt r=KErrNone;

 		if (DriveNumberIsInRange(ldmi.iDriveMapping[0]) && DriveNumberIsInRange(ldmi.iDriveMapping[1]))

 			r=SwapDriveMapping(ldmi.iDriveMapping[0],ldmi.iDriveMapping[1]);

 		iMappingSet=ETrue;

 		return(r);

 		}

 	// That just leaves EWriteMappingsAndSet and EWriteMappingsNoSet

 	for (TInt i=0;i<KMaxLocalDrives;++i)

 		{

 		TInt driveLetter=ldmi.iDriveMapping[i];

 		if(driveLetter==KDriveInvalid)

 			continue;

 		if ( !DriveNumberIsInRange(driveLetter))

 			{

 			// invalid mapping list passed in, clear all mappings set up

 			for(TInt j=0;j<KMaxDrives;j++)

 				iMapping[j] = KDriveInvalid;

 			return(KErrArgument);

 			}

 		__PRINT2(_L("drive letter %d -> local drive %d"),driveLetter,i);

 		// If this mapping (letter -> localdrive) is already set then

 		// this must be a multislot device. Save this mapping as an 

 		// alternative mapping (by storing it in iReverseMapping)

 		if(iMapping[driveLetter] != KDriveInvalid)

 			{

 			iIsMultiSlotDrive[driveLetter] = ETrue;

 			}

 		// first time we've seen this drive letter

 		iMapping[driveLetter]=i;

 		// following mapping is used when we want to swap back again. 

 		iReverseMapping[i]=driveLetter;

 		}

 	InitDriveMapping();

 	if (ldmi.iOperation==TLocalDriveMappingInfo::EWriteMappingsAndSet)

 		iMappingSet=ETrue;

 	return(KErrNone);

 	}

 // Changes here must be reflected in SwapDriveMapping() 	

 void LocalDrives::InitDriveMapping()

 	{

 	__PRINT(_L("InitDriveMapping()"));

 	TDriveInfoV1Buf driveInfo;

 	TInt r=UserHal::DriveInfo(driveInfo);

 	__ASSERT_ALWAYS(r==KErrNone,Fault(EInitDriveMappingDriveInfo));	

 	// initialise the local drives

 	TInt i;

 	for(i=0;i<KMaxLocalDrives;++i)

 		{

 		TInt driveNo = iReverseMapping[i];

 		if(driveNo!=KDriveInvalid)

 			{

 			r=iLocalDrives[i].Connect(i,TheDrives[driveNo].iChanged);

 			__ASSERT_ALWAYS(r==KErrNone,Fault(EInitConnectLocalDrive));

 			__PRINT2(_L("connect to locdrv %d using drive %d"),i,driveNo);

 			//If this is a multislot then we need to set the iChanged to True

 			//So that we are mapped to the correct drive when we're booted.

 			if(iIsMultiSlotDrive[driveNo])

 				{

 				TheDrives[driveNo].iChanged = ETrue;

 				}

 			if (driveInfo().iDriveName[i].Length()==0)

 				continue;

 			TheDriveNames[driveNo]=driveInfo().iDriveName[i].Alloc();

 			__ASSERT_ALWAYS(TheDriveNames[driveNo],Fault(EInitCreateDriveName));

 			}

 		}

 	TInt drivesPerSocket[KMaxPBusSockets];

 	Mem::FillZ(&drivesPerSocket,KMaxPBusSockets*sizeof(TInt));

 	TInt nSockets=driveInfo().iTotalSockets;

 	for(i=0;i<KMaxLocalDrives;++i)

 		{

 		TInt socket;

 		if(iLocalDrives[i].Handle()==0 || !iLocalDrives[i].IsRemovable(socket))

 			{

 			TInt driveNo = iReverseMapping[i];

 			// Non-removable drive so shouldn't be listed as a Multislot drive

 			// Drives such as composite drives may have been

 			// set to true as the drive letter had been encountered before.

 			// make sure those drives are set to false here.

 			iIsMultiSlotDrive[driveNo]=EFalse;

 			continue;

 			}

 		__ASSERT_ALWAYS(socket>=0 && socket<nSockets,Fault(EInitDriveMappingSocketNo));

 		TInt drv=GetDriveFromLocalDrive(i);

 		// get local socket number

 		TMediaDevice mediaDevice = iLocalDrives[i].MediaDevice();

 		TInt localSocket = LocalDrives::GetLocalSocket(socket, mediaDevice);

 		__ASSERT_ALWAYS(localSocket>=0 && localSocket<KMaxPBusSockets,Fault(EInitDriveMappingSocketNo));

 		__PRINT4(_L("InitDriveMapping(), i = %d, , mediaDevice = %d, socket = %d, localSocket = %d"), 

 			i, mediaDevice, socket, localSocket);

 		__PRINT2(_L("drv = %d (%C:)"), drv, 'A' + drv);

 		TSocketDesc& socketDesc = iSocketDescs[localSocket];

 		if(drv!=KDriveInvalid)

 			{

 			TInt& count = drivesPerSocket[localSocket];

 			// setup up socket to drive mapping

 			__ASSERT_ALWAYS(count < KMaxDrivesPerSocket,Fault(ETooManyDrivesPerSocket));

 			socketDesc.iDriveNumbers[count]=drv;

 			if(count==0)

 				{

 				// setup media change notifier if this is first local drive found on socket

 				CNotifyMediaChange* pN=new CNotifyMediaChange(&iLocalDrives[i],localSocket);

 				__ASSERT_ALWAYS(pN!=NULL,Fault(EInitCreateMediaChangeNotifier));

 				__PRINT2(_L("created CNotifyMediaChange media 0x%x using local drive %d"), localSocket,i);

 				socketDesc.iMediaChanges = pN;

 				CActiveSchedulerFs::Add(pN);

 				pN->RunL();

 				}

 			++count;

 			}

 		}

 	}

 TInt LocalDrives::InitProxyDrive(CFsRequest* aRequest)

 	{

 	__PRINT(_L("LocalDrives::InitProxyDrive"));

 	TInt drive = aRequest->Message().Int0() ;

 	if (drive < 0 || drive >= KMaxDrives) 

 		return KErrArgument;

 	if (drive!=EDriveZ && iMapping[drive]!=KDriveInvalid) 

 		return KErrInUse; // Z is special case for composite

 	TFullName extname;

 	aRequest->ReadL(KMsgPtr1,extname);

 	// leave info thing for now

 	CExtProxyDriveFactory* pF = GetProxyDriveFactory(extname);

 	if (!pF) 

 		return KErrArgument;	// that extension has not been added

 	FsThreadManager::LockDrive(drive);

 	// find a free mapping to place this drive into

 	TInt i;

 	for (i=0; i <KMaxProxyDrives; i++)

 		{

 		if (!iProxyDriveMapping[i]) 

 			break;

 		}

 	FsThreadManager::UnlockDrive(drive);

 	if (i==KMaxProxyDrives) 

 		return KErrInUse;   // there are no free proxy drives left

 	// Create the actual proxy drive...

 	CProxyDrive* pD = NULL;

 	TInt r = pF->CreateProxyDrive(pD, NULL);

 	__ASSERT_ALWAYS(r == KErrNone, User::Panic(_L("CreateProxyDrive Error"), r));

 	__ASSERT_ALWAYS(pD != NULL, User::Panic(_L("CreateProxyDrive returned NULL"), -999));

 	iMapping[drive] = i+KMaxLocalDrives;

 	aRequest->SetDrive(&TheDrives[drive]);

 	aRequest->SetScratchValue((TUint)pD);

 	return KErrNone;

 	}

 TInt LocalDrives::MountProxyDrive(CFsRequest* aRequest)

 	{

 	CExtProxyDrive* pProxyDrive = (CExtProxyDrive*)aRequest->ScratchValue();

 	__ASSERT_ALWAYS(pProxyDrive != NULL, User::Panic(_L("MountProxyDrive has NULL proxy extension class"), -999));

 	TInt driveNumber = aRequest->Drive()->DriveNumber();

 	TInt proxyDriveNo = iMapping[driveNumber] - KMaxLocalDrives;

 	FsThreadManager::LockDrive(driveNumber);

 	iProxyDriveMapping[proxyDriveNo] = pProxyDrive;

 	pProxyDrive->SetDriveNumber(driveNumber);

 	FsThreadManager::UnlockDrive(driveNumber);

 	//

 	// Pass initialisation information onto the extension to allow it to initialise

 	//

 	TInt err = pProxyDrive->SetInfo(aRequest->Message(), 

 									(TAny*)aRequest->Message().Ptr2(), 

 									(TAny*)aRequest->Message().Ptr3());

 	if (err != KErrNone) 

 		{

 		//

 		// If we fail to initialise the extension, then close the drive (destroying the thread)

 		// and remove the mapping so we can attempt to mount again in the future.

 		//

 		FsThreadManager::LockDrive(driveNumber);

 		FsThreadManager::CloseDrive(driveNumber);

 		ClearProxyDriveMapping(driveNumber);

 		FsThreadManager::UnlockDrive(driveNumber);

 		return err;

 		}

 	return(iMapping[driveNumber]);

  	}

 TBool LocalDrives::IsProxyDrive(TInt aDrive)

 	{

 	__ASSERT_ALWAYS(aDrive>=0 && aDrive<KMaxDrives,Fault(EIsProxyDrive));

 	return (iMapping[aDrive] >= KMaxLocalDrives);

 	}

 TBool LocalDrives::IsProxyDriveInUse(CExtProxyDriveFactory* aDevice)

 	{

 	for (TInt i=0; i < KMaxProxyDrives; i++)

 		if (iProxyDriveMapping[i] && (iProxyDriveMapping[i]->FactoryP() == aDevice))

 			return(ETrue);

 	return(EFalse);

 	}

 void LocalDrives::ClearProxyDriveMapping(TInt aDrive)

 	{

 	__ASSERT_ALWAYS(aDrive>=0 && aDrive<KMaxDrives,Fault(EClearProxyDriveMapping1));

 	__ASSERT_DEBUG(iMapping[aDrive]>= KMaxLocalDrives && iProxyDriveMapping[iMapping[aDrive]-KMaxLocalDrives],Fault(EClearProxyDriveMapping2));

 	TInt idx = iMapping[aDrive]-KMaxLocalDrives;

 	delete iProxyDriveMapping[idx];

 	iProxyDriveMapping[idx] = NULL;

 	iMapping[aDrive] = KDriveInvalid;

 	}

 TInt LocalDrives::SetupMediaChange(TInt aDrive)

 	{

 	CExtProxyDrive* pProxyDrive = LocalDrives::GetProxyDrive(aDrive);

 	__ASSERT_ALWAYS(pProxyDrive != NULL,User::Panic(_L("SetupMediaChange - pProxyDrive == NULL"), ESetupMediaChange));

 	return pProxyDrive->SetupMediaChange();

 	}

 void LocalDrives::NotifyChangeCancel(TInt aDrive)

 	{

 	CExtProxyDrive* pProxyDrive = LocalDrives::GetProxyDrive(aDrive);

 	__ASSERT_ALWAYS(pProxyDrive != NULL,User::Panic(_L("NotifyChangeCancel - pProxyDrive == NULL"), ECancelNotifyChange));

 	pProxyDrive->NotifyChangeCancel();

 	}

 TInt LocalDrives::SwapDriveMapping(TInt aFirstDrive,TInt aSecondDrive)

 	{

 	__PRINT(_L("SwapDriveMapping()"));

 	TInt firstLocalDrv=iMapping[aFirstDrive];

 	TInt secondLocalDrv=iMapping[aSecondDrive];

 	// First, check this swap doesn't affect removable drives

 	TInt socket;

 	if (iLocalDrives[firstLocalDrv].Handle()!=0 && iLocalDrives[firstLocalDrv].IsRemovable(socket))

 		return(KErrAccessDenied);

 	if (iLocalDrives[secondLocalDrv].Handle()!=0 && iLocalDrives[secondLocalDrv].IsRemovable(socket))

 		return(KErrAccessDenied);	

 	// Now swap the mappings over

 	iMapping[aFirstDrive]=secondLocalDrv;	

 	iMapping[aSecondDrive]=firstLocalDrv;

 	iReverseMapping[firstLocalDrv]=aSecondDrive;

 	iReverseMapping[secondLocalDrv]=aFirstDrive;

 	// Finally, swap the drive names over

 	HBufC* drvName=TheDriveNames[aSecondDrive];

 	TheDriveNames[aSecondDrive]=TheDriveNames[aFirstDrive];

 	TheDriveNames[aFirstDrive]=drvName;

 	return(KErrNone);

 	}

 void LocalDrives::CompleteNotifications(TInt aSocket)

 //

 //

 //

 	{

 	__ASSERT_DEBUG(aSocket>=0 && aSocket<KMaxPBusSockets && iSocketDescs[aSocket].iDriveNumbers[0]!=KDriveInvalid,Fault(ECompleteNotifSocketNo));

 	TInt i=0;

 	// In a data-paging environment, the local media subsytem will only update the TDrive::iChanged flag

 	// for drives which have a CNotifyMediaChange object, i.e. for drives which call TBusLocalDrive::NotifyChange().

 	// Since we only create ONE CNotifyMediaChange object for each socket (no matter how many partitions/local drives

 	// are associated with that socket), we need to propagate the TDrive::iChanged flag to all drives on the socket.

 	TBool changedFlag = TheDrives[iSocketDescs[aSocket].iDriveNumbers[0]].IsChanged();

 	while(i<KMaxDrivesPerSocket && iSocketDescs[aSocket].iDriveNumbers[i]!=KDriveInvalid)

 		{

 		TheDrives[iSocketDescs[aSocket].iDriveNumbers[i]].SetChanged(changedFlag);

 		CompleteDriveNotifications(iSocketDescs[aSocket].iDriveNumbers[i++]);

 		}

 	}

 void LocalDrives::CompleteDriveNotifications(TInt aDrive)

 //

 //

 //

 	{

 	// If the drive is hung, then don't complete any disk change 

 	// notifications until the request causing the hang completes

 	if(FsThreadManager::IsDriveHung(aDrive))

 		FsThreadManager::SetMediaChangePending(aDrive);

 	else

 		{

 		FsNotify::DiskChange(aDrive);

 #ifdef SYMBIAN_F32_ENHANCED_CHANGE_NOTIFICATION	

 		if(FsNotificationManager::IsInitialised())

 			{

 			__PRINT3(_L("LocalDrives::CompleteDriveNotifications() Initialised=%d, Count=%d, Drive=%d"),FsNotificationManager::IsInitialised(),FsNotificationManager::Count(), aDrive);

 			TBuf<2> driveDes;

 			driveDes.Append((TChar)aDrive+(TChar)'A');

 			driveDes.Append((TChar)':');

 			FsNotificationManager::HandleChange(NULL,driveDes,TFsNotification::EMediaChange);

 			}

 #endif //SYMBIAN_F32_ENHANCED_CHANGE_NOTIFICATION		

 	 	//If this is a multislot device we should update mappings here.

 		TheDrives[aDrive].MultiSlotDriveCheck();

 		}

 	}

 TInt LocalDrives::GetDriveFromLocalDrive(TInt aLocDrv)

 //

 //

 //

 	{

 	return iReverseMapping[aLocDrv];

 	}

 CNotifyMediaChange::CNotifyMediaChange(RLocalDrive* aDrive,TInt aSocketNo)

 //

 // Constructor

 //

 	: CActive(EPriorityHigh), iDrive(aDrive), iSocket(aSocketNo)

 	{}

 void CNotifyMediaChange::RunL()

 //

 // Notification that a card has been mounted/removed

 //

 	{

 	LocalDrives::CompleteNotifications(iSocket);

 	iDrive->NotifyChange(&iStatus);

 	SetActive();

 	}

 CExtNotifyMediaChange::CExtNotifyMediaChange(CExtProxyDrive* aDrive)

 //

 // Constructor

 //

 	: CActive(EPriorityHigh), 

 	  iDrive(aDrive),

 	  iPtr((TUint8*)&TheDrives[aDrive->DriveNumber()].iChanged,sizeof(TBool))

 	{

 	}

 CExtNotifyMediaChange* CExtNotifyMediaChange::NewL(CExtProxyDrive* aDrive)

 	{

 	CExtNotifyMediaChange* pSelf = new(ELeave) CExtNotifyMediaChange(aDrive);

 	CleanupStack::PushL(pSelf);

 	pSelf->ConstructL();

 	CleanupStack::Pop();

 	return pSelf;

 	}

 void CExtNotifyMediaChange::ConstructL()

 	{

 	CActiveSchedulerFs::Add(this);

 	TRAPD(err, RunL());

 	if(err != KErrNone)

 		Deque();

 	User::LeaveIfError(err);

 	}

 CExtNotifyMediaChange::~CExtNotifyMediaChange()

     {

     Cancel();

     }

 void CExtNotifyMediaChange::RequestL()

     {

     if (!IsActive())

         {

         User::LeaveIfError(iDrive->NotifyChange(iPtr, &iStatus));

         SetActive();

         }

     }

 void CExtNotifyMediaChange::DoCancel()

     {

     iDrive->NotifyChangeCancel();

     }

 void CExtNotifyMediaChange::RunL()

 	{

     if(iStatus==KErrDisconnected || iStatus==KErrCancel)

         return;

     TInt driveNum = iDrive->DriveNumber();

     LocalDrives::CompleteDriveNotifications(driveNum);

     /* NOTE: We need SetChanged here though the iChanged variable is set in the MSC, since the cache is not getting cleared

         (inside the CompleteDriveNotifications call) during the initial first notification */

     TheDrives[driveNum].SetChanged(ETrue);

     if(iStatus != KErrNotSupported)

         {

         RequestL();

         }

 	}