C++ CFileStore::Root方法代码示例

LOCAL_C void doDeferredLoadingL(const TDesC& aName)
	{
	TParse	filestorename;
	fsSession.Parse(aName,filestorename);
				// construct file store object - specifying the file
				// containing the store.
	CFileStore* store = CPermanentFileStore::OpenLC(fsSession,filestorename.FullName(),EFileRead);
	
				// Construct an object of type CCompound.
				// The loading of its components is deferred 
				// until needed.
	CCompound* thecompound = CCompound::NewLC(*store,store->Root());
	
				// Display component A.
				// The component is loaded in from the 
				// stream if not already loaded.
	_LIT(KTxtFirstDisplay," (first display)");
	thecompound->DisplayAL(KTxtFirstDisplay);

				// Re-Display component A
				// The component should now be in memory.
	_LIT(KTxtSecondDisplay," (second display)");
	thecompound->DisplayAL(KTxtSecondDisplay);

	console->Printf(KTxtNewLine);

				// Destroy:
				// 1. the CCompound object
				// 2. the store object (this also closes 
				//    the file containing the store)
				// Remove both from the cleanup stack
	CleanupStack::PopAndDestroy(2);
	}

TInt CSecMgrStore::ReadCounter(TExecutableID& aExecID)
	{
	HBufC *configFile = HBufC::NewLC(KMaxName);
	TPtr ptr(configFile->Des());
	TInt ret(GetConfigFile (ptr));

	if ( KErrNone==ret)
		{
		if ( !BaflUtils::FileExists(iFsSession,*configFile))
			{
			aExecID = (TExecutableID)KCRUIdSecMgr.iUid;
			BaflUtils::EnsurePathExistsL (iFsSession, *configFile);
			CleanupStack::PopAndDestroy (configFile);
			return WriteCounter (aExecID);
			}

		CFileStore* store = CPermanentFileStore::OpenLC (iFsSession,
				*configFile, EFileRead);

		RStoreReadStream instream;
		instream.OpenLC (*store, store->Root ());

		aExecID = instream.ReadInt32L ();

		CleanupStack::PopAndDestroy (&instream);
		CleanupStack::PopAndDestroy (store);
		}
	CleanupStack::PopAndDestroy (configFile);
	return ret;
	}

void CMsvSendExe::RetrievePackagesL()
	{
	
	//open the filestore 	
	CFileStore* store = CDirectFileStore::FromLC(iTaskFile);//pushes store

	RStoreReadStream instream;
	instream.OpenLC(*store,store->Root());//pushes instream

	//get task count
	TInt taskCount = instream.ReadInt32L();

	SCHSENDLOG(FLog(iFileName, _L("\tTask Count=%d"), taskCount));

	for (TInt curTask = 0; curTask < taskCount; curTask++)
		{
		CScheduledTask* task = CScheduledTask::NewLC(instream);

		AddPackageL(*task);

		CleanupStack::PopAndDestroy(task);
		}

	CleanupStack::PopAndDestroy(2, store);
	}

LOCAL_C void doInternalizeL(const TDesC& aName)
{
    TParse	filestorename;

    fsSession.Parse(aName,filestorename);
    // construct file store object - specifying the file
    // containing the store.
    CFileStore* store = CDirectFileStore::OpenLC(fsSession,filestorename.FullName(),EFileRead);

    // Construct a CCompound object
    // from the root stream created earlier.
    CCompound* thecompound = CCompound::NewL(*store,store->Root());

    // Show contents of the CCompound object (and its
    // components)
    _LIT(KTxtRestoredContent,"... Restored CCompound content.");
    doShow(KTxtRestoredContent,*thecompound);

    // destroy the store object (this also closes the file
    // containing the store)
    CleanupStack::PopAndDestroy();

    // Now destroy the CCompound object
    delete thecompound;
}

