// 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 "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 "PFSDUMP.H"

// entry point

int main(int argc,char *argv[])

	{

	if (TheProgram.ProcessCommandLine(argc,argv))

		{

		TheProgram.ExplainUsage();

		return 1;

		}

	TheProgram.Run();

	return 0;

	}

// Class Program

class Program TheProgram;

Program::Program()

	: iFile(NULL),iOptions(0),iBin(&iBinBuf),iErrors(0)

	{

	cout << setfill('0');

	}

void Program::Information()

	{

	if (!Option(quiet))

		cout << "\nEPOC PermanentFileStore Dump Utility   Version " << MajorVersion << '.' \

			<< setw(2) << MinorVersion << "(build " << setw(3) << setfill('0') << Build \

			<< ")\nCopyright (c) Symbian Software Limited 1997-2004. All rights reserved.\n\n" << flush;

	cout << hex;

	cerr << hex;

	}

void Program::ExplainUsage()

	{

	Information();

	cout << "Usage:  PFSDUMP [options] storefile\n" \

			" -v    verbose: dump contents\n" \

			" -f    generate a frame dump\n" \

			" -r<n> use nth previous store revision\n" \

			" -c    format output for comparison (not for frame dumps)\n"

			" -q    quiet: suppress logo\n" << flush;

	}

int Program::ProcessCommandLine(int argc,char ** argv)

	{

	if (argc<2)

		return 1;

	int options=0;

	while (--argc>0)

		{

		istrstream arg(*++argv);

		int c=arg.get();

		if (c=='/' || c=='-')

			{

			while ((c=arg.get())!=EOF)

				{

				switch (c)

					{

				case 'c': case 'C':

					options|=compare;

					break;

				case 'f': case 'F':

					options|=frame;

					break;

				case 'q': case 'Q':

					options|=quiet;

					break;

				case 'r': case 'R':

					arg >> iTocRevision;

					if (arg.fail() || iTocRevision<0)

						return 1;

					break;

				case 'v': case 'V':

					options|=verbose;

					break;

				default:			// unrecognised option

					return 1;

					}

				}

			}

		else if (iFile!=NULL)

			return 1;		// two filenames?

		else

			iFile=arg.str();

		}

	if (options&frame)

		options&=~compare;

	iOptions=options;

	return iFile==NULL;

	}

void Program::Run()

//

// The main part of the program

//

	{

	Information();

	StoreFile store(iFile);

	if (iErrors)

		cerr << endl;

	if (store.Empty())

		{

		cout << "Store is empty" << endl;

		return;

		}

	if (Option(frame))

		{

		store.EmitHeader();

		store.EmitFrames();

		}

	store.EmitToc();

	if (!Option(frame))

		store.EmitStreams();

	}

void Program::Abort(char const* aMessage)

	{

	cerr << aMessage << endl;

	exit(3);

	}

void Program::Corrupt(char const* aMessage)

//

// terminate after detecting a fatal corruption error

//

	{

	cerr << "\nfatal error: " << aMessage << "\ncannot continue\n" << flush;

	exit(2);

	}

ostream& Program::Error()

	{

	++TheProgram.iErrors;

	return cerr << "error: ";

	}

ostream& Program::Warning()

	{

	++TheProgram.iErrors;

	return cerr << "warning: ";

	}

// Bin stream buffer

binbuf::binbuf()

	: streambuf()

	{}

int binbuf::overflow(int)

	{return 0;}

int binbuf::underflow()

	{return EOF;}

// Class StoreFile

int StoreFile::OutWidth;

