archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
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.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 5c6fe3db62
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5c6fe3db62'
${ noResults }
windows-server-2003/inetcore/setup/active/inseng/cifcomp.cpp

2690 lines
81 KiB
Raw Blame History

#include "inspch.h"
#include "inseng.h"
#include "insobj.h"
#include "util2.h"
#define MAX_VALUE_LEN 256
#define MAX_SMALL_BUF 64
#define NO_ENTRY ""
#define UNINSTALL_BRANCH "Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall"
char g_pBuffer[BUFFERSIZE];
#define NUM_RETRIES 2
HINSTANCE CCifComponent::_hDetLib = NULL;
char CCifComponent::_szDetDllName[] = "";
const char c_gszSRLiteOffset[] = "patch/";
char gszIsPatchable[] = "IsPatchable";
//=--------------------------------------------------------------------------=
// Function name here
//=--------------------------------------------------------------------------=
// Function description
//
// Parameters:
//
// Returns:
//
// Notes:
//
CCifComponent::CCifComponent(LPCSTR pszCompID, CCifFile *pCif) : CCifEntry(pszCompID, pCif)
{
_dwPlatform = 0xffffffff;
_uInstallStatus = 0xffffffff;
_uInstallCount = 0;
_fDependenciesQueued = FALSE;
_fUseSRLite = FALSE;
_fBeforeInstall = TRUE;
SetDownloadDir("");
}
//=--------------------------------------------------------------------------=
// Function name here
//=--------------------------------------------------------------------------=
// Function description
//
// Parameters:
//
// Returns:
//
// Notes:
//
CCifComponent::~CCifComponent()
{
if(_hDetLib)
{
FreeLibrary(_hDetLib);
_hDetLib = NULL;
}
}
STDMETHODIMP CCifComponent::GetID(LPSTR pszID, DWORD dwSize)
{
lstrcpyn(pszID, _szID, dwSize);
return NOERROR;
}
STDMETHODIMP CCifComponent::GetGUID(LPSTR pszGUID, DWORD dwSize)
{
return(GetPrivateProfileString(_szID, GUID_KEY, "", pszGUID, dwSize, _pCif->GetCifPath()) ? NOERROR : E_FAIL);
}
STDMETHODIMP CCifComponent::GetDescription(LPSTR pszDesc, DWORD dwSize)
{
return(MyTranslateString(_pCif->GetCifPath(), _szID, DISPLAYNAME_KEY, pszDesc, dwSize));
}
STDMETHODIMP CCifComponent::GetDetails(LPSTR pszDetails, DWORD dwSize)
{
return(MyTranslateString(_pCif->GetCifPath(), _szID, DETAILS_KEY, pszDetails, dwSize));
}
STDMETHODIMP CCifComponent::GetUrl(UINT uUrlNum, LPSTR pszUrl, DWORD dwSize, LPDWORD pdwUrlFlags)
{
char szKey[16];
char szBuf[MAX_VALUE_LEN];
HRESULT hr = E_FAIL;
// in cif, these things start at 1. we want to start at 0 when handing them out
uUrlNum++;
// Build up the key
wsprintf(szKey, "%s%lu", URL_KEY, uUrlNum);
GetPrivateProfileString(_szID, szKey, NO_ENTRY, szBuf, sizeof(szBuf), _pCif->GetCifPath());
// See if there is any such entry
if(lstrcmp(szBuf, NO_ENTRY) != 0)
{
// snatch the url name
if(GetStringField(szBuf, 0, pszUrl, dwSize) != 0)
{
// This url looks ok
hr = NOERROR;
*pdwUrlFlags = GetIntField(szBuf, 1, URLF_DEFAULT);
}
}
return hr;
}
STDMETHODIMP CCifComponent::GetFileExtractList(UINT uUrlNum, LPSTR pszExtract, DWORD dwSize)
{
char szKey[16];
char szBuf[MAX_VALUE_LEN];
HRESULT hr = E_FAIL;
uUrlNum++;
// Build up the key
wsprintf(szKey, "%s%lu", URL_KEY, uUrlNum);
GetPrivateProfileString(_szID, szKey, NO_ENTRY, szBuf, sizeof(szBuf), _pCif->GetCifPath());
// See if there is any such entry
if(lstrcmp(szBuf, NO_ENTRY) != 0)
{
// snatch the extract list
if(GetStringField(szBuf, 2, pszExtract, dwSize))
hr = NOERROR;
}
return hr;
}
STDMETHODIMP CCifComponent::GetUrlCheckRange(UINT uUrlNum, LPDWORD pdwMin, LPDWORD pdwMax)
{
char szKey[16];
char szBuf[MAX_VALUE_LEN];
HRESULT hr = E_FAIL;
uUrlNum++;
*pdwMin = *pdwMax = 0;
// Build up the key
wsprintf(szKey, "%s%lu", URLSIZE_KEY, uUrlNum);
GetPrivateProfileString(_szID, szKey, NO_ENTRY, szBuf, sizeof(szBuf), _pCif->GetCifPath());
// See if there is any such entry
if(lstrcmp(szBuf, NO_ENTRY) != 0)
{
// snatch the extract list
*pdwMin = GetIntField(szBuf, 0, 0);
*pdwMax = GetIntField(szBuf, 1, *pdwMin);
}
return hr;
}
STDMETHODIMP CCifComponent::GetCommand(UINT uCmdNum, LPSTR pszCmd, DWORD dwCmdSize,
LPSTR pszSwitches, DWORD dwSwitchSize, LPDWORD pdwType)
{
char szKey[16];
HRESULT hr = E_FAIL;
uCmdNum++;
// Build up the key
wsprintf(szKey, "%s%lu", CMD_KEY, uCmdNum);
GetPrivateProfileString(_szID, szKey, NO_ENTRY, pszCmd, dwCmdSize, _pCif->GetCifPath());
if(lstrcmp(pszCmd, NO_ENTRY) != 0)
{
// Build up the key
wsprintf(szKey, "%s%d", ARGS_KEY, uCmdNum);
GetPrivateProfileString(_szID, szKey, NO_ENTRY, pszSwitches, dwSwitchSize, _pCif->GetCifPath());
// expand #W (or #w) to windows directory
ExpandString( pszSwitches, dwSwitchSize );
// Build up the key
wsprintf(szKey, "%s%d", TYPE_KEY, uCmdNum);
*pdwType = GetPrivateProfileInt(_szID, szKey, CMDF_DEFAULT, _pCif->GetCifPath());
hr = NOERROR;
}
return hr;
}
STDMETHODIMP CCifComponent::GetVersion(LPDWORD pdwVersion, LPDWORD pdwBuild)
{
char szBuf[MAX_VALUE_LEN];
szBuf[0] = '\0';
// Version
GetPrivateProfileString(_szID, VERSION_KEY, "", szBuf, sizeof(szBuf), _pCif->GetCifPath());
ConvertVersionStrToDwords(szBuf, pdwVersion, pdwBuild);
return NOERROR;
}
STDMETHODIMP CCifComponent::GetLocale(LPSTR pszLocale, DWORD dwSize)
{
if(FAILED(MyTranslateString(_pCif->GetCifPath(), _szID, LOCALE_KEY, pszLocale, dwSize)))
lstrcpyn(pszLocale, DEFAULT_LOCALE, dwSize);
return NOERROR;
}
STDMETHODIMP CCifComponent::GetUninstallKey(LPSTR pszKey, DWORD dwSize)
{
return(GetPrivateProfileString(_szID, UNINSTALLSTRING_KEY, "", pszKey, dwSize, _pCif->GetCifPath()) ? NOERROR : E_FAIL);
}
STDMETHODIMP CCifComponent::GetInstalledSize(LPDWORD pdwWin, LPDWORD pdwApp)
{
char szBuf[MAX_VALUE_LEN];
if(GetPrivateProfileString(_szID, INSTALLSIZE_KEY, "", szBuf, sizeof(szBuf), _pCif->GetCifPath()))
{
*pdwApp = GetIntField(szBuf, 0, 0);
*pdwWin = GetIntField(szBuf, 1, 0);
}
else
{
*pdwWin = 0;
*pdwApp = 2 * GetDownloadSize();
}
return NOERROR;
}
STDMETHODIMP_(DWORD) CCifComponent::GetDownloadSize()
{
char szBuf[MAX_VALUE_LEN];
szBuf[0] = '\0';
// Read in size
GetPrivateProfileString(_szID, SIZE_KEY, "0,0", szBuf, sizeof(szBuf), _pCif->GetCifPath());
return(GetIntField(szBuf, 0, 0));
}
STDMETHODIMP_(DWORD) CCifComponent::GetExtractSize()
{
char szBuf[MAX_VALUE_LEN];
DWORD dwSize;
szBuf[0] = '\0';
// Read in size
GetPrivateProfileString(_szID, SIZE_KEY, "0,0", szBuf, sizeof(szBuf), _pCif->GetCifPath());
dwSize = GetIntField(szBuf, 1, 2 * GetIntField(szBuf, 0, 0));
return dwSize;
}
STDMETHODIMP CCifComponent::GetSuccessKey(LPSTR pszKey, DWORD dwSize)
{
return(GetPrivateProfileString(_szID, SUCCESS_KEY, "", pszKey, dwSize, _pCif->GetCifPath()) ? NOERROR : E_FAIL);
}
STDMETHODIMP CCifComponent::GetProgressKeys(LPSTR pszProgress, DWORD dwProgSize, LPSTR pszCancel, DWORD dwCancelSize)
{
GetPrivateProfileString(_szID, PROGRESS_KEY, "", pszProgress, dwProgSize, _pCif->GetCifPath());
GetPrivateProfileString(_szID, MUTEX_KEY, "", pszCancel, dwCancelSize, _pCif->GetCifPath());
if(*pszProgress != 0 || *pszCancel != 0)
return NOERROR;
else
return E_FAIL;
}
STDMETHODIMP CCifComponent::IsActiveSetupAware()
{
return(GetPrivateProfileInt(_szID, ACTSETUPAWARE_KEY, 0, _pCif->GetCifPath()) ? S_OK : S_FALSE);
}
STDMETHODIMP CCifComponent::IsRebootRequired()
{
return(GetPrivateProfileInt(_szID, REBOOT_KEY, 0, _pCif->GetCifPath()) ? S_OK : S_FALSE);
}
STDMETHODIMP CCifComponent::RequiresAdminRights()
{
return(GetPrivateProfileInt(_szID, ADMIN_KEY, 0, _pCif->GetCifPath()) ? S_OK : S_FALSE);
}
STDMETHODIMP_(DWORD) CCifComponent::GetPriority()
{
return(GetPrivateProfileInt(_szID, PRIORITY, 0, _pCif->GetCifPath()));
}
STDMETHODIMP CCifComponent::GetDependency(UINT uDepNum, LPSTR pszID, DWORD dwBuf, char *pchType, LPDWORD pdwVer, LPDWORD pdwBuild)
{
char szBuf[MAX_VALUE_LEN];
char szBuf2[MAX_VALUE_LEN];
HRESULT hr = E_FAIL;
DWORD dwLen;
LPSTR pszTemp;
DWORD dwV, dwBld;
dwV = dwBld = 0xffffffff;
if(GetPrivateProfileString(_szID, DEPENDENCY_KEY, NO_ENTRY, szBuf2, sizeof(szBuf2), _pCif->GetCifPath()))
{
if(GetStringField(szBuf2, uDepNum, szBuf, sizeof(szBuf)))
{
// Do some funky parsing
dwLen = lstrlen(szBuf);
*pchType = DEP_INSTALL;
pszTemp = FindChar(szBuf, ':');
if(*pszTemp)
{
*pszTemp = 0;
lstrcpyn(pszID, szBuf, dwBuf);
pszTemp++;
*pchType = *pszTemp;
// see if we have a version
pszTemp = FindChar(pszTemp, ':');
if(*pszTemp)
{
pszTemp++;
// wierdness - scan the string, convert . to , for parsing
LPSTR pszTemp2 = pszTemp;
while(*pszTemp2 != 0)
{
if(*pszTemp2 == '.')
*pszTemp2 = ',';
pszTemp2++;
}
ConvertVersionStrToDwords(pszTemp, &dwV, &dwBld);
}
}
else
lstrcpyn(pszID, szBuf, dwBuf);
if(dwV == 0xffffffff && dwBld == 0xffffffff)
{
// get version of dependency from cif
ICifComponent *pcomp;
if(SUCCEEDED(_pCif->FindComponent(pszID, &pcomp)))
pcomp->GetVersion(&dwV, &dwBld);
}
hr = NOERROR;
}
}
if(pdwVer)
*pdwVer = dwV;
if(pdwBuild)
*pdwBuild = dwBld;
return hr;
}
LPSTR g_pszComp[] = { "Branding.cab",
"desktop.cab",
"custom0",
"custom1",
"custom2",
"custom3",
"custom4",
"custom5",
"custom6",
"custom7",
"custom8",
"custom9",
"CustIcmPro",
NULL};
STDMETHODIMP_(DWORD) CCifComponent::GetPlatform()
{
if(_dwPlatform == 0xffffffff)
{
char *rszPlatforms[7] = { STR_WIN95, STR_WIN98, STR_NT4, STR_NT5, STR_NT4ALPHA, STR_NT5ALPHA,STR_MILLEN };
DWORD rdwPlatforms[] = { PLATFORM_WIN95, PLATFORM_WIN98, PLATFORM_NT4, PLATFORM_NT5,
PLATFORM_NT4ALPHA, PLATFORM_NT5ALPHA, PLATFORM_MILLEN };
char szBuf[MAX_VALUE_LEN];
char szPlatBuf[MAX_VALUE_LEN];
BOOL bFound = FALSE;
int i = 0;
while (!bFound && g_pszComp[i])
{
bFound = (lstrcmpi(g_pszComp[i], _szID) == 0);
i++;
}
_dwPlatform = 0;
if(!bFound && GetPrivateProfileString(_szID, PLATFORM_KEY, NO_ENTRY, szBuf, sizeof(szBuf), _pCif->GetCifPath()))
{
int j = 0;
while(GetStringField(szBuf, j++, szPlatBuf, sizeof(szPlatBuf)))
{
for(int i = 0; i < 7; i++)
{
if(lstrcmpi(szPlatBuf, rszPlatforms[i]) == 0)
{
// check if we should add this platform for this component.
if ((GetCurrentPlatform() != rdwPlatforms[i]) ||
!DisableComponent())
_dwPlatform |= rdwPlatforms[i];
}
}
}
}
else
_dwPlatform = PLATFORM_WIN95 | PLATFORM_WIN98 | PLATFORM_NT4 | PLATFORM_NT5 | PLATFORM_NT4ALPHA | PLATFORM_NT5ALPHA | PLATFORM_MILLEN;
}
return _dwPlatform;
}
STDMETHODIMP_(BOOL) CCifComponent::DisableComponent()
{
BOOL bDisableComp = FALSE;
BOOL bGuidMatch = FALSE;
HKEY hKey;
DWORD dwIndex = 0;
CHAR szGUIDComp[MAX_VALUE_LEN];
CHAR szGUID[MAX_VALUE_LEN];
DWORD dwGUIDSize = sizeof(szGUID);
CHAR szData[MAX_VALUE_LEN];
DWORD dwDataSize = sizeof(szData);
LPSTR pTmp;
DWORD dwVersion , dwBuild;
DWORD dwInstallVer, dwInstallBuild;
if(RegOpenKeyExA(HKEY_LOCAL_MACHINE, COMPONENTBLOCK_KEY, 0, KEY_READ, &hKey) == ERROR_SUCCESS)
{
while (!bDisableComp &&
(RegEnumValue(hKey, dwIndex, szGUID, &dwGUIDSize, NULL, NULL,
(LPBYTE)szData, &dwDataSize) == ERROR_SUCCESS) )
{
GetGUID(szGUIDComp, sizeof(szGUIDComp));
pTmp = ANSIStrChr( szGUID, '*' );
if (pTmp)
{
// If there is a * assume it is at the end
*pTmp = '\0';
szGUIDComp[lstrlen(szGUID)] = '\0';
}
bGuidMatch = (lstrcmpi(szGUID, szGUIDComp) == 0);
// Did the Guids match?
if (bGuidMatch)
{
// now see if we have version info.
if (dwDataSize == 0)
bDisableComp = TRUE;
else
{
// Convert the versin number for the registry
ConvertVersionStrToDwords(szData, &dwVersion, &dwBuild);
if (dwVersion == 0)
bDisableComp = TRUE;
else
{
// Get the versin we would install.
GetVersion(&dwInstallVer, &dwInstallBuild);
// If the version we would install is equal or less, disable the component.
if ((dwInstallVer < dwVersion) ||
((dwInstallVer == dwVersion) && (dwInstallBuild <= dwBuild)) )
bDisableComp = TRUE;
}
}
}
dwGUIDSize = sizeof(szGUID);
dwDataSize = sizeof(szData);
dwIndex++;
}
RegCloseKey(hKey);
}
return bDisableComp;
}
STDMETHODIMP CCifComponent::GetMode(UINT uModeNum, LPSTR pszMode, DWORD dwSize)
{
char szBuf[MAX_VALUE_LEN];
if(FAILED(MyTranslateString(_pCif->GetCifPath(), _szID, MODES_KEY, szBuf, sizeof(szBuf))))
return E_FAIL;
return(GetStringField(szBuf, uModeNum, pszMode, dwSize) ? NOERROR : E_FAIL);
}
STDMETHODIMP CCifComponent::GetGroup(LPSTR pszID, DWORD dwSize)
{
return(GetPrivateProfileString(_szID, GROUP_KEY, "", pszID, dwSize, _pCif->GetCifPath()) ? NOERROR : E_FAIL);
}
STDMETHODIMP CCifComponent::IsUIVisible()
{
return(GetPrivateProfileInt(_szID, UIVISIBLE_KEY, 1, _pCif->GetCifPath()) ? S_OK : S_FALSE);
}
STDMETHODIMP CCifComponent::GetPatchID(LPSTR pszID, DWORD dwSize)
{
return(GetPrivateProfileString(_szID, PATCHID_KEY, "", pszID, dwSize, _pCif->GetCifPath()) ? NOERROR : E_FAIL);
}
STDMETHODIMP CCifComponent::GetTreatAsOneComponents(UINT uNum, LPSTR pszID, DWORD dwBuf)
{
char szBuf[MAX_VALUE_LEN];
szBuf[0] = '\0';
GetPrivateProfileString(_szID, TREATAS_KEY, "", szBuf, sizeof(szBuf), _pCif->GetCifPath());
return(GetStringField(szBuf, uNum, pszID, dwBuf) ? NOERROR : E_FAIL);
}
STDMETHODIMP CCifComponent::GetCustomData(LPSTR pszKey, LPSTR pszData, DWORD dwSize)
{
char szNewKey[MAX_VALUE_LEN];
wsprintf(szNewKey, "_%s", pszKey);
return(MyTranslateString(_pCif->GetCifPath(), _szID, szNewKey, pszData, dwSize));
}
STDMETHODIMP_(DWORD) CCifComponent::IsComponentInstalled()
{
CHAR szCifBuf[512];
CHAR szCompBuf[512];
CHAR szGUID[MAX_VALUE_LEN];
CHAR szLocale[8];
HKEY hComponentKey = NULL;
DETECTION_STRUCT Det;
DWORD dwCifVer, dwCifBuild, dwInstalledVer, dwInstalledBuild;
DWORD dwUnused, dwType, dwIsInstalled;
BOOL bVersionFound = FALSE;
if(_uInstallStatus != ICI_NOTINITIALIZED)
return _uInstallStatus;
_uInstallStatus = ICI_NOTINSTALLED;
// use detection dll first if it is available
if ( SUCCEEDED(GetDetVersion(szCifBuf, sizeof(szCifBuf), szCompBuf, sizeof(szCompBuf))))
{
GetVersion(&dwCifVer, &dwCifBuild);
Det.dwSize = sizeof(DETECTION_STRUCT);
Det.pdwInstalledVer = &dwInstalledVer;
Det.pdwInstalledBuild = &dwInstalledBuild;
GetLocale(szLocale, sizeof(szLocale));
Det.pszLocale = szLocale;
GetGUID(szGUID, sizeof(szGUID));
Det.pszGUID = szGUID;
Det.dwAskVer = dwCifVer;
Det.dwAskBuild = dwCifBuild;
Det.pCifFile = (ICifFile *) _pCif;
Det.pCifComp = (ICifComponent *) this;
if (SUCCEEDED(_GetDetVerResult(szCifBuf, szCompBuf, &Det, &_uInstallStatus)))
{
// only wizard want to know this status, if the newer version is installed, means Installed.
if (_uInstallStatus == ICI_OLDVERSIONAVAILABLE)
_uInstallStatus = ICI_INSTALLED;
return _uInstallStatus;
}
}
// Build GUID Key
lstrcpy(szCompBuf, COMPONENT_KEY);
lstrcat(szCompBuf, "\\");
GetGUID(szCifBuf, sizeof(szCifBuf));
lstrcat(szCompBuf, szCifBuf);
if(RegOpenKeyExA(HKEY_LOCAL_MACHINE, szCompBuf, 0, KEY_READ, &hComponentKey) == ERROR_SUCCESS)
{
// first check for the IsInstalled valuename
// if the valuename is there AND equals zero, we say not installed.
// otherwise continue.
// NOTE: We default to ISINSTALLED_YES if valuename not present to be Back-compatible
// with when we didn't write this valuename at all.....
dwUnused = sizeof(dwIsInstalled);
if(RegQueryValueEx(hComponentKey, ISINSTALLED_KEY, 0, NULL, (LPBYTE) (&dwIsInstalled), &dwUnused) != ERROR_SUCCESS)
dwIsInstalled = ISINSTALLED_YES;
if(dwIsInstalled == ISINSTALLED_YES)
{
// next check for a locale match (no locale entry use default)
dwUnused = sizeof(szCompBuf);
if(RegQueryValueEx(hComponentKey, LOCALE_KEY, 0, NULL, (LPBYTE) szCompBuf, &dwUnused) != ERROR_SUCCESS)
lstrcpy(szCompBuf, DEFAULT_LOCALE);
GetLocale(szCifBuf, sizeof(szCifBuf));
if(_fBeforeInstall || (CompareLocales(szCompBuf, szCifBuf) == 0))
{
// locales match so go check the version
// first check for updated version key
dwUnused = sizeof(szCompBuf);
bVersionFound = (RegQueryValueEx(hComponentKey, QFE_VERSION_KEY,
0, &dwType, (LPBYTE) szCompBuf, &dwUnused) == ERROR_SUCCESS);
// if QFEVersion doesn't exist, look for version
if(!bVersionFound)
{
dwUnused = sizeof(szCompBuf);
bVersionFound = (RegQueryValueEx(hComponentKey, VERSION_KEY,
0, &dwType, (LPBYTE) szCompBuf, &dwUnused) == ERROR_SUCCESS);
}
// figure out if we have REG_STR
if(bVersionFound)
{
// if we have a string convert to ver, if we have binary directly copy into version struct
if(dwType == REG_SZ)
{
ConvertVersionStrToDwords(szCompBuf, &dwInstalledVer, &dwInstalledBuild);
GetVersion(&dwCifVer, &dwCifBuild);
if( (dwInstalledVer > dwCifVer) ||
((dwInstalledVer == dwCifVer) && (dwInstalledBuild >= dwCifBuild)) )
{
_uInstallStatus = ICI_INSTALLED;
}
else
{
_uInstallStatus = ICI_NEWVERSIONAVAILABLE;
}
}
else
_uInstallStatus = ICI_NEWVERSIONAVAILABLE;
}
}
}
}
if(hComponentKey)
RegCloseKey(hComponentKey);
// We think its installed, now check
if(_uInstallStatus != ICI_NOTINSTALLED)
{
// if there is an uninstall key to check do it
if(SUCCEEDED(GetUninstallKey(szCompBuf, sizeof(szCompBuf))))
{
if(!UninstallKeyExists(szCompBuf))
{
_uInstallStatus = ICI_NOTINSTALLED;
}
else
{
// if there is a success key to check do it
if(SUCCEEDED(GetSuccessKey(szCompBuf, sizeof(szCompBuf))))
{
if(!SuccessCheck(szCompBuf))
{
_uInstallStatus = ICI_NOTINSTALLED;
}
}
}
}
}
return _uInstallStatus;
}
STDMETHODIMP CCifComponent::IsComponentDownloaded()
{
if(GetActualDownloadSize() == 0)
return S_OK;
else
return S_FALSE;
}
STDMETHODIMP_(DWORD) CCifComponent::IsThisVersionInstalled(DWORD dwAskVer, DWORD dwAskBld, LPDWORD pdwVersion, LPDWORD pdwBuild)
{
CHAR szCifBuf[512];
CHAR szCompBuf[512];
CHAR szLocale[8];
CHAR szGUID[MAX_VALUE_LEN];
DETECTION_STRUCT Det;
HKEY hComponentKey = NULL;
UINT uStatus = ICI_NOTINSTALLED;
*pdwVersion = 0;
*pdwBuild = 0;
// use detection dll first if it is available
if ( SUCCEEDED(GetDetVersion(szCifBuf, sizeof(szCifBuf), szCompBuf, sizeof(szCompBuf))))
{
Det.dwSize = sizeof(DETECTION_STRUCT);
Det.pdwInstalledVer = pdwVersion;
Det.pdwInstalledBuild = pdwBuild;
GetLocale(szLocale, sizeof(szLocale));
Det.pszLocale = szLocale;
GetGUID(szGUID, sizeof(szGUID));
Det.pszGUID = szGUID;
Det.dwAskVer = dwAskVer;
Det.dwAskBuild = dwAskBld;
Det.pCifFile = (ICifFile *) _pCif;
Det.pCifComp = (ICifComponent *) this;
if (SUCCEEDED(_GetDetVerResult(szCifBuf, szCompBuf, &Det, &uStatus)))
{
return uStatus;
}
}
if(IsComponentInstalled() == ICI_NOTINSTALLED)
return uStatus;
DWORD dwUnused, dwType;
BOOL bVersionFound = FALSE;
// Build GUID Key
lstrcpy(szCompBuf, COMPONENT_KEY);
lstrcat(szCompBuf, "\\");
GetGUID(szCifBuf, sizeof(szCifBuf));
lstrcat(szCompBuf, szCifBuf);
if(RegOpenKeyExA(HKEY_LOCAL_MACHINE, szCompBuf, 0, KEY_READ, &hComponentKey) == ERROR_SUCCESS)
{
// first check for updated version key
dwUnused = sizeof(szCompBuf);
bVersionFound = (RegQueryValueEx(hComponentKey, QFE_VERSION_KEY,
0, &dwType, (LPBYTE) szCompBuf, &dwUnused) == ERROR_SUCCESS);
// if QFEVersion doesn't exist, look for version
if(!bVersionFound)
{
dwUnused = sizeof(szCompBuf);
bVersionFound = (RegQueryValueEx(hComponentKey, VERSION_KEY,
0, &dwType, (LPBYTE) szCompBuf, &dwUnused) == ERROR_SUCCESS);
}
//figure out if we have REG_STR
if(bVersionFound)
{
// if we have a string convert to ver, if we have binary directly copy into version struct
if(dwType == REG_SZ)
{
ConvertVersionStrToDwords(szCompBuf, pdwVersion, pdwBuild);
if((*pdwVersion == dwAskVer) && (*pdwBuild == dwAskBld) )
{
uStatus = ICI_INSTALLED;
}
else if ((*pdwVersion > dwAskVer) ||
(*pdwVersion == dwAskVer) && (*pdwBuild > dwAskBld) )
{
uStatus = ICI_OLDVERSIONAVAILABLE;
}
else
{
uStatus = ICI_NEWVERSIONAVAILABLE;
}
}
else
uStatus = ICI_NEWVERSIONAVAILABLE;
}
RegCloseKey(hComponentKey);
}
return uStatus;
}
STDMETHODIMP_(DWORD) CCifComponent::GetInstallQueueState()
{
if(_uInstallCount)
return SETACTION_INSTALL;
else
return SETACTION_NONE;
}
STDMETHODIMP CCifComponent::SetInstallQueueState(DWORD dwState)
{
HRESULT hr = NOERROR;
DWORD uDependencyAction;
char szCompBuf[MAX_ID_LENGTH];
char chType;
ICifComponent *pcomp;
BOOL fProcessDependencies = TRUE;
// check to see if we allow install on this platform
if((dwState != SETACTION_NONE) && (dwState != SETACTION_DEPENDENCYNONE) &&
!_pCif->GetInstallEngine()->AllowCrossPlatform())
{
if(!(GetPlatform() & GetCurrentPlatform()))
return S_FALSE;
}
switch(dwState)
{
case SETACTION_INSTALL:
// check if it was already on. If so, don't process dependencies
if(_uInstallCount & 0x80000000)
fProcessDependencies = FALSE;
_uInstallCount |= 0x80000000;
uDependencyAction = SETACTION_DEPENDENCYINSTALL;
break;
case SETACTION_DEPENDENCYINSTALL:
_uInstallCount++;
uDependencyAction = SETACTION_DEPENDENCYINSTALL;
break;
case SETACTION_NONE:
// check if it was not on to begin with. If not, don't process dependencies
if(!(_uInstallCount & 0x80000000))
fProcessDependencies = FALSE;
_uInstallCount &= 0x7fffffff;
uDependencyAction = SETACTION_DEPENDENCYNONE;
break;
case SETACTION_DEPENDENCYNONE:
// if our depdency refcount is greater than zero, decrement it.
// this allows us to unconditionally call this when an item is "unqueued"
if(_uInstallCount & 0x7fffffff) _uInstallCount--;
uDependencyAction = SETACTION_DEPENDENCYNONE;
break;
default:
hr = E_INVALIDARG;
break;
}
// now set each dependency, if needed
if(SUCCEEDED(hr) && fProcessDependencies)
{
if(!_fDependenciesQueued)
{
_fDependenciesQueued = TRUE;
DWORD dwNeedVer, dwNeedBuild, dwInsVer, dwInsBuild;
for(int i = 0; SUCCEEDED(GetDependency(i, szCompBuf, sizeof(szCompBuf), &chType, &dwNeedVer, &dwNeedBuild)); i++)
{
if(chType == DEP_INSTALL || chType == DEP_BUDDY)
{
if(SUCCEEDED(_pCif->FindComponent(szCompBuf, &pcomp)))
{
// queue for install if
// 1. Not installed
// 2. Not a good enough version
// 3. FORCEDEPENDIECIES is set
UINT uStatus = pcomp->IsThisVersionInstalled(dwNeedVer, dwNeedBuild, &dwInsVer, &dwInsBuild);
if( (uStatus == ICI_NOTINSTALLED) ||
(uStatus == ICI_NEWVERSIONAVAILABLE) ||
(_pCif->GetInstallEngine()->ForceDependencies()) )
pcomp->SetInstallQueueState(uDependencyAction);
}
}
}
_fDependenciesQueued = FALSE;
}
}
return hr;
}
STDMETHODIMP_(DWORD) CCifComponent::GetActualDownloadSize()
{
char szCompBuf[MAX_PATH];
LPSTR pszFilename = NULL;
LPSTR pszPathEnd = NULL;
DWORD dwUrlSize, dwFlags;
DWORD dwTotalSize = 0;
BOOL alldownloaded = TRUE;
if (_fUseSRLite)
{
// Let the patching engine determine the correct value
dwTotalSize = 0;
}
else
{
if(_CompareDownloadInfo())
{
// so our versions match correctly, check each file
for(UINT i = 0; SUCCEEDED(GetUrl(i, szCompBuf, sizeof(szCompBuf), &dwFlags)); i++)
{
pszFilename = ParseURLA(szCompBuf);
if(_FileIsDownloaded(pszFilename, i, &dwUrlSize))
dwTotalSize += dwUrlSize;
else
alldownloaded = FALSE;
}
}
else
alldownloaded = FALSE;
if(alldownloaded)
dwTotalSize = 0;
else
dwTotalSize = GetDownloadSize() - (dwTotalSize >> 10);
}
return dwTotalSize;
}
HRESULT CCifComponent::OnProgress(ULONG uProgSoFar, LPCSTR pszStatus)
{
_uIndivProgress = uProgSoFar;
if(_uTotalProgress + _uIndivProgress > _uTotalGoal)
_uIndivProgress = _uTotalGoal - _uTotalProgress;
_pCif->GetInstallEngine()->OnComponentProgress(_szID, _uPhase, _szDesc,
pszStatus, _uTotalProgress + _uIndivProgress, _uTotalGoal);
return NOERROR;
}
STDMETHODIMP_(DWORD) CCifComponent::GetCurrentPriority()
{
if(_uPriority == 0xffffffff)
{
char szID[MAX_ID_LENGTH];
ICifGroup *pgrp;
_uPriority = 0;
GetGroup(szID, sizeof(szID));
if(SUCCEEDED(_pCif->FindGroup(szID, &pgrp)))
{
_uPriority = pgrp->GetCurrentPriority();
}
_uPriority += GetPriority();
}
return _uPriority;
}
STDMETHODIMP CCifComponent::SetCurrentPriority(DWORD dwPriority)
{
_uPriority = dwPriority;
// priorities may have changed need to resort
_pCif->ReinsertComponent(this);
return NOERROR;
}
HRESULT CCifComponent::Download()
{
char szBuf[INTERNET_MAX_URL_LENGTH];
HRESULT hr = NOERROR;
DWORD uType;
GetDescription(_szDesc, sizeof(_szDesc));
// BUGBUG: Download size isn't accurate for SR lite and patching
_uTotalGoal = GetActualDownloadSize();
// Engage SR lite behavior only if we're going to install the component,
// and the new advpack extension is available.
DWORD dwOptions = 0;
BOOL fRetryClassic = TRUE;
CHAR szCompBuf[MAX_VALUE_LEN];
CHAR szDir[MAX_PATH];
LPSTR pszSubDir = NULL;
CHAR szCanPatch[MAX_VALUE_LEN];
lstrcpyn(szDir, _pCif->GetDownloadDir(), sizeof(szDir));
SetDownloadDir(szDir);
if (IsPatchableIEVersion() &&
SUCCEEDED(_pCif->GetInstallEngine()->GetInstallOptions(&dwOptions)) &&
(dwOptions & INSTALLOPTIONS_INSTALL) &&
(dwOptions & INSTALLOPTIONS_DOWNLOAD) &&
_pCif->GetInstallEngine()->IsAdvpackExtAvailable() &&
_pCif->GetInstallEngine()->GetPatchDownloader()->IsEnabled() &&
SUCCEEDED(GetCustomData(gszIsPatchable, szCanPatch, sizeof(szCanPatch))) &&
lstrcmp(szCanPatch, "1") == 0)
{
_fUseSRLite = TRUE;
// Adjust the download directory
// The idea here is that the download directory will contain
// subdirectories which will contain the empty cabs + inf +
// the downloaded files.
//
GetID(szCompBuf, sizeof(szCompBuf));
wsprintf(szLogBuf, "Attempting to download empty cabs for %s\r\n", szCompBuf);
_pCif->GetInstallEngine()->WriteToLog(szLogBuf, FALSE);
AddPath(szDir, szCompBuf);
SetDownloadDir(szDir);
if (GetFileAttributes(szDir) == 0xFFFFFFFF)
CreateDirectory(szDir, NULL);
}
_pCif->GetInstallEngine()->OnStartComponent(_szID, _uTotalGoal, 0 , _szDesc);
_MarkDownloadStarted();
// check for disk space
_uPhase = INSTALLSTATUS_INITIALIZING;
_pCif->GetInstallEngine()->OnComponentProgress(_szID, _uPhase, _szDesc, NULL, 0, 0);
if(!IsEnoughSpace(GetDownloadDir(), _uTotalGoal))
hr = E_FAIL;
_uTotalProgress = 0;
for(int i = 0; SUCCEEDED(hr) && SUCCEEDED(GetUrl(i, szBuf, sizeof(szBuf), &uType)); i++)
{
// Change the download loc to point to the special
// "empty cab" location, so we can download the empty
// cabs + the INF that will contain instructions for
// generating the file list for this type of installation.
//
// Assume the new download loc to be in the "patch" subdirectory
// relative to the passed in URL
//
// BUGBUG... only handle the case for relative URLs
if (_fUseSRLite && (uType & URLF_RELATIVEURL) && lstrlen(c_gszSRLiteOffset) + lstrlen(szBuf) < INTERNET_MAX_URL_LENGTH)
{
char szBuf2[INTERNET_MAX_URL_LENGTH];
lstrcpy(szBuf2, c_gszSRLiteOffset);
lstrcat(szBuf2, szBuf);
hr = _DownloadUrl(i, szBuf2, uType);
wsprintf(szLogBuf, "Empty cab download of %s returned 0x%lx\r\n", szBuf2, hr);
_pCif->GetInstallEngine()->WriteToLog(szLogBuf, FALSE);
}
else
{
wsprintf(szLogBuf, "Initial download attempt will be tried as a full download.\r\n");
_pCif->GetInstallEngine()->WriteToLog(szLogBuf, FALSE);
// No need to retry because the first attempt will be the old way...
fRetryClassic = FALSE;
// Restore the download dir to the same state as a normal
// full download.
if (_fUseSRLite)
{
SetDownloadDir(_pCif->GetDownloadDir());
// Ensure we're set to false...just in case there was a problem
// with obtaining the URL for the SR Lite download.
_fUseSRLite = FALSE;
}
hr = _DownloadUrl(i, szBuf, uType);
}
}
if (_fUseSRLite && SUCCEEDED(hr))
{
// Ok...time for the real action of using advpext.dll to
// download the needed files.
hr = _SRLiteDownloadFiles();
}
if (_fUseSRLite && !SUCCEEDED(hr))
{
DelNode(szDir, 0);
// Restore the download dir
SetDownloadDir(_pCif->GetDownloadDir());
}
if(SUCCEEDED(hr))
_uPhase = INSTALLSTATUS_DOWNLOADFINISHED;
else if (_fUseSRLite && fRetryClassic)
{
// Fall back to downloading the full cabs.
_fUseSRLite = FALSE;
_pCif->GetInstallEngine()->WriteToLog("Retrying via full download\r\n", FALSE);
hr = S_OK;
// this re-sets the progress for the retry
_uPhase = INSTALLSTATUS_DOWNLOADING;
_pCif->GetInstallEngine()->OnComponentProgress(_szID, _uPhase, _szDesc, NULL, 0, 0);
_uTotalProgress = 0;
for(int i = 0; SUCCEEDED(hr) && SUCCEEDED(GetUrl(i, szBuf, sizeof(szBuf), &uType)); i++)
{
hr = _DownloadUrl(i, szBuf, uType);
}
if(SUCCEEDED(hr))
_uPhase = INSTALLSTATUS_DOWNLOADFINISHED;
}
_pCif->GetInstallEngine()->OnStopComponent(_szID, hr, _uPhase, _szDesc, 0);
return hr;
}
HRESULT CCifComponent::_DownloadUrl(UINT uUrlNum, LPCSTR pszUrl, UINT uType)
{
// call the downloader
// check the file
// if good
// move to download dir
// else
// redo
HRESULT hr;
char szTempfile[MAX_PATH];
char szFullUrl[INTERNET_MAX_URL_LENGTH];
UINT uStartProgress;
char szDest[MAX_PATH];
char szTimeStamp[MAX_PATH*2];
_uPhase = INSTALLSTATUS_DOWNLOADING;
if(_FileIsDownloaded(ParseURLA(pszUrl), uUrlNum, NULL))
return NOERROR;
CDownloader *pDL = _pCif->GetInstallEngine()->GetDownloader();
uStartProgress = _uTotalProgress;
// retry until success
// save starting progress in case we retry
hr = E_FAIL;
for(int i = 1; i <= NUM_RETRIES && FAILED(hr) && (hr != E_ABORT); i++)
{
_uTotalProgress = uStartProgress;
if(uType & URLF_RELATIVEURL)
{
lstrcpyn(szFullUrl, _pCif->GetInstallEngine()->GetBaseUrl(),
INTERNET_MAX_URL_LENGTH - (lstrlen(pszUrl) + 2));
lstrcat(szFullUrl, "/");
lstrcat(szFullUrl, pszUrl);
}
else
lstrcpy(szFullUrl, pszUrl);
if(SUCCEEDED(_pCif->GetInstallEngine()->CheckForContinue()))
{
DWORD dwFlags = 0;
if(_pCif->GetInstallEngine()->UseCache())
dwFlags |= DOWNLOADFLAGS_USEWRITECACHE;
hr = pDL->SetupDownload(szFullUrl, (IMyDownloadCallback *) this, dwFlags, NULL);
szTempfile[0] = 0;
if(SUCCEEDED(hr))
{
// Log the start time.
wsprintf(szLogBuf, " Downloading : %s\r\n", szFullUrl);
_pCif->GetInstallEngine()->WriteToLog(szLogBuf, FALSE);
GetTimeDateStamp(szTimeStamp);
wsprintf(szLogBuf, " Start : %s\r\n", szTimeStamp);
_pCif->GetInstallEngine()->WriteToLog(szLogBuf, FALSE);
hr = pDL->DoDownload(szTempfile, sizeof(szTempfile));
// Log the stop time.
GetTimeDateStamp(szTimeStamp);
wsprintf(szLogBuf, " Stop : %s\r\n", szTimeStamp);
_pCif->GetInstallEngine()->WriteToLog(szLogBuf, FALSE);
wsprintf(szLogBuf, " Result: %x (%s)\r\n", hr, SUCCEEDED(hr) ? STR_OK : STR_FAILED);
_pCif->GetInstallEngine()->WriteToLog(szLogBuf, FALSE);
}
}
else
hr = E_ABORT;
if(SUCCEEDED(hr))
{
// Check if it is save to download from this URL
_uPhase = INSTALLSTATUS_CHECKINGTRUST;
hr = _pCif->GetInstallEngine()->CheckForContinue();
if(SUCCEEDED(hr))
hr = _CheckForTrust(szFullUrl, szTempfile);
if(SUCCEEDED(hr) && (hr == S_FALSE) )
{
DWORD dwMin, dwMax;
DWORD dwFileSize = 0;
dwFileSize = MyGetFileSize(szTempfile);
dwFileSize = dwFileSize >> 10;
/*
// Open the file
HANDLE h = CreateFile(szTempfile, GENERIC_READ, 0, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if(h != INVALID_HANDLE_VALUE)
{
dwFileSize = GetFileSize(h, NULL);
CloseHandle(h);
}
*/
GetUrlCheckRange(uUrlNum, &dwMin, &dwMax);
if(dwMin != 0)
{
if(dwMin > dwFileSize || dwMax < dwFileSize)
hr = E_FAIL;
else
hr = S_OK;
}
}
if(SUCCEEDED(hr))
hr = _pCif->GetInstallEngine()->CheckForContinue();
// so now we downloaded and checked
// if it is OK, move to download dir
if(SUCCEEDED(hr))
{
lstrcpy(szDest, GetDownloadDir());
AddPath(szDest, ParseURLA(pszUrl));
if(!CopyFile(szTempfile, szDest, FALSE))
{
wsprintf(szLogBuf, "CopyFile FAILED, szTempfile=%s, szDest=%s\r\n", szTempfile, szDest);
_pCif->GetInstallEngine()->WriteToLog(szLogBuf, FALSE);
hr = E_FAIL;
}
_uTotalProgress += _uIndivProgress;
}
// delete the temp download copy
if(szTempfile[0] != 0)
{
GetParentDir(szTempfile);
DelNode(szTempfile, 0);
}
}
if(FAILED(hr) && (hr != E_ABORT))
{
// we failed
// if this is last retry, call EngineProblem
// else just retry
if(i == NUM_RETRIES)
{
HRESULT hEngProb;
DWORD dwResult = 0;
hEngProb = _pCif->GetInstallEngine()->OnEngineProblem(ENGINEPROBLEM_DOWNLOADFAIL, &dwResult);
if(hEngProb == S_OK)
{
if(dwResult == DOWNLOADFAIL_RETRY)
i = 0;
}
}
}
}
if(SUCCEEDED(hr))
_MarkFileDownloadFinished(szDest, uUrlNum, ParseURLA(pszUrl));
return hr;
}
HRESULT CCifComponent::Install()
{
CHAR szCompBuf[MAX_PATH];
HKEY hKey;
DWORD dwWin, dwApp;
HRESULT hr = NOERROR;
DWORD dwStatus = 0;
GetTimeDateStamp(szCompBuf);
wsprintf(szLogBuf, " Start : %s\r\n", szCompBuf);
_pCif->GetInstallEngine()->WriteToLog(szLogBuf, FALSE);
szCompBuf[0] = 0;
_uInstallStatus = ICI_NOTINITIALIZED;
GetDescription(_szDesc, sizeof(_szDesc));
GetInstalledSize(&dwWin, &dwApp);
_uTotalGoal = dwWin + dwApp;
_pCif->GetInstallEngine()->OnStartComponent(_szID, 0, _uTotalGoal, _szDesc);
_uPhase = INSTALLSTATUS_DEPENDENCY;
hr = _CheckForDependencies();
// check for disk space here
if(SUCCEEDED(hr))
{
_uPhase = INSTALLSTATUS_INITIALIZING;
_pCif->GetInstallEngine()->OnComponentProgress(_szID, _uPhase, _szDesc, NULL, 0, 0);
hr = CreateTempDir(GetDownloadSize(), GetExtractSize(), _pCif->GetInstallEngine()->GetInstallDrive(),
dwApp, dwWin, szCompBuf, sizeof(szCompBuf), 0);
}
if(SUCCEEDED(hr))
{
if( IsNT() && (RequiresAdminRights() == S_OK) && !IsNTAdmin(0,NULL))
{
hr = E_ACCESSDENIED;
_pCif->GetInstallEngine()->WriteToLog("Admin Check failed\n", TRUE);
}
}
_uTotalProgress = 0;
// BUGBUG: ie6wzd sets the download directory for non web-based
// installs at a later time. Make sure it's set here
// if we weren't successful with installing via SR Lite.
if (lstrlen(GetDownloadDir()) == 0)
{
SetDownloadDir(_pCif->GetDownloadDir());
}
if(SUCCEEDED(hr))
{
hr = _CopyAllUrls(szCompBuf);
if(SUCCEEDED(hr))
{
// The new PerUser method requires to leave the IsInstalled flag & StubPath as it was
//_MarkComponentInstallStarted();
_pCif->GetInstallEngine()->GetInstaller()->StartClock();
hr = _RunAllCommands(szCompBuf, &dwStatus);
}
}
if(szCompBuf[0] != 0)
DelNode(szCompBuf, 0);
if(SUCCEEDED(hr))
{
_fBeforeInstall = FALSE;
// we think it made it, now double check
if(IsActiveSetupAware() == S_OK)
{
if(IsComponentInstalled() != ICI_INSTALLED)
{
// we think they made it but they didn't write their key ...
_pCif->GetInstallEngine()->WriteToLog("Component did not write to InstalledComponent branch\r\n", TRUE);
hr = E_FAIL;
}
}
else
{
char szCompBuf[MAX_VALUE_LEN];
// if there is an uninstall key to check do it
if(SUCCEEDED(GetUninstallKey(szCompBuf, sizeof(szCompBuf))))
{
if(!UninstallKeyExists(szCompBuf))
{
_pCif->GetInstallEngine()->WriteToLog("UninstallKey check failed\r\n", TRUE);
hr = E_FAIL;
}
else
{
// if there is a success key to check do it
if(SUCCEEDED(GetSuccessKey(szCompBuf, sizeof(szCompBuf))))
{
if(!SuccessCheck(szCompBuf))
{
_pCif->GetInstallEngine()->WriteToLog("Success key check failed\r\n", TRUE);
hr = E_FAIL;
}
}
}
}
}
}
_pCif->RemoveFromCriticalComponents(this);
if(SUCCEEDED(hr))
{
_MarkAsInstalled();
_pCif->MarkCriticalComponents(this);
_uPhase = INSTALLSTATUS_FINISHED;
_pCif->GetInstallEngine()->GetInstaller()->SetBytes((dwWin + dwApp) << 10, TRUE);
if(IsRebootRequired() == S_OK)
{
dwStatus |= STOPINSTALL_REBOOTNEEDED;
}
_pCif->GetInstallEngine()->SetStatus(dwStatus);
}
_pCif->GetInstallEngine()->GetInstaller()->StopClock();
_pCif->GetInstallEngine()->OnStopComponent(_szID, hr, _uPhase, _szDesc, dwStatus);
GetTimeDateStamp(szCompBuf);
wsprintf(szLogBuf, " Stop : %s\r\n", szCompBuf);
_pCif->GetInstallEngine()->WriteToLog(szLogBuf, FALSE);
return hr;
}
HRESULT CCifComponent::_RunAllCommands(LPCSTR pszDir, DWORD *pdwStatus)
{
char szCmd[MAX_PATH];
char szArg[MAX_VALUE_LEN];
char szProg[MAX_VALUE_LEN];
char szCancel[MAX_VALUE_LEN];
char szPath[] = "X:\\";
DWORD dwWinSpace, dwInstallSpace;
DWORD dwType;
HRESULT hr = NOERROR;
// Save the widows space and install drive space
szPath[0] = g_szWindowsDir[0];
dwWinSpace = GetSpace(szPath);
if(szPath[0] != _pCif->GetInstallEngine()->GetInstallDrive())
{
szPath[0] = _pCif->GetInstallEngine()->GetInstallDrive();
dwInstallSpace = GetSpace(szPath);
}
else
{
dwInstallSpace = 0;
}
_uTotalProgress = 0;
_uPhase = INSTALLSTATUS_RUNNING;
_pCif->GetInstallEngine()->OnComponentProgress(_szID, INSTALLSTATUS_RUNNING,
_szDesc, NULL, _uTotalProgress, _uTotalGoal);
hr = _pCif->GetInstallEngine()->CheckForContinue();
for(UINT i = 0; SUCCEEDED(hr) && SUCCEEDED(GetCommand(i, szCmd, sizeof(szCmd), szArg, sizeof(szArg), &dwType)); i++)
{
_uIndivProgress = 0;
GetProgressKeys(szProg, sizeof(szProg), szCancel, sizeof(szCancel));
hr = _pCif->GetInstallEngine()->GetInstaller()->DoInstall(pszDir, szCmd, szArg,
lstrlen(szProg) ? szProg : NULL, lstrlen(szCancel) ? szCancel : NULL,
dwType, pdwStatus, (IMyDownloadCallback *) this) ;
_uTotalProgress += _uIndivProgress;
}
_pCif->GetInstallEngine()->OnComponentProgress(_szID, _uPhase, _szDesc, NULL, _uTotalGoal,_uTotalGoal);
// figure how much we used, and log it
szPath[0] = g_szWindowsDir[0];
dwWinSpace = dwWinSpace - GetSpace(szPath);
if(szPath[0] != _pCif->GetInstallEngine()->GetInstallDrive())
{
szPath[0] = _pCif->GetInstallEngine()->GetInstallDrive();
dwInstallSpace = dwInstallSpace - GetSpace(szPath);
}
// log the space used
wsprintf(szCmd, "SpaceUsed: Windows drive: %d InstallDrive: %d\r\n", dwWinSpace, dwInstallSpace);
_pCif->GetInstallEngine()->WriteToLog(szCmd, FALSE);
return hr;
}
HRESULT CCifComponent::_CopyAllUrls(LPCSTR pszTemp)
{
char szCompBuf[MAX_VALUE_LEN];
char szDest[MAX_PATH];
char szSource[MAX_PATH];
DWORD dwType;
HRESULT hr = NOERROR;
HANDLE hFind;
WIN32_FIND_DATA ffd;
char szBuf[MAX_PATH];
for(UINT i = 0; SUCCEEDED(hr) && SUCCEEDED(GetUrl(i, szCompBuf, sizeof(szCompBuf), &dwType)) ; i++)
{
_uPhase = INSTALLSTATUS_COPYING;
_pCif->GetInstallEngine()->OnComponentProgress(_szID, _uPhase, _szDesc, NULL, 0, 0);
lstrcpy(szSource, GetDownloadDir());
AddPath(szSource, ParseURLA(szCompBuf));
lstrcpy(szDest, pszTemp);
AddPath(szDest, ParseURLA(szCompBuf));
// Copy the file
if(!CopyFile(szSource, szDest, FALSE))
{
wsprintf(szLogBuf, "CopyFile failed for szSource=%s, szDest=%s, DLDir=%s\r\n", szSource, szDest, GetDownloadDir());
_pCif->GetInstallEngine()->WriteToLog(szLogBuf, FALSE);
hr = E_FILESMISSING;
}
if(SUCCEEDED(hr))
hr = _pCif->GetInstallEngine()->CheckForContinue();
if(SUCCEEDED(hr))
{
_uPhase = INSTALLSTATUS_CHECKINGTRUST;
hr = _CheckForTrust(szSource, szDest);
if (hr == S_FALSE && !_pCif->GetInstallEngine()->IgnoreTrustCheck())
hr = TRUST_E_FAIL;
if(FAILED(hr))
{
DeleteFile(szSource);
}
}
if(SUCCEEDED(hr))
hr = _pCif->GetInstallEngine()->CheckForContinue();
if(SUCCEEDED(hr))
hr = _ExtractFiles(i, szDest, dwType);
if(SUCCEEDED(hr))
hr = _pCif->GetInstallEngine()->CheckForContinue();
}
// Now, if we're attempting an SR Lite install, then after
// extracting cab files to the temp directory...copy all of
// downloaded files to the temp directory.
if (_fUseSRLite)
{
lstrcpy(szSource, GetDownloadDir());
AddPath(szSource, "*.*");
if ( (hFind = FindFirstFile(szSource, &ffd)) != INVALID_HANDLE_VALUE)
{
do
{
if (ffd.dwFileAttributes != FILE_ATTRIBUTE_DIRECTORY)
{
lstrcpyn(szSource, GetDownloadDir(), sizeof(szSource));
SafeAddPath(szSource, ffd.cFileName, sizeof(szSource) - lstrlen(szSource));
lstrcpy(szDest, pszTemp);
AddPath(szDest, ffd.cFileName);
MoveFile(szSource, szDest);
}
} while (SUCCEEDED(hr) && FindNextFile(hFind, &ffd));
FindClose(hFind);
}
}
return hr;
}
STDMETHODIMP CCifComponent::GetDetVersion(LPSTR pszDll, DWORD dwdllSize, LPSTR pszEntry, DWORD dwentSize)
{
char szBuf[MAX_VALUE_LEN];
HRESULT hr = E_FAIL;
if(pszDll && pszEntry)
*pszDll = *pszEntry = 0;
else
return hr;
if(GetPrivateProfileString(_szID, DETVERSION_KEY, "", szBuf, sizeof(szBuf), _pCif->GetCifPath()))
{
if((GetStringField(szBuf, 0, pszDll, dwdllSize) != 0) && (GetStringField(szBuf, 1, pszEntry, dwentSize) != 0))
{
hr = NOERROR;
}
}
return hr;
}
HRESULT CCifComponent::_GetDetVerResult(LPCSTR pszDll, LPCSTR pszEntry, DETECTION_STRUCT *pDet, UINT *puStatus)
{
char szBuf[MAX_PATH];
HRESULT hr = E_FAIL;
HINSTANCE hLib;
DETECTVERSION fpDetVer;
*puStatus = ICI_NOTINSTALLED;
if (pszDll && pszEntry)
{
if(_hDetLib && (lstrcmpi(pszDll, _szDetDllName) == 0))
{
hLib = _hDetLib;
}
else
{
lstrcpy(szBuf, _pCif->GetCifPath());
GetParentDir(szBuf);
AddPath(szBuf, pszDll);
hLib = LoadLibrary(szBuf);
if (hLib == NULL)
{
// if Cif folder failed try IE folder before using searching path
if (SUCCEEDED(GetIEPath(szBuf, sizeof(szBuf))))
{
AddPath(szBuf, pszDll);
hLib = LoadLibrary(szBuf);
}
}
if(hLib)
{
lstrcpy(_szDetDllName, pszDll);
_hDetLib = hLib;
}
}
if (hLib)
{
fpDetVer = (DETECTVERSION)GetProcAddress(hLib, pszEntry);
if (fpDetVer)
{
switch(fpDetVer(pDet))
{
case DET_NOTINSTALLED:
*puStatus = ICI_NOTINSTALLED;
break;
case DET_INSTALLED:
*puStatus = ICI_INSTALLED;
break;
case DET_NEWVERSIONINSTALLED:
*puStatus = ICI_OLDVERSIONAVAILABLE;
break;
case DET_OLDVERSIONINSTALLED:
*puStatus = ICI_NEWVERSIONAVAILABLE;
break;
}
hr = NOERROR;
}
}
}
return hr;
}
//=--------------------------------------------------------------------------=
// Function name here
//=--------------------------------------------------------------------------=
// Function description
//
// Parameters:
//
// Returns:
//
// Notes:
//
HRESULT CCifComponent::_CheckForTrust(LPCSTR pszURL, LPCSTR pszFilename)
{
HRESULT hr = S_FALSE;
// BUGBUG: Our internal workaround for non signed stuff
// if(rdwUrlFlags[i] & URLF_NOCHECKTRUST)
// return S_OK;
_uPhase = INSTALLSTATUS_CHECKINGTRUST;
_pCif->GetInstallEngine()->OnComponentProgress(_szID, _uPhase, _szDesc, NULL, 0, 0);
if(!_pCif->GetInstallEngine()->IgnoreTrustCheck())
hr = ::CheckTrustEx(pszURL, pszFilename, _pCif->GetInstallEngine()->GetHWND(), FALSE, NULL);
wsprintf(szLogBuf, " CheckTrust: %s, Result: %x (%s)\r\n", pszFilename, hr, SUCCEEDED(hr) ? STR_OK : STR_FAILED);
_pCif->GetInstallEngine()->WriteToLog(szLogBuf, TRUE);
return hr;
}
//=--------------------------------------------------------------------------=
// Function name here
//=--------------------------------------------------------------------------=
// Function description
//
// Parameters:
//
// Returns:
//
// Notes:
//
HRESULT CCifComponent::_ExtractFiles(UINT i, LPCSTR pszFile, DWORD dwType)
{
HRESULT hr = NOERROR;
char szPath[MAX_PATH];
char szExtractList[MAX_VALUE_LEN];
// Need to pay attention to rdwUrlFlags[i] to see if there is anything to do
if(dwType & URLF_EXTRACT)
{
_uPhase = INSTALLSTATUS_EXTRACTING;
_pCif->GetInstallEngine()->OnComponentProgress(_szID, _uPhase, _szDesc, NULL, 0, 0);
lstrcpy(szPath, pszFile);
GetParentDir(szPath);
GetFileExtractList(i, szExtractList, sizeof(szExtractList));
hr=ExtractFiles(pszFile, szPath, 0, lstrlen(szExtractList) ? szExtractList : NULL, NULL, 0);
wsprintf(szLogBuf, "File extraction: %s, Result: %x (%s)\r\n", pszFile, hr, SUCCEEDED(hr) ? STR_OK : STR_FAILED);
_pCif->GetInstallEngine()->WriteToLog(szLogBuf, TRUE);
// if the flag is set to delte the cab after an extract, do it
// I don't really care too much if this fails, at least not
// enough to fail this component
if(dwType & URLF_DELETE_AFTER_EXTRACT)
DeleteFile(pszFile);
}
return hr;
}
void CCifComponent::_MarkComponentInstallStarted()
{
char szReg[MAX_PATH];
char szCompBuf[MAX_DISPLAYNAME_LENGTH];
HKEY hKey;
DWORD dwDumb;
lstrcpy(szReg, COMPONENT_KEY);
lstrcat(szReg, "\\");
GetGUID(szCompBuf, sizeof(szCompBuf));
lstrcat(szReg, szCompBuf);
if(RegOpenKeyEx( HKEY_LOCAL_MACHINE, szReg, 0,
KEY_READ | KEY_WRITE, &hKey) == ERROR_SUCCESS)
{
// Set IsInstalled=0
dwDumb = ISINSTALLED_NO;
RegSetValueExA(hKey, ISINSTALLED_KEY, 0, REG_DWORD,
(BYTE *) &dwDumb , sizeof(dwDumb));
// Delete StubPath so peruser isn't confused
RegDeleteValue(hKey, STUBPATH_KEY);
RegCloseKey(hKey);
}
}
BOOL CCifComponent::_CompareDownloadInfo()
{
char szCompBuf[MAX_VALUE_LEN];
char szInfoBuf[128];
DWORD dwCompVer, dwCompBuild, dwDLVer, dwDLBuild;
// first check this is the same language
GetPrivateProfileString(_szID, LOCALE_KEY, "", szInfoBuf, sizeof(szInfoBuf), _pCif->GetFilelist());
GetLocale(szCompBuf, sizeof(szCompBuf));
if(CompareLocales(szInfoBuf, szCompBuf) == 0)
{
// compare guids
GetPrivateProfileString(_szID, GUID_KEY, "", szInfoBuf, sizeof(szInfoBuf), _pCif->GetFilelist());
GetGUID(szCompBuf, sizeof(szCompBuf));
// intentionally let blank guid match to be backward compatible
if(lstrcmpi(szCompBuf, szInfoBuf) == 0)
{
GetPrivateProfileString(_szID, VERSION_KEY,"",szInfoBuf,
sizeof(szInfoBuf), _pCif->GetFilelist());
ConvertVersionStrToDwords(szInfoBuf, &dwDLVer, &dwDLBuild);
GetVersion(&dwCompVer, &dwCompBuild);
if((dwDLVer == dwCompVer) && (dwDLBuild == dwCompBuild))
return TRUE;
}
}
return FALSE;
}
BOOL CCifComponent::_FileIsDownloaded(LPCSTR pszFile, UINT i, DWORD *pdwSize)
{
HANDLE h;
DWORD dwSize, dwFileSize;
char szKey[16];
char szBuf[MAX_PATH];
szBuf[0] = '\0';
if(pdwSize)
*pdwSize = 0;
wsprintf(szKey, "URL%d", i);
GetPrivateProfileString(_szID, szKey,"0",szBuf,
sizeof(szBuf), _pCif->GetFilelist());
dwSize = GetIntField(szBuf, 0, 0);
if(dwSize == 0)
return FALSE;
if (_fUseSRLite && lstrlen(GetDownloadDir()) != 0)
lstrcpy(szBuf, GetDownloadDir());
else
lstrcpy(szBuf, _pCif->GetDownloadDir());
AddPath(szBuf, pszFile);
dwFileSize = MyGetFileSize(szBuf);
/*
// Open the file
h = CreateFile(pszFile, GENERIC_READ, 0, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if(h == INVALID_HANDLE_VALUE)
return FALSE;
// dont worry about files over 4 gig
dwFileSize = GetFileSize(h, NULL);
CloseHandle(h);
*/
if(dwFileSize == dwSize)
{
if(pdwSize)
*pdwSize = dwFileSize;
return TRUE;
}
return FALSE;
}
//=--------------------------------------------------------------------------=
// Function name here
//=--------------------------------------------------------------------------=
// Function description
//
// Parameters:
//
// Returns:
//
// Notes:
//
void CCifComponent::_MarkAsInstalled()
{
CHAR szCompBuf[MAX_VALUE_LEN];
HKEY hComponentKey = NULL;
HKEY hGUIDKey = NULL;
DWORD dwDumb, dwVer, dwBuild;
LPSTR psz;
if(RegCreateKeyExA(HKEY_LOCAL_MACHINE, COMPONENT_KEY, 0, 0, 0,
KEY_WRITE, NULL, &hComponentKey, &dwDumb) == ERROR_SUCCESS)
{
GetGUID(szCompBuf, sizeof(szCompBuf));
if(RegCreateKeyExA(hComponentKey, szCompBuf, 0, 0, 0, KEY_WRITE, NULL, &hGUIDKey, &dwDumb) == ERROR_SUCCESS)
{
// we only write to the key if this guy is NOT active setup aware
if(IsActiveSetupAware() == S_FALSE)
{
// write Display name to Default
GetDescription(szCompBuf, sizeof(szCompBuf));
RegSetValueExA(hGUIDKey, NULL, 0, REG_SZ, (BYTE *)szCompBuf , lstrlen(szCompBuf) + 1 );
// write component ID
GetID(szCompBuf, sizeof(szCompBuf));
RegSetValueExA(hGUIDKey, "ComponentID", 0, REG_SZ, (BYTE *)szCompBuf , lstrlen(szCompBuf) + 1 );
// write out version
GetVersion(&dwVer, &dwBuild);
wsprintf(szCompBuf, "%d,%d,%d,%d", HIWORD(dwVer),LOWORD(dwVer),HIWORD(dwBuild),LOWORD(dwBuild));
RegSetValueExA(hGUIDKey, VERSION_KEY, 0, REG_SZ, (BYTE *)szCompBuf , lstrlen(szCompBuf) + 1);
// write out locale
GetLocale(szCompBuf, sizeof(szCompBuf));
RegSetValueExA(hGUIDKey, LOCALE_KEY, 0, REG_SZ, (BYTE *)szCompBuf , lstrlen(szCompBuf) + 1);
// Write out "IsInstalled=1"
dwDumb = ISINSTALLED_YES;
RegSetValueExA(hGUIDKey, ISINSTALLED_KEY, 0, REG_DWORD, (BYTE *) &dwDumb , sizeof(dwDumb));
}
}
}
if(hComponentKey)
RegCloseKey(hComponentKey);
if(hGUIDKey)
RegCloseKey(hGUIDKey);
}
void CCifComponent::_MarkFileDownloadFinished(LPCSTR pszFilePath, UINT i, LPCSTR pszFilename)
{
char szSize[MAX_PATH];
char szKey[16];
DWORD dwFileSize;
HANDLE h;
// put any entry in filelist.dat
// [CompID]
// URLi=Filesize
dwFileSize = MyGetFileSize(pszFilePath);
/*
// Create the file
h = CreateFile(pszFilePath, GENERIC_READ, 0, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if(h == INVALID_HANDLE_VALUE)
return;
// dont worry about files over 4 gig
dwFileSize = GetFileSize(h, NULL);
CloseHandle(h);
*/
if(dwFileSize != 0xffffffff)
{
wsprintf(szKey, "URL%d", i);
wsprintf(szSize, "%d,%s", dwFileSize, pszFilename);
WritePrivateProfileString(_szID, szKey, szSize, _pCif->GetFilelist());
// need to flush the pszFileList file; otherwise, with Stacker installed,
// it GPFs when trying to open the file in another thread (bug #13041)
WritePrivateProfileString(NULL, NULL, NULL, _pCif->GetFilelist());
}
}
void CCifComponent::_MarkFileDownloadStarted(UINT i)
{
char szKey[10];
wsprintf(szKey, "URL%d", i);
WritePrivateProfileString(_szID, szKey, NULL, _pCif->GetFilelist());
// flush -- fixes the Stacker bug #13041
WritePrivateProfileString(NULL, NULL, NULL, _pCif->GetFilelist());
}
void CCifComponent::_MarkDownloadStarted()
{
char szCompBuf[MAX_VALUE_LEN];
DWORD dwVer, dwBuild;
// if the section doesn't match what we expect, we kill
// section so we will redownload everything
if(!_CompareDownloadInfo())
WritePrivateProfileSection(_szID, NULL, _pCif->GetFilelist());
// write the version
GetVersion(&dwVer, &dwBuild);
wsprintf(szCompBuf, "%d,%d,%d,%d", HIWORD(dwVer),LOWORD(dwVer),HIWORD(dwBuild),LOWORD(dwBuild));
WritePrivateProfileString(_szID, VERSION_KEY, szCompBuf, _pCif->GetFilelist());
// write locale
GetLocale(szCompBuf, sizeof(szCompBuf));
WritePrivateProfileString(_szID, LOCALE_KEY, szCompBuf, _pCif->GetFilelist());
// write the guid
GetGUID(szCompBuf, sizeof(szCompBuf));
WritePrivateProfileString(_szID, GUID_KEY, szCompBuf, _pCif->GetFilelist());
// flush -- fixes the Stacker bug #13041
WritePrivateProfileString(NULL, NULL, NULL, _pCif->GetFilelist());
}
HRESULT CCifComponent::_CheckForDependencies()
{
char szCompBuf[MAX_ID_LENGTH];
char chType;
ICifComponent *pcomp;
HRESULT hr = NOERROR;
DWORD dwNeedVer, dwNeedBuild, dwInsVer, dwInsBuild;
for(int i = 0; SUCCEEDED(GetDependency(i, szCompBuf, sizeof(szCompBuf), &chType, &dwNeedVer, &dwNeedBuild)); i++)
{
if(SUCCEEDED(_pCif->FindComponent(szCompBuf, &pcomp)))
{
if(chType != DEP_BUDDY)
{
UINT uStatus = pcomp->IsThisVersionInstalled(dwNeedVer, dwNeedBuild, &dwInsVer, &dwInsBuild);
if( (uStatus == ICI_NOTINSTALLED) || (uStatus == ICI_NEWVERSIONAVAILABLE) )
{
hr = E_FAIL;
break;
}
}
}
}
return hr;
}
HRESULT CCifComponent::_SRLiteDownloadFiles()
{
HANDLE hFile;
WIN32_FIND_DATA ffd = {0};
CHAR szFile[MAX_PATH];
LPSTR pszFile = NULL;
HRESULT hr = S_OK;
CHAR szCompBuf[INTERNET_MAX_URL_LENGTH];
DWORD dwType;
BOOL fRet;
UINT uPatchCount = 0;
_uPhase = INSTALLSTATUS_DOWNLOADING;
// Look for presence of [DownloadFileSection] in a single
// .inf file extracted from the cabs.
for(UINT i = 0; SUCCEEDED(hr) && SUCCEEDED(GetUrl(i, szCompBuf, sizeof(szCompBuf), &dwType)) ; i++)
{
TCHAR szShortPath[MAX_PATH] = "";
GetShortPathName(GetDownloadDir(), szShortPath, sizeof(szShortPath));
// If all goes well, we should just get a single INF file extracted
lstrcpyn(szFile, GetDownloadDir(), sizeof(szFile));
SafeAddPath(szFile, szCompBuf, sizeof(szCompBuf));
hr = ExtractFiles(szFile, szShortPath, 0, NULL, NULL, 0);
wsprintf(szLogBuf, "Extracting empty cabs for %s in %s returned 0x%lx\r\n", szCompBuf, szShortPath, hr);
_pCif->GetInstallEngine()->WriteToLog(szLogBuf, FALSE);
}
lstrcpyn(szFile, GetDownloadDir(), sizeof(szFile));
SafeAddPath(szFile, "*.inf", sizeof(szFile));
// Get the file count because we're going to hack the
// progress bar UI since we don't know the real download sizes
// for the patch INFs upfront.
hFile = FindFirstFile(szFile, &ffd);
if (hFile != INVALID_HANDLE_VALUE)
{
do
{
// Strip filename from path
lstrcpyn(szFile, GetDownloadDir(), sizeof(szFile));
SafeAddPath(szFile, ffd.cFileName, sizeof(szFile) - lstrlen(szFile));
if (IsPatchableINF(szFile))
{
uPatchCount++;
}
} while (FindNextFile(hFile, &ffd));
FindClose(hFile);
}
lstrcpyn(szFile, GetDownloadDir(), sizeof(szFile));
SafeAddPath(szFile, "*.inf", sizeof(szFile));
hFile = FindFirstFile(szFile, &ffd);
// No need to keep the grep pattern...
lstrcpyn(szFile, GetDownloadDir(), sizeof(szFile));
pszFile = szFile + lstrlen(szFile);
if (hFile != INVALID_HANDLE_VALUE)
{
do
{
// Strip filename from path
lstrcpyn(szFile, GetDownloadDir(), sizeof(szFile));
SafeAddPath(szFile, ffd.cFileName, sizeof(szFile) - lstrlen(szFile));
if (IsPatchableINF(szFile))
{
fRet = TRUE;
// Found an inf that supports SR Lite. Try downloading the patch files.
// Use our downloader wrapper for the advpack extension to do the
// downloading.
hr = _pCif->GetInstallEngine()->GetPatchDownloader()->SetupDownload(_uTotalGoal, uPatchCount, (IMyDownloadCallback *) this, GetDownloadDir());
hr = _pCif->GetInstallEngine()->GetPatchDownloader()->DoDownload(szFile);
}
else
{
wsprintf(szLogBuf, "%s INF found with no DownloadFileSection\r\n", szFile);
_pCif->GetInstallEngine()->WriteToLog(szLogBuf, FALSE);
}
_uTotalProgress += _uIndivProgress;
} while (SUCCEEDED(hr) && FindNextFile(hFile, &ffd));
FindClose(hFile);
}
if (!fRet || !SUCCEEDED(hr))
{
wsprintf(szLogBuf, "Either no INF was found with a DownloadFileSection or an error occured during processing\r\n");
_pCif->GetInstallEngine()->WriteToLog(szLogBuf, FALSE);
return E_FAIL;
}
return hr;
}
void CCifComponent::SetDownloadDir(LPCSTR pszDownloadDir)
{
if (pszDownloadDir)
lstrcpyn(_szDLDir, pszDownloadDir, MAX_PATH);
}
//========= ICifRWComponent implementation ================================================
//
CCifRWComponent::CCifRWComponent(LPCSTR pszID, CCifFile *pCif) : CCifComponent(pszID, pCif)
{
}
CCifRWComponent::~CCifRWComponent()
{
}
STDMETHODIMP CCifRWComponent::GetID(LPSTR pszID, DWORD dwSize)
{
return(CCifComponent::GetID(pszID, dwSize));
}
STDMETHODIMP CCifRWComponent::GetGUID(LPSTR pszGUID, DWORD dwSize)
{
return(CCifComponent::GetGUID(pszGUID, dwSize));
}
STDMETHODIMP CCifRWComponent::GetDescription(LPSTR pszDesc, DWORD dwSize)
{
return(CCifComponent::GetDescription(pszDesc, dwSize));
}
STDMETHODIMP CCifRWComponent::GetDetails(LPSTR pszDetails, DWORD dwSize)
{
return(CCifComponent::GetDetails(pszDetails, dwSize));
}
STDMETHODIMP CCifRWComponent::GetUrl(UINT uUrlNum, LPSTR pszUrl, DWORD dwSize, LPDWORD pdwUrlFlags)
{
return(CCifComponent::GetUrl(uUrlNum, pszUrl, dwSize, pdwUrlFlags));
}
STDMETHODIMP CCifRWComponent::GetFileExtractList(UINT uUrlNum, LPSTR pszExtract, DWORD dwSize)
{
return(CCifComponent::GetFileExtractList(uUrlNum, pszExtract, dwSize));
}
STDMETHODIMP CCifRWComponent::GetUrlCheckRange(UINT uUrlNum, LPDWORD pdwMin, LPDWORD pdwMax)
{
return(CCifComponent::GetUrlCheckRange(uUrlNum, pdwMin, pdwMax));
}
STDMETHODIMP CCifRWComponent::GetCommand(UINT uCmdNum, LPSTR pszCmd, DWORD dwCmdSize, LPSTR pszSwitches,
DWORD dwSwitchSize, LPDWORD pdwType)
{
return(CCifComponent::GetCommand(uCmdNum, pszCmd, dwCmdSize, pszSwitches, dwSwitchSize, pdwType));
}
STDMETHODIMP CCifRWComponent::GetVersion(LPDWORD pdwVersion, LPDWORD pdwBuild)
{
return(CCifComponent::GetVersion(pdwVersion, pdwBuild));
}
STDMETHODIMP CCifRWComponent::GetLocale(LPSTR pszLocale, DWORD dwSize)
{
return(CCifComponent::GetLocale(pszLocale, dwSize));
}
STDMETHODIMP CCifRWComponent::GetUninstallKey(LPSTR pszKey, DWORD dwSize)
{
return(CCifComponent::GetUninstallKey(pszKey, dwSize));
}
STDMETHODIMP CCifRWComponent::GetInstalledSize(LPDWORD pdwWin, LPDWORD pdwApp)
{
return(CCifComponent::GetInstalledSize(pdwWin, pdwApp));
}
STDMETHODIMP_(DWORD) CCifRWComponent::GetDownloadSize()
{
return(CCifComponent::GetDownloadSize());
}
STDMETHODIMP_(DWORD) CCifRWComponent::GetExtractSize()
{
return(CCifComponent::GetExtractSize());
}
STDMETHODIMP CCifRWComponent::GetSuccessKey(LPSTR pszKey, DWORD dwSize)
{
return(CCifComponent::GetSuccessKey(pszKey, dwSize));
}
STDMETHODIMP CCifRWComponent::GetProgressKeys(LPSTR pszProgress, DWORD dwProgSize,
LPSTR pszCancel, DWORD dwCancelSize)
{
return(CCifComponent::GetProgressKeys(pszProgress, dwProgSize, pszCancel, dwCancelSize));
}
STDMETHODIMP CCifRWComponent::IsActiveSetupAware()
{
return(CCifComponent::IsActiveSetupAware());
}
STDMETHODIMP CCifRWComponent::IsRebootRequired()
{
return(CCifComponent::IsActiveSetupAware());
}
STDMETHODIMP CCifRWComponent::RequiresAdminRights()
{
return(CCifComponent::RequiresAdminRights());
}
STDMETHODIMP_(DWORD) CCifRWComponent::GetPriority()
{
return(CCifComponent::GetPriority());
}
STDMETHODIMP CCifRWComponent::GetDependency(UINT uDepNum, LPSTR pszID, DWORD dwBuf, char *pchType, LPDWORD pdwVer, LPDWORD pdwBuild)
{
return(CCifComponent::GetDependency(uDepNum, pszID, dwBuf, pchType, pdwVer, pdwBuild));
}
STDMETHODIMP_(DWORD) CCifRWComponent::GetPlatform()
{
return(CCifComponent::GetPlatform());
}
STDMETHODIMP CCifRWComponent::GetMode(UINT uModeNum, LPSTR pszModes, DWORD dwSize)
{
return(CCifComponent::GetMode(uModeNum, pszModes, dwSize));
}
STDMETHODIMP CCifRWComponent::GetTreatAsOneComponents(UINT uNum, LPSTR pszID, DWORD dwBuf)
{
return(CCifComponent::GetTreatAsOneComponents(uNum, pszID, dwBuf));
}
STDMETHODIMP CCifRWComponent::GetCustomData(LPSTR pszKey, LPSTR pszData, DWORD dwSize)
{
return(CCifComponent::GetCustomData(pszKey, pszData, dwSize));
}
STDMETHODIMP CCifRWComponent::GetGroup(LPSTR pszID, DWORD dwSize)
{
return(CCifComponent::GetGroup(pszID, dwSize));
}
STDMETHODIMP CCifRWComponent::IsUIVisible()
{
return(CCifComponent::IsUIVisible());
}
STDMETHODIMP CCifRWComponent::GetPatchID(LPSTR pszID, DWORD dwSize)
{
return(CCifComponent::GetPatchID(pszID, dwSize));
}
STDMETHODIMP_(DWORD) CCifRWComponent::IsComponentInstalled()
{
return(CCifComponent::IsComponentInstalled());
}
STDMETHODIMP CCifRWComponent::IsComponentDownloaded()
{
return(CCifComponent::IsComponentDownloaded());
}
STDMETHODIMP_(DWORD) CCifRWComponent::IsThisVersionInstalled(DWORD dwAskVer, DWORD dwAskBld, LPDWORD pdwVersion, LPDWORD pdwBuild)
{
return(CCifComponent::IsThisVersionInstalled(dwAskVer, dwAskBld, pdwVersion, pdwBuild));
}
STDMETHODIMP_(DWORD) CCifRWComponent::GetInstallQueueState()
{
return(CCifComponent::GetInstallQueueState());
}
STDMETHODIMP CCifRWComponent::SetInstallQueueState(DWORD dwState)
{
return(CCifComponent::SetInstallQueueState(dwState));
}
STDMETHODIMP_(DWORD) CCifRWComponent::GetActualDownloadSize()
{
return(CCifComponent::GetActualDownloadSize());
}
STDMETHODIMP_(DWORD) CCifRWComponent::GetCurrentPriority()
{
return(CCifComponent::GetCurrentPriority());
}
STDMETHODIMP CCifRWComponent::SetCurrentPriority(DWORD dwPriority)
{
return(CCifComponent::SetCurrentPriority(dwPriority));
}
STDMETHODIMP CCifRWComponent:: GetDetVersion(LPSTR pszDLL, DWORD dwdllSize, LPSTR pszEntry, DWORD dwentSize)
{
return(CCifComponent::GetDetVersion(pszDLL, dwdllSize, pszEntry, dwentSize));
}
STDMETHODIMP CCifRWComponent::SetGUID(LPCSTR pszGUID)
{
return (WritePrivateProfileString(_szID, GUID_KEY, pszGUID, _pCif->GetCifPath())? NOERROR:E_FAIL);
}
STDMETHODIMP CCifRWComponent::SetDescription(LPCSTR pszDesc)
{
return (WriteTokenizeString(_pCif->GetCifPath(), _szID, DISPLAYNAME_KEY, pszDesc));
}
STDMETHODIMP CCifRWComponent::SetDetails(LPCSTR pszDesc)
{
return (WriteTokenizeString(_pCif->GetCifPath(), _szID, DETAILS_KEY, pszDesc));
}
STDMETHODIMP CCifRWComponent::SetVersion(LPCSTR pszVersion)
{
return (WritePrivateProfileString(_szID, VERSION_KEY, pszVersion, _pCif->GetCifPath())? NOERROR:E_FAIL);
}
STDMETHODIMP CCifRWComponent::SetUninstallKey(LPCSTR pszKey)
{
return (MyWritePrivateProfileString(_szID, UNINSTALLSTRING_KEY, pszKey, _pCif->GetCifPath())? NOERROR:E_FAIL);
}
STDMETHODIMP CCifRWComponent::SetInstalledSize(DWORD dwWin, DWORD dwApp)
{
char szBuf[50];
wsprintf(szBuf,"%d,%d", dwWin, dwApp);
return (WritePrivateProfileString(_szID, INSTALLSIZE_KEY, szBuf, _pCif->GetCifPath())? NOERROR:E_FAIL);
}
STDMETHODIMP CCifRWComponent::SetDownloadSize(DWORD dwSize)
{
char szBuf1[MAX_VALUE_LEN];
char szBuf2[MAX_VALUE_LEN];
DWORD dwExtractSize;
szBuf1[0] = '\0';
// Read in size
GetPrivateProfileString(_szID, SIZE_KEY, "0", szBuf1, sizeof(szBuf1), _pCif->GetCifPath());
dwExtractSize = GetIntField(szBuf1, 1, (DWORD)-1);
if (dwExtractSize == (DWORD)-1)
wsprintf(szBuf2,"%d", dwSize);
else
wsprintf(szBuf2,"%d,%d", dwSize, dwExtractSize);
return (WritePrivateProfileString(_szID, SIZE_KEY, szBuf2, _pCif->GetCifPath())? NOERROR:E_FAIL);
}
STDMETHODIMP CCifRWComponent::SetExtractSize(DWORD dwSize)
{
char szBuf1[MAX_VALUE_LEN];
char szBuf2[MAX_VALUE_LEN];
szBuf1[0] = '\0';
// Read in size
GetPrivateProfileString(_szID, SIZE_KEY, "0,0", szBuf1, sizeof(szBuf1), _pCif->GetCifPath());
wsprintf(szBuf2,"%d,%d", GetIntField(szBuf1, 0, 0), dwSize);
return (WritePrivateProfileString(_szID, SIZE_KEY, szBuf2, _pCif->GetCifPath())? NOERROR:E_FAIL);
}
STDMETHODIMP CCifRWComponent::DeleteDependency(LPCSTR pszID, char chType)
{
HRESULT hr;
if (pszID == NULL) //delete all from all modes
hr = WritePrivateProfileString(_szID, DEPENDENCY_KEY, NULL, _pCif->GetCifPath())?NOERROR:E_FAIL;
else
{
// delete only the given ones
char szBuf[MAX_VALUE_LEN];
char szBufIn[MAX_VALUE_LEN];
char szBufOut[MAX_VALUE_LEN];
char szOne[MAX_ID_LENGTH];
LPSTR pszTmp;
UINT i = 0;
szBufOut[0] =0;
wsprintf( szBuf, "%s:%c", pszID, chType);
if (GetPrivateProfileString(_szID, DEPENDENCY_KEY, "", szBufIn, sizeof(szBufIn), _pCif->GetCifPath()))
{
pszTmp = szBufOut;
while(GetStringField(szBufIn, i++, szOne, sizeof(szOne)))
{
if (lstrcmpi(szOne, szBuf))
{
if ( i != 1)
{
lstrcpy(pszTmp,",");
pszTmp++;
}
lstrcpy(pszTmp, szOne);
pszTmp = pszTmp + lstrlen(szOne);
}
}
hr = WritePrivateProfileString(_szID, DEPENDENCY_KEY, szBufOut, _pCif->GetCifPath())? NOERROR:E_FAIL;
}
}
return hr;
}
STDMETHODIMP CCifRWComponent::AddDependency(LPCSTR pszID, char chType)
{
char szBuf[MAX_VALUE_LEN];
char szBuf1[MAX_VALUE_LEN];
char szOne[MAX_ID_LENGTH];
LPSTR pszTmp;
UINT i = 0;
BOOL bFound = FALSE;
HRESULT hr = NOERROR;
if (pszID==NULL)
return hr;
if (chType == '\\')
wsprintf( szBuf1, "%s:N:6.0.0.0", pszID, chType);
else
wsprintf( szBuf1, "%s:%c", pszID, chType);
if (GetPrivateProfileString(_szID, DEPENDENCY_KEY, "", szBuf, sizeof(szBuf), _pCif->GetCifPath()))
{
while(GetStringField(szBuf, i++, szOne, sizeof(szOne)))
{
if (lstrcmpi(szOne, szBuf1) == 0)
{
// found it, no need to add
bFound = TRUE;
break;
}
}
if (!bFound)
{
LPSTR pszTmp = szBuf + lstrlen(szBuf);
lstrcpy(pszTmp, ",");
pszTmp++;
lstrcpy(pszTmp, szBuf1);
hr = WritePrivateProfileString(_szID, DEPENDENCY_KEY, szBuf, _pCif->GetCifPath())? NOERROR:E_FAIL;
}
}
else
hr = WritePrivateProfileString(_szID, DEPENDENCY_KEY, szBuf1, _pCif->GetCifPath())? NOERROR:E_FAIL;
return hr;
}
STDMETHODIMP CCifRWComponent::SetUIVisible(BOOL bFlag)
{
return (WritePrivateProfileString(_szID, UIVISIBLE_KEY, bFlag? "1" : "0", _pCif->GetCifPath())? NOERROR:E_FAIL);
}
STDMETHODIMP CCifRWComponent::SetGroup(LPCSTR pszID)
{
return (WritePrivateProfileString(_szID, GROUP_KEY, pszID, _pCif->GetCifPath())? NOERROR:E_FAIL);
}
STDMETHODIMP CCifRWComponent::SetPlatform(DWORD dwPlatform)
{
char szBuf[MAX_VALUE_LEN];
char *rszPlatforms[7] = { STR_WIN95, STR_WIN98, STR_NT4, STR_NT5, STR_NT4ALPHA, STR_NT5ALPHA, STR_MILLEN };
DWORD rdwPlatforms[] = { PLATFORM_WIN95, PLATFORM_WIN98, PLATFORM_NT4, PLATFORM_NT5,
PLATFORM_NT4ALPHA, PLATFORM_NT5ALPHA, PLATFORM_MILLEN };
_dwPlatform = dwPlatform;
szBuf[0] = 0;
for(int i = 0; i < 7; i++)
{
if(dwPlatform & rdwPlatforms[i])
{
lstrcat(szBuf, rszPlatforms[i]);
lstrcat(szBuf, ",");
}
}
return (WritePrivateProfileString(_szID, PLATFORM_KEY, szBuf, _pCif->GetCifPath())? NOERROR:E_FAIL);
}
STDMETHODIMP CCifRWComponent::SetPriority(DWORD dwPri)
{
char szBuf[MAX_SMALL_BUF];
wsprintf(szBuf, "%d", dwPri);
return (WritePrivateProfileString(_szID, PRIORITY, szBuf, _pCif->GetCifPath())? NOERROR:E_FAIL);
}
STDMETHODIMP CCifRWComponent::SetReboot(BOOL bReboot)
{
return (WritePrivateProfileString(_szID, REBOOT_KEY, bReboot? "1":"0", _pCif->GetCifPath())? NOERROR:E_FAIL);
}
STDMETHODIMP CCifRWComponent::SetCommand(UINT uCmdNum, LPCSTR pszCmd, LPCSTR pszSwitches, DWORD dwType)
{
char szKey[16];
char szType[10];
HRESULT hr = NOERROR;
uCmdNum++;
wsprintf(szKey, "%s%lu", CMD_KEY, uCmdNum);
if (!MyWritePrivateProfileString(_szID, szKey, pszCmd, _pCif->GetCifPath()))
hr = E_FAIL;
wsprintf(szKey, "%s%lu", ARGS_KEY, uCmdNum);
if(!MyWritePrivateProfileString(_szID, szKey, (pszCmd==NULL)?NULL:pszSwitches, _pCif->GetCifPath()))
hr = E_FAIL;
wsprintf(szKey, "%s%lu", TYPE_KEY, uCmdNum);
wsprintf(szType,"%d", dwType);
if(!WritePrivateProfileString(_szID, szKey, (pszCmd==NULL)? NULL:szType, _pCif->GetCifPath()))
hr = E_FAIL;
return hr;
}
STDMETHODIMP CCifRWComponent::SetUrl(UINT uUrlNum, LPCSTR pszUrl, DWORD dwUrlFlags)
{
char szKey[16];
char szBuf[MAX_VALUE_LEN];
HRESULT hr = NOERROR;
uUrlNum++;
wsprintf(szKey, "%s%lu", URL_KEY, uUrlNum);
wsprintf(szBuf, "\"%s\",%d", pszUrl, dwUrlFlags);
if (!WritePrivateProfileString(_szID, szKey, szBuf, _pCif->GetCifPath()))
hr = E_FAIL;
wsprintf(szKey, "%s%lu", SIZE_KEY, uUrlNum);
if(!WritePrivateProfileString(_szID, szKey, NULL, _pCif->GetCifPath()))
hr = E_FAIL;
return hr;
}
STDMETHODIMP CCifRWComponent::DeleteFromModes(LPCSTR pszMode)
{
HRESULT hr;
if (pszMode == NULL) //delete all from all modes
hr = WritePrivateProfileString(_szID, MODES_KEY, pszMode, _pCif->GetCifPath())?NOERROR:E_FAIL;
else
{
// delete only the given ones
char szBufIn[MAX_VALUE_LEN];
char szBufOut[MAX_VALUE_LEN];
char szOneMode[MAX_ID_LENGTH];
LPSTR pszTmp;
UINT i = 0;
szBufOut[0] =0;
if (SUCCEEDED(MyTranslateString(_pCif->GetCifPath(), _szID, MODES_KEY, szBufIn, sizeof(szBufIn))))
{
pszTmp = szBufOut;
while(GetStringField(szBufIn, i++, szOneMode, sizeof(szOneMode)))
{
if (lstrcmpi(szOneMode, pszMode))
{
if ( i != 1)
{
lstrcpy(pszTmp,",");
pszTmp++;
}
lstrcpy(pszTmp, szOneMode);
pszTmp = pszTmp + lstrlen(szOneMode);
}
}
hr = WriteTokenizeString(_pCif->GetCifPath(), _szID, MODES_KEY, szBufOut);
}
}
return hr;
}
STDMETHODIMP CCifRWComponent::AddToMode(LPCSTR pszMode)
{
char szBuf[MAX_VALUE_LEN];
char szOneMode[MAX_ID_LENGTH];
LPSTR pszTmp;
UINT i = 0;
BOOL bFound = FALSE;
HRESULT hr = NOERROR;
if (SUCCEEDED(MyTranslateString(_pCif->GetCifPath(), _szID, MODES_KEY, szBuf, sizeof(szBuf))))
{
while(GetStringField(szBuf, i++, szOneMode, sizeof(szOneMode)))
{
if (lstrcmpi(szOneMode, pszMode) == 0)
{
// found it, no need to add
bFound = TRUE;
break;
}
}
if (!bFound)
{
LPSTR pszTmp = szBuf + lstrlen(szBuf);
lstrcpy(pszTmp, ",");
pszTmp++;
lstrcpy(pszTmp, pszMode);
hr = WriteTokenizeString(_pCif->GetCifPath(), _szID, MODES_KEY, szBuf);
}
}
else
hr = WritePrivateProfileString(_szID, MODES_KEY, pszMode, _pCif->GetCifPath()) ? NOERROR : E_FAIL;
return hr;
}
STDMETHODIMP CCifRWComponent::SetModes(LPCSTR pszMode)
{
return (WriteTokenizeString(_pCif->GetCifPath(), _szID, MODES_KEY, pszMode)?NOERROR:E_FAIL);
}
STDMETHODIMP CCifRWComponent::CopyComponent(LPCSTR pszCifFile)
{
LPSTR pszSec;
DWORD dwSize;
HRESULT hr = NOERROR;
dwSize = MAX_VALUE_LEN*4*4;
pszSec = (LPSTR)LocalAlloc(LPTR, dwSize); //allocate 4K buffer to read section
while(pszSec && GetPrivateProfileSection(_szID, pszSec, dwSize, pszCifFile)==(dwSize-2))
{
LocalFree(pszSec);
dwSize = dwSize*2;
pszSec = (LPSTR)LocalAlloc(LPTR, dwSize);
}
if (pszSec)
{
// first clean the Old section if there
WritePrivateProfileString(_szID, NULL, NULL, _pCif->GetCifPath());
// write out the copied section
WritePrivateProfileSection(_szID, pszSec, _pCif->GetCifPath());
LocalFree(pszSec);
}
else
hr = E_OUTOFMEMORY;
// need to check to see if we need to get strings out of the Strings section
CopyCifString(_szID, DISPLAYNAME_KEY, pszCifFile, _pCif->GetCifPath());
CopyCifString(_szID, DETAILS_KEY, pszCifFile, _pCif->GetCifPath());
CopyCifString(_szID, MODES_KEY, pszCifFile, _pCif->GetCifPath());
CopyCifString(_szID, LOCALE_KEY, pszCifFile, _pCif->GetCifPath());
return hr;
}
STDMETHODIMP CCifRWComponent::AddToTreatAsOne(LPCSTR pszCompID)
{
char szBuf[MAX_VALUE_LEN];
char szOneID[MAX_ID_LENGTH];
LPSTR pszTmp;
UINT i = 0;
BOOL bFound = FALSE;
HRESULT hr = NOERROR;
if (SUCCEEDED(MyTranslateString(_pCif->GetCifPath(), _szID, TREATAS_KEY, szBuf, sizeof(szBuf))))
{
while(GetStringField(szBuf, i++, szOneID, sizeof(szOneID)))
{
if (lstrcmpi(szOneID, pszCompID) == 0)
{
// found it, no need to add
bFound = TRUE;
break;
}
}
if (!bFound)
{
LPSTR pszTmp = szBuf + lstrlen(szBuf);
lstrcpy(pszTmp, ",");
pszTmp++;
lstrcpy(pszTmp, pszCompID);
hr = WriteTokenizeString(_pCif->GetCifPath(), _szID, TREATAS_KEY, szBuf);
}
}
else
hr = WritePrivateProfileString(_szID, TREATAS_KEY, pszCompID, _pCif->GetCifPath()) ? NOERROR : E_FAIL;
return hr;
}