//
//		Copyright (c) 1996 Microsoft Corporation
//
//
//		INF.CPP		-- Implemtation for Classes:
//							CInfFile
//
//		History:
//			05/21/96	JosephJ		Created
//
//
#include "common.h"
#include "ini.h"
#include "inf.h"

// Version-related constants
LPCTSTR lpctszVersion		= TEXT("Version");
LPCTSTR lpctszLayoutFile	= TEXT("LayoutFile");
LPCTSTR lpctszSignature		= TEXT("Signature");
LPCTSTR lpctszClass			= TEXT("Class");
LPCTSTR lpctszClassGUID		= TEXT("ClassGUID");
LPCTSTR lpctszProvider		= TEXT("Provider");


LPCTSTR lpctszManufacturer	= TEXT("Manufacturer");
LPCTSTR lpctszControlFlags	= TEXT("ControlFlags");
LPCTSTR lpctszStrings		= TEXT("Strings");

///////////////////////////////////////////////////////////////////////////
//		CLASS CInfFile
///////////////////////////////////////////////////////////////////////////


CInfFile::CInfFile(void)
{
	m_pVersion=NULL;
	m_pFirstManuE=NULL;
	m_pSymFileName=NULL;
	m_pIniFile=NULL;
}


CInfFile::~CInfFile()
{
	mfn_EnterCrit();

	// Free resources -- there should be none to free...
	ASSERT(!m_pVersion);
	ASSERT(!m_pFirstManuE);
	ASSERT(!m_pIniFile);

}


//--------------	Load			------------------
// Loads the specified file. (Obviously) only one file can be loaded at
// a time.
BOOL CInfFile::Load	(const TCHAR rgchPathname[])
{
	BOOL fRet = FALSE;

	mfn_EnterCrit();

	// TODO: call m_sync.BeginLoad

	ASSERT(!m_pVersion);
	ASSERT(!m_pFirstManuE);
	ASSERT(!m_pIniFile);

	// Save file name
	m_pSymFileName = gSymtab.Lookup(rgchPathname, TRUE);
	if (!m_pSymFileName) goto end;

	// Create and Load Ini File
	m_pIniFile  = new CIniFile;
	if (m_pIniFile)
	{
		if (!m_pIniFile->Load(rgchPathname))
		{
			delete m_pIniFile;
			m_pIniFile=NULL;
		}
	}
	if (!m_pIniFile) goto end;

	// Create and Load version
	{
		CInfVersionSection *pVS = new CInfVersionSection;
		if (pVS)
		{
			// Override const * declaration of m_pVersion
			if (!pVS->Load(m_pIniFile))
			{
				delete pVS;
				pVS=NULL;
			}
		}
		m_pVersion = pVS;
	}
	if (!m_pVersion) goto end;

	// Create and load Manufacturer list...
	m_pFirstManuE = sfn_CreateManufacturerList(m_pIniFile);
	if (!m_pFirstManuE) goto end;

	fRet = TRUE;

end:

	if (!fRet)
	{
		mfn_Cleanup();
	}

	mfn_LeaveCrit();

	return fRet;
}


//--------------	Unload			------------------
// Unloads a previously loaded file. If there are open sessions to this
// object, Unload returns a handle which will be signalled when all
// sessions are closed. New sessions will not be allowed after this
// function returns. The call should free the handle.
HANDLE CInfFile::Unload	(void)
{
	HANDLE hUnload = NULL;

	mfn_EnterCrit();

	// TODO: call m_sync.BeginUnload to try to put us in unloadable state.

	mfn_Cleanup();

	mfn_LeaveCrit();


	return hUnload;
}


///////////////////////////////////////////////////////////////////////////
//		CLASS CInfVersionSection
///////////////////////////////////////////////////////////////////////////

// Sample Version section:
//		[Version]
//		LayoutFile=layout.inf
//		Signature="$CHICAGO$"
//		Class=Modem
//		ClassGUID={4D36E96D-E325-11CE-BFC1-08002BE10318}
//		Provider=%MS%
	