StoreFile::StoreFile(char const* aFile)

	{

#ifdef __MSVCDOTNET__

	iFile.open(aFile, ios::binary);

#else //!__MSVCDOTNET__

	iFile.open(aFile, ios::binary | ios::nocreate);

#endif //__MSVCDOTNET__

	if (!iFile)

		Program::Abort("Unable to open file or file does not exist");

//

	unsigned long uid;

	iFile.read((char*)&uid,sizeof(uid));

	iFile.seekg(0,ios::end);

	int size=iFile.tellg();

	if (size<FrameDes::First || uid!=PermanentFileStoreUid)

		Program::Abort("Not a permanent file store");

//

	iSize=size;

	if (TheProgram.Option(Program::compare))

		OutWidth=7;

	else

		{

		int width=0;

		while (size)

			{

			++width;

			size>>=4;

			}

		OutWidth=width;

		}

//

	cout << "Dumping " << aFile << "\n\n";

//

	iFile.seekg(Header::Offset,ios::beg);

	iFile.read((char*)&iHeader,Header::Size);

//

	if (Empty())

		return;

	LoadFrames();

	LoadToc();

	}

StoreFile::~StoreFile()

	{

	iFile.close();

	}

void StoreFile::LoadFrames()

	{

	FrameDes frame;

	int offset=FrameDes::First;

	int full=FrameDes::First+FrameDes::Interval;

	int diff=FrameDes::First;

	while (offset-FrameDes::Size<iSize)

		{

		if (offset==full)

			{

			full+=FrameDes::Interval;

			diff+=FrameDes::Size;

			}

		if (offset>iSize)

			{

			Program::Warning() << "incomplete link at " << FramePos(offset-diff) << endl;

			break;

			}

		iFile.seekg(offset-FrameDes::Size,ios::beg);

		iFile >> frame;

		iFrames.Add(FramePos(offset-diff),frame);

		int length=frame.Length();

		if (length==0)

			{

			if (full>iSize && offset>iSize)

				Program::Warning() << "incomplete frame at " << FramePos(offset-diff) << endl;

			offset=full;

			}

		else

			{

			int newoffset=offset+length+FrameDes::Size;

			if (newoffset>=full || newoffset-FrameDes::Size>iSize)

				{

				Program::Error() << "bad link at " << FramePos(offset-diff) << ", skipping to next anchor link" << endl;

				offset=full;

				}

			else

				{

				offset=newoffset;

				if (full-offset<=FrameDes::Size)

					offset=full;

				}

			}

		}

	iFrames.Complete();

	}

void StoreFile::LoadToc()

	{

	FramePos toc=iHeader.Toc();

	Stream stream(iFrames,toc);

	if (!stream.IsGood())

		{

		Program::Error() << "invalid toc address " << toc << endl;

		return;

		}

	if (stream.Type()!=FrameDes::Toc)

		{

		Program::Error() << "toc address " << toc << ": refers to non-toc frame"<< endl;

		return;

		}

// find the requested store revision

	Frames::Iterator f=stream.Frame();

	Frames::Iterator const first=iFrames.Begin();

	for (int rev=TheProgram.TocRevision();rev;--rev)

		{

		do	{

			if (--f<first)

				Program::Abort("Store revision not found");

			} while (f->iDes.Type()!=FrameDes::Toc);

		}

	iToc.Load(iFile,iFrames,f,iHeader.GetReloc());

// verify the Toc stream references

	Toc::Iterator const end=iToc.End();

	for (Toc::Iterator iter=iToc.Begin();iter<end;++iter)

		{

		if (iter->iHandle.IsNull())

			Program::Error() << "missing entry in toc-delta for index " << (1+iter-iToc.Begin()) << endl;

		else if (!iter->iHandle.Avail() && iter->Pos().Pos()>=0)

			{

			f=iFrames.Find(iter->Pos());

			if (f==NULL)

				Program::Error() << "invalid stream reference in toc entry " << iter->iHandle << endl;

			else if (iter->Pos().Pos()>=toc.Pos())

				Program::Error() << "virtual stream reference in toc entry " << iter->iHandle << endl;

			else if (f->iDes.Type()!=FrameDes::Data)

				Program::Error() << "toc entry " << iter->iHandle << ": refers to non-data frame" << endl;

			}

		}

	}

