// // Copyright (c) 1996 Microsoft Corporation
//
//
// INF.H -- Header for Classes:
//
// CInfFile
//
// CInfVersionSection
// CInfManufacturerSection
// CInfInstallSection
// CInfAddRegSection
// CInfCopyFilesSection
//
// CInfManufacturerEntry
// CInfModelEntry
// CInfCopyFilesEntry
// CInfAddRegEntry
//
// CInfModelEntryAux
//
//
// History:
// 05/21/96 JosephJ Created
//
//
class CInfVersionSection;
class CInfManufacturerEntry;
class CInfManufacturerSection;
class CInfModelEntry;
class CInfInstallSection;
class CInfAddRegSection;
class CInfAddRegEntry;
class CInfCopyFilesEntry;
class CInfCopyFilesSection;
class CInfModelEntryAux;
// Control flags
const DWORD dwCF_EXCLUDE_FROM_SELECT = 0x1<<0;
///////////////////////////////////////////////////////////////////////////
// CLASS CInfFile
///////////////////////////////////////////////////////////////////////////
// Represents an inf (device information) file -- which is a special kind
// of INI file.
class CInfFile
{
public:
CInfFile(void);
~CInfFile();
//-------------- Load ------------------
// Loads the specified file. (Obviously) only one file can be loaded at
// a time.
BOOL Load (const TCHAR rgchPathname[]);
//-------------- 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.
// See CloseSession for more info.
HANDLE Unload (void);
//-------------- OpenSession ------------------
// Open a session to this object. The object will not be unloaded until
// this session is closed. 0 indicates failure.
// TODO: unimplemented
const void * OpenSession (void) const {return (const void *) 1;}
//-------------- CloseSession ------------------
// Close the specified session to this object.
// If the reference count goes to zero and we're marked for unloading,
// the object is unloaded as well.
// TODO: unimplemented
void CloseSession (const void *) const {}
// --------------- Dump ------------------
// Dump state
void Dump(void) const;
// --------------- GetFileName ------------------
// Get Version info
const CInfSymbol * GetFileName(void) const
{
return m_pSymFileName;
}
// --------------- GetVersion ------------------
// Get Version info
const CInfVersionSection * GetVersion(void) const
{
return m_pVersion;
}
// --------------- GetFirstManufacturerEntry ------
// Get first manufacturer entry under the manufacturer section
const CInfManufacturerEntry * GetFirstManufacturerEntry(void) const
{
return m_pFirstManuE;
}
#if (TODO)
// --------------- GetFirstStringEntry --------------
// Get first string entry under the strings section
const CInfStringEntry * GetFirstStringEntry(void) const;
DestinationDirs
// --------------- LookupManufacturerSection ----------
// Lookup and return the manufacturer section with the specified name.
const CInfManufacturerSection *
LookupInstallSection(const CInfSymbol *pSymManSection)
const;
// --------------- LookupInstallSection ----------
// Lookup and return the install section with the specified name.
const CInfInstallSection * LookupInstallSection(const TCHAR pchName[])const;
// --------------- LookupAddRegSection --------------
// Lookup and return the addreg section with the specifed name.
const CInfAddRegSection * LookupAddRegSection(const TCHAR pchName[]) const;
// --------------- LookupString --------------
// Lookup and return the specified string
const CInfSymbol * LookupString(const TCHAR pchName[]) const;
#endif // TODO
private:
// ============= PRIVATE MEMBER FUNCTIONS ===============
void mfn_EnterCrit(void) const {m_sync.EnterCrit();}
void mfn_LeaveCrit(void) const {m_sync.LeaveCrit();}
void mfn_Cleanup(void);
// ============= PRIVATE STATIC HELPER FUNCTIONS ========
static
const CInfManufacturerEntry *
sfn_CreateManufacturerList(CIniFile *);
static
void
sfn_DeleteManufacturerList(const CInfManufacturerEntry *);
// ======================= DATA ========================
const CInfVersionSection * m_pVersion;
const CInfManufacturerEntry * m_pFirstManuE;
const CInfSymbol * m_pSymFileName;
CSync m_sync;
CIniFile *m_pIniFile;
};
///////////////////////////////////////////////////////////////////////////
// CLASS CInfVersionSection
///////////////////////////////////////////////////////////////////////////
// Sample Version section:
// [Version]
// LayoutFile=layout.inf
// Signature="$CHICAGO$"
// Class=Modem
// ClassGUID={4D36E96D-E325-11CE-BFC1-08002BE10318}
// Provider=%MS%
class CInfVersionSection
{
public:
CInfVersionSection(void)
{
m_pSymLayoutFile = NULL;
m_pSymSignature = NULL;
m_pSymClass = NULL;;
m_pSymClassGUID = NULL;
m_pSymProvider = NULL;
m_dwChecksum = 0;
}
~CInfVersionSection()
{
}
// --------------- Dump ------------------
// Dump state
void Dump(void) const;
// --------------- Checksum ------------------
// Return checksum of contents
DWORD Checksum(void) const
{
return m_dwChecksum;
}
// --------------- GetLayoutFile ------------------
const CInfSymbol * GetLayoutFile (void) const
{
return m_pSymLayoutFile;
}
// --------------- GetSignature ------------------
const CInfSymbol * GetSignature (void) const
{
return m_pSymSignature;
}
// --------------- GetClass ------------------
const CInfSymbol * GetClass (void) const
{
return m_pSymClass;
}
// --------------- GetClassGUID ------------------
const CInfSymbol * GetClassGUID (void) const
{
return m_pSymClassGUID;
}
// --------------- GetProvider ------------------
const CInfSymbol * GetProvider (void) const
{
return m_pSymProvider;
}
private:
friend class CInfFile;
BOOL Load(const CIniFile *);
void Unload(void);
void mfn_Cleanup(void);
const CInfSymbol * m_pSymLayoutFile;
const CInfSymbol * m_pSymSignature;
const CInfSymbol * m_pSymClass;
const CInfSymbol * m_pSymClassGUID;
const CInfSymbol * m_pSymProvider;
DWORD m_dwChecksum;
};
///////////////////////////////////////////////////////////////////////////
// CLASS CInfManufacturerEntry
///////////////////////////////////////////////////////////////////////////
// Sample Manufacturer list section:
// [Manufacturer]
// %Generic% = Generic
// %MagicRam% = MagicRam
// ..
class CInfManufacturerEntry: private CInfList
{
public:
CInfManufacturerEntry(const CInfManufacturerEntry *pNext)
: CInfList(NULL, pNext),
m_pManuS(NULL),
m_pSymManuName(NULL)
{}
~CInfManufacturerEntry() {}
// --------------- Dump ------------------
// Dump state
void Dump(void) const;
// --------------- GetManufacturerSection ----------
// Get manufacturer section
const CInfManufacturerSection * GetManufacturerSection (void) const
{
return m_pManuS;
}
// --------------- GetName ------------------
// Get manufacturer name (actual manufacturer name, not %xxxx%.)
const CInfSymbol * GetName (void) const
{
return m_pSymManuName;
}
// --------------- Next ------------------
// Get next Entry. NULL if no more...
const CInfManufacturerEntry * Next(void) const
{
return (const CInfManufacturerEntry *) CInfList::Next();
}
// --------------- Load ------------------
BOOL
Load(
const CIniFile *pIniFile,
const CIniFileSection *pISStr,
const CIniFileEntry *pIE
);
// --------------- Unload ------------------
void Unload(void);
//-------------- ReverseList ------------------
// Reverses the implicit list of manufacturer entries
static void ReverseList(CInfManufacturerEntry **ppManuE)
{
CInfList::ReverseList((const CInfList **) ppManuE);
}
private:
void mfn_Cleanup(void);
const CInfManufacturerSection *m_pManuS;
const CInfSymbol *m_pSymManuName;
};
///////////////////////////////////////////////////////////////////////////
// CLASS CInfManufacturerSection
///////////////////////////////////////////////////////////////////////////
// Sample Manufacturer section:
// [Generic]
// %Gen% = Gen, MDMGEN
// %Gen3% = Gen3, MDMGEN3
// %Gen12% = Gen12, MDMGEN12
// %Gen24% = Gen24, MDMGEN24
// ...
class CInfManufacturerSection
{
public:
CInfManufacturerSection(void)
{
m_eObjSig=eOBJSIG_CInfManufacturerSection;
m_pSymSectionName = NULL;
m_pFirstModelE = NULL;
}
~CInfManufacturerSection()
//TODO
{
m_eObjSig = eOBJSIG_INVALID;
}
// --------------- Dump ------------------
// Dump state
void Dump(void) const;
// --------------- GetFirstModelEntry --------------
// Get first model entry
const CInfModelEntry * GetFirstModelEntry (void) const;
// --------------- GetSectionName ------------------
// Get section name
const CInfSymbol * GetSectionName (void) const
{
return m_pSymSectionName;
}
// --------------- Load ------------------
BOOL
Load
(
const CIniFile *pIniFile,
const CIniFileSection *pISStr,
const CInfSymbol *pSymManuSection
);
// --------------- Unload ------------------
void Unload(void);
// --------------- Validate ------------------
BOOL Validate(void) const
{
// TODO: can place in try-except clause...
return this && m_eObjSig==eOBJSIG_CInfManufacturerSection;
}
#if (TODO)
// --------------- GetName ------------------
// Get manufacturer name (actual manufacturer name),
const CInfSymbol * GetName (void) const;
#endif
private:
void mfn_Cleanup(void);
// Static helper function
const CInfModelEntry *
sfn_CreateModelList(
const CIniFile *pIniFile,
const CIniFileSection *pISStr,
const CIniFileSection *pISManuS
);
const CInfSymbol *m_pSymSectionName;
const CInfModelEntry * m_pFirstModelE;
eOBJSIG m_eObjSig;
};
///////////////////////////////////////////////////////////////////////////
// CLASS CInfModelEntry
///////////////////////////////////////////////////////////////////////////
// Sample Model entry:
// %Gen% = Gen, MDMGEN
class CInfModelEntry : private CInfList
{
public:
CInfModelEntry(const CInfModelEntry *pNext)
: CInfList(NULL, pNext)
{
/*TODO*/
m_dwControlFlags_All = dwCF_EXCLUDE_FROM_SELECT;
m_dwControlFlags_NT_All = dwCF_EXCLUDE_FROM_SELECT;
m_dwControlFlags_NT_Alpha = dwCF_EXCLUDE_FROM_SELECT;
m_dwControlFlags_NT_PPC = dwCF_EXCLUDE_FROM_SELECT;
m_dwControlFlags_NT_Mips = dwCF_EXCLUDE_FROM_SELECT;
}
~CInfModelEntry() {/*TODO*/}
// --------------- Dump ------------------
// Dump state
void Dump(void) const;
// --------------- Load ------------------
BOOL
Load(
const CIniFile *pIniFile,
const CIniFileSection *pISStr,
const CIniFileEntry *pIE
);
// --------------- Unload ------------------
void Unload(void);
// --------------- GetNext ------------------
// Get next Entry. NULL if no more...
const CInfModelEntry * Next(void) const
{
return (const CInfModelEntry *) CInfList::Next();
}
//-------------- ReverseList ------------------
// Reverses the implicit list of model entries
static void ReverseList(CInfModelEntry **ppModelE)
{
CInfList::ReverseList((const CInfList **) ppModelE);
}
// --------------- GetLHS ------------------
// Get next Entry. NULL if no more...
const CInfSymbol * GetLHS(void) const
{
// TODO
return gSymtab.Lookup(TEXT("%bongo101%"), TRUE);
}
// --------------- GetInstallSection --------------
// Get install section
const CInfInstallSection * GetInstallSection (void) const
{
return m_pInstallSection;
}
// --------------- GetName ------------------
// Get model name (actual model name, not %xxx%)
const CInfSymbol * GetName (void) const
{
// TODO
//return m_pSymName;
return gSymtab.Lookup(TEXT("Christy Brinkly"), TRUE);
}
// --------------- GetRank0ID ------------------
// Rank-0 ID
const CInfSymbol * GetRank0ID (void) const
{
// TODO
//return m_pSymRank0ID;
// TODO
return gSymtab.Lookup(TEXT("RANK-0-ID"), TRUE);
}
// --------------- GetRank1ID ------------------
// Rank-1 ID
const CInfSymbol * GetRank1ID (void) const
{
// TODO
// return m_pSymRank1ID;
return gSymtab.Lookup(TEXT("RANK-1-ID"), TRUE);
}
// --------------- GetRank2ID ------------------
// Rank-2 ID
const CInfSymbol * GetRank2ID (void) const
{
// TODO
// return m_pSymRank2ID;
return gSymtab.Lookup(TEXT("RANK-2-ID"), TRUE);
}
// --------------- GetControlFlags -----------------
// Return install flags (one or more dwCF_* flags) for the specified
// platform.
DWORD GetControlFlags(ePLATFORM ePlat) const
{
DWORD dwRet = 0;
switch(ePlat)
{
case ePLAT_ALL:
break;
case ePLAT_NT_ALL:
dwRet = m_dwControlFlags_NT_All;
break;
case ePLAT_NT_ALPHA:
dwRet = m_dwControlFlags_NT_Alpha;
break;
case ePLAT_NT_PPC:
dwRet = m_dwControlFlags_NT_PPC;
break;
case ePLAT_NT_MIPS:
dwRet = m_dwControlFlags_NT_Mips;
break;
default:
break;
}
return dwRet;
}
private:
void mfn_Cleanup(void);
const CInfInstallSection * m_pInstallSection;
// Pointer to install section
const CInfSymbol * m_pSymName;
// Device name
const CInfSymbol * m_pSymRank0ID;
// Rank-0 ID (primary device ID)
const CInfSymbol * m_pSymRank1ID;
// Rank-1 ID (compatible device ID)
const CInfSymbol * m_pSymRank2ID;
// Rank-2 ID (Rank 2 ID)
DWORD m_dwControlFlags_All;
// Install flags (eg exclude from select, needs reboot, etc) that
// apply to all platforms.
DWORD m_dwControlFlags_NT_All;
// Install flags (eg exclude from select, needs reboot, etc) that
// apply to all NT platforms.
DWORD m_dwControlFlags_NT_Alpha;
// Install flags (eg exclude from select, needs reboot, etc) that
// apply to NT Alpha platform.
DWORD m_dwControlFlags_NT_PPC;
// Install flags (eg exclude from select, needs reboot, etc) that
// apply to NT PPC platform.
DWORD m_dwControlFlags_NT_Mips;
// Install flags (eg exclude from select, needs reboot, etc) that
// apply to NT MIPS platform.
};
///////////////////////////////////////////////////////////////////////////
// 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:
//
// [Modem12.PosDup]
// *PNP0500
//
// [Modem6.NoResDup]
// UNIMODEMCC646872,UNIMODEMA4970248,UNIMODEMB6071C15
//
class CInfInstallSection
{
public:
CInfInstallSection(void);
~CInfInstallSection();
// --------------- Dump ------------------
// Dump state
void Dump(void) const;
// --------------- GetAddRegSectionList ----------
// Get generic list whose data items are pointers to
// CInfAddRegSection objects
const CInfList * GetAddRegSectionList (void) const;
// --------------- GetCopyFilesSectionList ----------
// Get generic list whose data items are pointers to
// CInfCopyFilesSection objects
const CInfList * GetCopyFilesSectionList (void) const;
// --------------- GetNoResDupIDList ----------
// Get generic list whose data items are pointers to
// InfSymbol objects representing the Rank0 IDs in the corresponding
// NoResDup section.
const CInfList * GetNoResDupIDList (void) const;
// --------------- 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;
#if (TODO)
// --------------- GetUpdateInisSectionList ------
// Get generic list whose data items are pointers to
// CInfUpdateInisSection objects
const CInfList * GetUpdateInisSectionList (void) const;
// --------------- GetUninstallSectionList ------
// Get generic list whose data items are pointers to
// CInfUninstallSection objects
const CInfList * GetUninstallSectionList (void) const;
// TODO: Also, treat as errors any sections which we don't understand or
// don't expect in a modem inf file or we don't support in the compiler:
// eg rename sections, and other fancy INF file constructs.
#endif // (TODO)
private:
void mfn_Cleanup(void);
};
///////////////////////////////////////////////////////////////////////////
// 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.
class CInfAddRegSection
{
public:
CInfAddRegSection(void) {/*TODO*/}
~CInfAddRegSection() {/*TODO*/}
// --------------- Dump ------------------
// Dump state
void
Dump(void)
const;
// --------------- GetFirstAddRegEntry --------------
// Get first addreg entry
const
CInfAddRegEntry *
GetFirstAddRegEntry (void)
const;
private:
void mfn_Cleanup(void);
};
///////////////////////////////////////////////////////////////////////////
// CLASS CInfAddRegEntry
///////////////////////////////////////////////////////////////////////////
// Sample AddReg entry:
// HKR, Init, 1,, "AT<cr>"
class CInfAddRegEntry
{
public:
CInfAddRegEntry(void)
{
// TODO -- faked out
m_pSymRegRoot = gSymtab.Lookup(TEXT("HKR"), TRUE);
m_pSymSubKey = gSymtab.Lookup(TEXT("Init"), TRUE);
m_pSymValueName = gSymtab.Lookup(TEXT("1"), TRUE);
m_dwFlag = MAXDWORD;
m_pSymValue = gSymtab.Lookup(TEXT("\"AT<cr>\""), TRUE);
m_dwChecksum = 1000;
}
~CInfAddRegEntry() {/*TODO*/}
// --------------- Dump ------------------
// Dump state
void
Dump(void)
const
{
// TODO: unimplemented
printf(" HKR, Init, 1,, \"AT<cr>\"\n");
}
// --------------- Checksum ------------------
// Compute and return checksum of contents
DWORD
Checksum(void)
const
{
return m_dwChecksum;
}
// --------------- Next ------------------
// Get next Entry. NULL if no more...
const CInfAddRegEntry *
Next(void)
const
{
// TODO: unimplemented
return NULL;
}
// --------------- GetRegRoot ------------------
// Get reg-root-string key (HKR, etc)
const CInfSymbol *
GetRegRoot (void)
const
{
return m_pSymRegRoot;
}
// --------------- GetSubKey ------------------
// Get sub key, NULL if none.
const CInfSymbol *
GetSubKey (void)
const
{
return m_pSymSubKey;
}
// --------------- GetValueName ------------------
// Get value-name, NULL if none.
const CInfSymbol *
GetValueName (void)
const
{
return m_pSymValueName;
}
// --------------- GetFlag ------------------
// Get flag-name, MAXDWORD if none.
DWORD
GetFlag (void)
const
{
return m_dwFlag;
}
// --------------- GetValue ------------------
// Get value-name, NULL if none.
// For binary data, this represents a normalized version of the
// string specified in the inf file: it has the format: "xxyxxyxx.."
// where xx is 2-digit hex representation of a byte and y is the space
// character (' '). For ASCII data, the value is the ascii string without
// the enclosing quotes. Extending '\' characters are processed.
const CInfSymbol *
GetValue (void)
const
{
return m_pSymValue;
}
#if (TODO)
... more stuff
#endif
private:
void mfn_Cleanup(void);
const CInfSymbol * m_pSymRegRoot;
const CInfSymbol * m_pSymSubKey;
const CInfSymbol * m_pSymValueName;
const CInfSymbol * m_pSymValue;
DWORD m_dwFlag;
DWORD m_dwChecksum;
};
///////////////////////////////////////////////////////////////////////////
// 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
// Note: each CInfCopyFilesEntry object keeps a pointer to its destination
// directory (all the entries for a particular section will have the same
// destination dir, because in the inf, a destination directory is associated
// with an entire section.
class CInfCopyFilesSection
{
public:
// --------------- Dump ------------------
// Dump state
void Dump(void) const;
// --------------- GetFirstCopyFilesEntry ----------
// Get first copyfiles entry
const CInfCopyFilesEntry * GetFirstCopyFilesEntry (void) const;
#if (TODO)
// Following reflect the Copyfiles.NT* extensions. We need to keep
// this information along with the section.
enum {PROC_X86, PROC_MIPS, PROC_ALPHA, PROC_PPC} eProcessorType;
enum {PLAT_NT, , PLAT_WIN9X} ePlatformType;
#endif // (TODO)
// TODO: remove following friend declaration once
// CInfInstallSection::GetCopyFilesList
// is properly implemented (it currently needs to access this
// class's constructor.
// Also, move ~CInfCopyFIlesEntry to protected when done.
friend class CInfInstallSection;
~CInfCopyFilesSection() {/*TODO*/}
protected:
CInfCopyFilesSection(void) {/*TODO*/}
private:
void mfn_Cleanup(void);
};
///////////////////////////////////////////////////////////////////////////
// CLASS CInfCopyFilesEntry
///////////////////////////////////////////////////////////////////////////
// Sample CopyFiles entry:
// fte.dll
// Note: each CInfCopyFilesEntry object keeps a pointer to its destination
// directory.
// TODO: keep information about platform & processor as well (see TODO
// notes under CInfCopyFilesSection).
class CInfCopyFilesEntry
{
public:
// --------------- Dump ------------------
// Dump state
void Dump(void) const
{
// TODO: unimplemented
printf(" fte.dll ; goes to 11\n");
}
// --------------- Checksum ------------------
// Compute and return checksum of contents
// Compute and return checksum of contents
DWORD
Checksum(void)
const
{
return m_dwChecksum;
}
// --------------- GetNext ------------------
// Get next Entry. NULL if no more...
const CInfCopyFilesEntry * Next(void) const
{
// TODO: unimplemented
return NULL;
}
// --------------- GetFileName ------------------
// Get file name to be copied.
const CInfSymbol * GetFileName (void) const;
// --------------- GetDestDir ------------------
// Get file name to be copied.
const CInfSymbol * GetDestDir (void) const;
// TODO: remove following friend declaration once
// CInfCopyFilesSection::GetFirstCopyFilesEntry
// is properly implemented (it currently needs to access this
// class's constructor.
// Also, move ~CInfCopyFIlesEntry to protected when done.
friend class CInfCopyFilesSection;
~CInfCopyFilesEntry() {/*TODO*/}
protected:
CInfCopyFilesEntry(void)
{
// TODO -- faked out
m_dwChecksum = 1001;
}
private:
void mfn_Cleanup(void);
DWORD m_dwChecksum;
};
#if 0
pInf->Load("mdmgen.inf");
pManuf = pInf->GetFirstManufacturerEntry();
for(;pManuf; pManuf = pManuf->Next())
{
pNewDevice = new ModemDevice(pDevice);
pDevice->Load(pInf, pManuf);
pDevice->Dump();
pDevice = pNewDevice;
}
pInf->Unload("
NewSession()
FreeSession()
#endif