//--------------	Load			------------------
// TODO: unimplemented
BOOL CInfVersionSection::Load	(const CIniFile *pIniFile)
{
	BOOL fRet = FALSE;
	const CIniFileSection *pISVer = pIniFile->LookupSection(lpctszVersion);
	const CIniFileSection *pISStr = pIniFile->LookupSection(lpctszStrings);
	const CIniFileEntry   *pIE  = NULL;

#if 0
	m_pSymLayoutFile	= gSymtab.Lookup(TEXT("layout.inf"), TRUE);
	m_pSymSignature		= gSymtab.Lookup(TEXT("\"$CHICAGO$\""), TRUE);
	m_pSymClass			= gSymtab.Lookup(TEXT("Modem"), TRUE);
	m_pSymClassGUID		= gSymtab.Lookup
						  (
							TEXT("{4D36E96D-E325-11CE-BFC1-08002BE10318}"),
							TRUE
						  );
	m_pSymProvider		= gSymtab.Lookup(TEXT("Microsoft"), TRUE);

	m_dwChecksum		= 0x12345678L;
#endif

	ASSERT
	(
			!m_pSymLayoutFile
		&&	!m_pSymSignature
		&&	!m_pSymClass	
		&&	!m_pSymClassGUID
		&&	!m_pSymProvider	
		&&	!m_dwChecksum
	);

	if (!pISVer || !pISStr) goto end;

	//		LayoutFile=layout.inf
	pIE = pISVer->LookupEntry(lpctszLayoutFile);
	if (pIE)
	{
		m_pSymLayoutFile	= pIE->GetRHS();
		pIE->Release();pIE=NULL;
		// TODO: further checks here
	}

	//		Signature="$CHICAGO$"
	pIE = pISVer->LookupEntry(lpctszSignature);
	if (pIE)
	{
		m_pSymSignature	= pIE->GetRHS();
		pIE->Release();pIE=NULL;
		// TODO: further checks here
	}

	//		Class=Modem
	pIE = pISVer->LookupEntry(lpctszClass);
	if (pIE)
	{
		m_pSymClass	= pIE->GetRHS();
		pIE->Release();pIE=NULL;
		// TODO: further checks here
	}

	//		ClassGUID={4D36E96D-E325-11CE-BFC1-08002BE10318}
	pIE = pISVer->LookupEntry(lpctszClassGUID);
	if (pIE)
	{
		m_pSymClassGUID	= pIE->GetRHS();
		pIE->Release();pIE=NULL;
		// TODO: further checks here
	}

	//		Provider=%MS%
	pIE = pISVer->LookupEntry(lpctszProvider);
	if (pIE)
	{
		const CInfSymbol *pSymLHS	= pIE->GetLHS();
		pIE->Release();pIE=NULL;

		if (pSymLHS)
		{
			pIE	= pISStr->LookupEntry(pSymLHS->GetText());
			if (pIE)
			{
				m_pSymProvider	= pIE->GetRHS();
				pIE->Release();pIE=NULL;
			}
		}
		// TODO: further checks here
	}

	// Compute checksum of entire version structure
	m_dwChecksum = m_pSymLayoutFile->Checksum();
	AddToChecksumDW(&m_dwChecksum, m_pSymSignature->Checksum());
	AddToChecksumDW(&m_dwChecksum, m_pSymClass->Checksum());
	AddToChecksumDW(&m_dwChecksum, m_pSymClassGUID->Checksum());
	AddToChecksumDW(&m_dwChecksum, m_pSymProvider->Checksum());

	fRet =TRUE;

end:

	if (pIE) 	{ pIE->Release(); pIE=NULL; }
	if (pISVer) { pISVer->Release(); pISVer=NULL; }
	if (pISStr) { pISStr->Release(); pISStr=NULL; }

	if (!fRet)
	{
		mfn_Cleanup();
	}

	return fRet;
}


//--------------	Unload			------------------
void CInfVersionSection::Unload	(void)
{
	// TODO: call m_sync.BeginUnload to try to put us in unloadable state.

	mfn_Cleanup();

	return;
}



//--------------	Dump			------------------
// Dump state
void
CInfVersionSection::Dump(void)
const
{
}