void StoreFile::EmitHeader()

	{

	cout << iHeader;

	}

void StoreFile::EmitFrames()

	{

	int verbose=TheProgram.Option(Program::verbose);

	Frames::Iterator const end=iFrames.End();

	for (Frames::Iterator iter=iFrames.Begin();iter<end;++iter)

		{

		FramePos pos=iter->iPos;

		cout << "Frame at " << pos << ": " << iter->iDes << endl;

		if (!verbose)

			continue;

	// dump contents

		int length=iter->iDes.Length();

		if (length==0)

			{	// full frame

			if (iter+1==end)	// no more

				continue;

			length=iter[1].iPos.Pos()-pos.Pos();

			}

		HexDump hex;

		iFile.seekg(FileOffset(pos).Offset(),ios::beg);

		hex.Dump(iFile,length);

		hex.Flush();

		cout << endl;

		}

	cout << endl;

	}

void StoreFile::EmitToc()

	{

	cout << iToc;

	}

void StoreFile::EmitStreams()

	{

	int verbose=TheProgram.Option(Program::verbose);

	cout << endl;

	Toc::Iterator const end=iToc.End();

	for (Toc::Iterator iter=iToc.Begin();iter<end;++iter)

		{

		if (!iter->iHandle.Avail())

			{

			cout << "Stream " << iter->iHandle;

			if (iter->Pos().Pos()==-1)

				{

				cout << " is empty\n";

				continue;

				}

			if (!TheProgram.Option(Program::compare))

				cout << " at " << iter->Pos();

			Stream stream(iFrames,iter->Pos());

			if (!stream.IsGood() || stream.Type()!=FrameDes::Data)

				{

				cout << " is invalid\n";

				continue;

				}

			int len=stream.Length();

			cout << ", " << dec << len << hex << " byte" << (len==1 ? "\n" : "s\n");

			if (!verbose)

				continue;

		// dump contents

			HexDump hex;

			Frames::Iterator f=stream.Frame();

			do

				{

				FramePos pos=f->iPos;

				int len=f++->iDes.Length();

				if (len==0)

					len=f->iPos.Pos()-pos.Pos();

				iFile.seekg(FileOffset(pos).Offset(),ios::beg);

				hex.Dump(iFile,len);

				} while (f->iDes.Type()==FrameDes::Continuation);

			hex.Flush();

			cout << endl;

			}

		}

	}

// Class HexDump

HexDump::HexDump()

	: iPos(0),iByte(0)

	{

	Reset();

	}

HexDump::~HexDump()

	{

	Flush();

	}

void HexDump::Reset()

	{

	memset(iChar,' ',HexInterval+3);

	iChar[HexInterval+3]=0;

	iPtr=&iChar[2];

	}

void HexDump::Dump(istream& aStream,int aBytes)

	{

	while (--aBytes>=0 && !aStream.eof())

		{

		if (iByte==0)

			cout << Margin << FileOffset(iPos) << ':';

		int c=aStream.get();

		cout << ' ' << setw(2) << c;

		*iPtr++=char(isprint(c) ? c : '.');

		if (++iByte==HexInterval/2)

			{

			cout << ' ';

			++iPtr;

			}

		else if (iByte==HexInterval)

			Flush();

		}

	}

void HexDump::Flush()

	{

	if (iByte)

		{

		for (int ii=iByte;ii<HexInterval;++ii)

			cout << "   ";

		if (iByte<HexInterval/2)

			cout << ' ';

		cout << iChar << endl;

		iPos+=iByte;

		iByte=0;

		Reset();

		}

	}

// Toc

Toc::Toc()

	: iPos(0), iRep(NULL), iAvail(0)

	{

	memset(&iHeader,0,sizeof(iHeader));

	}

Toc::~Toc()

	{

	free(iRep);

	}

