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

 // f32\sfile\sf_disk.cpp

 // 

 //

 #include "sf_std.h"

 #if defined(_LOCKABLE_MEDIA)

 LOCAL_C TInt DelayedWriter(TAny *aPtr);

 LOCAL_C void DelayedWriterL(const TDelayedWriter *aDW);

 EXPORT_C void WriteToDisk(const TDesC& aFileName, const TDesC8& aBuf)

 // 

 // Launches as separate thread that writes the contents of the pbus pswd

 // store to disk.  It is possible that this function will be called again

 // before the thread has finished writing.  In that case, a new thread

 // will be created and it will wait on the global DelayedWriteSem semaphore.

 // 

 	{

 	static TInt32 ctr = 0x00000000;				// ctr to create unique thd names

 	__PRINT(_L("WriteToDisk"));

 	__PRINT1(_L("wtd:afn%S"), &aFileName);

 	TDelayedWriterInit dwi;

 	dwi.iFileName = &aFileName;

 	dwi.iData = &aBuf;

 	// Create local semaphore this thread can wait on until the child thread has

 	// made copies of the file name and the store data.

 	__PRINT(_L("wtd:cr sem"));

 	TBuf<3 + 8> semName;

 	semName.Format(_L("dws%08x"), ctr++);

 	dwi.iSemName = &semName;

 	RSemaphore svrSem;

 	if (svrSem.CreateGlobal(semName, 0) != KErrNone)

 		return;

 	// Spin off a thread with a unique name.

 	__PRINT(_L("wtd:cr thd"));

 	TName nm;

 	nm.Format(_L("dw%08x"), ctr);

 	RThread t;

 	TInt hminsz = Max(KHeapMinSize, aFileName.Length() + aBuf.Length() + 1024);

 	if (t.Create(

 		nm, DelayedWriter, KDefaultStackSize,

 		hminsz /* aHeapMinSize */, hminsz /* aHeapMaxSize */, &dwi) == KErrNone)

 		{

 		__PRINT(_L("wtd:set pri"));

 		t.SetPriority(EPriorityMuchLess);		// run as low priority task

 		__PRINT(_L("wtd:res"));

 		t.Resume();

 		__PRINT(_L("wtd:wait"));

 		svrSem.Wait();

 		__PRINT(_L("wtd:cls thd"));

 		t.Close();								// get rid of our handle

 		}

 	__PRINT(_L("wtd:cls sem"));

 	svrSem.Close();

 	}

 LOCAL_D TInt DelayedWriter(TAny *aPtr)

 //

 // Main thread function for thread that is spun off from WriteToDisk().

 // After local copies of the data have been allocated (or failed), tell

 // the server to continue.

 // 

 	{

 	__PRINT(_L("DelayedWriter"));

 	User::SetCritical(User::ESystemCritical);

 	TInt r;

 	TDelayedWriterInit *dwi = (TDelayedWriterInit *) aPtr;

 	RSemaphore svrSem;							// signal svr when data copied

 	CTrapCleanup *th = NULL;					// thread trap handler

 	TDelayedWriter *dw = NULL;					// thread copy of data

 	RSemaphore queueSem;						// queued delayed write threads

 	// Allocate a trap handler.

 	__PRINT(_L("dlw:alc tp"));

 	if ((th = CTrapCleanup::New()) == NULL)

 		{

 		r = KErrNoMemory;

 		goto cleanup;

 		}

 	// Make copies of the filename and store data.

 	__PRINT(_L("dlw:cp dat"));

 	TRAP(r, dw = TDelayedWriter::NewL(dwi));

 	if (r != KErrNone)

 		goto cleanup;

 	// Tell file server made local copies of data and so can continue.

 	__PRINT(_L("dlw:sg cp dat"));

 	if ((r = svrSem.OpenGlobal(*dwi->iSemName)) != KErrNone)

 		goto cleanup;

 	svrSem.Signal();

 	// Wait for the other store threads to finish.

 	__PRINT(_L("dlw:wait"));

 	if ((r = queueSem.OpenGlobal(_L("dwsem"))) != KErrNone)

 		goto cleanup;

 	queueSem.Wait();

 	// Write the data and signal the global semaphore so follow up threads can run.

 	__PRINT(_L("dlw:wrt"));

 	TRAP(r, DelayedWriterL(dw));

 	__PRINT1(_L("dlw:wrt r = %d"), r);

 	queueSem.Signal();

 cleanup:										// free any opened resources

 	__PRINT(_L("dlw:cln"));

 	svrSem.Close();

 	delete th;

 	delete dw;

 	queueSem.Close();

 	return KErrNone;

 	}

 LOCAL_D void DelayedWriterL(const TDelayedWriter *aDW)

 //

 // Replace any existing store file; write data and set file as hidden and system.

 //

 	{

 	__PRINT(_L("DelayedWriterL"));

 	RFs fs;										// connect to the file server

 	CleanupClosePushL(fs);

 	User::LeaveIfError(fs.Connect());

 	RFile f;									// replace any existing file

 	CleanupClosePushL(f);

 	__PRINT(_L("dlw: opn"));

 	// Create the directory if it doesn't already exist

 	TInt r;

 	r = fs.MkDirAll(*aDW->iFileName);

 	if (r != KErrNone && r != KErrAlreadyExists)

 		{

 		__PRINT(_L("dlw: MkDirAll err"));

 		User::Leave(r);

 		}

 	User::LeaveIfError(f.Replace(fs, *aDW->iFileName, EFileShareExclusive | EFileStream | EFileWrite));

 	__PRINT(_L("dlw: wrt"));

 	User::LeaveIfError(f.Write(*aDW->iData));

 	__PRINT(_L("dlw: sat"));

 #ifndef __WINS__								// cannot replace hidden | system file in WINS.

 	User::LeaveIfError(f.SetAtt(KEntryAttHidden | KEntryAttSystem, 0x00000000));

 #endif

 	__PRINT(_L("dlw: dst"));

 	CleanupStack::PopAndDestroy(2);				// f, fs

 	}

 //

 // TDelayedWriter

 // 

 TDelayedWriter *TDelayedWriter::NewL(const TDelayedWriterInit *dwi)

 //

 // static

 // Allocates a TDelayedWriter structure on the thread's heap that is used to

 // persist the data that the writer thread will need during its lifetime.

 // 

 	{

 	__PRINT(_L("TDelayedWriter::NewL"));

 	TDelayedWriter *self = new(ELeave) TDelayedWriter();

 	CleanupStack::PushL(self);

 	self->ConstructL(dwi);

 	CleanupStack::Pop();						// self

 	return self;

 	}

 TDelayedWriter::TDelayedWriter()

 	{

 	__PRINT(_L("TDelayedWriter::TDelayedWriter"));

 	// empty.

 	}

 void TDelayedWriter::ConstructL(const TDelayedWriterInit *dwi)

 //

 // 2y initialisation.  Makes own copy of filename and data.

 // Fields are not popped onto CleanupStack because will be deleted in dtor

 // 

 	{

 	__PRINT(_L("TDelayedWriter::ConstructL"));

 	iFileName = dwi->iFileName->AllocL();

 	iData = dwi->iData->AllocL();

 	}

 TDelayedWriter::~TDelayedWriter()

 //

 // dtor - frees filename and store data that was allocated in ConstructL().

 //

 	{

 	__PRINT(_L("TDelayedWriter::~TDelayedWriter"));

 	delete iFileName;							// alloc in ConstructL()

 	delete iData;								// alloc in server

 	}

 #else

 EXPORT_C void WriteToDisk(const TDesC& /*aFileName*/, const TDesC8& /*aBuf*/)

 //

 //

 //

 	{}

 #endif