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.
1958 lines
62 KiB
1958 lines
62 KiB
///////////////////////////////////////////////////////////////////////////////
|
|
// Implementation of class CParseInf
|
|
//
|
|
// CParseInf is created to deal with parsing of an INF file.
|
|
|
|
#include <ole2.h>
|
|
#include "ParseInf.h"
|
|
#include "resource.h"
|
|
#include "init.h"
|
|
#include "global.h"
|
|
#include <shlwapi.h>
|
|
#include <initguid.h>
|
|
#include <pkgguid.h>
|
|
#include <cleanoc.h> // for STATUS_CTRL values
|
|
#include <mluisupp.h>
|
|
|
|
#define ARRAYSIZE(a) (sizeof(a)/sizeof(a[0]))
|
|
|
|
static BOOL FGetCLSIDFile( LPTSTR szFile, LPCTSTR szCLSID )
|
|
{
|
|
BOOL fGotIt = FALSE;
|
|
HKEY hkeyClsid;
|
|
TCHAR szT[MAX_PATH];
|
|
TCHAR *szPath = CatPathStrN( szT, HKCR_CLSID, szCLSID, MAX_PATH );
|
|
|
|
if ( RegOpenKeyEx( HKEY_CLASSES_ROOT, szPath, 0, KEY_READ, &hkeyClsid ) == ERROR_SUCCESS )
|
|
{
|
|
DWORD dw;
|
|
LRESULT lResult;
|
|
|
|
// Look for InprocServer[32] or LocalServer[32] key
|
|
dw = MAX_PATH;
|
|
lResult = RegQueryValue(hkeyClsid, INPROCSERVER32, szT, (PLONG)&dw);
|
|
if (lResult != ERROR_SUCCESS)
|
|
{
|
|
dw = MAX_PATH;
|
|
lResult = RegQueryValue(hkeyClsid, LOCALSERVER32, szT, (PLONG)&dw);
|
|
}
|
|
|
|
if (lResult != ERROR_SUCCESS)
|
|
{
|
|
dw = MAX_PATH;
|
|
lResult = RegQueryValue(hkeyClsid, INPROCSERVERX86, szT, (PLONG)&dw);
|
|
}
|
|
|
|
if (lResult != ERROR_SUCCESS)
|
|
{
|
|
dw = MAX_PATH;
|
|
lResult = RegQueryValue(hkeyClsid, LOCALSERVERX86, szT, (PLONG)&dw);
|
|
}
|
|
|
|
if ( lResult == ERROR_SUCCESS )
|
|
{
|
|
if ( OCCGetLongPathName( szFile, szT, MAX_PATH ) == 0 )
|
|
lstrcpy( szFile, szT );
|
|
fGotIt = TRUE;
|
|
}
|
|
|
|
RegCloseKey( hkeyClsid );
|
|
}
|
|
|
|
return fGotIt;
|
|
}
|
|
|
|
// constructor
|
|
CParseInf::CParseInf()
|
|
{
|
|
m_pHeadFileList = NULL;
|
|
m_pCurFileNode = NULL;
|
|
m_pFileRetrievalPtr = NULL;
|
|
m_pHeadPackageList = NULL;
|
|
m_pCurPackageNode = NULL;
|
|
m_pPackageRetrievalPtr = NULL;
|
|
m_bIsDistUnit = FALSE;
|
|
m_bHasActiveX = FALSE;
|
|
m_bHasJava = FALSE;
|
|
m_pijpm = NULL;
|
|
m_bCoInit = FALSE;
|
|
m_dwStatus = STATUS_CTRL_UNKNOWN;
|
|
GetDaysBeforeExpireGeneral( &m_cExpireDays );
|
|
}
|
|
|
|
// destructor
|
|
CParseInf::~CParseInf()
|
|
{
|
|
DestroyFileList();
|
|
DestroyPackageList();
|
|
|
|
if ( m_pijpm != NULL )
|
|
m_pijpm->Release();
|
|
|
|
if ( m_bCoInit )
|
|
CoUninitialize();
|
|
}
|
|
|
|
// initialization
|
|
void CParseInf::Init()
|
|
{
|
|
m_dwFileSizeSaved = 0;
|
|
m_dwTotalFileSize = 0;
|
|
m_nTotalFiles = 0;
|
|
m_pHeadFileList = m_pCurFileNode = NULL;
|
|
m_pHeadPackageList = m_pCurPackageNode = NULL;
|
|
|
|
lstrcpyn(m_szInf, m_szFileName, ARRAYSIZE(m_szInf));
|
|
TCHAR *pCh = ReverseStrchr(m_szInf, '.');
|
|
if (pCh != NULL)
|
|
*pCh = '\0';
|
|
if ( lstrlen(m_szInf) + lstrlen(INF_EXTENSION) < ARRAYSIZE(m_szInf))
|
|
lstrcat(m_szInf, INF_EXTENSION);
|
|
else
|
|
m_szInf[0] = 0; // if can't hold it, we can't hold it.
|
|
}
|
|
|
|
// release memory used by a linked list of files
|
|
void CParseInf::DestroyFileList()
|
|
{
|
|
if (m_pHeadFileList != NULL)
|
|
delete m_pHeadFileList;
|
|
m_pHeadFileList = m_pCurFileNode = NULL;
|
|
}
|
|
|
|
void CParseInf::DestroyPackageList()
|
|
{
|
|
if (m_pHeadPackageList != NULL)
|
|
delete m_pHeadPackageList;
|
|
m_pHeadPackageList = m_pCurPackageNode = NULL;
|
|
}
|
|
|
|
|
|
// find inf from cache directory if one with the
|
|
// same name as the OCX is not found
|
|
HRESULT CParseInf::FindInf(LPTSTR szInf)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
WIN32_FIND_DATA dataFile;
|
|
HANDLE h = INVALID_HANDLE_VALUE;
|
|
DWORD dwLen = 0;
|
|
TCHAR szValueBuf[MAX_PATH];
|
|
TCHAR *szOcxFileName = ReverseStrchr(m_szFileName, '\\');
|
|
int nCachePathLength = 0, i = 0;
|
|
|
|
Assert(szOcxFileName != NULL);
|
|
szOcxFileName += 1;
|
|
Assert (szInf != NULL);
|
|
if (szInf == NULL)
|
|
goto ExitFindInf;
|
|
|
|
// search for inf file in two directories. First the dir where the
|
|
// OCX is, then the OC cache dir.
|
|
for (i = 0; dwLen == 0 && i < 2; i++)
|
|
{
|
|
if (i == 0)
|
|
hr = GetDirectory(GD_EXTRACTDIR, szInf, ARRAYSIZE(szInf), m_szFileName);
|
|
else
|
|
{
|
|
TCHAR szTemp[MAX_PATH];
|
|
hr = GetDirectory(GD_CACHEDIR, szTemp, ARRAYSIZE(szTemp));
|
|
if (lstrcmpi(szTemp, szInf) == 0)
|
|
continue;
|
|
lstrcpy(szInf, szTemp);
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
goto ExitFindInf;
|
|
|
|
lstrcat(szInf, TEXT("\\"));
|
|
nCachePathLength = lstrlen(szInf);
|
|
lstrcat(szInf, TEXT("*"));
|
|
lstrcat(szInf, INF_EXTENSION);
|
|
h = FindFirstFile(szInf, &dataFile);
|
|
if (h == INVALID_HANDLE_VALUE)
|
|
{
|
|
goto ExitFindInf;
|
|
}
|
|
|
|
// find an inf file with a section in [Add.Code] dedicated
|
|
// to the OCX file in question
|
|
do {
|
|
szInf[nCachePathLength] = '\0';
|
|
lstrcat(szInf, (LPCTSTR)dataFile.cFileName);
|
|
dwLen = GetPrivateProfileString(
|
|
KEY_ADDCODE,
|
|
szOcxFileName,
|
|
DEFAULT_VALUE,
|
|
szValueBuf,
|
|
MAX_PATH,
|
|
szInf);
|
|
} while(dwLen == 0 && FindNextFile(h, &dataFile));
|
|
}
|
|
|
|
hr = (dwLen != 0 ? hr : S_FALSE);
|
|
|
|
ExitFindInf:
|
|
|
|
if (h != INVALID_HANDLE_VALUE)
|
|
FindClose(h);
|
|
|
|
if (hr != S_OK)
|
|
szInf[0] = '\0';
|
|
|
|
return hr;
|
|
}
|
|
|
|
// initiate parsing of INF file
|
|
// szCLSID -- address to a buffer storing CLSID of control
|
|
// szOCXFileName -- full path and name (ie. long file name) of OCX file
|
|
HRESULT CParseInf::DoParse(
|
|
LPCTSTR szOCXFileName,
|
|
LPCTSTR szCLSID)
|
|
{
|
|
Assert(szOCXFileName != NULL);
|
|
Assert(szCLSID != NULL);
|
|
|
|
HRESULT hr = S_OK;
|
|
const TCHAR *pszPath = NULL;
|
|
TCHAR szFileName[MAX_PATH];
|
|
DWORD dwFileSize = 0;
|
|
|
|
if ( FGetCLSIDFile( szFileName, szCLSID ) &&
|
|
lstrcmpi( szFileName, szOCXFileName ) != 0 )
|
|
m_dwStatus = STATUS_CTRL_UNPLUGGED;
|
|
|
|
|
|
// If DoParse was called, we are assumed to be a legacy control and not
|
|
// a distribution unit (subsequent call to DoParseDU will change the
|
|
// status). This information is required for control removal purposes.
|
|
|
|
m_bIsDistUnit = FALSE;
|
|
m_bHasActiveX = TRUE; // all legacy controls are ActiveX
|
|
|
|
// initialization
|
|
|
|
if ( OCCGetLongPathName(m_szFileName, szOCXFileName, MAX_PATH) == 0 )
|
|
lstrcpyn( m_szFileName, szOCXFileName, MAX_PATH );
|
|
|
|
lstrcpyn(m_szCLSID, szCLSID, MAX_CLSID_LEN);
|
|
DestroyFileList();
|
|
Init();
|
|
|
|
BOOL bOCXRemovable = IsModuleRemovable(m_szFileName);
|
|
|
|
// test INF file existance, if not, try to find one in OC cache dir.
|
|
if (!FileExist(m_szInf))
|
|
{
|
|
if (!ReadInfFileNameFromRegistry(m_szCLSID, m_szInf, MAX_PATH))
|
|
{
|
|
FindInf(m_szInf);
|
|
|
|
// record inf file name into the registry
|
|
WriteInfFileNameToRegistry(
|
|
m_szCLSID,
|
|
(m_szInf[0] == '\0' ? NULL : m_szInf));
|
|
}
|
|
}
|
|
|
|
// enumerate files assocated with a particular OCX
|
|
if (FAILED(hr = EnumSections()))
|
|
goto ExitDoParse;
|
|
|
|
// S_FALSE is returned when an ocx has no inf file
|
|
if (hr == S_FALSE)
|
|
{
|
|
m_nTotalFiles = 1;
|
|
if (FAILED(GetSizeOfFile(m_szFileName, &m_dwFileSizeSaved)))
|
|
{
|
|
m_dwFileSizeSaved = 0;
|
|
m_dwTotalFileSize = 0;
|
|
}
|
|
else
|
|
{
|
|
m_dwTotalFileSize = m_dwFileSizeSaved;
|
|
}
|
|
hr = S_OK;
|
|
if ( !PathFileExists( m_szFileName ) )
|
|
m_dwStatus = STATUS_CTRL_DAMAGED;
|
|
else
|
|
m_dwStatus = STATUS_CTRL_INSTALLED;
|
|
goto ExitDoParse;
|
|
}
|
|
|
|
// OCX has an corresponding INF file.
|
|
// Loop through the list of assocated files to dig out info for each
|
|
// from their corresponding section in the INF file
|
|
for (m_pCurFileNode = m_pHeadFileList;
|
|
m_pCurFileNode != NULL;
|
|
m_pCurFileNode = m_pCurFileNode->GetNextFileNode(), hr = S_OK)
|
|
{
|
|
// if m_pCurFileNode->GetNextFileNode() == NULL => it's the inf file itself,
|
|
// which does not need to be processed.
|
|
if (m_pCurFileNode->GetNextFileNode() != NULL)
|
|
{
|
|
pszPath = m_pCurFileNode->GetPath();
|
|
Assert(pszPath != NULL);
|
|
if (pszPath == NULL)
|
|
{
|
|
hr = E_UNEXPECTED;
|
|
goto ExitDoParse;
|
|
}
|
|
CatPathStrN( szFileName, pszPath, m_pCurFileNode->GetName(), ARRAYSIZE(szFileName));
|
|
}
|
|
else
|
|
{
|
|
lstrcpyn(szFileName, m_szInf, ARRAYSIZE(szFileName));
|
|
pszPath = NULL;
|
|
}
|
|
|
|
// hr might either be S_OK or S_FALSE
|
|
// S_OK means file can be removed as it has a SharedDlls count of 1
|
|
// S_FALSE if the count is greater than 1
|
|
|
|
// calculate total num of files and their sizes
|
|
if (SUCCEEDED(hr = GetSizeOfFile(szFileName, &dwFileSize)))
|
|
{
|
|
if (pszPath == NULL ||
|
|
IsModuleRemovable(szFileName) ||
|
|
lstrcmpi(szFileName, m_szFileName) == 0)
|
|
{
|
|
m_dwFileSizeSaved += dwFileSize;
|
|
}
|
|
|
|
m_dwTotalFileSize += dwFileSize;
|
|
} else
|
|
m_dwStatus = STATUS_CTRL_DAMAGED; // failure to get size indicative of missing file.
|
|
|
|
m_nTotalFiles += 1;
|
|
}
|
|
|
|
// if we didn't detect a problem, flag the control as installed.
|
|
if ( m_dwStatus == STATUS_CTRL_UNKNOWN )
|
|
m_dwStatus = STATUS_CTRL_INSTALLED;
|
|
|
|
ExitDoParse:
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CParseInf::BuildDUFileList( HKEY hKeyDU )
|
|
{
|
|
HRESULT hr = S_OK;
|
|
LRESULT lResult;
|
|
HKEY hkeyFiles;
|
|
TCHAR szDUFileName[MAX_PATH + 1];
|
|
DWORD dwStrSize = MAX_PATH;
|
|
int cFilesEnum = 0;
|
|
|
|
lResult = RegOpenKeyEx(hKeyDU, REGSTR_DU_CONTAINS_FILES, 0,
|
|
KEY_READ, &hkeyFiles);
|
|
|
|
if ( lResult != ERROR_SUCCESS ) // if no files, maybe there's Java
|
|
return hr;
|
|
|
|
while ((lResult = RegEnumValue(hkeyFiles, cFilesEnum++, szDUFileName,
|
|
&dwStrSize, NULL, NULL, NULL, NULL)) == ERROR_SUCCESS)
|
|
{
|
|
TCHAR szPath[MAX_PATH + 1];
|
|
CFileNode *pFileNode;
|
|
|
|
lstrcpyn(szPath, szDUFileName, MAX_PATH);
|
|
TCHAR *szFName = ReverseStrchr(szPath, '\\');
|
|
|
|
Assert(szFName != NULL);
|
|
// long ago and far away, in the IE4, PP1-2 timeframe, there was a horrible
|
|
// bug that corrupted these entries on Memphis and NT5. We suspect that GetLongPathName
|
|
// was doing something wrong for code download, but repro scenarios were not
|
|
// to be found. Anywho, the damaged registries are out there, so we need to
|
|
// cope with them more gracefully than faulting at the *szFName = NULL;
|
|
if ( szFName == NULL )
|
|
continue;
|
|
|
|
*szFName = NULL;
|
|
szFName++;
|
|
|
|
pFileNode = new CFileNode(szFName, "", szPath);
|
|
if (pFileNode == NULL)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
break;
|
|
}
|
|
|
|
// create and add node to list
|
|
if (m_pHeadFileList == NULL)
|
|
{
|
|
m_pHeadFileList = pFileNode;
|
|
m_pCurFileNode = m_pHeadFileList;
|
|
}
|
|
else
|
|
{
|
|
hr = m_pCurFileNode->Insert(pFileNode);
|
|
m_pCurFileNode = m_pCurFileNode->GetNextFileNode();
|
|
}
|
|
dwStrSize = MAX_PATH;
|
|
}
|
|
|
|
RegCloseKey( hkeyFiles );
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CParseInf::BuildDUPackageList( HKEY hKeyDU )
|
|
{
|
|
HRESULT hr = S_OK;
|
|
LRESULT lResult;
|
|
HKEY hkeyJava;
|
|
ICreateJavaPackageMgr *picjpm;
|
|
|
|
|
|
DestroyPackageList();
|
|
|
|
lResult = RegOpenKeyEx(hKeyDU, REGSTR_DU_CONTAINS_JAVA, 0,
|
|
KEY_READ, &hkeyJava);
|
|
|
|
if ( lResult != ERROR_SUCCESS ) // it's OK if there's no Java
|
|
return hr;
|
|
|
|
if ( !m_bCoInit )
|
|
m_bCoInit = SUCCEEDED(hr = CoInitialize(NULL));
|
|
|
|
if ( m_bCoInit )
|
|
{
|
|
hr=CoCreateInstance(CLSID_JavaPackageManager,NULL,CLSCTX_INPROC_SERVER,
|
|
IID_ICreateJavaPackageMgr,(LPVOID *) &picjpm);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = picjpm->GetPackageManager(&m_pijpm);
|
|
picjpm->Release();
|
|
}
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
return S_OK; // hr; // quietly fail until we're sure the JavaVM with package manager support is in the build.
|
|
|
|
// list the packages under Contains/Java - these are in the gobal namespace
|
|
hr = BuildNamespacePackageList(hkeyJava, "");
|
|
|
|
// add packages for each namespace key under Contains\Java
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
DWORD dwIndex;
|
|
TCHAR szNamespace[MAX_PATH + 1]; //
|
|
DWORD dwStrSize;
|
|
|
|
for ( dwIndex = 0, dwStrSize = MAX_PATH;
|
|
RegEnumKey( hkeyJava, dwIndex, szNamespace, dwStrSize ) == ERROR_SUCCESS &&
|
|
SUCCEEDED(hr);
|
|
dwIndex++, dwStrSize = MAX_PATH )
|
|
{
|
|
HKEY hkeyNamespace;
|
|
|
|
lResult = RegOpenKeyEx(hkeyJava, szNamespace, 0, KEY_READ, &hkeyNamespace);
|
|
if ( lResult == ERROR_SUCCESS )
|
|
{
|
|
hr = BuildNamespacePackageList(hkeyNamespace, szNamespace );
|
|
RegCloseKey( hkeyNamespace );
|
|
}
|
|
else
|
|
{
|
|
hr = HRESULT_FROM_WIN32(lResult);
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
RegCloseKey( hkeyJava );
|
|
|
|
m_bHasJava = m_pHeadPackageList != NULL;
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CParseInf::BuildNamespacePackageList( HKEY hKeyNS, LPCTSTR szNamespace )
|
|
{
|
|
HRESULT hr = S_OK;
|
|
LRESULT lResult;
|
|
int cPackagesEnum = 0;
|
|
TCHAR szDUPackageName[MAX_PATH + 1];
|
|
DWORD dwStrSize = MAX_PATH;
|
|
BOOL fIsSystemClass = FALSE;
|
|
|
|
while ((lResult = RegEnumValue(hKeyNS, cPackagesEnum++, szDUPackageName,
|
|
&dwStrSize, NULL, NULL, NULL, NULL)) == ERROR_SUCCESS)
|
|
{
|
|
IJavaPackage *pijp;
|
|
|
|
#ifndef UNICODE
|
|
MAKE_WIDEPTR_FROMANSI(swzPackage, szDUPackageName );
|
|
MAKE_WIDEPTR_FROMANSI(swzNamespace, szNamespace );
|
|
#else
|
|
OLESTR swzPackage = szDUPackageName;
|
|
OLESTR swzNamespace = szNamespace;
|
|
#endif
|
|
hr = m_pijpm->GetPackage( swzPackage,
|
|
((*szNamespace == '\0')? NULL : swzNamespace),
|
|
&pijp );
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
BSTR bstrPath;
|
|
|
|
hr = pijp->GetFilePath( &bstrPath );
|
|
if ( SUCCEEDED(hr) ) {
|
|
CPackageNode *pPackageNode;
|
|
|
|
pPackageNode = new CPackageNode(szDUPackageName, szNamespace);
|
|
if (pPackageNode == NULL)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
pijp->Release();
|
|
break;
|
|
}
|
|
#ifndef UNICODE
|
|
MAKE_ANSIPTR_FROMWIDE(szPath, bstrPath );
|
|
#else
|
|
TCHAR *szPath = bstrPath;
|
|
#endif
|
|
pPackageNode->SetPath( szPath );
|
|
|
|
pijp->IsSystemClass(&fIsSystemClass);
|
|
pPackageNode->SetIsSystemClass(fIsSystemClass);
|
|
|
|
if (m_pHeadPackageList == NULL)
|
|
{
|
|
m_pHeadPackageList = pPackageNode;
|
|
m_pCurPackageNode = m_pHeadPackageList;
|
|
}
|
|
else
|
|
{
|
|
hr = m_pCurPackageNode->Insert(pPackageNode);
|
|
m_pCurPackageNode = m_pCurPackageNode->GetNextPackageNode();
|
|
}
|
|
|
|
SysFreeString( bstrPath );
|
|
pijp->Release(); // we're done with the package
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_dwStatus = STATUS_CTRL_DAMAGED;
|
|
hr = S_OK; // don't barf if this doesn't work, some villain might have uninstalled it
|
|
}
|
|
|
|
dwStrSize = MAX_PATH;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT CParseInf::DoParseDU(LPCTSTR szOCXFileName, LPCTSTR szCLSID)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
TCHAR szFileName[MAX_PATH];
|
|
TCHAR szDUSvrName[MAX_PATH];
|
|
const TCHAR *pszSvrFile = NULL;
|
|
DWORD dwFileSize = 0;
|
|
HKEY hKeyFiles = 0;
|
|
HKEY hKeyDU = 0;
|
|
HKEY hKeyDLInfo = 0;
|
|
TCHAR szDistUnit[MAX_REGPATH_LEN];
|
|
HRESULT lResult;
|
|
CFileNode *pFileNode = NULL;
|
|
DWORD dwExpire;
|
|
DWORD dw;
|
|
|
|
Assert(szCLSID != NULL);
|
|
|
|
// Since this function was called, we must be a distribution unit.
|
|
// Set a member flag so that all other member functions realize that
|
|
// we are really part of a DU now.
|
|
|
|
m_bIsDistUnit = TRUE;
|
|
|
|
// initialization
|
|
|
|
if ( szOCXFileName != NULL )
|
|
lstrcpyn(m_szFileName, szOCXFileName, ARRAYSIZE(m_szFileName));
|
|
lstrcpyn(m_szCLSID, szCLSID, ARRAYSIZE(m_szCLSID));
|
|
Init();
|
|
|
|
// Add files from ...\Distribution Units\{Name}\Contains\Files
|
|
CatPathStrN( szDistUnit, REGSTR_PATH_DIST_UNITS, szCLSID, ARRAYSIZE(szDistUnit));
|
|
|
|
lResult = RegOpenKeyEx(HKEY_LOCAL_MACHINE, szDistUnit, 0, KEY_READ,
|
|
&hKeyDU);
|
|
if (lResult != ERROR_SUCCESS)
|
|
{
|
|
hr = E_FAIL;
|
|
goto ExitDoParseDU;
|
|
}
|
|
|
|
hr = BuildDUFileList( hKeyDU );
|
|
if (FAILED(hr))
|
|
{
|
|
goto ExitDoParseDU;
|
|
}
|
|
|
|
hr = BuildDUPackageList( hKeyDU );
|
|
if (FAILED(hr))
|
|
{
|
|
goto ExitDoParseDU;
|
|
}
|
|
|
|
// Now add the OSD and INF files
|
|
|
|
lResult = RegOpenKeyEx(hKeyDU, REGSTR_DOWNLOAD_INFORMATION, 0,
|
|
KEY_READ, &hKeyDLInfo);
|
|
if (lResult == ERROR_SUCCESS)
|
|
{
|
|
TCHAR *pFileName = NULL;
|
|
TCHAR szBuffer[MAX_PATH + 1];
|
|
|
|
dw = MAX_PATH;
|
|
lResult = RegQueryValueEx(hKeyDLInfo, REGSTR_VALUE_INF, NULL, NULL,
|
|
(unsigned char*)szBuffer, &dw);
|
|
if (lResult == ERROR_SUCCESS)
|
|
{
|
|
pFileName = ReverseStrchr(szBuffer, '\\');
|
|
if (pFileName != NULL)
|
|
{
|
|
pFileName++;
|
|
|
|
// set INF member variable
|
|
lstrcpyn(m_szInf, szBuffer, ARRAYSIZE(m_szInf));
|
|
|
|
pFileNode = new CFileNode(szBuffer, "", NULL);
|
|
if (pFileNode == NULL)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto ExitDoParseDU;
|
|
}
|
|
|
|
// create and add node to list
|
|
if (m_pHeadFileList == NULL)
|
|
{
|
|
m_pHeadFileList = pFileNode;
|
|
m_pCurFileNode = m_pHeadFileList;
|
|
}
|
|
else
|
|
{
|
|
hr = m_pCurFileNode->Insert(pFileNode);
|
|
m_pCurFileNode = m_pCurFileNode->GetNextFileNode();
|
|
}
|
|
}
|
|
}
|
|
|
|
pFileName = NULL;
|
|
dw = MAX_PATH;
|
|
lResult = RegQueryValueEx(hKeyDLInfo, REGSTR_VALUE_OSD, NULL, NULL,
|
|
(unsigned char*)szBuffer, &dw);
|
|
if (lResult == ERROR_SUCCESS)
|
|
{
|
|
pFileName = ReverseStrchr(szBuffer, '\\');
|
|
if (pFileName != NULL)
|
|
{
|
|
pFileName++;
|
|
pFileNode = new CFileNode(szBuffer, "", NULL);
|
|
// create and add node to list
|
|
if (m_pHeadFileList == NULL)
|
|
{
|
|
m_pHeadFileList = pFileNode;
|
|
m_pCurFileNode = m_pHeadFileList;
|
|
}
|
|
else
|
|
{
|
|
hr = m_pCurFileNode->Insert(pFileNode);
|
|
m_pCurFileNode = m_pCurFileNode->GetNextFileNode();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// See if there's an Expire value, and if so, override the default/general expire.
|
|
dw = sizeof(DWORD);
|
|
dwExpire = 0;
|
|
if ( RegQueryValueEx(hKeyDU, REGSTR_VALUE_EXPIRE, NULL, NULL, (LPBYTE)&dwExpire, &dw) == ERROR_SUCCESS )
|
|
{
|
|
if ( dwExpire )
|
|
m_cExpireDays = dwExpire;
|
|
else
|
|
GetDaysBeforeExpireAuto(&m_cExpireDays);
|
|
}
|
|
|
|
// Find out where COM thinks our CLSID is, and what the server name is.
|
|
if ( FGetCLSIDFile( szDUSvrName, szCLSID ) )
|
|
{
|
|
m_bHasActiveX = TRUE;
|
|
pszSvrFile = PathFindFileName(szDUSvrName);
|
|
}
|
|
else
|
|
szDUSvrName[0] = '\0';
|
|
|
|
|
|
for (m_pCurFileNode = m_pHeadFileList;
|
|
m_pCurFileNode != NULL;
|
|
m_pCurFileNode = m_pCurFileNode->GetNextFileNode(), hr = S_OK)
|
|
{
|
|
const TCHAR *pszPath = m_pCurFileNode->GetPath();
|
|
|
|
if (pszPath != NULL)
|
|
{
|
|
CatPathStrN( szFileName, m_pCurFileNode->GetPath(), m_pCurFileNode->GetName(), ARRAYSIZE(szFileName));
|
|
}
|
|
else
|
|
{
|
|
lstrcpyn(szFileName, m_pCurFileNode->GetName(),ARRAYSIZE(szFileName));
|
|
}
|
|
|
|
if (SUCCEEDED(hr = GetSizeOfFile(szFileName, &dwFileSize)))
|
|
{
|
|
if (pszPath == NULL ||
|
|
IsModuleRemovable(szFileName) ||
|
|
lstrcmpi(szFileName, m_szFileName) == 0)
|
|
{
|
|
m_dwFileSizeSaved += dwFileSize;
|
|
}
|
|
|
|
// only play with the status if we haven't already flagged the installation
|
|
// as damaged and we're looking at the the file that should be the host for
|
|
// our control, if any.
|
|
if ( m_dwStatus != STATUS_CTRL_DAMAGED && pszSvrFile != NULL &&
|
|
lstrcmpi( pszSvrFile, m_pCurFileNode->GetName() ) == 0 )
|
|
{
|
|
TCHAR szDUSvrNameSPN[MAX_PATH];
|
|
TCHAR szFileNameSPN[MAX_PATH];
|
|
|
|
GetShortPathName(szDUSvrName, szDUSvrNameSPN, MAX_PATH);
|
|
GetShortPathName(szFileName, szFileNameSPN, MAX_PATH);
|
|
|
|
if ( lstrcmpi( szDUSvrNameSPN, szFileNameSPN ) == 0 )
|
|
m_dwStatus = STATUS_CTRL_INSTALLED; // no, we're not unplugged
|
|
else // server and our file are in different directories - unplugged scenario
|
|
m_dwStatus = STATUS_CTRL_UNPLUGGED;
|
|
}
|
|
|
|
m_dwTotalFileSize += dwFileSize;
|
|
} else if ( !PathFileExists( szFileName ) ) // if a DU file is missing, then the installation is damaged.
|
|
m_dwStatus = STATUS_CTRL_DAMAGED;
|
|
|
|
m_nTotalFiles += 1;
|
|
}
|
|
|
|
// If we're still unsure, and there are packages, then this is a pure Java
|
|
// DU and will say we're installed unless a check of the package files indicates otherwise.
|
|
if ( m_pHeadPackageList != NULL && m_dwStatus == STATUS_CTRL_UNKNOWN )
|
|
m_dwStatus = STATUS_CTRL_INSTALLED;
|
|
|
|
// Accumulate package sizes and such into our running total
|
|
for (m_pCurPackageNode = m_pHeadPackageList;
|
|
m_pCurPackageNode != NULL;
|
|
m_pCurPackageNode = m_pCurPackageNode->GetNextPackageNode(), hr = S_OK)
|
|
{
|
|
// the files can hold more than one of our packages, so only add a package
|
|
// path file to the totals if we haven't already counted it.
|
|
// N^2 to be sure, but the numbers will be small.
|
|
CPackageNode *ppn;
|
|
LPCTSTR szPackagePath = m_pCurPackageNode->GetPath();
|
|
BOOL bAlreadySeen = FALSE;
|
|
|
|
for ( ppn = m_pHeadPackageList;
|
|
ppn != m_pCurPackageNode && !bAlreadySeen;
|
|
ppn = ppn->GetNextPackageNode() )
|
|
bAlreadySeen = lstrcmp( szPackagePath, ppn->GetPath() ) == 0;
|
|
if ( bAlreadySeen )
|
|
continue;
|
|
|
|
// Must be a new file,
|
|
if ( SUCCEEDED(GetSizeOfFile(szPackagePath, &dwFileSize)) )
|
|
{
|
|
m_dwFileSizeSaved += dwFileSize;
|
|
m_dwTotalFileSize += dwFileSize;
|
|
}
|
|
else
|
|
m_dwStatus = STATUS_CTRL_DAMAGED;
|
|
|
|
// m_nTotalFiles += 1; don't count these files, or the dependency file list will have a bunch of blank entries
|
|
}
|
|
|
|
// Some DUs, like SportsZone or Shockwave, have no Contains subkeys.
|
|
// If status is still unknown here, but the server is in place, consider it
|
|
// installed.
|
|
if ( m_dwStatus == STATUS_CTRL_UNKNOWN && PathFileExists( szDUSvrName ) )
|
|
m_dwStatus = STATUS_CTRL_INSTALLED;
|
|
|
|
ExitDoParseDU:
|
|
|
|
if (hKeyDU)
|
|
{
|
|
RegCloseKey(hKeyDU);
|
|
}
|
|
|
|
if (hKeyDLInfo)
|
|
{
|
|
RegCloseKey(hKeyDLInfo);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// CParseInf::IsSectionInINF
|
|
// Checks if a section is in the INF
|
|
// returns:
|
|
// S_OK: lpCurCode has the satellite binary name
|
|
// S_FALSE: ignore this code and use default resources in main dll
|
|
// E_XXX: any other error
|
|
BOOL
|
|
CParseInf::IsSectionInINF(
|
|
LPCSTR lpCurCode)
|
|
{
|
|
const char *szDefault = "";
|
|
DWORD len;
|
|
#define FAKE_BUF_SIZE 3
|
|
char szBuf[FAKE_BUF_SIZE];
|
|
|
|
len = GetPrivateProfileString(lpCurCode, NULL, szDefault,
|
|
szBuf, FAKE_BUF_SIZE, m_szInf);
|
|
|
|
if (len == (FAKE_BUF_SIZE - 2)) { // returns Out Of Buffer Space?
|
|
// yes, section found
|
|
return TRUE;
|
|
} else {
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
// loop through the keys in [Add.Code} section and enumerate the
|
|
// files and their corresponding sections.
|
|
HRESULT CParseInf::HandleSatellites(LPCTSTR pszFileName)
|
|
{
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
// BEGIN NOTE: add vars and values in matching order
|
|
// add a var by adding a new define VAR_NEW_VAR = NUM_VARS++
|
|
const char *szVars[] = {
|
|
|
|
#define VAR_LANG 0 // expands to 3 letter lang code based on lcid
|
|
"%LANG%",
|
|
|
|
#define NUM_VARS 1
|
|
|
|
""
|
|
};
|
|
|
|
const char *szValues[NUM_VARS + 1];
|
|
szValues[VAR_LANG] = "***"; // unint magic
|
|
szValues[NUM_VARS] = NULL;
|
|
// END NOTE: add vars and values in matching order
|
|
|
|
// look for and substitute variables like %EXTRACT_DIR%
|
|
// and expand out the command line
|
|
|
|
TCHAR szSectionName[MAX_PATH];
|
|
TCHAR szSectionNameCopy[MAX_PATH];
|
|
hr = ExpandCommandLine(pszFileName, szSectionName, MAX_PATH, szVars, szValues);
|
|
|
|
if (hr != S_OK)
|
|
return hr; // no vars to expand ignore section
|
|
|
|
lstrcpy(szSectionNameCopy, szSectionName); // preserve
|
|
|
|
|
|
// OK, this is a satellite DLL. Now we need to find the section(s) that
|
|
// got installed.
|
|
|
|
// we first enum the registry's Module Usage looking for DLLs that were
|
|
// installed by (or used by) this CLSID. For each of those we need to
|
|
// check if the base filename matches the pattern of the section,
|
|
// if it does then we process those sections
|
|
|
|
DWORD iSubKey = 0;
|
|
TCHAR szModName[MAX_PATH];
|
|
|
|
while ( SUCCEEDED(hr = FindDLLInModuleUsage( szModName, m_szCLSID, iSubKey)) ) {
|
|
|
|
if (PatternMatch(szModName, szSectionName) &&
|
|
IsSectionInINF(szSectionName) ) {
|
|
|
|
// create new node
|
|
|
|
CFileNode *pFileNode = new CFileNode(szSectionName, szSectionName);
|
|
if (pFileNode == NULL)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto Exit;
|
|
}
|
|
|
|
// don't insert file into list if it's path cannot be found
|
|
if (FAILED(GetFilePath(pFileNode)))
|
|
{
|
|
delete pFileNode;
|
|
continue;
|
|
}
|
|
|
|
// create and add node to list
|
|
if (m_pHeadFileList == NULL)
|
|
{
|
|
m_pHeadFileList = pFileNode;
|
|
m_pCurFileNode = m_pHeadFileList;
|
|
}
|
|
else if (SUCCEEDED(hr = m_pCurFileNode->Insert(pFileNode)))
|
|
{
|
|
m_pCurFileNode = m_pCurFileNode->GetNextFileNode();
|
|
}
|
|
else
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
lstrcpy(szSectionName, szSectionNameCopy); // restore
|
|
|
|
|
|
}
|
|
}
|
|
|
|
if ( hr == HRESULT_FROM_WIN32(ERROR_NO_MORE_ITEMS)) {
|
|
hr = S_OK;
|
|
}
|
|
|
|
Exit:
|
|
|
|
return hr;
|
|
|
|
}
|
|
|
|
// loop through the keys in [Add.Code} section and enumerate the
|
|
// files and their corresponding sections.
|
|
HRESULT CParseInf::EnumSections()
|
|
{
|
|
HRESULT hr = S_OK;
|
|
TCHAR szSectionBuffer[MAX_INF_SECTION_SIZE];
|
|
TCHAR szValueBuffer[MAX_PATH];
|
|
TCHAR *pszFileName = NULL;
|
|
CFileNode *pFileNode = NULL;
|
|
DWORD dwLen = GetPrivateProfileString(
|
|
KEY_ADDCODE,
|
|
NULL,
|
|
DEFAULT_VALUE,
|
|
szSectionBuffer,
|
|
MAX_INF_SECTION_SIZE,
|
|
m_szInf);
|
|
if (dwLen == 0)
|
|
{
|
|
// if inf file or [Add.Code] section
|
|
// does not exist, just delete the OCX
|
|
|
|
Assert (m_pHeadFileList == NULL);
|
|
|
|
// separate file name from its directory
|
|
Assert( lstrlen(m_szFileName) < ARRAYSIZE(szValueBuffer) );
|
|
lstrcpy(szValueBuffer, m_szFileName);
|
|
TCHAR *szName = ReverseStrchr(szValueBuffer, '\\');
|
|
Assert (szName != NULL);
|
|
if (szName == NULL)
|
|
{
|
|
hr = E_UNEXPECTED;
|
|
goto ExitEnumSections;
|
|
}
|
|
|
|
// create a node of the OCX and put it in a linked list
|
|
m_pHeadFileList = new CFileNode(szName + 1, DEFAULT_VALUE);
|
|
if (m_pHeadFileList == NULL)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto ExitEnumSections;
|
|
}
|
|
m_pCurFileNode = m_pHeadFileList;
|
|
|
|
*szName = '\0';
|
|
if (FAILED(hr = m_pHeadFileList->SetPath(szValueBuffer)))
|
|
{
|
|
goto ExitEnumSections;
|
|
}
|
|
hr = S_FALSE;
|
|
goto ExitEnumSections;
|
|
}
|
|
|
|
// For OCX's that have an INF file and [Add.Code] section, loop
|
|
// through the section to get filenames and section names. Store
|
|
// each file and its section in a node and add the node to a
|
|
// linked list
|
|
|
|
for (pszFileName = szSectionBuffer;
|
|
pszFileName[0] != '\0';
|
|
pszFileName += lstrlen(pszFileName) + 1)
|
|
{
|
|
dwLen = GetPrivateProfileString(
|
|
KEY_ADDCODE,
|
|
pszFileName,
|
|
DEFAULT_VALUE,
|
|
szValueBuffer,
|
|
MAX_PATH,
|
|
m_szInf);
|
|
|
|
// skip the file if no section is specified for it
|
|
if (dwLen == 0) {
|
|
continue;
|
|
}
|
|
|
|
if (StrChr(pszFileName, '%')) {
|
|
// if section not found and it contains a %
|
|
// could be a variable like %LANG% that gets
|
|
// substituted to install satellite DLLs
|
|
|
|
// check if it has any vars that we know about
|
|
// and expand them and add filenodes if reqd.
|
|
|
|
if (HandleSatellites(pszFileName) == S_OK) {
|
|
|
|
// if this expanded to a satellite dll name then
|
|
// we would have already added that
|
|
// as a node in HandleSatellites
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
// create new node
|
|
pFileNode = new CFileNode(pszFileName, szValueBuffer);
|
|
if (pFileNode == NULL)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto ExitEnumSections;
|
|
}
|
|
|
|
// don't insert file into list if it's path cannot be found
|
|
if (FAILED(GetFilePath(pFileNode)))
|
|
{
|
|
delete pFileNode;
|
|
continue;
|
|
}
|
|
|
|
// create and add node to list
|
|
if (m_pHeadFileList == NULL)
|
|
{
|
|
m_pHeadFileList = pFileNode;
|
|
m_pCurFileNode = m_pHeadFileList;
|
|
}
|
|
else if (SUCCEEDED(hr = m_pCurFileNode->Insert(pFileNode)))
|
|
{
|
|
m_pCurFileNode = m_pCurFileNode->GetNextFileNode();
|
|
}
|
|
else
|
|
{
|
|
goto ExitEnumSections;
|
|
}
|
|
}
|
|
|
|
// include inf file into file list
|
|
|
|
if (m_pHeadFileList && m_pCurFileNode)
|
|
{
|
|
hr = m_pCurFileNode->Insert(new CFileNode(m_szInf, DEFAULT_VALUE));
|
|
if (SUCCEEDED(hr))
|
|
m_pCurFileNode = m_pCurFileNode->GetNextFileNode();
|
|
}
|
|
|
|
ExitEnumSections:
|
|
|
|
return hr;
|
|
}
|
|
|
|
// Loop through all the sections in [Setup Hooks]. For each
|
|
// section, call ParseUninstallSection to find its UNINSTALL section
|
|
// and execute it.
|
|
HRESULT CParseInf::ParseSetupHook()
|
|
{
|
|
HRESULT hr = S_FALSE; // Return S_FALSE if we don't run into any errors, but also don't do any work.
|
|
TCHAR szSectionBuffer[MAX_INF_SECTION_SIZE];
|
|
TCHAR szSection[MAX_PATH];
|
|
TCHAR *pszKey = NULL;
|
|
|
|
DWORD dwLen = GetPrivateProfileString(
|
|
KEY_SETUPHOOK,
|
|
NULL,
|
|
DEFAULT_VALUE,
|
|
szSectionBuffer,
|
|
MAX_INF_SECTION_SIZE,
|
|
m_szInf);
|
|
|
|
// no Setup Hook section found
|
|
if (dwLen == 0)
|
|
goto EXITPARSESETUPHOOK;
|
|
|
|
for (pszKey = szSectionBuffer;
|
|
pszKey[0] != '\0';
|
|
pszKey += lstrlen(pszKey) + 1)
|
|
{
|
|
// For each key, get the section and run the section with RunSetupCommand
|
|
|
|
dwLen = GetPrivateProfileString(
|
|
KEY_SETUPHOOK,
|
|
pszKey,
|
|
DEFAULT_VALUE,
|
|
szSection,
|
|
MAX_PATH,
|
|
m_szInf);
|
|
|
|
if (dwLen == 0)
|
|
continue;
|
|
|
|
hr = ParseUninstallSection(szSection);
|
|
if (FAILED(hr))
|
|
goto EXITPARSESETUPHOOK;
|
|
}
|
|
|
|
EXITPARSESETUPHOOK:
|
|
return hr;
|
|
}
|
|
|
|
// Go to each file's section, find its conditional hook section, then
|
|
// call ParseUninstallSection to execute the conditional hook section.
|
|
HRESULT CParseInf::ParseConditionalHook()
|
|
{
|
|
HRESULT hr = S_FALSE; // Return S_FALSE if we don't run into any errors, but also don't do any work.
|
|
TCHAR szHookSection[MAX_PATH];
|
|
const TCHAR *pszSection = NULL;
|
|
CFileNode *pNode = NULL;
|
|
|
|
if (m_pHeadFileList == NULL)
|
|
{
|
|
hr = S_FALSE;
|
|
goto EXITPARSECONDITIONALHOOK;
|
|
}
|
|
|
|
pNode = m_pHeadFileList;
|
|
for (pNode = m_pHeadFileList; pNode != NULL; pNode = pNode->GetNextFileNode())
|
|
{
|
|
pszSection = pNode->GetSection();
|
|
if (pszSection == NULL)
|
|
continue;
|
|
|
|
if (GetPrivateProfileString(
|
|
pszSection,
|
|
KEY_HOOK,
|
|
DEFAULT_VALUE,
|
|
szHookSection,
|
|
MAX_PATH,
|
|
m_szInf) == 0)
|
|
continue;
|
|
|
|
hr = ParseUninstallSection(szHookSection);
|
|
if (FAILED(hr))
|
|
goto EXITPARSECONDITIONALHOOK;
|
|
}
|
|
|
|
EXITPARSECONDITIONALHOOK:
|
|
return hr;
|
|
}
|
|
|
|
// Given a file section, find its UNINSTALL section, go to the
|
|
// section and executes the commands there
|
|
HRESULT CParseInf::ParseUninstallSection(LPCTSTR lpszSection)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
TCHAR szUninstallSection[MAX_PATH];
|
|
TCHAR szBuf[MAX_PATH];
|
|
TCHAR szInfSection[MAX_PATH];
|
|
TCHAR szCacheDir[MAX_PATH];
|
|
HANDLE hExe = INVALID_HANDLE_VALUE;
|
|
HINSTANCE hInst = NULL;
|
|
|
|
// check for "UNINSTALL" key
|
|
DWORD dwLen = GetPrivateProfileString(
|
|
lpszSection,
|
|
KEY_UNINSTALL,
|
|
DEFAULT_VALUE,
|
|
szUninstallSection,
|
|
ARRAYSIZE(szUninstallSection),
|
|
m_szInf);
|
|
|
|
// UNINSTALL key not found, quit.
|
|
if (dwLen == 0)
|
|
{
|
|
return S_FALSE;
|
|
}
|
|
|
|
// There are 4 possible combinations inside the uninstall section
|
|
// 1) Both inffile and infsection are specified -> simply to go those
|
|
// 2) Only inffile is given -> go to inffile and do DefaultInstall
|
|
// 3) Only infsection is given -> do infsection in this inf file
|
|
// 4) Nothing is specified -> simply do this section
|
|
|
|
GetDirectory(GD_EXTRACTDIR, szCacheDir, ARRAYSIZE(szCacheDir), m_szFileName);
|
|
|
|
lstrcpyn(szBuf, szCacheDir, MAX_PATH - 1);
|
|
lstrcat(szBuf, TEXT("\\"));
|
|
|
|
int cch = lstrlen(szBuf);
|
|
|
|
dwLen = GetPrivateProfileString(
|
|
szUninstallSection,
|
|
KEY_INFFILE,
|
|
DEFAULT_VALUE,
|
|
szBuf + cch,
|
|
MAX_PATH - cch,
|
|
m_szInf);
|
|
|
|
if (dwLen == 0)
|
|
{
|
|
szBuf[0] = '\0';
|
|
}
|
|
|
|
// get inf section
|
|
dwLen = GetPrivateProfileString(
|
|
szUninstallSection,
|
|
KEY_INFSECTION,
|
|
DEFAULT_VALUE,
|
|
szInfSection,
|
|
ARRAYSIZE(szInfSection),
|
|
m_szInf);
|
|
|
|
if (dwLen == 0)
|
|
{
|
|
if (szBuf[0] != '\0')
|
|
lstrcpyn(szInfSection, KEY_DEFAULTUNINSTALL,ARRAYSIZE(szInfSection));
|
|
else
|
|
{
|
|
lstrcpyn(szBuf, m_szInf,ARRAYSIZE(szBuf));
|
|
lstrcpyn(szInfSection, szUninstallSection,ARRAYSIZE(szInfSection));
|
|
}
|
|
}
|
|
|
|
// load advpack.dll and call RunSetupCommand() to process
|
|
// any special uninstall commands
|
|
|
|
hr = STG_E_FILENOTFOUND;
|
|
|
|
HINSTANCE hinstAdvPack = LoadLibrary(TEXT("ADVPACK.DLL"));
|
|
if (hinstAdvPack)
|
|
{
|
|
RUNSETUPCOMMAND pfnRunSetup = (RUNSETUPCOMMAND)GetProcAddress(
|
|
hinstAdvPack, achRUNSETUPCOMMANDFUNCTION);
|
|
if (pfnRunSetup)
|
|
{
|
|
hr = pfnRunSetup(NULL, szBuf, szInfSection,
|
|
szCacheDir, NULL, &hExe, 1, NULL);
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
// For each file specified in the INF file, find its
|
|
// path in this order
|
|
// 1) OCX path
|
|
// 2) System dir
|
|
// 3) Windows dir
|
|
// 4) PATH directories
|
|
HRESULT CParseInf::GetFilePath(CFileNode *pFileNode)
|
|
{
|
|
Assert (pFileNode != NULL);
|
|
HRESULT hr = S_OK;
|
|
TCHAR szValueBuf[MAX_PATH];
|
|
TCHAR *pszPathPtr = NULL;
|
|
TCHAR *pszPathEnv = NULL;
|
|
TCHAR *pchPathEnd = NULL;
|
|
DWORD dwLenPATH = 0;
|
|
|
|
// ocx directory
|
|
hr = GetDirectory(GD_EXTRACTDIR, szValueBuf, ARRAYSIZE(szValueBuf), m_szFileName);
|
|
CatPathStrN( szValueBuf, szValueBuf, pFileNode->GetName(), ARRAYSIZE(szValueBuf));
|
|
|
|
// if file being searched for now is the OCX itself, just leave
|
|
if (lstrcmpi(szValueBuf, m_szFileName) == 0)
|
|
{
|
|
goto EXITGETFILEPATH;
|
|
}
|
|
|
|
if (SUCCEEDED(hr) &&
|
|
SUCCEEDED(LookUpModuleUsage(szValueBuf, m_szCLSID)))
|
|
{
|
|
goto EXITGETFILEPATH;
|
|
}
|
|
|
|
// system directory
|
|
hr = GetDirectory(GD_SYSTEMDIR, szValueBuf, ARRAYSIZE(szValueBuf));
|
|
if (SUCCEEDED(hr) && CatPathStrN( szValueBuf, szValueBuf, pFileNode->GetName(), ARRAYSIZE(szValueBuf)) &&
|
|
SUCCEEDED(LookUpModuleUsage(szValueBuf, m_szCLSID)))
|
|
{
|
|
goto EXITGETFILEPATH;
|
|
}
|
|
|
|
// windows directory
|
|
hr = GetDirectory(GD_WINDOWSDIR, szValueBuf, ARRAYSIZE(szValueBuf));
|
|
if (SUCCEEDED(hr) && CatPathStrN( szValueBuf, szValueBuf, pFileNode->GetName(), ARRAYSIZE(szValueBuf)) &&
|
|
SUCCEEDED(LookUpModuleUsage(szValueBuf, m_szCLSID)))
|
|
{
|
|
goto EXITGETFILEPATH;
|
|
}
|
|
|
|
// get PATH envirnment variable
|
|
dwLenPATH = GetEnvironmentVariable(ENV_PATH, szValueBuf, 0);
|
|
if (dwLenPATH == 0)
|
|
{
|
|
hr = E_FAIL;
|
|
goto EXITGETFILEPATH;
|
|
}
|
|
|
|
pszPathEnv = new TCHAR[dwLenPATH];
|
|
if (pszPathEnv == NULL)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto EXITGETFILEPATH;
|
|
}
|
|
GetEnvironmentVariable(ENV_PATH, pszPathEnv, dwLenPATH);
|
|
pchPathEnd = pszPathPtr = pszPathEnv;
|
|
|
|
// walk all directories in PATH and see if file is found
|
|
// in any of them
|
|
while (pchPathEnd != NULL)
|
|
{
|
|
pchPathEnd = StrChr(pszPathPtr, ';');
|
|
if (pchPathEnd != NULL)
|
|
*pchPathEnd = '\0';
|
|
|
|
CatPathStrN( szValueBuf, pszPathPtr, pFileNode->GetName(), ARRAYSIZE(szValueBuf));
|
|
|
|
if (SUCCEEDED(LookUpModuleUsage(szValueBuf, m_szCLSID)))
|
|
goto EXITGETFILEPATH;
|
|
|
|
if (pchPathEnd != NULL)
|
|
*(pchPathEnd++) = ';';
|
|
|
|
pszPathPtr = pchPathEnd;
|
|
}
|
|
|
|
// file not found anywhere
|
|
hr = E_FAIL;
|
|
|
|
EXITGETFILEPATH:
|
|
|
|
if (pszPathEnv != NULL)
|
|
delete [] pszPathEnv;
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = NullLastSlash(szValueBuf, 0);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pFileNode->SetPath(szValueBuf);
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CParseInf::CheckFilesRemovability(void)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
TCHAR szFullName[MAX_PATH];
|
|
const TCHAR *pszPath = NULL;
|
|
BOOL bFileExist;
|
|
|
|
// Walk through every file and see if it is deletable. If so,
|
|
// then check if for sharing violations on that file.
|
|
for (m_pCurFileNode = m_pHeadFileList;
|
|
m_pCurFileNode != NULL && SUCCEEDED(hr);
|
|
m_pCurFileNode = m_pCurFileNode->GetNextFileNode())
|
|
{
|
|
pszPath = m_pCurFileNode->GetPath();
|
|
if (pszPath == NULL || pszPath[0] == '\0')
|
|
continue;
|
|
|
|
CatPathStrN( szFullName, pszPath, m_pCurFileNode->GetName(), ARRAYSIZE(szFullName) );
|
|
|
|
if (IsModuleRemovable(szFullName))
|
|
{
|
|
HANDLE h = CreateFile(
|
|
szFullName,
|
|
GENERIC_READ|GENERIC_WRITE,
|
|
0,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL|FILE_FLAG_NO_BUFFERING,
|
|
NULL);
|
|
if (h == INVALID_HANDLE_VALUE)
|
|
{
|
|
bFileExist = (GetLastError() != ERROR_FILE_NOT_FOUND);
|
|
if (bFileExist)
|
|
{
|
|
hr = STG_E_SHAREVIOLATION;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CloseHandle(h);
|
|
m_pCurFileNode->SetRemovable( TRUE );
|
|
}
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CParseInf::CheckLegacyRemovability(LONG *cOldSharedCount )
|
|
{
|
|
HRESULT hr = S_OK;
|
|
BOOL bFileExist;
|
|
|
|
HANDLE h = CreateFile(
|
|
m_szFileName,
|
|
GENERIC_READ|GENERIC_WRITE,
|
|
0,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL|FILE_FLAG_NO_BUFFERING,
|
|
NULL);
|
|
if (h == INVALID_HANDLE_VALUE)
|
|
{
|
|
bFileExist = (GetLastError() != ERROR_FILE_NOT_FOUND);
|
|
if (bFileExist)
|
|
{
|
|
hr = STG_E_SHAREVIOLATION;
|
|
} else
|
|
hr = S_FALSE;
|
|
}
|
|
else
|
|
{
|
|
CloseHandle(h);
|
|
}
|
|
|
|
if ( SUCCEEDED(hr) )
|
|
hr = CheckFilesRemovability();
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CParseInf::CheckDURemovability(HKEY hkeyDUDB, BOOL bSilent)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
BOOL bAskSystemClass = TRUE;
|
|
|
|
hr = CheckFilesRemovability();
|
|
if (FAILED(hr)) {
|
|
goto CheckDURemovabilityExit;
|
|
}
|
|
|
|
hr = CheckDUDependencies(hkeyDUDB, bSilent);
|
|
if (FAILED(hr)) {
|
|
goto CheckDURemovabilityExit;
|
|
}
|
|
|
|
// Check for package removability.
|
|
// We shouldn't remove a package if another DU also uses it.
|
|
// TODO: Some sort of package-currently-in-use test. Either test the path file, as above,
|
|
// or use some groovy new IJavaPackage(Manager) method.
|
|
for (m_pCurPackageNode = m_pHeadPackageList;
|
|
m_pCurPackageNode != NULL;
|
|
m_pCurPackageNode = m_pCurPackageNode->GetNextPackageNode())
|
|
{
|
|
TCHAR szT[MAX_PATH];
|
|
LRESULT lResult;
|
|
BOOL bFoundInOtherDU = FALSE;
|
|
int cDistUnitEnum = 0;
|
|
|
|
if (!bAskSystemClass && m_pCurPackageNode->GetIsSystemClass()) {
|
|
char lpszBuf[MAX_MSGBOX_STRING_LEN];
|
|
char lpszBufTitle[MAX_MSGBOX_TITLE_LEN];
|
|
|
|
MLLoadString(IDS_OCCACHE_WARNING_JAVA_SYSTEM_CLASS,
|
|
lpszBuf, MAX_MSGBOX_STRING_LEN);
|
|
MLLoadString(IDS_REMOVAL_WARNING,
|
|
lpszBufTitle, MAX_MSGBOX_TITLE_LEN);
|
|
|
|
// Attempting to remove system class. Warn user.
|
|
if ( bSilent ||
|
|
MessageBox(NULL, lpszBuf, lpszBufTitle,
|
|
MB_YESNO | MB_ICONWARNING) != IDYES) {
|
|
|
|
hr = E_FAIL;
|
|
goto CheckDURemovabilityExit;
|
|
}
|
|
bAskSystemClass = FALSE;
|
|
}
|
|
|
|
// Enumerate distribution units
|
|
while ( (lResult = RegEnumKey(hkeyDUDB, cDistUnitEnum++, szT, MAX_PATH)) == ERROR_SUCCESS &&
|
|
!bFoundInOtherDU )
|
|
{
|
|
if ( lstrcmp(szT, m_szCLSID) != 0 ) // skip the current DU
|
|
{
|
|
HKEY hkeyDUCJ;
|
|
DWORD dw = MAX_PATH;
|
|
lstrcat(szT, REGSTR_DU_CONTAINS_JAVA );
|
|
lResult = RegOpenKeyEx( hkeyDUDB, szT, 0, KEY_READ, &hkeyDUCJ );
|
|
if ( lResult == ERROR_SUCCESS )
|
|
{
|
|
lResult = RegQueryValueEx(hkeyDUCJ, REGSTR_VALUE_INF, NULL, NULL,
|
|
(unsigned char*)szT, &dw);
|
|
// To be safe, assume that anything other than value not found means
|
|
// that the other DU also uses the package.
|
|
bFoundInOtherDU = lResult != ERROR_FILE_NOT_FOUND;
|
|
RegCloseKey( hkeyDUCJ );
|
|
} // if we could open other key's Contains\Java subkey
|
|
} // if it's a different DU
|
|
} // while enumerating DUs
|
|
|
|
// if we found it in another DU, then we shouldn't remove this package with this DU
|
|
m_pCurPackageNode->SetRemovable( !bFoundInOtherDU );
|
|
} // for each package
|
|
|
|
CheckDURemovabilityExit:
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT CParseInf::RemoveLegacyControl( LPCTSTR lpszTypeLibID, BOOL bSilent )
|
|
{
|
|
HRESULT hr = S_FALSE;
|
|
const TCHAR *pszPath;
|
|
BOOL bUnplug = m_dwStatus != STATUS_CTRL_UNPLUGGED;
|
|
BOOL bFileMissing = !PathFileExists( m_szFileName );
|
|
BOOL bDidRemove = FALSE;
|
|
TCHAR szFullName[MAX_PATH];
|
|
|
|
// loop through the list of assocated files, remove them as
|
|
// well as their registry entries.
|
|
for (m_pCurFileNode = m_pHeadFileList;
|
|
m_pCurFileNode != NULL;
|
|
m_pCurFileNode = m_pCurFileNode->GetNextFileNode())
|
|
{
|
|
int cOwners;
|
|
|
|
pszPath = m_pCurFileNode->GetPath();
|
|
|
|
// Process INF file, which as no path since it's not described in INF
|
|
if (pszPath == NULL || pszPath[0] == '\0')
|
|
{
|
|
if ( DeleteFile(m_pCurFileNode->GetName()) )
|
|
hr = S_OK; // hey, we did _something_ - averts the "not enough info" message
|
|
continue;
|
|
}
|
|
|
|
// If we're where, we had some other file besides the INF.
|
|
// Even if we don't remove it, we still knock down its module
|
|
// usage, which has gotta count for having done something.
|
|
hr = S_OK;
|
|
|
|
CatPathStrN( szFullName, pszPath, m_pCurFileNode->GetName(), MAX_PATH);
|
|
|
|
cOwners = SubtractModuleOwner( szFullName, m_szCLSID );
|
|
if (m_pCurFileNode->GetRemovable() && cOwners == 0)
|
|
{
|
|
if ( bUnplug )
|
|
UnregisterOCX(szFullName);
|
|
DeleteFile(szFullName);
|
|
bDidRemove = bDidRemove || StrCmpI(szFullName,m_szFileName) == 0;
|
|
}
|
|
}
|
|
|
|
if (hr == S_OK && bDidRemove && lpszTypeLibID != NULL)
|
|
CleanInterfaceEntries(lpszTypeLibID);
|
|
|
|
if ( bUnplug && bFileMissing )
|
|
{
|
|
if ( m_szFileName[0] != '\0' ) // only do this if there is an ocx to clean up after
|
|
CleanOrphanedRegistry(m_szFileName, m_szCLSID, lpszTypeLibID);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT CParseInf::RemoveDU( LPTSTR szFullName, LPCTSTR lpszTypeLibID, HKEY hkeyDUDB, BOOL bSilent )
|
|
{
|
|
HRESULT hr = S_FALSE; // only say S_OK if we actually do something beyond yanking the INF
|
|
const TCHAR *pszPath = NULL;
|
|
|
|
hr = RemoveLegacyControl( lpszTypeLibID, bSilent );
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
|
|
// Remove the packages that we have determined are safe to remove.
|
|
for (m_pCurPackageNode = m_pHeadPackageList;
|
|
m_pCurPackageNode != NULL;
|
|
m_pCurPackageNode = m_pCurPackageNode->GetNextPackageNode())
|
|
{
|
|
if ( m_pCurPackageNode->GetRemovable() )
|
|
{
|
|
Assert(m_pijpm != NULL);
|
|
#ifdef UNICODE
|
|
OLECHAR *swzPkg = m_pCurPackageNode->GetName();
|
|
OLECHAR *swzNamespace = m_pCurPackageNode->GetNamespace();
|
|
#else
|
|
MAKE_WIDEPTR_FROMANSI(swzPkg, m_pCurPackageNode->GetName());
|
|
MAKE_WIDEPTR_FROMANSI(swzNamespace, m_pCurPackageNode->GetNamespace());
|
|
#endif
|
|
hr = m_pijpm->UninstallPackage( swzPkg,
|
|
((*swzNamespace == 0)? NULL : swzNamespace),
|
|
0 );
|
|
}
|
|
}
|
|
}
|
|
|
|
DeleteKeyAndSubKeys(hkeyDUDB, m_szCLSID);
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CParseInf::CheckDUDependencies(HKEY hKeyDUDB, BOOL bSilent )
|
|
{
|
|
long lrDist = 0;
|
|
long lResult = 0;
|
|
long lr = 0;
|
|
int iSubKey = 0;
|
|
HKEY hkeyCurrent = 0;
|
|
HKEY hkeyCurDU = 0;
|
|
char szName[MAX_REGPATH_LEN];
|
|
int iValue = 0;
|
|
unsigned long ulSize;
|
|
char szDependency[MAX_REGPATH_LEN];
|
|
HKEY hkeyCOM = 0;
|
|
DWORD dwType = 0;
|
|
char szDepName[MAX_CONTROL_NAME_LEN];
|
|
char szDepWarnBuf[MAX_MSGBOX_STRING_LEN];
|
|
char szCOMControl[MAX_REGPATH_LEN];
|
|
DWORD dwSize = 0;
|
|
HRESULT hr = S_OK;
|
|
|
|
// Iterate through DUs that have a ...\contains\Distribution Units
|
|
// key in the registry and compare the entries inside with the DU
|
|
// being removed.
|
|
|
|
while ((lResult = RegEnumKey(hKeyDUDB, iSubKey++, szName,
|
|
MAX_REGPATH_LEN)) == ERROR_SUCCESS)
|
|
{
|
|
|
|
if (!lstrcmpi(szName, m_szCLSID))
|
|
{
|
|
// Skip ourselves
|
|
continue;
|
|
}
|
|
|
|
if (RegOpenKeyEx(hKeyDUDB, szName, 0, KEY_READ, &hkeyCurrent) ==
|
|
ERROR_SUCCESS)
|
|
{
|
|
lr = RegOpenKeyEx(hkeyCurrent, REGSTR_DU_CONTAINS_DIST_UNITS,
|
|
0, KEY_READ, &hkeyCurDU);
|
|
if (lr != ERROR_SUCCESS)
|
|
{
|
|
RegCloseKey(hkeyCurrent);
|
|
continue;
|
|
}
|
|
|
|
ulSize = MAX_REGPATH_LEN;
|
|
while ((lResult = RegEnumValue(hkeyCurDU, iValue++, szDependency,
|
|
&ulSize, NULL, NULL, NULL, NULL)) == ERROR_SUCCESS)
|
|
{
|
|
if (!lstrcmpi(szDependency, m_szCLSID))
|
|
{
|
|
// dependency found
|
|
|
|
// Try to get a friendly name for the dependency control
|
|
|
|
dwSize = MAX_CONTROL_NAME_LEN;
|
|
lResult = RegQueryValueEx(hkeyCurrent, NULL, NULL,
|
|
&dwType, (unsigned char *)szDepName,
|
|
&dwSize);
|
|
|
|
if (lResult != ERROR_SUCCESS || szDepName[0] == '\0') {
|
|
// Couldn't get a friendly name. Try the COM branch.
|
|
|
|
// Technically, this could overflow because
|
|
// szName and szCOMControl are the same size, but
|
|
// this is already at our defined maximum size for reg
|
|
// entries.
|
|
|
|
wsprintf(szCOMControl, "%s\\%s", REGSTR_COM_BRANCH, szName);
|
|
|
|
lResult = RegOpenKeyEx(HKEY_CLASSES_ROOT, szCOMControl,
|
|
0, KEY_READ, &hkeyCOM);
|
|
|
|
if (lResult != ERROR_SUCCESS) {
|
|
MLLoadString(IDS_OCCACHE_WARNING_DEP_REMOVAL_NAME_UNKNOWN,
|
|
szDepWarnBuf, MAX_MSGBOX_STRING_LEN);
|
|
}
|
|
else {
|
|
dwSize = MAX_CONTROL_NAME_LEN;
|
|
lResult = RegQueryValueEx(hkeyCOM, NULL, NULL,
|
|
&dwType, (unsigned char *)szDepName,
|
|
&dwSize);
|
|
|
|
if (lResult != ERROR_SUCCESS || szDepName[0] == '\0') {
|
|
MLLoadString(IDS_OCCACHE_WARNING_DEP_REMOVAL_NAME_UNKNOWN,
|
|
szDepWarnBuf, MAX_MSGBOX_STRING_LEN);
|
|
}
|
|
else {
|
|
char lpszBuf[MAX_MSGBOX_STRING_LEN];
|
|
|
|
MLLoadString(IDS_OCCACHE_WARNING_DEPENDENCY_REMOVAL,
|
|
lpszBuf, MAX_MSGBOX_STRING_LEN);
|
|
wsprintf(szDepWarnBuf, lpszBuf, szDepName);
|
|
}
|
|
|
|
if (hkeyCOM) {
|
|
RegCloseKey(hkeyCOM);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
char lpszBuf[MAX_MSGBOX_STRING_LEN];
|
|
|
|
MLLoadString(IDS_OCCACHE_WARNING_DEPENDENCY_REMOVAL,
|
|
lpszBuf, MAX_MSGBOX_STRING_LEN);
|
|
|
|
wsprintf(szDepWarnBuf, lpszBuf, szDepName);
|
|
}
|
|
|
|
|
|
// TODO: Consider using better HWND than desktop
|
|
char lpszBufTitle[MAX_MSGBOX_TITLE_LEN];
|
|
|
|
MLLoadString(IDS_REMOVAL_WARNING,
|
|
lpszBufTitle, MAX_MSGBOX_TITLE_LEN);
|
|
|
|
if (bSilent ||
|
|
MessageBox(NULL, szDepWarnBuf, lpszBufTitle,
|
|
MB_YESNO | MB_ICONWARNING) != IDYES)
|
|
{
|
|
hr = E_FAIL;
|
|
RegCloseKey(hkeyCurDU);
|
|
RegCloseKey(hkeyCurrent);
|
|
RegCloseKey(hKeyDUDB);
|
|
goto ReturnCheckDUDependencies;
|
|
}
|
|
}
|
|
ulSize = MAX_REGPATH_LEN;
|
|
}
|
|
RegCloseKey(hkeyCurDU);
|
|
RegCloseKey(hkeyCurrent);
|
|
}
|
|
}
|
|
|
|
|
|
ReturnCheckDUDependencies:
|
|
return hr;
|
|
}
|
|
|
|
// uninstall OCX and its associated files
|
|
HRESULT CParseInf::RemoveFiles(
|
|
LPCTSTR lpszTypeLibID /* = NULL */,
|
|
BOOL bForceRemove, /* = FALSE */
|
|
DWORD dwIsDistUnit,
|
|
BOOL bSilent)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
HRESULT hrInf1;
|
|
HRESULT hrInf2;
|
|
TCHAR szFullName[MAX_PATH];
|
|
const TCHAR *pszPath = NULL;
|
|
BOOL bRemovable = (dwIsDistUnit) ? (TRUE) : (IsModuleRemovable(m_szFileName));
|
|
BOOL bIsOCX = FALSE;
|
|
LONG cRefOld = 0;
|
|
HKEY hKeyDUDB = 0;
|
|
BOOL bUnplug = m_dwStatus == STATUS_CTRL_DAMAGED || m_dwStatus == STATUS_CTRL_INSTALLED;
|
|
|
|
if ( !g_fAllAccess || (!bForceRemove && !bRemovable))
|
|
{
|
|
hr = E_ACCESSDENIED;
|
|
goto ExitRemoveFiles;
|
|
}
|
|
|
|
// Check sharing violation (if it is a legacy control)
|
|
|
|
if (!dwIsDistUnit)
|
|
{
|
|
hr = CheckLegacyRemovability( &cRefOld );
|
|
// set SharedDlls count to 1 and save up the old
|
|
// count in case the removal fails
|
|
if (hr == S_OK && !bRemovable &&
|
|
FAILED(hr = SetSharedDllsCount(m_szFileName, 1, &cRefOld)))
|
|
{
|
|
hr = (!PathFileExists( m_szFileName ) ? S_OK : hr);
|
|
goto ExitRemoveFiles;
|
|
}
|
|
|
|
if ( FAILED(hr) )
|
|
goto ExitRemoveFiles;
|
|
}
|
|
else
|
|
{
|
|
long lResultDist;
|
|
|
|
lResultDist = RegOpenKeyEx(HKEY_LOCAL_MACHINE, REGSTR_PATH_DIST_UNITS, 0,
|
|
KEY_READ, &hKeyDUDB);
|
|
if (lResultDist == ERROR_SUCCESS)
|
|
hr = CheckDURemovability( hKeyDUDB, bSilent );
|
|
else
|
|
hr = E_FAIL;
|
|
|
|
if ( FAILED(hr) )
|
|
goto ReturnRemoveFiles;
|
|
}
|
|
|
|
|
|
// ** keyword UNINSTALL -- new feature that hasn't been implemented yet **
|
|
|
|
// parse [Setup Hook], look for "UNINSTALL" key
|
|
if (FAILED(hrInf1 = ParseSetupHook()))
|
|
{
|
|
goto ExitRemoveFiles;
|
|
}
|
|
|
|
// parse conditional hooks in each of the file sections
|
|
if (FAILED(hrInf2 = ParseConditionalHook()))
|
|
{
|
|
goto ExitRemoveFiles;
|
|
}
|
|
|
|
// Okay, if the both didn't do anything, we'll try the DefaultUninstall
|
|
if ( hrInf1 == S_FALSE && hrInf2 == S_FALSE && PathFileExists( m_szInf ) )
|
|
{
|
|
// see if there's anybody home in the default uninstall section
|
|
DWORD dwSize = GetPrivateProfileString( KEY_DEFAULTUNINSTALL,
|
|
NULL,
|
|
DEFAULT_VALUE,
|
|
szFullName,
|
|
MAX_PATH,
|
|
m_szInf );
|
|
|
|
if ( dwSize > 0 )
|
|
{
|
|
HINSTANCE hinstAdvPack = LoadLibrary(TEXT("ADVPACK.DLL"));
|
|
HANDLE hExe = INVALID_HANDLE_VALUE;
|
|
|
|
GetDirectory(GD_EXTRACTDIR, szFullName, ARRAYSIZE(szFullName), m_szInf);
|
|
|
|
if (hinstAdvPack)
|
|
{
|
|
RUNSETUPCOMMAND pfnRunSetup = (RUNSETUPCOMMAND)GetProcAddress(
|
|
hinstAdvPack, achRUNSETUPCOMMANDFUNCTION);
|
|
if (pfnRunSetup)
|
|
{
|
|
// reset hrINf2 to reflect the success of running the default
|
|
// uninstall section. This will prevent us from pointing to the
|
|
// Add/Remove control panel in some cases, like Shockwave.
|
|
hrInf2 = pfnRunSetup(NULL, m_szInf, KEY_DEFAULTUNINSTALL,
|
|
szFullName, NULL, &hExe, RSC_FLAG_INF, NULL);
|
|
}
|
|
|
|
FreeLibrary( hinstAdvPack );
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( !dwIsDistUnit )
|
|
hr = RemoveLegacyControl( lpszTypeLibID, bSilent );
|
|
else
|
|
hr = RemoveDU( szFullName, lpszTypeLibID, hKeyDUDB, bSilent );
|
|
if ( FAILED(hr) )
|
|
goto ExitRemoveFiles;
|
|
|
|
// Return S_FALSE iff none of our uninstall efforts succeeded
|
|
if ( hr == S_FALSE && (hrInf1 == S_OK || hrInf2 == S_OK) )
|
|
hr = S_OK;
|
|
|
|
// remove conflict directory
|
|
if (SUCCEEDED(GetDirectory(GD_CONFLICTDIR, szFullName, ARRAYSIZE(szFullName))) &&
|
|
LStrNICmp(m_szFileName, szFullName, lstrlen(szFullName)) == 0)
|
|
{
|
|
TCHAR *pCh = ReverseStrchr(m_szFileName, '\\');
|
|
Assert (pCh != NULL);
|
|
TCHAR chTemp = *pCh;
|
|
*pCh = '\0';
|
|
RemoveDirectory(m_szFileName);
|
|
*pCh = chTemp;
|
|
}
|
|
|
|
DestroyFileList();
|
|
|
|
ExitRemoveFiles:
|
|
|
|
// set shared dlls count back to where it was if OCX cannot be removed
|
|
if (cRefOld > 0 && FileExist(m_szFileName))
|
|
{
|
|
if (SUCCEEDED(hr))
|
|
hr = SetSharedDllsCount(m_szFileName, cRefOld);
|
|
else
|
|
SetSharedDllsCount(m_szFileName, cRefOld);
|
|
}
|
|
|
|
if ( hKeyDUDB )
|
|
RegCloseKey( hKeyDUDB );
|
|
|
|
ReturnRemoveFiles:
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
void CParseInf::SetIsDistUnit(BOOL bDist)
|
|
{
|
|
m_bIsDistUnit = bDist;
|
|
}
|
|
|
|
BOOL CParseInf::GetIsDistUnit() const
|
|
{
|
|
return m_bIsDistUnit;
|
|
}
|
|
|
|
// return total size of OCX and its associated files
|
|
DWORD CParseInf::GetTotalFileSize() const
|
|
{
|
|
return m_dwTotalFileSize;
|
|
}
|
|
|
|
DWORD CParseInf::GetTotalSizeSaved() const
|
|
{
|
|
return m_dwFileSizeSaved;
|
|
}
|
|
|
|
DWORD CParseInf::GetStatus() const
|
|
{
|
|
return m_dwStatus;
|
|
}
|
|
|
|
// return total number of files which will be removed
|
|
// together with the OCX
|
|
int CParseInf::GetTotalFiles() const
|
|
{
|
|
return m_nTotalFiles;
|
|
}
|
|
|
|
// return first file in the list of associated files
|
|
CFileNode* CParseInf::GetFirstFile()
|
|
{
|
|
m_pFileRetrievalPtr = m_pHeadFileList;
|
|
return m_pFileRetrievalPtr;
|
|
}
|
|
|
|
// get the next file in the list of associated files
|
|
CFileNode* CParseInf::GetNextFile()
|
|
{
|
|
m_pFileRetrievalPtr = m_pFileRetrievalPtr->GetNextFileNode();
|
|
return m_pFileRetrievalPtr;
|
|
}
|
|
|
|
// return first file in the list of associated files
|
|
CPackageNode* CParseInf::GetFirstPackage()
|
|
{
|
|
m_pPackageRetrievalPtr = m_pHeadPackageList;
|
|
return m_pPackageRetrievalPtr;
|
|
}
|
|
|
|
// get the next file in the list of associated files
|
|
CPackageNode* CParseInf::GetNextPackage()
|
|
{
|
|
m_pPackageRetrievalPtr = (m_pPackageRetrievalPtr != NULL)?
|
|
m_pPackageRetrievalPtr->GetNextPackageNode() :
|
|
NULL;
|
|
return m_pPackageRetrievalPtr;
|
|
}
|
|
|