void Toc::Base(const char* aPtr,int aCount)

	{

	Entry* e=iRep;

	for (int i=1;i<=aCount;++e,++i)

		{

		e->iHandle=i;	// set the index part

		memcpy((char*)e+Entry::BaseRedundant,aPtr,Entry::BaseSize);

		aPtr+=Entry::BaseSize;

		}

	}

void Toc::Load(istream& aStream,Frames const& aFrames,Frames::Iterator aFrame,Header::Reloc const* aReloc)

	{

	iPos = aFrame->iPos;

	Stream toc1(aFrame);

	void* toc = toc1.Load(aStream);

	const char* p = reinterpret_cast<char*>(toc);

	memcpy(&iHeader,p,Head::Size);

	p+=Head::Size;

	int n = iHeader.iCount;

	if (n < 0)

		{

		memset(&iHeader,0,Head::Size);

		Program::Error() << "corrupt toc" << endl;

		return;

		}

	iRep=static_cast<Entry*>(malloc(n*sizeof(Entry)));

	if (iRep==NULL)

		Program::Abort("Out of memory");

	if (iHeader.IsDelta())

		{

		// verify the delta header

		memcpy(&iDelta,p,DeltaHead::Size);

		p+=DeltaHead::Size;

		int dn = iDelta.iCount;

		if (toc1.Length() != Head::Size + DeltaHead::Size + dn * Entry::DeltaSize)

			{

			memset(&iHeader,0,Head::Size);

			Program::Error() << "incomplete toc" << endl;

			return;

			}

		// find the toc-base

		FramePos tocbase(iDelta.iBase + Header::tocoffset);

		if (aReloc && aReloc->iHandle.IsTocBase())

			tocbase = aReloc->iPos;

		Stream toc2(aFrames,tocbase);

		if (!toc2.IsGood())

			{

			memset(&iHeader,0,Head::Size);

			Program::Error() << "invalid toc-base address " << tocbase << endl;

			return;

			}

		if (toc2.Type()!=FrameDes::Toc)

			{

			memset(&iHeader,0,Head::Size);

			Program::Error() << "toc-base address " << tocbase << ": refers to non-toc frame"<< endl;

			return;

			}

		// validate and load the toc-base

		void* tocb = toc2.Load(aStream);

		const char* p2 = reinterpret_cast<char*>(tocb);

		Head headbase;

		memcpy(&headbase,p2,Head::Size);

		p2+=Head::Size;

		if (headbase.IsDelta())

			{

			memset(&iHeader,0,Head::Size);

			Program::Error() << "toc-base is a toc-delta"<< endl;

			return;

			}

		int bn = headbase.iCount;

		if (bn > n)

			{

			memset(&iHeader,0,Head::Size);

			Program::Error() << "toc-base is larger than toc"<< endl;

			return;

			}

		Base(p2,bn);

		free(tocb);

		// validate and update with the toc-delta

		int last = 0;

		while (--dn>=0)

			{

			Entry e;

			memcpy(&e,p,Entry::DeltaSize);

			p+=Entry::DeltaSize;

			int ix = e.iHandle.Index();

			if (ix<=0 || ix > n)

				{

				memset(&iHeader,0,Head::Size);

				Program::Error() << "toc-delta entry " << e.iHandle << " is outside toc"<< endl;

				return;

				}

			if (ix <= last)

				{

				memset(&iHeader,0,Head::Size);

				Program::Error() << "toc-delta entry " << e.iHandle << " is out of order"<< endl;

				return;

				}

			iRep[ix-1] = e;

			last = ix;

			}

		}

	else

		{

		if (toc1.Length() != Head::Size + n * Entry::BaseSize)

			{

			memset(&iHeader,0,Head::Size);

			Program::Error() << "incomplete toc" << endl;

			return;

			}

		Base(p,n);

		}

	free(toc);

	// apply the relocation

	if (aReloc && !aReloc->iHandle.IsTocBase())

		{

		int ix=aReloc->iHandle.Index();

		if (ix<=0 || ix>n)

			Program::Corrupt("invalid index in relocation patch");

		Entry& e=iRep[ix-1];

		if (e.iHandle.Generation()!=aReloc->iHandle.Generation())

			Program::Corrupt("incorrect generation in relocation patch");

		e.iPos=aReloc->iPos.Pos();

		}

	// count the available entries

	int avail=0;

	for (int i=0;i<n;++i)

		{

		if (iRep[i].iHandle.Avail())

			++avail;

		}

	iAvail=avail;

// verify the available list

	Handle link=iHeader.iAvail;

	if (!link.IsNull())

		{

		int ix=link.Index();

		if (!link.Avail() || ix<=0 || ix >iHeader.iCount)

			{

eAvail:		Program::Error() << "corrupt available link in toc header " << link << endl;

			return;

			}

		Entry const* en=&(*this)[ix];

		if (en->iHandle!=link)

			goto eAvail;

		for (;;)

			{

			if (--avail<0)

				{

				Program::Error() << "corrupt available list, possible circular reference" << endl;

				return;

				}

			Handle next=en->Link();

			if (next.IsNull())

				break;

			ix=next.Index();

			if (!next.Avail() || ix<=0 || ix >iHeader.iCount)

				{

eLink:			Program::Error() << "corrupt link in toc entry " << link << endl;

				return;

				}

			en=&(*this)[ix];

			if (en->iHandle!=next)

				goto eLink;

			link=next;

			}

		}

	if (avail!=0)

		Program::Error() << "corrupt available list: free index leakage" << endl;

	}