void CSecMgrStore::RestorePoliciesL(RPolicies& aPolicy)
	{
	//Fetch all the individual policy files from "epoc32\winscw\c\private\<SECMGR_UID>\policy" directory
	//Iteratively internalise the policy files, with the policyID (PolicyID is = to filename)
	HBufC *privateDir = HBufC::NewLC(KMaxName);
	TPtr privateDirptr(privateDir->Des());
	GetPolicyPath (privateDirptr);

	// create search string
	HBufC* searchBuf = privateDirptr.AllocLC ();
	TPtr searchPtr(searchBuf->Des());

	CDir* dir=  NULL;
	iFsSession.GetDir (searchPtr, KEntryAttNormal,
			ESortByName | EAscending, dir);

	if ( dir)
		{
		CleanupStack::PushL (dir);
		for (TInt i=0; i!=dir->Count ();++i)
			{
			TEntry entry = dir->operator[] (i);
			HBufC *fileName = HBufC::NewLC(KMaxName);
			TPtr ptr(fileName->Des());
			ptr = entry.iName;

			HBufC *policyFile = HBufC::NewLC(KMaxName);
			TPtr policyFileptr(policyFile->Des());
			policyFileptr.Copy(privateDirptr) ;
			policyFileptr.Append (ptr);

			CFileStore* store = CPermanentFileStore::OpenLC (iFsSession,
					policyFileptr, EFileShareAny);

			RStoreReadStream instream;
			instream.OpenLC (*store, store->Root ());

			TLex16 lexer(ptr);
			TPolicyID pID;
			lexer.Val (pID);

			CPolicy* policy = CPolicy::NewL (pID, instream);
			aPolicy.Append (policy);

			CleanupStack::PopAndDestroy (&instream); //instream
			CleanupStack::PopAndDestroy (store); //store
			CleanupStack::PopAndDestroy (policyFile);
			CleanupStack::PopAndDestroy (fileName);
			}

		CleanupStack::PopAndDestroy (dir);
		}

	CleanupStack::PopAndDestroy (searchBuf);
	CleanupStack::PopAndDestroy (privateDir);
	}

void CApaProcess::DoReadRootStreamL(CStreamDictionary& aStreamDictionary, const CFileStore& aStore)
	{ // static
	const TStreamId rootStreamId=aStore.Root();
	if ((aStore.Type()[1] != KUidAppDllDoc) || (rootStreamId == KNullStreamId))
		User::Leave(KErrCorrupt);
	
	RStoreReadStream rootStream;
	rootStream.OpenLC(aStore, rootStreamId);
	rootStream >> aStreamDictionary;
	CleanupStack::PopAndDestroy(&rootStream);
	}

void CVersitTest::StreamLC(RReadStream& aStream)
	{
	GetSampleVersitL();
	RFs fsSession; 
	User::LeaveIfError(fsSession.Connect());
	CFileStore* store = CDirectFileStore::ReplaceLC(fsSession,_L("c:\\TTVersitIn"),EFileWrite);
	store->SetTypeL(KDirectFileStoreLayoutUid);
	RStoreWriteStream outstream;
	TStreamId id = outstream.CreateLC(*store);
	TInt length=iVersit.Length();
	for (TInt ii=0; ii<length; ii++)
		outstream.WriteInt8L(iVersit[ii]);
	outstream.CommitL();
	CleanupStack::PopAndDestroy();
	store->SetRootL(id);
	store->CommitL();
 	CleanupStack::PopAndDestroy();	// store
	store = CDirectFileStore::OpenLC(fsSession,_L("c:\\TTVersitIn"),EFileRead); //retrieve stream
	RStoreReadStream instream;
	instream.OpenLC(*store,store->Root());
	CleanupStack::Pop();	// instream
	aStream=RReadStream(instream);
	}