// Cleanup by freeing any allocated resources.
void	CInfVersionSection::mfn_Cleanup (void)
{
		m_pSymLayoutFile	= NULL;
		m_pSymSignature		= NULL;
		m_pSymClass			= NULL;;
		m_pSymClassGUID		= NULL;
		m_pSymProvider		= NULL;
		m_dwChecksum		= 0;
}


///////////////////////////////////////////////////////////////////////////
//		CLASS CInfManufacturerEntry
///////////////////////////////////////////////////////////////////////////

// Sample Manufacturer list section:
//		[Manufacturer]
//		%Generic%     = Generic
//		%MagicRam%    = MagicRam
// 		..


///////////////////////////////////////////////////////////////////////////
//		CLASS CInfManufacturerSection
///////////////////////////////////////////////////////////////////////////

// Sample Manufacturer section:
//		[Generic]
//		%Gen%    = Gen,    MDMGEN
//		%Gen3%   = Gen3,   MDMGEN3
//		%Gen12%  = Gen12,  MDMGEN12
//		%Gen24%  = Gen24,  MDMGEN24
//		...


// ---------------	GetFirstModelEntry	--------------
// Get first model entry
const	CInfModelEntry		*
CInfManufacturerSection::GetFirstModelEntry	(void)
const
{
	return m_pFirstModelE;
}

///////////////////////////////////////////////////////////////////////////
//		CLASS CInfInstallSection
///////////////////////////////////////////////////////////////////////////

// Sample Install section:
//		[Modem29]
//		AddReg=All, MfgAddReg, ROCK_VOICE_ALL, ROCK_VOICE_SERWAVE, INTERNAL
//		CopyFiles   = VV_Sys, VV_Sock_Sys, VV_App, VV_Help
//		UpdateInis  = VView.Inis
//		Uninstall   = VoiceView_remove
//
// Also contains info from the related PosDup and NoResDup sections.


// ---------------	GetAddRegSectionList	----------
// Get generic list whose data items are pointers to
// CInfAddRegSection objects
const CInfList		*
CInfInstallSection::GetAddRegSectionList	(void)
const
{
	// TODO: unimplemented

	static const CInfAddRegSection AddRegSection;
	static const CInfList AddRegSectionList((void *) &AddRegSection, NULL);

	return &AddRegSectionList;
}


// ---------------	GetCopyFilesSectionList	----------
// Get generic list whose data items are pointers to
// CInfCopyFilesSection objects
const CInfList		*
CInfInstallSection::GetCopyFilesSectionList	(void)
const
{
	// TODO: unimplemented

	static const CInfCopyFilesSection CopyFilesSection;
	static const CInfList CopyFilesSectionList((void *) &CopyFilesSection, NULL);

	return &CopyFilesSectionList;
}


// ---------------	GetNoResDupIDList		----------
// Get generic list whose data items are pointers to
// InfSymbol objects representing the Rank0 IDs in the corresponding
// NoResDup section.
const CInfList		*
CInfInstallSection::GetNoResDupIDList	(void)
const
{
	// TODO: unimplemented

	static const CInfList NoResDupIDList
						  (
							(void *) gSymtab.Lookup(TEXT("NORESDUP-ID"), TRUE),
							NULL
						  );

	return &NoResDupIDList;
}


// ---------------	GetPosDupIDList		----------
// Get generic list whose data items are pointers to
// InfSymbol objects representing the Rank0 IDs in the corresponding
// PosDup section.
// const	CInfList		*	GetPosDupIDList	(void)	const;
const CInfList		*
CInfInstallSection::GetPosDupIDList	(void)
const
{
	// TODO: unimplemented
	static const CInfList PosDupIDList1
						  (
							(void *) gSymtab.Lookup(TEXT("POSDUP-ID1"), TRUE),
							NULL
						  );
	static const CInfList PosDupIDList
						  (
							(void *) gSymtab.Lookup(TEXT("POSDUP-ID0"), TRUE),
							&PosDupIDList1
						  );

	return &PosDupIDList;
}


///////////////////////////////////////////////////////////////////////////
//		CLASS CInfAddRegSection
///////////////////////////////////////////////////////////////////////////