ostream& operator<<(ostream& aStream,Toc const& aToc)

	{

	int all=TheProgram.Option(Program::frame);

	Toc::Head const& head=aToc.iHeader;

	if (TheProgram.Option(Program::compare))

		aStream << "Toc: ";

	else

		aStream << "Toc at " << aToc.iPos << " with ";

	aStream << dec << head.iCount << (head.iCount==1 ? " entry: " : " entries: ") \

		<< head.iCount-aToc.iAvail  << " allocated, " << aToc.iAvail << " free\n" << hex;

	if (!all)

		aStream << "root is " << head.Root() << '\n';

	else

		{

		aStream << "first available is " << head.iAvail << '\n';

		Toc::Iterator const end=aToc.End();

		for (Toc::Iterator iter=aToc.Begin();iter<end;++iter)

			{

			aStream << (iter->iHandle==head.Root() ? "* " : Margin) << iter->iHandle;

			if (iter->iHandle.Avail())

				aStream << " free -> " << iter->Link() << '\n';

			else if (iter->Pos().Pos()==-1)

				aStream << " empty\n";

			else

				aStream << " alloc at " << iter->Pos() << '\n';

			}

		}

	return aStream << flush;

	}

// Class Stream

int Stream::Length() const

	{

	int total=0;

	Frames::Iterator f=iFrame;

	do	{

		int len=f->iDes.Length();

		if (len==0)

			len=f[1].iPos.Pos()-f[0].iPos.Pos();

		total+=len;

		} while ((++f)->iDes.Type()==FrameDes::Continuation);

	return total;

	}

void* Stream::Load(istream& aStream) const

	{

	int size = Length();

	void* data = malloc(size);

	if (data==NULL)

		Program::Abort("Out of memory");

	char* read=reinterpret_cast<char*>(data);

	Frames::Iterator f = iFrame;

	do

		{

		FramePos pos=f->iPos;

		int len=f++->iDes.Length();

		if (len==0)

			len=f->iPos.Pos()-pos.Pos();

		aStream.seekg(FileOffset(pos).Offset(),ios::beg);

		aStream.read(read,len);

		read+=len;

		} while (f->iDes.Type()==FrameDes::Continuation);

	return data;

	}