void CVersitTest::StreamInL()
//Convert the iVersit into stream format, save it as "TTVersitIn"
//and internalize it as a CVersitParser
	{
	RFs fsSession; 
	User::LeaveIfError(fsSession.Connect());
	CFileStore* store = CDirectFileStore::ReplaceLC(fsSession,_L("c:\\TTVersit2"),EFileWrite);
	store->SetTypeL(KDirectFileStoreLayoutUid);
	RStoreWriteStream outstream;
	TStreamId id = outstream.CreateLC(*store);
	TInt length=iVersit.Length();
	for (TInt ii=0; ii<length; ii++)
		outstream.WriteInt8L(iVersit[ii]);
	outstream.CommitL();
	CleanupStack::PopAndDestroy();
	store->SetRootL(id);
	store->CommitL();
	CleanupStack::PopAndDestroy();
	store = CDirectFileStore::OpenLC(fsSession,_L("c:\\TTVersit2"),EFileRead); //retrieve stream
	RStoreReadStream instream;
	instream.OpenLC(*store,store->Root());
	iParser->InternalizeL(instream);
	CleanupStack::PopAndDestroy(2); //store + stream
	}

/**
@SYMTestCaseID          SYSLIB-SCHSVR-CT-1345
@SYMTestCaseDesc	    Platform security Task handler test 
@SYMTestPriority 	    High
@SYMTestActions  	    Attempt to test the contents of a task file.
@SYMTestExpectedResults Test must not fail
@SYMREQ                 REQ0000
*/				
LOCAL_C void ConstructConsoleL(RFile& aTaskFile, RTest& aTest)
	{
	
	CConsoleBase* console=Console::NewL(KConsoleName, TSize(KConsFullScreen, KConsFullScreen));
	CleanupStack::PushL(console);
	console->Printf(_L(" contents of task file\n"));

	RArray<TCapability> enforcedCaps;
	CleanupStack::PushL(TCleanupItem(&DestroyArray,&enforcedCaps));

	for (TInt i=0; i<ECapability_Limit; i++)
		{
		// we're checking here to see which capabilities are enforced, skipping
		// ECapabilityMultimediaDD and ECapabilityWriteDeviceData as it is
		// needed to write persistent schedules upon which this test relies.
		
		if (i == KPlatSecTestCapability)
			continue;
		else if (i == ECapabilityWriteDeviceData)
			continue;
		else if (PlatSec::IsCapabilityEnforced((TCapability)i))
			enforcedCaps.Append((TCapability)i);
		}
	
	TBool isTestCapabilityEnforced = PlatSec::IsCapabilityEnforced(KPlatSecTestCapability);
	
	CFileStore* store;
	store = CDirectFileStore::FromLC(aTaskFile);

	RStoreReadStream instream;
	instream.OpenLC(*store,store->Root());
	
	TInt count = instream.ReadInt32L();
	for (TInt i=0;i<count;i++)
		{
		CScheduledTask* task = CScheduledTask::NewLC(instream);
		
		aTest(task->Info().iName.CompareF(KPlatSecTaskName)==0);
		aTest(task->Data().CompareF(KPlatSecTaskData)==0);
		aTest(task->SecurityInfo().iSecureId==KPlatSecTestSid); //This is the SID of tschsvrplatsec

		// check that client has capability it should have
		if(isTestCapabilityEnforced)
			aTest(task->SecurityInfo().iCaps.HasCapability(KPlatSecTestCapability));
		
		// check that the client has ECapabilityWriteDeviceData
		aTest(task->SecurityInfo().iCaps.HasCapability(ECapabilityWriteDeviceData));
		
		// check that client doesn't have any other capabilities
		for (TInt j=enforcedCaps.Count()-1; j>=0; --j)
			{
			aTest(!task->SecurityInfo().iCaps.HasCapability(enforcedCaps[j]));
			}
			
		
		CleanupStack::PopAndDestroy(task);
		}
		
	console->Printf(_L("Pausing for a one second..."));
	User::After(1000000);
	
	CleanupStack::PopAndDestroy(4); // instream, store, enforcedCaps, console
	}