// Sample AddReg section:
//		[All]
//		HKR,,FriendlyDriver,,Unimodem.vxd
//		HKR,,DevLoader,,*vcomm
//		HKR,,ConfigDialog,,modemui.dll
//		HKR,,EnumPropPages,,"modemui.dll,EnumPropPages"
//		HKR,,PortSubClass,1,02
//		HKR, Init, 1,, "AT<cr>"
//		HKR, Responses, "<cr><lf>OK<cr><lf>", 1, 00, 00, 00,00,00,00, ...etc.
//		HKR, Responses, "<cr><lf>ERROR<cr><lf>", 1, 03, 00, 00,00,00, ...etc.


// Get first addreg entry
const CInfAddRegEntry *
CInfAddRegSection::GetFirstAddRegEntry	(void)
const
{
	// TODO -- fake static entries
	static const CInfAddRegEntry FirstAddRegEntry;
	return &FirstAddRegEntry;
}


///////////////////////////////////////////////////////////////////////////
//		CLASS CInfCopyFilesSection
///////////////////////////////////////////////////////////////////////////

// Sample DestinationDirs section:
//		[DestinationDirs]
//		Register.Copy    = 17     ;LDID_INF
//		VV_Sys           = 11           
//		VV_Sock_Sys      = 11     ;LDID_SYS \Windows\system dir
//		VV_Sock_Win      = 10     ;LDID_WIN \Windows dir
//		VV_App           = 10
//		VV_Help          = 18     ;LDID_HELP

// Sample Copyfiles section:
//		[VV_Sys]
//		fte.dll
//		vvexe32.exe
//		wsvv.vxd


// ---------------	GetFirstCopyFilesEntry	----------
// Get first copyfiles entry
const	CInfCopyFilesEntry		*
CInfCopyFilesSection::GetFirstCopyFilesEntry	(void)	const
{
	// TODO -- fake static entries
	static const CInfCopyFilesEntry FirstCopyFilesEntry;
	return &FirstCopyFilesEntry;
}


// Cleanup by freeing any allocated resources.
// TODO: unimplemented
void	CInfFile::mfn_Cleanup (void)
{
	mfn_EnterCrit();

	// TODO: ASSERT(state == loading or state == unloading)

	// Unload and free version
	if (m_pVersion)
	{
		// override const *
		CInfVersionSection *pVS = (CInfVersionSection *) m_pVersion;
		pVS->Unload();
		delete pVS;
		m_pVersion=NULL;
	}


	// Unload and free Manufacturerlist.
	if (m_pFirstManuE)
	{
		sfn_DeleteManufacturerList(m_pFirstManuE);
		m_pFirstManuE=NULL;
	}

	if (m_pIniFile)
	{
		m_pIniFile->Unload();
		delete (CIniFile *) m_pIniFile; // override const *
		m_pIniFile=NULL;
	}

	m_pSymFileName=NULL;

	mfn_LeaveCrit();
}

// static helper function...
const CInfManufacturerEntry * 
CInfFile::sfn_CreateManufacturerList (CIniFile *pIniFile)
{
	CInfManufacturerEntry * pManuE = NULL;
	const CIniFileSection *pISStr = pIniFile->LookupSection(lpctszStrings);
	const CIniFileSection *pISManL =
									pIniFile->LookupSection(lpctszManufacturer);
	CIniFileEntry   *pIE  = NULL;

	if (!pISManL || !pISStr) goto end;

	pIE = pISManL->GetFirstEntry();
	if (!pIE) goto end;

	// Iterate through manufacturers, building manufacturer entries...
	do
	{
		pManuE = new CInfManufacturerEntry(pManuE);
		if (!pManuE || !pManuE->Load(pIniFile, pISStr, pIE))
		{
			// TODO: warning; for now break out.
			if (pManuE)
			{
				// TODO delete previously-created elements of the list as well!
				// (Or leave them there and deal with a partial list).
				delete pManuE;
				pManuE = NULL;
			}
			goto end;
		}

	} while(pIE->BecomeNext());

	// Reverse list
	CInfManufacturerEntry::ReverseList(&pManuE);

end:
	if (pIE) {pIE->Release(); pIE=NULL;}
	if (pISManL)	{ pISManL->Release(); pISManL=NULL; }
	if (pISStr)		{ pISStr->Release(); pISStr=NULL; }

	return pManuE;
}

