|
|
/////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 1996-1998 Microsoft Corporation
//
// Module Name:
// AnswerFile.cpp
//
// Abstract:
// This is the implementation file for the CAnswerFileSection class and
// its' contained classes.
//
// Author:
// C. Brent Thomas a-brentt
//
// Revision History:
//
// 24-Sep-1998 original
//
// Notes:
//
// The classes implemented in this file include:
//
// CAnswerFileSection
// CAnswerFileEntry
// CParameterListEntry
//
// I consciously chose not to use MFC because I expect cluster setup to
// move away from MFC (probably to ATL) when it gets rewritten.
//
/////////////////////////////////////////////////////////////////////////////
#include <windows.h>
#include <setupapi.h>
#include <tchar.h>
#include "AnswerFile.h"
// The following set of functions implements the CParameterList class.
/////////////////////////////////////////////////////////////////////////////
//++
//
// CParameterListEntry
//
// Routine Description:
// This is the constructor for the CParameterListEntry class.
//
// Arguments:
// None
//
// Return Value:
// None
//
//--
/////////////////////////////////////////////////////////////////////////////
CParameterListEntry::CParameterListEntry(){ // Initialize the pointer to the next CParameterListEntry object to NULL.
m_pNextParameter = NULL; // The CParameterList object that this data
// member points to will be allocated with the
// new operator.
// Initialize the pointer to the parameter string to NULL.
m_ptszParameter = NULL; // The string that this data member points to
// will be allocated with the new operator.
}
/////////////////////////////////////////////////////////////////////////////
//++
//
// ~CParameterListEntry
//
// Routine Description:
// This is the destructor for the CParameterListEntry class.
//
// Arguments:
// None
//
// Return Value:
// None
//
//--
/////////////////////////////////////////////////////////////////////////////
CParameterListEntry::~CParameterListEntry(){ // Delete the parameter string.
if ( m_ptszParameter != NULL ) { delete [] m_ptszParameter; }
// Delete any other CParameterListEntry objects that may be in this list.
if ( m_pNextParameter != NULL ) { delete m_pNextParameter; }}
/////////////////////////////////////////////////////////////////////////////
//++
//
// SetParameterString
//
// Routine Description:
// This function allocates memory for a parameter string, initializes the
// string, ans sets the m_ptszParameter data member of a CParameterListEntry
// object.
//
// Arguments:
// ptszParameter - the input string
//
// Return Value:
// TRUE - indicates success
// FALSE - indicates and error occured
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CParameterListEntry::SetParameterString( LPTSTR ptszParameter ){ BOOL fReturnValue;
// Has the parameter string already been set?
if ( m_ptszParameter != NULL ) { // Free the existing parameter string. It will be replaced below.
delete m_ptszParameter; }
// Is the parameter meaningfull?
if ( (ptszParameter != NULL) && (*ptszParameter != TEXT( '\0' )) ) { // Allocate memory for the parameter string ans save its' address.
m_ptszParameter = new TCHAR[_tcslen( ptszParameter ) + 1];
_tcscpy( m_ptszParameter, ptszParameter ); } else { m_ptszParameter = NULL; }
fReturnValue = TRUE;
return ( fReturnValue );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// GetparameterStringPointer
//
// Routine Description:
// This function returns the contents of the m_ptszParameter member of
// a CParameterListEntry object.
//
// Arguments:
// None
//
// Return Value:
// A pointer to a parameter string.
//
//--
/////////////////////////////////////////////////////////////////////////////
LPTSTR CParameterListEntry::GetParameterStringPointer( void ){ return ( m_ptszParameter );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// SetNextParameterPointer
//
// Routine Description:
// This function sets the m_pNextParameter data member of a CParameterListEntry object.
//
// Arguments:
// pParameterListPointer - Points to a CParameterListEntry object.
//
// Return Value:
// TRUE - indicates success
// FALSE - indicates error
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CParameterListEntry::SetNextParameterPointer( CParameterListEntry * pParameterListPointer ){ BOOL fReturnValue;
// If the parameter list pointer has already been set, free it. It will get replaced below.
if ( m_pNextParameter != NULL ) { delete m_pNextParameter; }
// Set the parameter list pointer member.
m_pNextParameter = pParameterListPointer;
fReturnValue = TRUE;
return ( fReturnValue );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// GetParameterListPointer
//
// Routine Description:
// This function returns the m_pNextParameter data member of a CParameterListEntry object.
//
// Arguments:
// None
//
// Return Value:
// The value of the m_pNextParameter data member of a CParameterListEntry object.
//
//--
/////////////////////////////////////////////////////////////////////////////
CParameterListEntry * CParameterListEntry::GetParameterListPointer( void ){ return ( m_pNextParameter );}
// The following set of functions implements the CAnswerFileEntry class.
/////////////////////////////////////////////////////////////////////////////
//++
//
// CAnswerFileEntry
//
// Routine Description:
// This is the constructor for the CAnswerFileEntry class.
//
// Arguments:
// None
//
// Return Value:
// None
//
//--
/////////////////////////////////////////////////////////////////////////////
CAnswerFileEntry::CAnswerFileEntry(){ // Initialize the pointer to the next CAnswerFileEntry object to NULL.
m_pNextEntry = NULL; // The CAnswerFileEntry object that this
// data member points to will be allocated
// with the new operator.
// Initialize the pointer to the key string to NULL.
m_ptszKey = NULL; // The string that this data member points to
// will be allocated with the new operator.
// Initialize the pointer to the list of parameters to NULL;
m_pParameterList = NULL; // The CParameterList object that this data
// member points to will be allocated with the
// new operator.
// Initialize the number of parameters to zero;
m_xParameterCount = 0;}
/////////////////////////////////////////////////////////////////////////////
//++
//
// ~CAnswerFileEntry
//
// Routine Description:
// This is the destructor for the CAnswerFileEntry class.
//
// Arguments:
// None
//
// Return Value:
// None
//
//--
/////////////////////////////////////////////////////////////////////////////
CAnswerFileEntry::~CAnswerFileEntry(){ // Delete the key string.
if ( m_ptszKey != NULL ) { delete [] m_ptszKey; }
// Delete the parameter list.
if ( m_pParameterList != NULL ) { delete m_pParameterList; }
// Delete any other CAnswerFileEntry objects that may be in this list.
if ( m_pNextEntry != NULL ) { delete m_pNextEntry; }}
/////////////////////////////////////////////////////////////////////////////
//++
//
// SetKey
//
// Routine Description:
// This function sets the m_ptszKey data member of a CAnswerFileEntry object.
// It allocates memory for the string, initializes the string, and sets the
// m_ptszKey member to point to the string.
//
// Arguments:
// ptszKey - the string to which the m_ptszKey member should be set.
//
// Return Value:
// TRUE - indicates success
// FALSE - indicates that an error occured
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CAnswerFileEntry::SetKey( LPTSTR ptszKey ){ BOOL fReturnValue;
// If the key string has previously been set delete it.
if ( m_ptszKey != NULL ) { delete m_ptszKey; }
// Set the key string.
// Is the parameter meaningfull?
if ( (ptszKey != NULL) && (*ptszKey != TEXT( '\0' )) ) { // Allocate memory for the string and save its' address.
m_ptszKey = new TCHAR[_tcslen(ptszKey) + 1];
// Store the key string.
_tcscpy( m_ptszKey, ptszKey ); } else { m_ptszKey = NULL; }
fReturnValue = TRUE;
return ( fReturnValue );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// GetKeyPointer
//
// Routine Description:
// This function returns the contents of the m_ptszKey member of a
// CAnswerFileEntry object.
//
// Arguments:
// None
//
// Return Value:
// A pointer to the key for a CAnswerFileEntry object.
//
//--
/////////////////////////////////////////////////////////////////////////////
LPTSTR CAnswerFileEntry::GetKeyPointer( void ){ return ( m_ptszKey );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// SetParameterCount
//
// Routine Description:
// This function sets the m_xParameterCount member of a CAnswerFileEntry object.
//
// Arguments:
// xParameterCount - the number of parameters in the answer file entry
//
// Return Value:
// TRUE - indicates success
// FALSE - indicates an error occured
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CAnswerFileEntry::SetParameterCount( int xParameterCount ){ BOOL fReturnValue;
m_xParameterCount = xParameterCount;
fReturnValue = TRUE;
return ( fReturnValue );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// GetParameterCount
//
// Routine Description:
// This function returns the m_xParameterCount member of a CAnswerFileEntry object.
//
// Arguments:
// None
//
// Return Value:
// the number of parameters read from the answer file for this entry
//
//--
/////////////////////////////////////////////////////////////////////////////
int CAnswerFileEntry::GetParameterCount( void ){ return ( m_xParameterCount );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// SetNextEntryPointer
//
// Routine Description:
// This function sets the m_pNextEntry member of a CAnswerFileEntry object.
//
// Arguments:
// pAnswerFileEntry - points to a CAnswerFileEntry object.
//
// Return Value:
// TRUE - indicates success
// FALSE - indicates that an error occured
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CAnswerFileEntry::SetNextEntryPointer( CAnswerFileEntry * pEntry ){ BOOL fReturnValue;
// If the next entry pointer has already been set free it. It will be set below.
if ( m_pNextEntry != NULL ) { delete m_pNextEntry; }
// Set the next entry pointer.
m_pNextEntry = pEntry;
fReturnValue = TRUE;
return ( fReturnValue );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// GetNextEntryPointer
//
// Routine Description:
// This function returns the m_pNextEntry member of a CAnswerFileEntry object.
//
// Arguments:
// None
//
// Return Value:
// The m_pNextEntry member of a CAnswerFileEntry object.
//
//--
/////////////////////////////////////////////////////////////////////////////
CAnswerFileEntry * CAnswerFileEntry::GetNextEntryPointer( void ){ return ( m_pNextEntry );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// ReadParameters
//
// Routine Description:
// This function reads the parameters for an entry in the answer file.
// It may create and initialize a CParameterListEntry object.
//
// Arguments:
// pAnswerFileEntry - points to the CAnswerFileEntry object
// pAnswerFileContext - points to the INFCONTEXT structure for the answer file
//
// Return Value:
// TRUE - indicates that the parameters were read successfully
// FALSE - indicates that an error occured
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CAnswerFileEntry::ReadParameters( PINFCONTEXT pAnswerFileContext ){ BOOL fReturnValue;
// Are the parameters meaningfull?
if ( pAnswerFileContext != NULL ) { DWORD dwFieldCount;
// How many fields are in the entry? There must be at least one to be meaningfull.
dwFieldCount = SetupGetFieldCount( pAnswerFileContext );
if ( dwFieldCount >= 1 ) { // Read the parameters. Apparently SetupGetStringField does not handle
// empty fields gracefully. So, any empty parameter shall be treated
// as an error. Parsing will terminate at that point.
TCHAR tszBuffer[MAX_INF_STRING_LENGTH]; // buffer to receive strings
// Attempt to read the first parameter.
fReturnValue = SetupGetStringField( pAnswerFileContext, 1, tszBuffer, MAX_INF_STRING_LENGTH, NULL );
// Was the first parameter read?
if ( fReturnValue == TRUE ) { // Is the parameter string non-empty?
if ( _tcslen( tszBuffer ) > 0 ) { // Create a CParameterListEntry object and save its' address.
CParameterListEntry * pParameterListEntry; // working pointer
pParameterListEntry = new CParameterListEntry; if ( pParameterListEntry != NULL ) { SetParameterListPointer( pParameterListEntry ); // Initialize the first parameter string.
pParameterListEntry->SetParameterString( tszBuffer ); int xParameterCount = 1; // one parameter has already been read.
// Are there additional parameters?
if ( dwFieldCount >= 2 ) { // Read the second and subsequent parameters.
int xIndex; // On entry to this loop pParameterListEntry points to the first
// CParameterListEntry object.
for ( xIndex = 2; xIndex <= (int) dwFieldCount; xIndex++ ) { // Attempt to read a parameter.
fReturnValue = SetupGetStringField( pAnswerFileContext, xIndex, tszBuffer, MAX_INF_STRING_LENGTH, NULL ); // Was a parameter read?
if ( fReturnValue == TRUE ) { // Is the parameter string non-empty?
if ( _tcslen( tszBuffer ) > 0 ) { // Create a CParameterListEntry object and save its' address.
pParameterListEntry->SetNextParameterPointer( new CParameterListEntry ); // Point to the newly created CParameterListEntry object.
pParameterListEntry = pParameterListEntry->GetParameterListPointer(); // Initialize the parameter string.
pParameterListEntry->SetParameterString( tszBuffer );
// Increment the count of parameters.
xParameterCount += 1; } // if - parameter non-empty?
else { // Since the parameter is an empty string, terminate
// the loop.
break; } // if - parameter non-empty?
} // if - SetupGetStringField succeeded?
else { // Since SetupGetStringField failed, terminate the loop.
// fReturnValue will indicate error.
break; } // if - SetupGetStringField succeeded?
} // for loop reading 2nd and subsequent parameters
} // Additional parameters?
else { fReturnValue = TRUE; } // Additional parameters?
// Set the parameter count.
SetParameterCount( xParameterCount ); } // if - memory allocation succeeded
else { fReturnValue = FALSE; } // else - memory allocation failed.
} // if - first parameter non-empty?
else { // There is no use attempting to read additional parameters.
SetParameterCount( 0 ); } // if - first parameter non-empty?
} // Was a parameter read?
else { // There is no use attempting to read additional parameters.
SetParameterCount( 0 ); } // Was a parameter read?
} // two or more fields?
else { // It is legal for an entry to have no parameters, but not useful.
SetParameterCount( 0 );
fReturnValue = TRUE; } // two or more fields?
} else { fReturnValue = FALSE; }
return ( fReturnValue );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// SetParameterListPointer
//
// Routine Description:
// This function sets the m_pParameterList member of a CAnswerFileEntry object.
//
// Arguments:
// pParameterList - points to a CParameterListEntry object.
//
// Return Value:
// TRUE - indicates success
// FALSE - indicates that an error occured.
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CAnswerFileEntry::SetParameterListPointer( CParameterListEntry * pParameterList ){ BOOL fReturnValue;
// If the parameter list pointer has already been set free it. It will be set below.
if ( m_pParameterList != NULL ) { delete m_pParameterList; }
// Set the next entry pointer.
m_pParameterList = pParameterList;
fReturnValue = TRUE;
return ( fReturnValue );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// GetParameterListPointer
//
// Routine Description:
// This function returns the m_pParameterList data member of a CAnswerFileEntry object.
//
// Arguments:
// None
//
// Return Value:
// The value of the m_pParameterList data member of a CAnswerFileEntry object.
//
//--
/////////////////////////////////////////////////////////////////////////////
CParameterListEntry * CAnswerFileEntry::GetParameterListPointer( void ){ return ( m_pParameterList );}
// The following set of functions implements the CAnswerFileSection class.
/////////////////////////////////////////////////////////////////////////////
//++
//
// CAnswerFileSection
//
// Routine Description:
// This is the constructor for the CAnswerFileSection class.
//
// Arguments:
// None
//
// Return Value:
// None
//
//--
/////////////////////////////////////////////////////////////////////////////
CAnswerFileSection::CAnswerFileSection(){ // Initialize the pointer to the CAnswerFileEntry objects to NULL.
m_pEntries = NULL; // The CAnswerFileEntry object that this data member
// points to will be allocated with the new operator.
}
/////////////////////////////////////////////////////////////////////////////
//++
//
// GetEntryPointer
//
// Routine Description:
// This function returns the contents of the m_pEntries member of a
// CAnswerFileSection object.
//
// Arguments:
// None
//
// Return Value:
// A pointer to a CAnswerFileEntry object.
//
//--
/////////////////////////////////////////////////////////////////////////////
CAnswerFileEntry * CAnswerFileSection::GetEntryPointer( void ){ return ( m_pEntries );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// ~CAnswerFileSection
//
// Routine Description:
// This is the destructor for the CAnswerFileSection class.
//
// Arguments:
// None
//
// Return Value:
// None
//
//--
/////////////////////////////////////////////////////////////////////////////
CAnswerFileSection::~CAnswerFileSection(){ // Delete the CAnswerFileEntry objects.
if ( m_pEntries != NULL ) { delete m_pEntries; }}
/////////////////////////////////////////////////////////////////////////////
//++
//
// ReadAnswerFileSection
//
// Routine Description:
// This function reads the entries in an answer file.
//
// Arguments:
// hAnswerFile - the handle to the answer file
// ptszSection - points to the answer file section name
//
//
// Return Value:
// TRUE - indicates that the section whose name is in ptszSection was read
// from the answer file whose handle is hAnswerFile successfully.
// FALSE - indicates that an error occured.
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CAnswerFileSection::ReadAnswerFileSection( HINF hAnswerFile, LPTSTR ptszSection ){ BOOL fReturnValue;
// Is the desired section present and non-empty in the answer file?
LONG lSectionLineCount;
lSectionLineCount = SetupGetLineCount( hAnswerFile, ptszSection );
if ( lSectionLineCount > 0L ) { // The section is present and non empty. Find the first entry.
INFCONTEXT AnswerFileContext;
fReturnValue = SetupFindFirstLine( hAnswerFile, ptszSection, NULL, // find first line of the section
&AnswerFileContext );
// Was the first entry found?
if ( fReturnValue == TRUE ) { // Get the key for the first entry.
TCHAR tszBuffer[MAX_INF_STRING_LENGTH]; // buffer to receive strings
fReturnValue = SetupGetStringField( &AnswerFileContext, 0, // get the key
tszBuffer, MAX_INF_STRING_LENGTH, NULL ); // Was the first key read?
if ( fReturnValue == TRUE ) { // The key for the first entry in the section was read.
// Create the first CAnswerFileEntry object and save its' address.
m_pEntries = new CAnswerFileEntry; // m_pEntries points to the head of
// the list of CAnswerFileEntry objects.
if ( m_pEntries == NULL ) { fReturnValue = FALSE; } else { // Set the key for the first CAnswerFileEntry object.
fReturnValue = m_pEntries->SetKey( tszBuffer ); }
// Was the key for the first entry set?
if ( fReturnValue == TRUE ) { // Read the parameters for the first entry.
fReturnValue = m_pEntries->ReadParameters( &AnswerFileContext );
// Were the parameters for the first entry read successfully?
if ( fReturnValue == TRUE ) { CAnswerFileEntry * pEntry; // working pointer to entries
// Initialize the working pointer to the head of the list.
pEntry = m_pEntries; // Read the rest of the entries/
while ( (SetupFindNextLine( &AnswerFileContext, &AnswerFileContext ) == TRUE) && (fReturnValue == TRUE) ) { // Create a CAnswerFileEntry object for the next entry.
pEntry->SetNextEntryPointer( new CAnswerFileEntry );
// Operate on the next entry object.
pEntry = pEntry->GetNextEntryPointer(); if ( pEntry == FALSE ) { fReturnValue = FALSE; break; }
// Read the key for this entry.
fReturnValue = SetupGetStringField( &AnswerFileContext, 0, // get the key
tszBuffer, MAX_INF_STRING_LENGTH, NULL ); // Was the key for this entry read?
if ( fReturnValue == TRUE ) { pEntry->SetKey( tszBuffer );
// Read the parameters for the next entry.
fReturnValue = pEntry->ReadParameters( &AnswerFileContext ); } } // while reading lines in the section
} // params for first entry read successfully?
} // Was the first key set?
} // Was the first key read?
} // Was the first entry found?
} else { // Either the section does not exist or it is empty.
fReturnValue = FALSE; } // Does a non-empty section exist?
return ( fReturnValue );}
|
