mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1879 lines
51 KiB
1879 lines
51 KiB
// infgen.cpp : Defines the initialization routines for the DLL.
|
|
//
|
|
|
|
#include <windows.h>
|
|
#include <stdio.h>
|
|
#include <mbctype.h>
|
|
#include <Shlwapi.h>
|
|
#include "infgen.h"
|
|
#include "message.h"
|
|
|
|
|
|
#define DELETE_EMPTY 1
|
|
|
|
#define MAX_LINE ( MAX_PATH * 2 )
|
|
|
|
struct _SectionEntry
|
|
{
|
|
|
|
TCHAR *szLine;
|
|
DWORD cRef;
|
|
|
|
};
|
|
|
|
// Track entries throughout the INF related to a section
|
|
typedef struct _AssociatedEntries
|
|
{
|
|
PSECTIONENTRY pse;
|
|
_AssociatedEntries *pNext;
|
|
} ASSOCIATEDENTRIES, *PASSOCIATEDENTRIES;
|
|
|
|
struct _SectionList
|
|
{
|
|
TCHAR szSectionName[ MAX_PATH ];
|
|
PSECTIONENTRY pseSectionEntries;
|
|
PASSOCIATEDENTRIES pAssociatedEntries;
|
|
DWORD dwSectionEntries;
|
|
DWORD cRef;
|
|
struct _SectionList *Next;
|
|
};
|
|
|
|
struct _SectionAssociationList
|
|
{
|
|
_SectionList *pSection;
|
|
_SectionAssociationList *pNext;
|
|
};
|
|
|
|
|
|
extern HINSTANCE g_hMyInstance;
|
|
|
|
CUpdateInf::CUpdateInf(
|
|
void
|
|
) : m_bGenInitCalled(FALSE), m_dwInfGenError(0),
|
|
m_sectionList(NULL), m_bActiveDB(FALSE), m_hInf(INVALID_HANDLE_VALUE),
|
|
m_pTypeInfo(NULL), m_cRef(1)
|
|
{
|
|
memset( m_rgNameHash, 0, sizeof( m_rgNameHash ) );
|
|
|
|
// Default DB connection
|
|
// WINSEQFE default DB with windows auth
|
|
_tcscpy( m_szDataServer, _T("WINSEQFE") );
|
|
m_szDatabase[0] = _T('\0');
|
|
m_szUserName[0] = _T('\0');
|
|
}
|
|
|
|
CUpdateInf::~CUpdateInf(
|
|
void
|
|
)
|
|
{
|
|
if ( m_pTypeInfo ) {
|
|
m_pTypeInfo->Release();
|
|
m_pTypeInfo = NULL;
|
|
}
|
|
Cleanup();
|
|
}
|
|
|
|
//
|
|
// IUnknown
|
|
//
|
|
ULONG
|
|
CUpdateInf::AddRef( void )
|
|
{
|
|
return ++m_cRef;
|
|
}
|
|
|
|
ULONG
|
|
CUpdateInf::Release( void )
|
|
{
|
|
if ( 0L == --m_cRef )
|
|
{
|
|
delete this;
|
|
return 0;
|
|
}
|
|
|
|
return m_cRef;
|
|
}
|
|
|
|
HRESULT
|
|
CUpdateInf::QueryInterface( REFIID riid, void **ppv )
|
|
{
|
|
if ( NULL == ppv )
|
|
return E_POINTER;
|
|
|
|
*ppv = NULL;
|
|
if ( IID_IUnknown == riid )
|
|
*ppv = (IUnknown *)this;
|
|
else if ( IID_IDispatch == riid )
|
|
*ppv = (IDispatch *)this;
|
|
else if ( IID_IUpdateInf == riid )
|
|
*ppv = (IUpdateInf *)this;
|
|
else
|
|
return E_NOINTERFACE;
|
|
|
|
AddRef();
|
|
return S_OK;
|
|
}
|
|
|
|
//
|
|
// IDispatch
|
|
//
|
|
HRESULT
|
|
CUpdateInf::GetTypeInfoCount( UINT *pCountTypeInfo )
|
|
{
|
|
*pCountTypeInfo = 1;
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT
|
|
CUpdateInf::GetTypeInfo( UINT iTypeInfo,
|
|
LCID lcid,
|
|
ITypeInfo **ppTypeInfo )
|
|
{
|
|
*ppTypeInfo = NULL;
|
|
|
|
if ( 0 != iTypeInfo )
|
|
return DISP_E_BADINDEX;
|
|
|
|
m_pTypeInfo->AddRef();
|
|
*ppTypeInfo = m_pTypeInfo;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT
|
|
CUpdateInf::GetIDsOfNames( REFIID riid,
|
|
LPOLESTR *aszNames,
|
|
UINT cNames,
|
|
LCID lcid,
|
|
DISPID *aDispIDs )
|
|
{
|
|
if ( IID_NULL != riid )
|
|
return DISP_E_UNKNOWNINTERFACE;
|
|
|
|
return DispGetIDsOfNames( m_pTypeInfo,
|
|
aszNames,
|
|
cNames,
|
|
aDispIDs );
|
|
}
|
|
|
|
HRESULT
|
|
CUpdateInf::Invoke( DISPID dispIdMember,
|
|
REFIID riid,
|
|
LCID lcid,
|
|
WORD wFlags,
|
|
DISPPARAMS *pDispParams,
|
|
VARIANT *pVarResult,
|
|
EXCEPINFO *pExcepInfo,
|
|
UINT *puArgErr )
|
|
{
|
|
if ( IID_NULL != riid )
|
|
return DISP_E_UNKNOWNINTERFACE;
|
|
|
|
return DispInvoke( this,
|
|
m_pTypeInfo,
|
|
dispIdMember,
|
|
wFlags,
|
|
pDispParams,
|
|
pVarResult,
|
|
pExcepInfo,
|
|
puArgErr );
|
|
}
|
|
|
|
//
|
|
// Initialization function so we can use type-library based
|
|
// functions to handle the IDispatch calls
|
|
//
|
|
BOOL
|
|
CUpdateInf::Init(
|
|
void
|
|
)
|
|
{
|
|
HRESULT hr;
|
|
ITypeLib *pTypeLib = NULL;
|
|
|
|
hr = LoadRegTypeLib( LIBID_InfGeneratorLib, (1), (0), LANG_NEUTRAL, &pTypeLib );
|
|
if ( FAILED(hr) )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
hr = pTypeLib->GetTypeInfoOfGuid( IID_IUpdateInf, &m_pTypeInfo );
|
|
if ( FAILED(hr) )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
// Cleanup
|
|
pTypeLib->Release();
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// IUpdateInf
|
|
//
|
|
HRESULT
|
|
CUpdateInf::InsertFile(
|
|
BSTR bstrFileName
|
|
)
|
|
{
|
|
HRESULT hr;
|
|
BOOL bRet = FALSE;
|
|
DWORD dwRecordCount;
|
|
LPTSTR lpszSQL;
|
|
CSimpleDBResults *prs;
|
|
|
|
if ( !m_bActiveDB )
|
|
{
|
|
m_dwInfGenError = FAIL_NO_DATABASE;
|
|
return E_FAIL;
|
|
}
|
|
|
|
if( NULL == bstrFileName ) {
|
|
m_dwInfGenError = FAIL_INVALIDPARAM;
|
|
return E_FAIL;
|
|
}
|
|
if( m_bGenInitCalled == FALSE ) {
|
|
m_dwInfGenError = FAIL_NOINITGENCALL;
|
|
return E_FAIL;
|
|
}
|
|
|
|
lpszSQL = new TCHAR [1000];
|
|
if( NULL == lpszSQL ) {
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
#ifndef UNICODE
|
|
char *szFileName;
|
|
size_t lenFileName = SysStringLen(bstrFileName) + 1;
|
|
szFileName = new char[lenFileName];
|
|
if ( NULL == szFileName )
|
|
{
|
|
m_dwInfGenError = ERROR_NOT_ENOUGH_MEMORY;
|
|
return E_FAIL;
|
|
}
|
|
|
|
if ( 0 == WideCharToMultiByte( CP_ACP,
|
|
0L,
|
|
bstrFileName,
|
|
lenFileName,
|
|
szFileName,
|
|
lenFileName,
|
|
NULL,
|
|
NULL ) ) {
|
|
m_dwInfGenError = GetLastError();
|
|
return E_FAIL;
|
|
}
|
|
#else
|
|
wchar_t *szFileName = bstrFileName;
|
|
#endif
|
|
_stprintf( lpszSQL,
|
|
_T("Select DISTINCT Section,Entry from Ref_SrcFileLocations,Ref_DefaultInstallerInf where Ref_SrcFileLocations.FileName = '%s' AND Ref_SrcFileLocations.FileID = Ref_DefaultInstallerInf.FileID"), szFileName );
|
|
|
|
//sprintf( lpszSQL,
|
|
// "Select * from Ref_SrcFileLocations" );
|
|
|
|
|
|
if( SUCCEEDED(m_pdb->Execute( lpszSQL, &prs )) ) {
|
|
|
|
|
|
if ( S_OK == (hr = prs->NextRow()) )
|
|
{
|
|
bRet = TRUE;
|
|
do {
|
|
// an entry can consist of one or more null-terminated
|
|
// strings, so we clear the entry buffer here
|
|
memset( m_textBuffer2, 0, sizeof(m_textBuffer2) );
|
|
|
|
if ( FAILED(prs->GetFieldValue( _T("Section"), m_textBuffer, BUFFER_SIZE )) ||
|
|
FAILED(prs->GetFieldValue( _T("Entry"), m_textBuffer2, BUFFER_SIZE )) ) {
|
|
m_dwInfGenError = FAIL_RECORDSET;
|
|
bRet = FALSE;
|
|
break;
|
|
}
|
|
if ( !WritePrivateProfileSection( m_textBuffer, m_textBuffer2, m_szFilledInxFile ) ) {
|
|
m_dwInfGenError = GetLastError();
|
|
bRet = FALSE;
|
|
break;
|
|
}
|
|
|
|
} while( S_OK == (hr = prs->NextRow()) );
|
|
|
|
if ( FAILED(hr) )
|
|
{
|
|
m_dwInfGenError = hr;
|
|
bRet = FALSE;
|
|
}
|
|
|
|
if ( bRet ) {
|
|
// Write an entry in the [SourceDiskFiles] section for this file
|
|
if ( !WritePrivateProfileString( _T("SourceDisksFiles"), szFileName, _T("1"), m_szFilledInxFile ) ) {
|
|
m_dwInfGenError = GetLastError();
|
|
bRet = FALSE;
|
|
}
|
|
}
|
|
} else if ( SUCCEEDED(hr) ) {
|
|
m_dwInfGenError = FAIL_NOSECTION;
|
|
}
|
|
else
|
|
{
|
|
m_dwInfGenError = hr;
|
|
}
|
|
|
|
delete prs;
|
|
} else {
|
|
m_dwInfGenError = FAIL_RECORDSET;
|
|
}
|
|
|
|
#ifndef UNICODE
|
|
delete [] szFileName;
|
|
#endif
|
|
delete [] lpszSQL;
|
|
|
|
if ( bRet ) {
|
|
return S_OK;
|
|
}
|
|
else {
|
|
return E_FAIL;
|
|
}
|
|
|
|
}
|
|
|
|
HRESULT
|
|
CUpdateInf::WriteSectionData(
|
|
BSTR bstrSection,
|
|
BSTR bstrValue
|
|
)
|
|
{
|
|
BOOL bRet = TRUE;
|
|
size_t lenSection = SysStringLen(bstrSection) + 1,
|
|
lenValue = SysStringLen(bstrValue) + 1;
|
|
|
|
if( m_bGenInitCalled == FALSE ) {
|
|
m_dwInfGenError = FAIL_NOINITGENCALL;
|
|
return E_FAIL;
|
|
}
|
|
|
|
if ( lenSection >= BUFFER_SIZE ||
|
|
lenValue + 1 >= BUFFER_SIZE )
|
|
{
|
|
m_dwInfGenError = FAIL_MAX_BUFFER;
|
|
return E_FAIL;
|
|
}
|
|
|
|
#ifndef UNICODE
|
|
if ( 0 == WideCharToMultiByte( CP_ACP,
|
|
0L,
|
|
bstrSection,
|
|
lenSection,
|
|
m_textBuffer,
|
|
BUFFER_SIZE,
|
|
NULL,
|
|
NULL ) ) {
|
|
m_dwInfGenError = GetLastError();
|
|
return E_FAIL;
|
|
}
|
|
if ( 0 == WideCharToMultiByte( CP_ACP,
|
|
0L,
|
|
bstrValue,
|
|
lenValue,
|
|
m_textBuffer2,
|
|
BUFFER_SIZE,
|
|
NULL,
|
|
NULL ) ) {
|
|
m_dwInfGenError = GetLastError();
|
|
return E_FAIL;
|
|
}
|
|
#else
|
|
memcpy( m_textBuffer, bstrSection, sizeof(wchar_t) * lenSection );
|
|
memcpy( m_textBuffer2, bstrValue, sizeof(wchar_t) * lenValue );
|
|
#endif
|
|
m_textBuffer2[lenValue] = '\0'; // end with a double NULL
|
|
|
|
if ( !WritePrivateProfileSection( m_textBuffer, m_textBuffer2, m_szFilledInxFile ) ) {
|
|
m_dwInfGenError = GetLastError();
|
|
bRet = FALSE;
|
|
}
|
|
|
|
if (bRet) {
|
|
return S_OK;
|
|
}
|
|
else {
|
|
return E_FAIL;
|
|
}
|
|
}
|
|
|
|
HRESULT
|
|
CUpdateInf::SetConfigurationField(
|
|
BSTR bstrFieldName,
|
|
BSTR bstrValue
|
|
)
|
|
{
|
|
BOOL bRet = TRUE;
|
|
size_t lenFieldName = SysStringLen(bstrFieldName) + 1,
|
|
lenValue = SysStringLen(bstrValue) + 1;
|
|
|
|
if( m_bGenInitCalled == FALSE ) {
|
|
m_dwInfGenError = FAIL_NOINITGENCALL;
|
|
return E_FAIL;
|
|
}
|
|
|
|
if ( lenFieldName >= BUFFER_SIZE ||
|
|
lenValue >= BUFFER_SIZE )
|
|
{
|
|
m_dwInfGenError = FAIL_MAX_BUFFER;
|
|
return E_FAIL;
|
|
}
|
|
|
|
|
|
#ifndef UNICODE
|
|
if ( 0 == WideCharToMultiByte( CP_ACP,
|
|
0L,
|
|
bstrFieldName,
|
|
lenFieldName,
|
|
m_textBuffer,
|
|
BUFFER_SIZE,
|
|
NULL,
|
|
NULL ) ) {
|
|
m_dwInfGenError = GetLastError();
|
|
return E_FAIL;
|
|
}
|
|
if ( 0 == WideCharToMultiByte( CP_ACP,
|
|
0L,
|
|
bstrValue,
|
|
lenValue,
|
|
m_textBuffer2,
|
|
BUFFER_SIZE,
|
|
NULL,
|
|
NULL ) ) {
|
|
m_dwInfGenError = GetLastError();
|
|
return E_FAIL;
|
|
}
|
|
#else
|
|
memcpy( m_textBuffer, bstrFieldName, sizeof(wchar_t) * lenFieldName );
|
|
memcpy( m_textBuffer2, bstrValue, sizeof(wchar_t) * lenValue );
|
|
#endif
|
|
|
|
if ( !WritePrivateProfileString( _T("Configuration"), m_textBuffer, m_textBuffer2, m_szFilledInxFile ) ) {
|
|
m_dwInfGenError = GetLastError();
|
|
bRet = FALSE;
|
|
}
|
|
|
|
if (bRet) {
|
|
return S_OK;
|
|
}
|
|
else {
|
|
return E_FAIL;
|
|
}
|
|
}
|
|
|
|
HRESULT
|
|
CUpdateInf::SetVersionField(
|
|
BSTR bstrFieldName,
|
|
BSTR bstrValue
|
|
)
|
|
{
|
|
BOOL bRet = TRUE;
|
|
size_t lenFieldName = SysStringLen(bstrFieldName) + 1,
|
|
lenValue = SysStringLen(bstrValue) + 1;
|
|
|
|
if( m_bGenInitCalled == FALSE ) {
|
|
m_dwInfGenError = FAIL_NOINITGENCALL;
|
|
return E_FAIL;
|
|
}
|
|
|
|
if ( lenFieldName >= BUFFER_SIZE ||
|
|
lenValue >= BUFFER_SIZE )
|
|
{
|
|
m_dwInfGenError = FAIL_MAX_BUFFER;
|
|
return E_FAIL;
|
|
}
|
|
|
|
#ifndef UNICODE
|
|
if ( 0 == WideCharToMultiByte( CP_ACP,
|
|
0L,
|
|
bstrFieldName,
|
|
lenFieldName,
|
|
m_textBuffer,
|
|
BUFFER_SIZE,
|
|
NULL,
|
|
NULL ) ) {
|
|
m_dwInfGenError = GetLastError();
|
|
return E_FAIL;
|
|
}
|
|
if ( 0 == WideCharToMultiByte( CP_ACP,
|
|
0L,
|
|
bstrValue,
|
|
lenValue,
|
|
m_textBuffer2,
|
|
BUFFER_SIZE,
|
|
NULL,
|
|
NULL ) ) {
|
|
m_dwInfGenError = GetLastError();
|
|
return E_FAIL;
|
|
}
|
|
#else
|
|
memcpy( m_textBuffer, bstrFieldName, sizeof(wchar_t) * lenFieldName );
|
|
memcpy( m_textBuffer2, bstrValue, sizeof(wchar_t) * lenValue );
|
|
#endif
|
|
|
|
if ( !WritePrivateProfileString( _T("Version"), m_textBuffer, m_textBuffer2, m_szFilledInxFile ) ) {
|
|
m_dwInfGenError = GetLastError();
|
|
bRet = FALSE;
|
|
}
|
|
|
|
if (bRet) {
|
|
return S_OK;
|
|
}
|
|
else {
|
|
return E_FAIL;
|
|
}
|
|
}
|
|
|
|
HRESULT
|
|
CUpdateInf::AddSourceDisksFilesEntry(
|
|
BSTR bstrFile,
|
|
BSTR bstrTag
|
|
)
|
|
{
|
|
BOOL bRet = TRUE;
|
|
size_t lenFile = SysStringLen(bstrFile) + 1,
|
|
lenTag = SysStringLen(bstrTag) + 1;
|
|
|
|
if( m_bGenInitCalled == FALSE ) {
|
|
m_dwInfGenError = FAIL_NOINITGENCALL;
|
|
return E_FAIL;
|
|
}
|
|
|
|
if ( lenFile >= BUFFER_SIZE ||
|
|
lenTag >= BUFFER_SIZE )
|
|
{
|
|
m_dwInfGenError = FAIL_MAX_BUFFER;
|
|
return E_FAIL;
|
|
}
|
|
|
|
#ifndef UNICODE
|
|
if ( 0 == WideCharToMultiByte( CP_ACP,
|
|
0L,
|
|
bstrFile,
|
|
lenFile,
|
|
m_textBuffer,
|
|
BUFFER_SIZE,
|
|
NULL,
|
|
NULL ) ) {
|
|
m_dwInfGenError = GetLastError();
|
|
return E_FAIL;
|
|
}
|
|
if ( 0 == WideCharToMultiByte( CP_ACP,
|
|
0L,
|
|
bstrTag,
|
|
lenTag,
|
|
m_textBuffer2,
|
|
BUFFER_SIZE,
|
|
NULL,
|
|
NULL ) ) {
|
|
m_dwInfGenError = GetLastError();
|
|
return E_FAIL;
|
|
}
|
|
#else
|
|
memcpy( m_textBuffer, bstrFile, sizeof(wchar_t) * lenFile );
|
|
memcpy( m_textBuffer2, bstrTag, sizeof(wchar_t) * lenTag );
|
|
#endif
|
|
|
|
if ( !WritePrivateProfileString( _T("SourceDisksFiles"), m_textBuffer, m_textBuffer2, m_szFilledInxFile ) ) {
|
|
m_dwInfGenError = GetLastError();
|
|
bRet = FALSE;
|
|
}
|
|
|
|
if (bRet) {
|
|
return S_OK;
|
|
}
|
|
else {
|
|
return E_FAIL;
|
|
}
|
|
}
|
|
|
|
HRESULT
|
|
CUpdateInf::AddEquality(
|
|
BSTR bstrSect,
|
|
BSTR bstrLVal,
|
|
BSTR bstrRVal
|
|
)
|
|
{
|
|
BOOL bRet = TRUE;
|
|
size_t lenSect = SysStringLen(bstrSect) + 1,
|
|
lenLVal = SysStringLen(bstrLVal) + 1,
|
|
lenRVal = SysStringLen(bstrRVal) + 1;
|
|
|
|
if( m_bGenInitCalled == FALSE ) {
|
|
m_dwInfGenError = FAIL_NOINITGENCALL;
|
|
return E_FAIL;
|
|
}
|
|
|
|
if ( lenLVal >= BUFFER_SIZE ||
|
|
lenRVal >= BUFFER_SIZE ||
|
|
lenSect >= BUFFER_SIZE )
|
|
{
|
|
m_dwInfGenError = FAIL_MAX_BUFFER;
|
|
return E_FAIL;
|
|
}
|
|
|
|
#ifndef UNICODE
|
|
if ( 0 == WideCharToMultiByte( CP_ACP,
|
|
0L,
|
|
bstrLVal,
|
|
lenLVal,
|
|
m_textBuffer,
|
|
BUFFER_SIZE,
|
|
NULL,
|
|
NULL ) ) {
|
|
m_dwInfGenError = GetLastError();
|
|
return E_FAIL;
|
|
}
|
|
if ( 0 == WideCharToMultiByte( CP_ACP,
|
|
0L,
|
|
bstrRVal,
|
|
lenRVal,
|
|
m_textBuffer2,
|
|
BUFFER_SIZE,
|
|
NULL,
|
|
NULL ) ) {
|
|
m_dwInfGenError = GetLastError();
|
|
return E_FAIL;
|
|
}
|
|
if ( 0 == WideCharToMultiByte( CP_ACP,
|
|
0L,
|
|
bstrSect,
|
|
lenSect,
|
|
m_textBuffer3,
|
|
BUFFER_SIZE,
|
|
NULL,
|
|
NULL ) ) {
|
|
m_dwInfGenError = GetLastError();
|
|
return E_FAIL;
|
|
}
|
|
#else
|
|
memcpy( m_textBuffer, bstrLVal, sizeof(wchar_t) * lenLVal );
|
|
memcpy( m_textBuffer2, bstrRVal, sizeof(wchar_t) * lenRVal );
|
|
memcpy( m_textBuffer3, bstrSect, sizeof(wchar_t) * lenSect );
|
|
#endif
|
|
|
|
if ( !WritePrivateProfileString( m_textBuffer3, m_textBuffer, m_textBuffer2, m_szFilledInxFile ) ) {
|
|
m_dwInfGenError = GetLastError();
|
|
bRet = FALSE;
|
|
}
|
|
|
|
if (bRet) {
|
|
return S_OK;
|
|
}
|
|
else {
|
|
return E_FAIL;
|
|
}
|
|
}
|
|
|
|
void
|
|
CUpdateInf::Cleanup(
|
|
void
|
|
)
|
|
{
|
|
PSECTION psRef = m_sectionList;
|
|
OutputDebugString( _T("Freeing m_sectionList ...\n") );
|
|
while( psRef ) {
|
|
|
|
PSECTION psRef1 = psRef;
|
|
PSECTIONENTRY pse = psRef1->pseSectionEntries;
|
|
PASSOCIATEDENTRIES pAssoc = psRef1->pAssociatedEntries;
|
|
psRef = psRef->Next;
|
|
if ( NULL != pse ) {
|
|
for ( DWORD i = 0; i < psRef1->dwSectionEntries; i++ ) {
|
|
if ( pse[i].szLine ) delete [] pse[i].szLine;
|
|
}
|
|
delete [] pse;
|
|
}
|
|
while ( pAssoc ) {
|
|
PASSOCIATEDENTRIES pDel = pAssoc;
|
|
pAssoc = pAssoc->pNext;
|
|
delete pDel;
|
|
}
|
|
delete psRef1;
|
|
}
|
|
m_sectionList = NULL;
|
|
|
|
OutputDebugString( _T("Freeing m_rgNameHash ...\n") );
|
|
for ( short i = 0; i < HASH_BUCKETS; i++ ) {
|
|
if ( m_rgNameHash[i] ) {
|
|
PSECTIONASSOCIATIONLIST pAssocList = m_rgNameHash[i];
|
|
while ( pAssocList ) {
|
|
PSECTIONASSOCIATIONLIST pDel = pAssocList;
|
|
pAssocList = pAssocList->pNext;
|
|
delete pDel;
|
|
}
|
|
|
|
m_rgNameHash[i] = NULL;
|
|
}
|
|
}
|
|
|
|
OutputDebugString( _T("Cleanup finished\n") );
|
|
}
|
|
|
|
HRESULT
|
|
CUpdateInf::CloseGen(
|
|
BOOL bTrimInf
|
|
)
|
|
{
|
|
BOOL bRet = TRUE;
|
|
|
|
if( m_bGenInitCalled == FALSE ) {
|
|
m_dwInfGenError = FAIL_NOINITGENCALL;
|
|
return E_FAIL;
|
|
}
|
|
|
|
if ( bTrimInf ) {
|
|
if ( !TrimInf( m_szFilledInxFile, m_szOutFile ) ) {
|
|
bRet = FALSE;
|
|
}
|
|
}
|
|
else {
|
|
if ( !CopyFile( m_szFilledInxFile, m_szOutFile, FALSE ) ) {
|
|
m_dwInfGenError = GetLastError();
|
|
bRet = FALSE;
|
|
}
|
|
}
|
|
|
|
if ( !DeleteFile( m_szFilledInxFile ) ) {
|
|
m_dwInfGenError = GetLastError();
|
|
return S_FALSE;
|
|
}
|
|
|
|
Cleanup();
|
|
|
|
m_bGenInitCalled = FALSE;
|
|
|
|
if ( bRet ) return S_OK;
|
|
else return E_FAIL;
|
|
}
|
|
|
|
HRESULT
|
|
CUpdateInf::SetDB(
|
|
BSTR bstrServer,
|
|
BSTR bstrDB,
|
|
BSTR bstrUser,
|
|
BSTR bstrPassword
|
|
)
|
|
{
|
|
size_t lenServer = SysStringLen(bstrServer) + 1,
|
|
lenDB = SysStringLen(bstrDB) + 1,
|
|
lenUser = SysStringLen(bstrUser) + 1,
|
|
lenPassword = SysStringLen(bstrPassword) + 1;
|
|
|
|
if ( lenServer >= MAX_PATH ||
|
|
lenDB >= MAX_PATH ||
|
|
lenUser >= MAX_PATH ||
|
|
lenPassword >= MAX_PATH )
|
|
{
|
|
m_dwInfGenError = FAIL_MAX_BUFFER;
|
|
return E_FAIL;
|
|
}
|
|
|
|
// Server
|
|
if ( lenServer > 1 )
|
|
{
|
|
#ifndef UNICODE
|
|
if ( 0 == WideCharToMultiByte( CP_ACP,
|
|
0L,
|
|
bstrServer,
|
|
lenServer,
|
|
m_szDataServer,
|
|
MAX_PATH,
|
|
NULL,
|
|
NULL ) ) {
|
|
m_dwInfGenError = GetLastError();
|
|
return E_FAIL;
|
|
}
|
|
#else
|
|
memcpy( m_szDataServer, bstrServer, sizeof(wchar_t) * lenServer );
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
m_szDataServer[0] = _T('\0');
|
|
}
|
|
|
|
// Default DB
|
|
if ( lenDB > 1 )
|
|
{
|
|
#ifndef UNICODE
|
|
if ( 0 == WideCharToMultiByte( CP_ACP,
|
|
0L,
|
|
bstrDB,
|
|
lenDB,
|
|
m_szDatabase,
|
|
MAX_PATH,
|
|
NULL,
|
|
NULL ) ) {
|
|
m_dwInfGenError = GetLastError();
|
|
return E_FAIL;
|
|
}
|
|
#else
|
|
memcpy( m_szDatabase, bstrDB, sizeof(wchar_t) * lenDB );
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
m_szDatabase[0] = _T('\0');
|
|
}
|
|
|
|
// Username
|
|
if ( lenUser > 1 )
|
|
{
|
|
#ifndef UNICODE
|
|
if ( 0 == WideCharToMultiByte( CP_ACP,
|
|
0L,
|
|
bstrUser,
|
|
lenUser,
|
|
m_szUserName,
|
|
MAX_PATH,
|
|
NULL,
|
|
NULL ) ) {
|
|
m_dwInfGenError = GetLastError();
|
|
return E_FAIL;
|
|
}
|
|
#else
|
|
memcpy( m_szUserName, bstrUser, sizeof(wchar_t) * lenUser );
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
m_szUserName[0] = _T('\0');
|
|
}
|
|
|
|
// Password
|
|
if ( lenPassword > 1 )
|
|
{
|
|
#ifndef UNICODE
|
|
if ( 0 == WideCharToMultiByte( CP_ACP,
|
|
0L,
|
|
bstrPassword,
|
|
lenPassword,
|
|
m_szPassword,
|
|
MAX_PATH,
|
|
NULL,
|
|
NULL ) ) {
|
|
m_dwInfGenError = GetLastError();
|
|
return E_FAIL;
|
|
}
|
|
#else
|
|
memcpy( m_szPassword, bstrPassword, sizeof(wchar_t) * lenPassword );
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
m_szPassword[0] = _T('\0');
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT
|
|
CUpdateInf::InitGen(
|
|
BSTR bstrInxFile,
|
|
BSTR bstrInfFile
|
|
)
|
|
{
|
|
size_t lenInxFile = SysStringLen(bstrInxFile) + 1,
|
|
lenInfFile = SysStringLen(bstrInfFile) + 1;
|
|
|
|
if( lenInxFile <= 1 ||
|
|
lenInfFile <= 1 )
|
|
{
|
|
m_dwInfGenError = FAIL_INVALIDPARAM;
|
|
return E_FAIL;
|
|
}
|
|
else if ( lenInxFile >= MAX_PATH ||
|
|
lenInfFile + 2 >= MAX_PATH ) // might need room to add '.\\'
|
|
{
|
|
m_dwInfGenError = FAIL_MAX_BUFFER;
|
|
return E_FAIL;
|
|
}
|
|
|
|
#ifndef UNICODE
|
|
char *szInxFile,
|
|
*szInfFile;
|
|
szInxFile = new char[lenInxFile];
|
|
szInfFile = new char[lenInfFile];
|
|
if ( NULL == szInxFile ||
|
|
NULL == szInfFile )
|
|
{
|
|
m_dwInfGenError = ERROR_NOT_ENOUGH_MEMORY;
|
|
return E_FAIL;
|
|
}
|
|
|
|
if ( 0 == WideCharToMultiByte( CP_ACP,
|
|
0L,
|
|
bstrInxFile,
|
|
lenInxFile,
|
|
szInxFile,
|
|
lenInxFile,
|
|
NULL,
|
|
NULL ) ) {
|
|
m_dwInfGenError = GetLastError();
|
|
return E_FAIL;
|
|
}
|
|
if ( 0 == WideCharToMultiByte( CP_ACP,
|
|
0L,
|
|
bstrInfFile,
|
|
lenInfFile,
|
|
szInfFile,
|
|
lenInfFile,
|
|
NULL,
|
|
NULL ) ) {
|
|
delete [] szInxFile;
|
|
m_dwInfGenError = GetLastError();
|
|
return E_FAIL;
|
|
}
|
|
#else
|
|
wchar_t *szInxFile = bstrInxFile,
|
|
*szInfFile = bstrInfFile;
|
|
#endif
|
|
|
|
_tcscpy( m_szInxFile, szInxFile );
|
|
_tcscpy( m_szOutFile,szInfFile );
|
|
|
|
// The Setup* function will infer a path given only a
|
|
// file, so we ensure that a path is always specified
|
|
_stprintf( m_szFilledInxFile, _T("%s%s"), (!_tcschr( szInfFile, _T('\\') )?_T(".\\"):_T("")), szInfFile );
|
|
_tcscpy( m_szFilledInxFile+_tcslen(m_szFilledInxFile)-3, _T("TMP") );
|
|
|
|
if( CopyFile( m_szInxFile, m_szFilledInxFile, FALSE ) ) {
|
|
|
|
SetFileAttributes( m_szFilledInxFile, FILE_ATTRIBUTE_NORMAL );
|
|
|
|
#ifndef UNICODE
|
|
delete [] szInfFile;
|
|
delete [] szInxFile;
|
|
#endif
|
|
|
|
// Open up a DB connection if a server was specified
|
|
if( m_szDataServer[0] ){
|
|
m_pdb = new CSimpleDatabase();
|
|
if ( SUCCEEDED(m_pdb->Connect( m_szDataServer,
|
|
m_szDatabase[0]?m_szDatabase:NULL,
|
|
m_szUserName[0]?m_szUserName:NULL,
|
|
m_szPassword[0]?m_szPassword:NULL )) ) {
|
|
m_bActiveDB = TRUE;
|
|
}
|
|
else {
|
|
m_dwInfGenError = FAIL_DSNOPEN;
|
|
return E_FAIL;
|
|
}
|
|
}
|
|
|
|
m_bGenInitCalled = TRUE;
|
|
return S_OK;
|
|
}
|
|
else {
|
|
#ifndef UNICODE
|
|
delete [] szInfFile;
|
|
delete [] szInxFile;
|
|
#endif
|
|
m_dwInfGenError = FAIL_COPYBASEINF;
|
|
return E_FAIL;
|
|
}
|
|
}
|
|
|
|
HRESULT
|
|
CUpdateInf::get_InfGenError(
|
|
BSTR *bstrError
|
|
)
|
|
{
|
|
LPVOID pErrorMsg;
|
|
DWORD dwFormatFlags = FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_IGNORE_INSERTS;
|
|
#ifndef UNICODE
|
|
wchar_t *wszErrorMsg;
|
|
size_t lenErrorMsg;
|
|
#endif
|
|
|
|
// assume system error codes will be win32-style or 0x8 stlye
|
|
if ( m_dwInfGenError | 0xc0000000 )
|
|
{
|
|
dwFormatFlags |= FORMAT_MESSAGE_FROM_HMODULE;
|
|
}
|
|
else
|
|
{
|
|
dwFormatFlags |= FORMAT_MESSAGE_FROM_SYSTEM;
|
|
}
|
|
|
|
if ( NULL == bstrError ) {
|
|
return E_POINTER;
|
|
}
|
|
|
|
if ( !FormatMessage( dwFormatFlags,
|
|
g_hMyInstance,
|
|
m_dwInfGenError,
|
|
NULL,
|
|
(LPTSTR) &pErrorMsg,
|
|
0,
|
|
NULL ) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
#ifndef UNICODE
|
|
lenErrorMsg = strlen((LPSTR)pErrorMsg) + 1;
|
|
wszErrorMsg = new wchar_t[lenErrorMsg];
|
|
if ( NULL == wszErrorMsg )
|
|
{
|
|
LocalFree( pErrorMsg );
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
if ( 0 == MultiByteToWideChar( _getmbcp(),
|
|
0L,
|
|
(LPSTR)pErrorMsg,
|
|
lenErrorMsg,
|
|
wszErrorMsg,
|
|
lenErrorMsg ) )
|
|
{
|
|
delete [] wszErrorMsg;
|
|
LocalFree( pErrorMsg );
|
|
return E_FAIL;
|
|
}
|
|
|
|
*bstrError = SysAllocString( wszErrorMsg );
|
|
delete [] wszErrorMsg;
|
|
#else
|
|
*bstrError = SysAllocString( (LPWSTR)pErrorMsg );
|
|
#endif
|
|
|
|
LocalFree( pErrorMsg );
|
|
|
|
if ( NULL == *bstrError ) {
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
BOOL
|
|
CUpdateInf::TrimInf(
|
|
LPTSTR szINFIn,
|
|
LPTSTR szINFOut
|
|
)
|
|
{
|
|
BOOL bRet = TRUE;
|
|
|
|
// Open a handle to the INF
|
|
m_hInf = SetupOpenInfFile( szINFIn, NULL, INF_STYLE_WIN4 , NULL );
|
|
if ( INVALID_HANDLE_VALUE == m_hInf ) {
|
|
m_dwInfGenError = GetLastError();
|
|
return FALSE;
|
|
}
|
|
|
|
if ( !GetSectionListFromInF( szINFIn ) ||
|
|
!ReadSectionEntries( szINFIn ) ||
|
|
!IdentifyUninstallSections() ||
|
|
!DeleteUnusedEntries() ||
|
|
!WriteSmallINF( szINFIn, szINFOut ) ) {
|
|
bRet = FALSE;
|
|
}
|
|
|
|
SetupCloseInfFile( m_hInf );
|
|
m_hInf = INVALID_HANDLE_VALUE;
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
|
|
BOOL
|
|
CUpdateInf::ReverseSectionList(
|
|
void
|
|
)
|
|
{
|
|
PSECTION pSectionList2 = NULL;
|
|
PSECTION psRef,psRef2;
|
|
|
|
|
|
psRef = m_sectionList;
|
|
psRef2 = psRef->Next;
|
|
|
|
while( psRef ) {
|
|
|
|
psRef->Next = NULL;
|
|
m_sectionList = psRef2;
|
|
|
|
if( pSectionList2 == NULL ) {
|
|
|
|
pSectionList2 = psRef;
|
|
|
|
} else {
|
|
|
|
psRef->Next = pSectionList2 ;
|
|
pSectionList2 = psRef;
|
|
|
|
}
|
|
psRef = psRef2;
|
|
if( psRef != NULL ) {
|
|
psRef2 = psRef->Next;
|
|
}
|
|
}
|
|
m_sectionList = pSectionList2;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
CUpdateInf::WriteSmallINF(
|
|
LPTSTR szINFIn,
|
|
LPTSTR szINFOut
|
|
)
|
|
{
|
|
BOOL bRet = FALSE;
|
|
FILE *fp2 = NULL;
|
|
PSECTION ps;
|
|
|
|
ReverseSectionList();
|
|
|
|
fp2 = _tfopen( szINFOut, _T("w+") );
|
|
if( fp2 ) {
|
|
// write all the entries from in file to out file excluding the empty sections from sectionlist
|
|
|
|
ps = m_sectionList;
|
|
while( ps ) {
|
|
|
|
|
|
if( ps->cRef ) {
|
|
|
|
if ( _ftprintf( fp2, _T("[%s]\n"),ps->szSectionName) < 0 ) {
|
|
m_dwInfGenError = GetLastError();
|
|
goto fail;
|
|
}
|
|
|
|
|
|
for( DWORD i=0; i < ps->dwSectionEntries ; i++ ) {
|
|
if( ps->pseSectionEntries[i].cRef ) {
|
|
if ( _ftprintf(fp2, _T(" %s\n"), ps->pseSectionEntries[i].szLine) < 0 ) {
|
|
m_dwInfGenError = GetLastError();
|
|
goto fail;
|
|
}
|
|
|
|
}
|
|
}
|
|
_ftprintf( fp2,_T("\n") );
|
|
|
|
}
|
|
ps = ps->Next;
|
|
}
|
|
|
|
bRet = TRUE;
|
|
|
|
}
|
|
|
|
fail:
|
|
if( fp2 ) {
|
|
|
|
fclose( fp2 );
|
|
}
|
|
|
|
return bRet ;
|
|
}
|
|
|
|
|
|
BOOL
|
|
CUpdateInf::DeleteUnusedEntries(
|
|
void
|
|
)
|
|
{
|
|
HINF hInf;
|
|
BOOL bRet = TRUE;
|
|
PSECTION ps, ps2;
|
|
|
|
if ( INVALID_HANDLE_VALUE == m_hInf ) {
|
|
return FALSE;
|
|
}
|
|
|
|
ps = m_sectionList;
|
|
while( ps ) {
|
|
|
|
if ( 0 == SetupGetLineCount( m_hInf, ps->szSectionName ) ) {
|
|
if ( 0 == --ps->cRef )
|
|
{
|
|
MarkAssociatedEntriesForDelete( ps );
|
|
}
|
|
}
|
|
ps = ps->Next;
|
|
}
|
|
|
|
ps2 = m_sectionList;
|
|
|
|
while( ps2 ) {
|
|
|
|
// If all the directives are marked delete, then mark this section
|
|
PSECTIONENTRY pse = ps2->pseSectionEntries;
|
|
|
|
// If this section has already been removed, ignore it
|
|
if ( ps2->cRef )
|
|
{
|
|
for( DWORD dwCount = 0; dwCount < ps2->dwSectionEntries ; dwCount++ ) {
|
|
|
|
if( pse[ dwCount ].cRef ) {
|
|
break;
|
|
}
|
|
}
|
|
if( dwCount == ps2->dwSectionEntries ) {
|
|
//All the directives are marked delete So mark this for delete.
|
|
if ( 0 == --ps2->cRef )
|
|
{
|
|
MarkAssociatedEntriesForDelete( ps2 );
|
|
}
|
|
}
|
|
}
|
|
ps2=ps2->Next;
|
|
}
|
|
|
|
// Determine if we can discard any AddDirId sections
|
|
DeleteUnusedDirIdSections();
|
|
|
|
return bRet;
|
|
}
|
|
|
|
/*
|
|
AddDirId sections are unused if their InstallFromSection entry has been marked
|
|
as deleted (as is the case if the corresponding section is empty). We identify
|
|
AddDirId sections by looking in the DirectoryId.Include section. This function
|
|
goes through all of the AddDirId section identified in the DirectoryId.Include
|
|
section and determines if the section is no longer used (based on whether
|
|
InstallFromSection has been marked deleted or not).
|
|
*/
|
|
BOOL
|
|
CUpdateInf::DeleteUnusedDirIdSections(
|
|
void
|
|
)
|
|
{
|
|
HINF hInf;
|
|
BOOL bRet = TRUE;
|
|
INFCONTEXT Context;
|
|
TCHAR szDirIDSection[ MAX_PATH ];
|
|
|
|
if ( INVALID_HANDLE_VALUE == m_hInf )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if ( SetupFindFirstLine( m_hInf, _T("DirectoryId.Include"), _T("AddDirId"), &Context ) ) {
|
|
do{
|
|
if( SetupGetLineText( &Context, NULL, NULL, NULL , szDirIDSection, MAX_PATH , NULL ) ) {
|
|
PSECTIONASSOCIATIONLIST pSectionAssoc;
|
|
DWORD dwHash = CalcHashFromSectionName( szDirIDSection );
|
|
|
|
pSectionAssoc = m_rgNameHash[dwHash];
|
|
while ( pSectionAssoc && _tcsicmp( szDirIDSection, pSectionAssoc->pSection->szSectionName ) )
|
|
{
|
|
pSectionAssoc = pSectionAssoc->pNext;
|
|
}
|
|
// If we found a matching section, find the InstallFromSection entry
|
|
if ( pSectionAssoc ) {
|
|
PSECTIONENTRY pse = pSectionAssoc->pSection->pseSectionEntries;
|
|
DWORD dwCount;
|
|
|
|
for( dwCount = 0; dwCount < pSectionAssoc->pSection->dwSectionEntries ; dwCount++ ) {
|
|
|
|
if( 0 == _tcsncicmp( _T("InstallFromSection="), pse[ dwCount ].szLine, 19 ) ) {
|
|
break;
|
|
}
|
|
}
|
|
// If we found the InstallFromSection entry and it is marked for delete
|
|
// then this section is no longer needed; remove it and its associated
|
|
// entries
|
|
if( dwCount < pSectionAssoc->pSection->dwSectionEntries &&
|
|
!pse[dwCount].cRef ) {
|
|
|
|
if ( 0 == --pSectionAssoc->pSection->cRef )
|
|
{
|
|
MarkAssociatedEntriesForDelete( pSectionAssoc->pSection );
|
|
}
|
|
}
|
|
else if ( dwCount < pSectionAssoc->pSection->dwSectionEntries )
|
|
{
|
|
// Can InstallFromSection have more than one
|
|
// comma-delimited entry?
|
|
}
|
|
}
|
|
}
|
|
} while( SetupFindNextLine( &Context, &Context ) );
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
BOOL
|
|
CUpdateInf::IdentifyUninstallSections(
|
|
void
|
|
)
|
|
{
|
|
PSECTIONASSOCIATIONLIST pSectionFinder;
|
|
|
|
DWORD dwHash = CalcHashFromSectionName( _T("UninstallSections") );
|
|
|
|
pSectionFinder = m_rgNameHash[dwHash];
|
|
while ( pSectionFinder && _tcsicmp( _T("UninstallSections"), pSectionFinder->pSection->szSectionName ) )
|
|
{
|
|
pSectionFinder = pSectionFinder->pNext;
|
|
}
|
|
|
|
// If we found the [UninstallSections] section, identify the other sections
|
|
if ( pSectionFinder ) {
|
|
DWORD dwCount;
|
|
PSECTION pUninstallSection = pSectionFinder->pSection;
|
|
|
|
// the uninstall section is used by the installer
|
|
pUninstallSection->cRef++;
|
|
|
|
// for each entry of <uninstall_name>,<current_name> update the current_name section
|
|
for( dwCount = 0; dwCount < pUninstallSection->dwSectionEntries ; dwCount++ ) {
|
|
PSECTIONASSOCIATIONLIST pAssocSection;
|
|
TCHAR *pCurName;
|
|
|
|
pCurName = _tcschr( pUninstallSection->pseSectionEntries[dwCount].szLine, _T(',') );
|
|
if ( pCurName ) {
|
|
pCurName++; // move past the ,
|
|
dwHash = CalcHashFromSectionName( pCurName );
|
|
|
|
pAssocSection = m_rgNameHash[dwHash];
|
|
while ( pAssocSection && _tcsicmp( pCurName, pAssocSection->pSection->szSectionName ) )
|
|
{
|
|
pAssocSection = pAssocSection->pNext;
|
|
}
|
|
|
|
if ( pAssocSection )
|
|
{
|
|
DWORD dwEntry = 0;
|
|
|
|
// Update reference count on section
|
|
// NOTE: this is only necessary if we want to keep
|
|
// empty sections around, but since we don't
|
|
// know a lot about the uninstall logic we
|
|
// are playing it safe
|
|
pAssocSection->pSection->cRef++;
|
|
|
|
// Update reference count on all of the section's entries
|
|
while ( dwEntry < pAssocSection->pSection->dwSectionEntries ) {
|
|
pAssocSection->pSection->pseSectionEntries[dwEntry++].cRef++;
|
|
}
|
|
|
|
// Associate the current entry with this found section
|
|
AssociateEntryWithSection( &pUninstallSection->pseSectionEntries[dwCount], pCurName, FALSE );
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
CUpdateInf::RemoveSectionFromMultiEntry(
|
|
PSECTIONENTRY pse,
|
|
LPCTSTR szSectionName
|
|
)
|
|
{
|
|
TCHAR *pSectionName = StrStrI( pse->szLine, szSectionName );
|
|
TCHAR *pEndSection;
|
|
|
|
if ( NULL != pSectionName )
|
|
{
|
|
pEndSection = _tcschr( pSectionName, _T(',') );
|
|
if ( pEndSection )
|
|
{
|
|
memmove( pSectionName, pEndSection + 1, sizeof(TCHAR) * (_tcslen(pEndSection+1) + 1) );
|
|
}
|
|
else
|
|
{
|
|
// We might be the last entry in the list
|
|
pSectionName--;
|
|
while ( pSectionName > pse->szLine &&
|
|
_istspace( *pSectionName ) ) pSectionName--;
|
|
if ( _T(',') == *pSectionName )
|
|
{
|
|
*pSectionName = _T('\0');
|
|
}
|
|
// We must be the only remaining entry
|
|
else
|
|
{
|
|
*(pSectionName+1) = _T('\0');
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
// We didn't find the section name to remove it
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
|
|
BOOL
|
|
CUpdateInf::MarkAssociatedEntriesForDelete(
|
|
PSECTION ps
|
|
)
|
|
{
|
|
PASSOCIATEDENTRIES pAssociatedEntries = ps->pAssociatedEntries;
|
|
|
|
while ( pAssociatedEntries )
|
|
{
|
|
if ( --pAssociatedEntries->pse->cRef )
|
|
{
|
|
// This line apparently references more than one section
|
|
// so remove ourselves so the line is still useable
|
|
RemoveSectionFromMultiEntry(pAssociatedEntries->pse, ps->szSectionName);
|
|
}
|
|
pAssociatedEntries = pAssociatedEntries->pNext;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
CUpdateInf::ReadSectionEntries(
|
|
LPCTSTR szINF
|
|
)
|
|
{
|
|
HINF hInf;
|
|
INFCONTEXT Context;
|
|
BOOL bRet = TRUE;
|
|
DWORD dwSectionEntries;
|
|
DWORD dwNumChars;
|
|
PSECTION ps;
|
|
|
|
|
|
if ( INVALID_HANDLE_VALUE == m_hInf ) {
|
|
return FALSE;
|
|
}
|
|
|
|
ps = m_sectionList;
|
|
while( ps ) {
|
|
|
|
if( ps->cRef ) {
|
|
|
|
dwSectionEntries = SetupGetLineCount( m_hInf, ps->szSectionName );
|
|
if( dwSectionEntries > 0 ) {
|
|
ps->pseSectionEntries = new SECTIONENTRY [dwSectionEntries];
|
|
if ( NULL == ps->pseSectionEntries ) {
|
|
m_dwInfGenError = ERROR_NOT_ENOUGH_MEMORY;
|
|
return FALSE;
|
|
}
|
|
memset( ps->pseSectionEntries, 0 , dwSectionEntries * sizeof( SECTIONENTRY ) );
|
|
|
|
memset( m_textBuffer, 0 , sizeof( m_textBuffer ) );
|
|
|
|
dwNumChars = GetPrivateProfileSection(
|
|
ps->szSectionName,
|
|
m_textBuffer,
|
|
BUFFER_SIZE,
|
|
szINF
|
|
);
|
|
if ( dwNumChars + 2 == BUFFER_SIZE ) {
|
|
m_dwInfGenError = FAIL_MAX_BUFFER;
|
|
return FALSE;
|
|
}
|
|
TCHAR * pch = m_textBuffer;
|
|
|
|
while( *pch ) {
|
|
TCHAR *pCurPos = m_textBuffer2;
|
|
do
|
|
{
|
|
if ( _T(';') != pch[0] )
|
|
{
|
|
_tcscpy( pCurPos, pch );
|
|
pCurPos += _tcslen(pch);
|
|
if ( _T('\\') == *(pCurPos - 1) ) pCurPos--;
|
|
}
|
|
pch = pch + _tcslen( pch) +1 ;
|
|
} while ( *pch && _T('\\') == *pCurPos );
|
|
|
|
pCurPos = _T('\0');
|
|
if ( _tcslen( m_textBuffer2 ) &&
|
|
!AddEntryToSection( ps, m_textBuffer2 ) ) {
|
|
bRet = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
ps = ps->Next;
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
BOOL
|
|
CUpdateInf::AddEntryToSection(
|
|
PSECTION ps,
|
|
LPCTSTR szEntry
|
|
)
|
|
{
|
|
static TCHAR *rgKeys[] = { _T("CopyFiles"),
|
|
_T("DelFiles"),
|
|
_T("AddReg"),
|
|
_T("DelReg"),
|
|
_T("AddDirId"),
|
|
_T("InstallFromSection") };
|
|
TCHAR szNewEntry[MAX_PATH],
|
|
*pNewEntry;
|
|
BOOL bInQuote = FALSE;
|
|
TCHAR *szPostKey;
|
|
TCHAR *szComment;
|
|
|
|
// Add entry to section
|
|
ps->pseSectionEntries[ps->dwSectionEntries].szLine = new TCHAR [_tcslen(szEntry) + 1];
|
|
if ( NULL == ps->pseSectionEntries[ps->dwSectionEntries].szLine )
|
|
{
|
|
m_dwInfGenError = ERROR_NOT_ENOUGH_MEMORY;
|
|
return FALSE;
|
|
}
|
|
_tcscpy( ps->pseSectionEntries[ps->dwSectionEntries].szLine, szEntry );
|
|
ps->pseSectionEntries[ps->dwSectionEntries].cRef = 1;
|
|
|
|
if ( _tcslen(szEntry) <= MAX_PATH )
|
|
{
|
|
pNewEntry = szNewEntry;
|
|
}
|
|
else
|
|
{
|
|
pNewEntry = new TCHAR [_tcslen(szEntry) + 1];
|
|
if ( NULL == pNewEntry )
|
|
{
|
|
m_dwInfGenError = ERROR_NOT_ENOUGH_MEMORY;
|
|
return FALSE;
|
|
}
|
|
}
|
|
_tcscpy( pNewEntry, szEntry );
|
|
|
|
// Remove any comments
|
|
szComment = pNewEntry;
|
|
while ( *szComment )
|
|
{
|
|
if ( _T('\"') == *szComment ) bInQuote = !bInQuote;
|
|
if ( !bInQuote && _T(';') == *szComment ) break;
|
|
szComment++;
|
|
}
|
|
if ( *szComment )
|
|
{
|
|
while ( szComment >= pNewEntry &&
|
|
_istspace( *szComment ) ) { szComment--; }
|
|
*(szComment + 1) = _T('\0');
|
|
}
|
|
|
|
// Find the key (if one exists)
|
|
szPostKey = _tcschr( pNewEntry, _T('=') );
|
|
|
|
if ( szPostKey )
|
|
{
|
|
*szPostKey = _T('\0');
|
|
|
|
// If we recognize the entry type, add it to list affecting specified section
|
|
if( _tcsicmp( ps->szSectionName , _T("DestinationDirs") ) == 0 ) {
|
|
|
|
// This entry is necessary only as long as it has associations
|
|
ps->pseSectionEntries[ps->dwSectionEntries].cRef = 0;
|
|
|
|
AssociateEntryWithSection( &ps->pseSectionEntries[ps->dwSectionEntries], pNewEntry, FALSE );
|
|
} else {
|
|
DWORD iKey;
|
|
szPostKey++;
|
|
for ( iKey = 0; iKey < sizeof(rgKeys) / sizeof(rgKeys[0]); iKey++ )
|
|
{
|
|
if ( !_tcsicmp( rgKeys[iKey], pNewEntry ) )
|
|
{
|
|
// The associated sections may appear in a comma-delimited list,
|
|
// so make sure to associate all of the entries
|
|
BOOL fMultiEntry = (NULL != _tcschr( szPostKey, _T(',') ));
|
|
TCHAR *pSection = _tcstok( szPostKey, _T(" ,") );
|
|
|
|
// This entry is necessary only as long as it has associations
|
|
ps->pseSectionEntries[ps->dwSectionEntries].cRef = 0;
|
|
|
|
do
|
|
{
|
|
AssociateEntryWithSection( &ps->pseSectionEntries[ps->dwSectionEntries], pSection, fMultiEntry );
|
|
} while ( pSection = _tcstok(NULL, _T(" ,")) );
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Free up buffer if we were forced to allocate one
|
|
if ( pNewEntry != szNewEntry ) delete [] pNewEntry;
|
|
|
|
ps->dwSectionEntries++;
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
CUpdateInf::AssociateEntryWithSection(
|
|
PSECTIONENTRY pse,
|
|
LPCTSTR szSectionName,
|
|
BOOL fMultiSection
|
|
)
|
|
{
|
|
DWORD dwHash;
|
|
PSECTION pSection;
|
|
PSECTIONASSOCIATIONLIST pSectionAssoc;
|
|
PASSOCIATEDENTRIES pAssociation;
|
|
|
|
// Find our section to associate in the hash list
|
|
dwHash = CalcHashFromSectionName( szSectionName );
|
|
pSectionAssoc = m_rgNameHash[dwHash];
|
|
while ( pSectionAssoc && _tcsicmp( szSectionName, pSectionAssoc->pSection->szSectionName ) )
|
|
{
|
|
pSectionAssoc = pSectionAssoc->pNext;
|
|
}
|
|
// If we couldn't find the section, assume it doesn't exit and mark the entry for delete
|
|
if ( !pSectionAssoc )
|
|
{
|
|
if ( fMultiSection )
|
|
{
|
|
// Remove the section name from a multi-section
|
|
// comma-delimited list
|
|
RemoveSectionFromMultiEntry(pse, szSectionName);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
// Add new entry to section association
|
|
pAssociation = new ASSOCIATEDENTRIES;
|
|
if ( NULL == pAssociation )
|
|
{
|
|
m_dwInfGenError = ERROR_NOT_ENOUGH_MEMORY;
|
|
return FALSE;
|
|
}
|
|
|
|
// Update the ref count on the entry
|
|
pse->cRef++;
|
|
|
|
pAssociation->pse = pse;
|
|
pAssociation->pNext = NULL;
|
|
|
|
pSection = pSectionAssoc->pSection;
|
|
if ( pSection->pAssociatedEntries )
|
|
{
|
|
pAssociation->pNext = pSection->pAssociatedEntries;
|
|
pSection->pAssociatedEntries = pAssociation;
|
|
}
|
|
else
|
|
{
|
|
pSection->pAssociatedEntries = pAssociation;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
DWORD
|
|
CUpdateInf::CalcHashFromSectionName(
|
|
LPCTSTR szSectionName
|
|
)
|
|
{
|
|
TCHAR szSectionNameLC[ MAX_PATH ];
|
|
DWORD dwHash = 0L,
|
|
dwHashExtra = 0L;
|
|
BYTE *pData;
|
|
size_t bytesSectionName = sizeof( TCHAR ) * _tcslen( szSectionName );
|
|
size_t i;
|
|
|
|
// Dependent on sizeof(DWORD) = 4 * sizeof(BYTE) so put in a check
|
|
// which the compiler should optimize out
|
|
if ( sizeof(DWORD) != 4*sizeof(BYTE) ) DebugBreak();
|
|
|
|
// convert section name to lower-case
|
|
for ( i = 0; i < _tcslen( szSectionName ); i++ )
|
|
{
|
|
szSectionNameLC[i] = (_istupper(szSectionName[i])?_totlower(szSectionName[i]):szSectionName[i]);
|
|
}
|
|
|
|
pData = (PBYTE)szSectionNameLC;
|
|
for ( i = 0; i < bytesSectionName / sizeof(DWORD); i++ )
|
|
{
|
|
DWORD dwTempHash = 0L;
|
|
|
|
dwTempHash = pData[0] << 24 | pData[1] << 16 | pData[2] << 8 | pData[3];
|
|
#ifdef UNICODE
|
|
dwHash ^= i%2?dwTempHash >> 8:dwTempHash;
|
|
#else
|
|
dwHash ^= dwTempHash;
|
|
#endif
|
|
pData += sizeof(DWORD);
|
|
}
|
|
// Pick up any remaining bits that don't fit into a DWORD
|
|
for ( i = 0; i < bytesSectionName % sizeof(DWORD); i++ )
|
|
{
|
|
dwHashExtra <<= 8;
|
|
dwHashExtra += pData[i];
|
|
}
|
|
|
|
return (dwHash ^ dwHashExtra) % HASH_BUCKETS;
|
|
}
|
|
|
|
BOOL
|
|
CUpdateInf::GetSectionListFromInF(
|
|
LPTSTR szINF
|
|
)
|
|
{
|
|
BOOL bRet = TRUE;
|
|
PSECTION ps = NULL;
|
|
DWORD dwSize =0;
|
|
LPTSTR lpReturnedString;
|
|
DWORD dwResult;
|
|
TCHAR *pc;
|
|
DWORD dwHash;
|
|
BOOL fDuplicate;
|
|
PSECTIONASSOCIATIONLIST pAssociationList;
|
|
|
|
dwSize = GetFileSizeByName( szINF, NULL );
|
|
|
|
lpReturnedString = new TCHAR [dwSize];
|
|
|
|
dwResult = GetPrivateProfileString(
|
|
NULL, // section name
|
|
NULL, // key name
|
|
_T("1"), // default string
|
|
lpReturnedString, // destination buffer
|
|
dwSize, // size of destination buffer
|
|
szINF
|
|
);
|
|
|
|
pc = lpReturnedString;
|
|
|
|
if( dwResult > 0 ) {
|
|
// Form the list
|
|
while( ( bRet ) && ( _tcslen( pc ) != 0 ) ) {
|
|
ps = new SECTION;
|
|
|
|
if( ps ) {
|
|
|
|
fDuplicate = FALSE;
|
|
memset( ps, 0, sizeof( SECTION ) );
|
|
_tcscpy( ps->szSectionName, pc );
|
|
ps->cRef = 1;
|
|
|
|
// Add section to association hash
|
|
dwHash = CalcHashFromSectionName( ps->szSectionName );
|
|
if ( !m_rgNameHash[dwHash] )
|
|
{
|
|
m_rgNameHash[dwHash] = new SECTIONASSOCIATIONLIST;
|
|
if ( NULL == m_rgNameHash[dwHash] )
|
|
{
|
|
m_dwInfGenError = ERROR_NOT_ENOUGH_MEMORY;
|
|
bRet = FALSE;
|
|
break;
|
|
}
|
|
pAssociationList = m_rgNameHash[dwHash];
|
|
}
|
|
else
|
|
{
|
|
pAssociationList = m_rgNameHash[dwHash];
|
|
// Check for duplicate section name
|
|
do
|
|
{
|
|
if ( !_tcsicmp(pAssociationList->pSection->szSectionName, ps->szSectionName) )
|
|
{
|
|
fDuplicate = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
while ( pAssociationList->pNext &&
|
|
NULL != (pAssociationList = pAssociationList->pNext) // should always be true
|
|
);
|
|
|
|
if ( !fDuplicate )
|
|
{
|
|
pAssociationList->pNext = new SECTIONASSOCIATIONLIST;
|
|
if ( NULL == pAssociationList->pNext )
|
|
{
|
|
m_dwInfGenError = ERROR_NOT_ENOUGH_MEMORY;
|
|
bRet = FALSE;
|
|
break;
|
|
}
|
|
pAssociationList = pAssociationList->pNext;
|
|
}
|
|
}
|
|
|
|
if ( !fDuplicate )
|
|
{
|
|
pAssociationList->pSection = ps;
|
|
pAssociationList->pNext = NULL;
|
|
|
|
|
|
//
|
|
// Add section to section list
|
|
//
|
|
if( m_sectionList == NULL ) {
|
|
|
|
m_sectionList = ps;
|
|
|
|
} else {
|
|
ps->Next = m_sectionList;
|
|
m_sectionList = ps;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// free duplicate section entry
|
|
delete ps;
|
|
}
|
|
|
|
} else{
|
|
bRet = FALSE;
|
|
|
|
}
|
|
|
|
pc += _tcslen( pc )+1 ;
|
|
}
|
|
} else {
|
|
bRet = FALSE;
|
|
}
|
|
if( lpReturnedString != NULL ) {
|
|
delete [] lpReturnedString;
|
|
}
|
|
|
|
TCHAR szDebug[50];
|
|
short cFilled = 0;
|
|
for ( short i = 0; i < HASH_BUCKETS; i++ ) { if ( m_rgNameHash[i] ) cFilled++; }
|
|
_stprintf( szDebug, _T("Buckets used: %u\n"), cFilled );
|
|
OutputDebugString( szDebug );
|
|
|
|
return bRet;
|
|
}
|
|
|
|
DWORD
|
|
CUpdateInf::GetFileSizeByName(
|
|
IN LPCTSTR pszFileName,
|
|
OUT PDWORD pdwFileSizeHigh
|
|
)
|
|
{
|
|
DWORD dwFileSizeLow = 0xFFFFFFFF;
|
|
HANDLE hFile;
|
|
|
|
hFile = CreateFile(
|
|
pszFileName,
|
|
GENERIC_READ,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
FILE_FLAG_NO_BUFFERING,
|
|
NULL
|
|
);
|
|
|
|
if ( hFile != INVALID_HANDLE_VALUE ) {
|
|
|
|
dwFileSizeLow = GetFileSize( hFile, pdwFileSizeHigh );
|
|
|
|
CloseHandle( hFile );
|
|
}
|
|
|
|
return dwFileSizeLow;
|
|
}
|