// Static helper function
void 
CInfFile::sfn_DeleteManufacturerList
(
	const CInfManufacturerEntry * pManuEFirst
)
{
	// TODO
}

// ---------------	Load			------------------
BOOL
CInfManufacturerEntry::Load
(
	const CIniFile *pIniFile,
	const CIniFileSection *pISStr,
	const CIniFileEntry *pIE
)
{
	BOOL fRet = FALSE;
	const CInfSymbol *pSymLHS	= pIE->GetLHS();
	const CInfSymbol *pSymManuName	= NULL;
	 // TODO need to make manu-section case insensitive!
	 // Basically pSymManuSection should be created based on an upper-case'd
	 // version of pIE->GetRHS().
	const CInfSymbol *pSymManuSection	= pIE->GetRHS();
	CInfManufacturerSection *pManuS = NULL;
	BOOL fNew=FALSE;

	ASSERT(!m_pManuS);
	ASSERT(!m_pSymManuName);

	// Get manufacturer name ...
	if (pSymLHS)
	{
		const CIniFileEntry *pIEStr	= pISStr->LookupEntry(pSymLHS->GetText());
		if (pIEStr)
		{
			pSymManuName	= pIE->GetRHS();
			pIEStr->Release();pIEStr=NULL;
		}
	}

	pManuS=NULL;

	// Look up/create manufacturer section
	{
		void **ppv=NULL;
		BOOL fExists=FALSE;
		BOOL fRet = pSymManuSection->GetOrCreatePropLoc(
											PROP_INFSECTION_MANUFACTURER,
											&ppv,
											&fExists);
		if (fRet)
		{
			if (fExists)
			{
				// This section already exists...
				pManuS = (CInfManufacturerSection *) *ppv;
				ASSERT(pManuS->Validate());
			}
			else
			{
				// This section doesn't exist -- create it.
				pManuS = new CInfManufacturerSection();
				if (pManuS)
				{
					if (pManuS->Load(pIniFile, pISStr, pSymManuSection))
					{
						// set the property data
						*ppv = (void *) pManuS;
					}
					else
					{
						delete pManuS;
						pManuS=NULL;
						pSymManuSection->DelProp(PROP_INFSECTION_MANUFACTURER);
					}
				}
			}
		}
	}
				
	if (pManuS)
	{
		m_pManuS = pManuS;
		m_pSymManuName = pSymManuName;
		fRet = TRUE;
	}

	if (!fRet)
	{
		mfn_Cleanup();
	}

	return fRet;

}

// ---------------	Unload			------------------
void	CInfManufacturerEntry::Unload(void)
// TODO
{
	m_pManuS = NULL;
	m_pSymManuName = NULL;
	// TODO: decrement ref count for the section and delete it  and delprop
	// it when done.
	mfn_Cleanup();

}


// ---------------	Cleanup			------------------
// Cleanup by freeing any allocated resources.
void	CInfManufacturerEntry::mfn_Cleanup (void)
{
	m_pManuS = NULL;
	m_pSymManuName = NULL;
}


// ---------------	Load	------------------
BOOL
CInfManufacturerSection::Load
(
	const CIniFile *pIniFile,
	const CIniFileSection *pISStr,
	const CInfSymbol *pSymManuSection
)
{
	BOOL fRet = FALSE;
	const CIniFileSection *pIS =
					pIniFile->LookupSection(pSymManuSection->GetText());

	ASSERT(!m_pSymSectionName);
	ASSERT(!m_pFirstModelE);
	ASSERT(m_eObjSig==eOBJSIG_CInfManufacturerSection);

	if (!pIS)
	{
		goto end;
	}

	m_pSymSectionName = pSymManuSection;

	// Create and load model list
	m_pFirstModelE = sfn_CreateModelList(pIniFile, pISStr, pIS);

	if (!m_pFirstModelE)
	{
		goto end;
	}

	fRet = TRUE;

end:

	if (!fRet)
	{
		mfn_Cleanup();
	}

	return fRet;
}

// ---------------	Unload			------------------
void	CInfManufacturerSection::Unload(void)
{
	mfn_Cleanup();
}