// Class Frames

Frames::Frames()

	: iSize(0),iElements(0),iRep(NULL)

	{}

Frames::~Frames()

	{

	free(iRep);

	}

void Frames::Add(FramePos aPos,FrameDes aDes)

	{

	if (iElements==iSize)

		{

		iSize=iSize==0 ? 128 : iSize+iSize;

		void* rep=realloc(iRep,iSize*sizeof(*iRep));

		if (rep==NULL)

			Program::Abort("Out of memory");

		iRep=(Element*)rep;

		}

	Element& element=iRep[iElements++];

	element.iPos=aPos;

	element.iDes=aDes;

	}

void Frames::Complete()

//

// add a terminating entry

//

	{

	Add(0,0);

	--iElements;

	}

Frames::Iterator Frames::Find(FramePos aPos) const

	{

	return (Element const*)bsearch(&aPos,iRep,iElements,sizeof(*iRep),Compare);

	}

int Frames::Compare(void const* aLeft,void const* aRight)

	{

	int left=static_cast<FramePos const*>(aLeft)->Pos();

	int right=static_cast<Element const*>(aRight)->iPos.Pos();

	if (left<right)

		return -1;

	if (left>right)

		return 1;

	return 0;

	}

// Header

FramePos Header::Toc() const

	{

	return tocoffset+(!Dirty() && iToc.iZero==0 ? iToc.iPos : iBackupToc>>backupshift);

	}

Header::Reloc const* Header::GetReloc() const

	{

	return (Dirty() || iToc.iZero==0) ? NULL : reinterpret_cast<Reloc const*>(&iReloc);

	}

ostream& operator<<(ostream& aStream,Header const& aHeader)

	{

	aStream << "Header is " << (aHeader.Dirty() ? "dirty" : "clean");

	Header::Reloc const* reloc=aHeader.GetReloc();

	if (reloc!=NULL)

		{

		aStream << "\npending relocation of ";

		if (reloc->iHandle.IsTocBase())

			aStream << "toc-base";

		else

			aStream << "stream " << StreamId(reloc->iHandle);

		aStream << " to " << reloc->iPos;

		}

	return aStream << "\n\n" << flush;

	}

// FileOffset

FileOffset::FileOffset(FramePos aPos)

// calculate the file offset for a streampos

	{

	int pos=aPos.Pos();

	int n=pos>>FrameDes::FullShift;

	pos+=FrameDes::Size*n+FrameDes::First;

	iValue=pos;

	}

FileOffset::operator FramePos() const

	{

	int pos=iValue-FrameDes::First;

	int n=pos/FrameDes::Interval;

	pos-=n*FrameDes::Size;

	return FramePos(pos);

	}

ostream& operator<<(ostream& aStream,FileOffset anOffset)

	{

	return aStream << setw(StoreFile::OutWidth) << anOffset.iValue;

	}

// Handle

ostream& operator<<(ostream& aStream,Handle aHandle)

	{

	if (aHandle.IsNull())

		aStream << "Null";

	else

		aStream << setw(6) << aHandle.Index() << ':' << aHandle.Generation();

	return aStream;

	}

// FramePos

ostream& operator<<(ostream& aStream,FramePos aPos)

	{

	return aStream << setw(StoreFile::OutWidth) << aPos.iValue << '[' << FileOffset(aPos) << ']';

	}

// FrameDes

istream& operator>>(istream& aStream,FrameDes& aFrame)

	{

	return aStream.read((char*)&aFrame,FrameDes::Size);

	}

ostream& operator<<(ostream& aStream,FrameDes aFrame)

	{

	static char const* FrameType[]={"free","data","toc","continuation"};

	aStream << FrameType[aFrame.Type()] << " (";

	int length=aFrame.Length();

	if (length==0)

		aStream << "full";

	else

		aStream << dec << length << hex;

	return aStream << ')';

	}