// ---------------	Cleanup			------------------
// Cleanup by freeing any allocated resources.
void	CInfManufacturerSection::mfn_Cleanup (void)
// TODO
{
	m_pSymSectionName	= NULL;
	m_pFirstModelE		= NULL;
}


// Static helper function to create the list of models for this manufacturer
const	CInfModelEntry		*
CInfManufacturerSection::sfn_CreateModelList
(
		const CIniFile *pIniFile,
		const CIniFileSection *pISStr,
		const CIniFileSection *pISManuS
)
{
	CInfModelEntry * pModelE = NULL;
	CIniFileEntry   *pIE  = NULL;

	if (!pISManuS || !pISStr) goto end;

	pIE = pISManuS->GetFirstEntry();
	if (!pIE) goto end;

	// Iterate through models, building model entries...
	do
	{
		pModelE = new CInfModelEntry(pModelE);
		if (!pModelE || !pModelE->Load(pIniFile, pISStr, pIE))
		{
			// TODO: warning; for now break out.
			if (pModelE)
			{
				// TODO delete previously-created elements of the list as well!
				// (Or leave them there and deal with a partial list).
				delete pModelE;
				pModelE = NULL;
			}
			goto end;
		}

	} while(pIE->BecomeNext());

	// Reverse list
	CInfModelEntry::ReverseList(&pModelE);

end:
	if (pIE) {pIE->Release(); pIE=NULL;}
	//if (pISManL)	{ pISManL->Release(); pISManL=NULL; }
	//if (pISStr)		{ pISStr->Release(); pISStr=NULL; }

	return pModelE;
}


// ---------------	Cleanup			------------------
// Cleanup by freeing any allocated resources.
void	CInfModelEntry::mfn_Cleanup (void)
// TODO
{
}


// ---------------	Load			------------------
BOOL
CInfModelEntry::Load
(
	const CIniFile *pIniFile,
	const CIniFileSection *pISStr,
	const CIniFileEntry *pIE
)
// TODO
{
	return TRUE;
#if 0
	BOOL fRet = FALSE;
	const CInfSymbol *pSymLHS	= pIE->GetLHS();
	const CInfSymbol *pSymManuName	= NULL;
	 // TODO need to make manu-section case insensitive!
	 // Basically pSymManuSection should be created based on an upper-case'd
	 // version of pIE->GetRHS().
	const CInfSymbol *pSymManuSection	= pIE->GetRHS();
	CInfManufacturerSection *pManuS = NULL;
	BOOL fNew=FALSE;

	ASSERT(!m_pManuS);
	ASSERT(!m_pSymManuName);

	// Get manufacturer name ...
	if (pSymLHS)
	{
		const CIniFileEntry *pIEStr	= pISStr->LookupEntry(pSymLHS->GetText());
		if (pIEStr)
		{
			pSymManuName	= pIE->GetRHS();
			pIEStr->Release();pIEStr=NULL;
		}
	}

	pManuS=NULL;

	// Look up/create manufacturer section
	{
		void **ppv=NULL;
		BOOL fExists=FALSE;
		BOOL fRet = pSymManuSection->GetOrCreatePropLoc(
											PROP_INFSECTION_MANUFACTURER,
											&ppv,
											&fExists);
		if (fRet)
		{
			if (fExists)
			{
				// This section already exists...
				pManuS = (CInfManufacturerSection *) *ppv;
				ASSERT(pManuS->Validate());
			}
			else
			{
				// This section doesn't exist -- create it.
				pManuS = new CInfManufacturerSection();
				if (pManuS)
				{
					if (pManuS->Load(pIniFile, pISStr, pSymManuSection))
					{
						// set the property data
						*ppv = (void *) pManuS;
					}
					else
					{
						delete pManuS;
						pManuS=NULL;
						pSymManuSection->DelProp(PROP_INFSECTION_MANUFACTURER);
					}
				}
			}
		}
	}
				
	if (pManuS)
	{
		m_pManuS = pManuS;
		m_pSymManuName = pSymManuName;
		fRet = TRUE;
	}

	if (!fRet)
	{
		mfn_Cleanup();
	}

	return fRet;
#endif

}

// ---------------	Unload			------------------
void	CInfModelEntry::Unload(void)
// TODO
{
	mfn_Cleanup();
}