1468 lines
49 KiB
C++
1468 lines
49 KiB
C++
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
//
|
|
// Copyright (C) Microsoft Corporation, 2000
|
|
//
|
|
// File: selfupdate.cpp
|
|
//
|
|
// Desc: This file contains all the functions necessary for self-update
|
|
//--------------------------------------------------------------------------
|
|
|
|
#include "pch.h"
|
|
|
|
#include <osdet.h>
|
|
#include <muiutil.h>
|
|
|
|
#define TCHAR_SCTRUCTURE_DELIMITER _T('|')
|
|
|
|
struct AU_FILEINCAB
|
|
{
|
|
TCHAR szFilePath[MAX_PATH + 1];
|
|
TCHAR szNewFilePath[MAX_PATH + 1];
|
|
TCHAR szBackupFilePath[MAX_PATH + 1];
|
|
TCHAR szExtractFilePath[MAX_PATH + 1];
|
|
BOOL fCreatedBackup;
|
|
BOOL fFileExists;
|
|
AU_FILEINCAB *pNextFileInCab;
|
|
};
|
|
|
|
struct AU_COMPONENT : AU_FILEINCAB
|
|
{
|
|
TCHAR *pszSectionName;
|
|
TCHAR szFileName[_MAX_FNAME + 1];
|
|
TCHAR szCabName[_MAX_FNAME + 1];
|
|
TCHAR szCabPath[MAX_PATH + 1];
|
|
CHAR a_szCabPath[MAX_PATH + 1];
|
|
TCHAR szInfName[_MAX_FNAME + 1];
|
|
CHAR a_szInfName[_MAX_FNAME + 1];
|
|
DWORD dwUpdateMS;
|
|
DWORD dwUpdateLS;
|
|
BOOL fDoUpgrade;
|
|
BOOL fNeedToCheckMui;
|
|
BOOL fMuiFile;
|
|
BOOL fHasHelpfile;
|
|
AU_COMPONENT *pNext;
|
|
};
|
|
|
|
|
|
// AU_UPDATE_VERSION should be updated when incompatible changes are made to the
|
|
// self update mechanism required AU to go to a new directory for update info.
|
|
const TCHAR IDENT_TXT[] = _T("iuident.txt");
|
|
const TCHAR WUAUCOMP_CAB[] = _T("wuaucomp.cab");
|
|
const TCHAR WUAUCOMP_CIF[] = _T("wuaucomp.cif");
|
|
const TCHAR WUAUENG_DLL[] = TEXT("wuaueng.dll");
|
|
const TCHAR AU_KEY_FILE_NAME[] = TEXT("file");
|
|
const TCHAR AU_KEY_FILE_VERSION[] = TEXT("version");
|
|
const TCHAR AU_KEY_CAB_NAME[] = TEXT("cab");
|
|
const TCHAR AU_KEY_INF_NAME[] = TEXT("inf");
|
|
const TCHAR AU_KEY_RESMOD_NAME[] = TEXT("resmodule");
|
|
const TCHAR AU_KEY_HELPFILE[] = TEXT("helpfile");
|
|
const DWORD MAX_SECTION = 30;
|
|
|
|
// main selfupdate keys
|
|
const TCHAR IDENT_SERVERURLEX[] = _T("ServerUrlEx");
|
|
const TCHAR IDENT_STRUCTUREKEYEX[] = _T("StructureKeyEx");
|
|
|
|
const TCHAR INIVALUE_NOTFOUND[] = _T("??");
|
|
|
|
BOOL fConvertVersionStrToDwords(LPTSTR pszVer, LPDWORD pdwVer, LPDWORD pdwBuild);
|
|
HRESULT InstallUpdatedComponents(LPCTSTR pszSelfUpdateUrl,
|
|
LPCTSTR pszMuiUpdateUrl,
|
|
LPCTSTR pszIdentTxt,
|
|
LPCTSTR pszFileCacheDir,
|
|
LPCTSTR pszCif,
|
|
BOOL *pfInstalledWUAUENG);
|
|
BOOL ReplaceFileInPath(LPCTSTR pszPath, LPCTSTR szNewFile, LPTSTR pszNewPathBuf, DWORD cchNewPathBuf);
|
|
BOOL MyGetPrivateProfileString( IN LPCWSTR lpAppName,
|
|
IN LPCWSTR lpKeyName,
|
|
OUT LPWSTR lpReturnedString,
|
|
IN DWORD nSize,
|
|
IN LPCWSTR lpFileName,
|
|
IN LPCTSTR lpDefault=_T(""));
|
|
|
|
inline BOOL fNewerFile(DWORD dwUpdateMS, DWORD dwUpdateLS, DWORD dwExistingMS, DWORD dwExistingLS)
|
|
{
|
|
return (dwUpdateMS > dwExistingMS) ||
|
|
((dwUpdateMS == dwExistingMS) && (dwUpdateLS > dwExistingLS));
|
|
}
|
|
|
|
inline HRESULT vAU_W2A(LPCWSTR lpWideCharStr, LPSTR lpMultiByteStr, int cbMultiByte)
|
|
{
|
|
if ( 0 != WideCharToMultiByte(CP_ACP, 0, lpWideCharStr, -1, lpMultiByteStr, cbMultiByte, NULL, NULL))
|
|
{
|
|
return S_OK;
|
|
}
|
|
else
|
|
{
|
|
return HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
}
|
|
|
|
HRESULT SelfUpdate(void)
|
|
{
|
|
HRESULT hr;
|
|
BOOL fInstalledWUAUENG = FALSE;
|
|
|
|
DEBUGMSG("------------------------SELFUPDATE BEGINS---------------------------");
|
|
|
|
|
|
if( FAILED(hr = CheckForUpdatedComponents(&fInstalledWUAUENG)) )
|
|
{
|
|
goto lCleanUp;
|
|
}
|
|
|
|
if ( fInstalledWUAUENG )
|
|
{
|
|
DEBUGMSG("SELFUPDATE installed new wuaueng");
|
|
hr = S_FALSE;
|
|
goto lCleanUp;
|
|
}
|
|
|
|
lCleanUp:
|
|
return hr;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CleanFileCache()
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
BOOL CleanFileCache(LPCTSTR pszFileCacheDir)
|
|
{
|
|
BOOL fRet = TRUE;
|
|
TCHAR szFileCacheDir[MAX_PATH + 1];
|
|
TCHAR szFilePath[MAX_PATH + 1];
|
|
WIN32_FIND_DATA fd;
|
|
HANDLE hFindFile = INVALID_HANDLE_VALUE;
|
|
|
|
|
|
if (FAILED(StringCchCopyEx(szFileCacheDir, ARRAYSIZE(szFileCacheDir), pszFileCacheDir, NULL, NULL, MISTSAFE_STRING_FLAGS)))
|
|
{
|
|
fRet = FALSE;
|
|
goto done;
|
|
}
|
|
|
|
if (FAILED(PathCchAppend(szFileCacheDir, ARRAYSIZE(szFileCacheDir), TEXT("*.*"))))
|
|
{
|
|
fRet = FALSE;
|
|
goto done;
|
|
}
|
|
|
|
// Find the first file
|
|
hFindFile = FindFirstFile(szFileCacheDir, &fd);
|
|
|
|
if ( INVALID_HANDLE_VALUE == hFindFile )
|
|
{
|
|
goto done;
|
|
}
|
|
|
|
do
|
|
{
|
|
if ( !(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) )
|
|
{
|
|
// Make file path
|
|
if (FAILED(StringCchCopyEx(szFilePath, ARRAYSIZE(szFilePath), pszFileCacheDir, NULL, NULL, MISTSAFE_STRING_FLAGS)) ||
|
|
FAILED(PathCchAppend(szFilePath, ARRAYSIZE(szFilePath), fd.cFileName)) ||
|
|
!SetFileAttributes(szFilePath, FILE_ATTRIBUTE_NORMAL) ||
|
|
!DeleteFile(szFilePath))
|
|
{
|
|
fRet = FALSE;
|
|
DEBUGMSG("Couldn't delete file %S", szFilePath);
|
|
}
|
|
}
|
|
}
|
|
while ( FindNextFile(hFindFile, &fd) );// Find the next entry
|
|
|
|
done:
|
|
if ( INVALID_HANDLE_VALUE != hFindFile )
|
|
{
|
|
FindClose(hFindFile);
|
|
}
|
|
|
|
return fRet;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
//
|
|
// GetSelfUpdateUrl()
|
|
//
|
|
// Should be like:
|
|
//
|
|
// http://windowsupdate.microsoft.com/selfupdate/x86/XP/en
|
|
////////////////////////////////////////////////////////////////////////
|
|
HRESULT GetSelfUpdateUrl(LPCTSTR ptszName,
|
|
LPCTSTR ptszBaseUrl,
|
|
LPCTSTR pszIdentTxt,
|
|
LPTSTR pszSelfUpdateUrl,
|
|
DWORD cchSelfUpdateUrl,
|
|
LPTSTR pszMuiUpdateUrl,
|
|
DWORD cchMuiUpdateUrl)
|
|
{
|
|
LOG_Block("GetSelfUpdateUrl");
|
|
HRESULT hr;
|
|
TCHAR tszKey[MAX_SECTION]; // at least MAX_ISO_CODE_LENGTH
|
|
TCHAR tszValue[MAX_PATH];
|
|
BOOL fLangField;
|
|
|
|
if (FAILED(hr = StringCchCopyEx(tszKey, ARRAYSIZE(tszKey), ptszName, NULL, NULL, MISTSAFE_STRING_FLAGS)) ||
|
|
FAILED(hr = StringCchCatEx(tszKey, ARRAYSIZE(tszKey), _T("SelfUpdate"), NULL, NULL, MISTSAFE_STRING_FLAGS)))
|
|
{
|
|
goto lFinish;
|
|
}
|
|
|
|
if (NULL == ptszBaseUrl)
|
|
{
|
|
// Get SelfUpdate Server URL
|
|
if (MyGetPrivateProfileString(
|
|
tszKey,
|
|
IDENT_SERVERURLEX,
|
|
pszSelfUpdateUrl,
|
|
cchSelfUpdateUrl,
|
|
pszIdentTxt) == FALSE)
|
|
{
|
|
// no URL specified in iuident..
|
|
hr = E_FAIL;
|
|
goto lFinish;
|
|
}
|
|
else
|
|
{
|
|
if (FAILED(hr = StringCchCopyEx(pszMuiUpdateUrl, cchMuiUpdateUrl, pszSelfUpdateUrl, NULL, NULL, MISTSAFE_STRING_FLAGS)))
|
|
goto lFinish;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (FAILED(hr = StringCchCopyEx(pszSelfUpdateUrl, cchSelfUpdateUrl, ptszBaseUrl, NULL, NULL, MISTSAFE_STRING_FLAGS)) ||
|
|
FAILED(hr = StringCchCopyEx(pszMuiUpdateUrl, cchMuiUpdateUrl, ptszBaseUrl, NULL, NULL, MISTSAFE_STRING_FLAGS)))
|
|
{
|
|
goto lFinish;
|
|
}
|
|
// Remove trailing _T('/') if present
|
|
int nBaseUrlLen = lstrlen(pszSelfUpdateUrl);
|
|
|
|
if(nBaseUrlLen <= 0)
|
|
{
|
|
hr = E_FAIL;
|
|
goto lFinish;
|
|
}
|
|
if (_T('/') == pszSelfUpdateUrl[nBaseUrlLen-1])
|
|
{
|
|
pszSelfUpdateUrl[nBaseUrlLen-1] = _T('\0');
|
|
pszMuiUpdateUrl[nBaseUrlLen-1] = _T('\0');
|
|
}
|
|
}
|
|
|
|
TCHAR tszStructure[MAX_PATH];
|
|
|
|
if (!MyGetPrivateProfileString(
|
|
tszKey,
|
|
IDENT_STRUCTUREKEYEX,
|
|
tszStructure,
|
|
ARRAYSIZE(tszStructure),
|
|
pszIdentTxt))
|
|
{
|
|
// no STRUCTYREKEY specified in iuident..
|
|
hr = E_FAIL;
|
|
goto lFinish;
|
|
}
|
|
|
|
// Parse the SelfUpdate Structure Key for Value Names to Read
|
|
LPTSTR ptszWalk = tszStructure;
|
|
while (_T('\0') != ptszWalk[0])
|
|
{
|
|
LPTSTR ptszDelim;
|
|
|
|
fLangField = FALSE;
|
|
|
|
if (NULL != (ptszDelim = StrChr(ptszWalk, TCHAR_SCTRUCTURE_DELIMITER)))
|
|
{
|
|
*ptszDelim = _T('\0');
|
|
}
|
|
|
|
if (_T('/') == ptszWalk[0])
|
|
{
|
|
if (FAILED(hr = StringCchCopyEx(tszValue, ARRAYSIZE(tszValue), ptszWalk, NULL, NULL, MISTSAFE_STRING_FLAGS)))
|
|
{
|
|
goto lFinish;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int nPrefixLength = lstrlen(ptszName);
|
|
LPCTSTR ptszToken = ptszWalk;
|
|
|
|
if (0 == StrCmpNI(ptszWalk, ptszName, nPrefixLength))
|
|
{
|
|
ptszToken += nPrefixLength;
|
|
}
|
|
|
|
if (0 == StrCmpI(ptszToken, IDENT_ARCH))
|
|
{
|
|
if (!MyGetPrivateProfileString(
|
|
ptszWalk,
|
|
#ifdef _IA64_
|
|
IDENT_IA64,
|
|
#else
|
|
IDENT_X86,
|
|
#endif
|
|
tszValue,
|
|
ARRAYSIZE(tszValue),
|
|
pszIdentTxt))
|
|
{
|
|
// insufficient buffer
|
|
hr = E_FAIL;
|
|
goto lFinish;
|
|
}
|
|
}
|
|
else if (0 == StrCmpI(ptszToken, IDENT_OS))
|
|
{
|
|
if (FAILED(hr = StringCchCopyEx(tszKey, ARRAYSIZE(tszKey), ptszWalk, NULL, NULL, MISTSAFE_STRING_FLAGS)) ||
|
|
FAILED(hr = StringCchCatEx(tszKey, ARRAYSIZE(tszKey), _T("NT"), NULL, NULL, MISTSAFE_STRING_FLAGS)))
|
|
{
|
|
goto lFinish;
|
|
}
|
|
|
|
if (S_OK != GetINIValueByOSVer(
|
|
pszIdentTxt,
|
|
tszKey,
|
|
tszValue,
|
|
ARRAYSIZE(tszValue)))
|
|
{
|
|
hr = E_FAIL;
|
|
goto lFinish;
|
|
}
|
|
}
|
|
else if (0 == StrCmpI(ptszToken, IDENT_LANG))
|
|
{
|
|
fLangField = TRUE;
|
|
|
|
// Get the Current Locale String
|
|
(void) LookupLocaleString(tszKey, ARRAYSIZE(tszKey), FALSE);
|
|
|
|
if (0 == StrCmp(tszKey, _T("Error")))
|
|
{
|
|
DEBUGMSG("GetSelfUpdateUrl() call to LookupLocaleString() failed.");
|
|
hr = E_FAIL;
|
|
goto lFinish;
|
|
}
|
|
|
|
if (!MyGetPrivateProfileString(
|
|
ptszWalk,
|
|
tszKey,
|
|
tszValue,
|
|
ARRAYSIZE(tszValue),
|
|
pszIdentTxt,INIVALUE_NOTFOUND))
|
|
{
|
|
hr = E_FAIL;
|
|
goto lFinish;
|
|
}
|
|
if (0 == StrCmp(tszValue, INIVALUE_NOTFOUND))
|
|
{
|
|
LPTSTR ptszDash = StrChr(tszKey, _T('-'));
|
|
|
|
if (NULL != ptszDash)
|
|
{
|
|
*ptszDash = _T('\0');
|
|
if (!MyGetPrivateProfileString(
|
|
ptszWalk,
|
|
tszKey,
|
|
tszValue,
|
|
ARRAYSIZE(tszValue),
|
|
pszIdentTxt))
|
|
{
|
|
hr = E_FAIL;
|
|
goto lFinish;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
tszValue[0] = _T('\0');
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOG_Internet(_T("Found Unrecognized Token in SelfUpdate Structure String: Token was: %s"), ptszWalk);
|
|
tszValue[0] = _T('\0'); // ignore the unrecognized token
|
|
}
|
|
}
|
|
|
|
if (_T('\0') != tszValue[0])
|
|
{
|
|
LPCTSTR ptszMuiCopy;
|
|
|
|
if (FAILED(hr = StringCchCatEx(pszSelfUpdateUrl, cchSelfUpdateUrl, tszValue, NULL, NULL, MISTSAFE_STRING_FLAGS)))
|
|
goto lFinish;
|
|
|
|
if (fLangField)
|
|
ptszMuiCopy = MUI_WEBSUBPATH;
|
|
else
|
|
ptszMuiCopy = tszValue;
|
|
|
|
if (FAILED(hr = StringCchCatEx(pszMuiUpdateUrl, cchMuiUpdateUrl, ptszMuiCopy, NULL, NULL, MISTSAFE_STRING_FLAGS)))
|
|
goto lFinish;
|
|
}
|
|
|
|
if (NULL == ptszDelim)
|
|
{
|
|
break;
|
|
}
|
|
|
|
ptszWalk = ptszDelim + 1; // skip the previous token, and go to the next one in the string.
|
|
*ptszDelim = TCHAR_SCTRUCTURE_DELIMITER;
|
|
}
|
|
|
|
DEBUGMSG("GetSelfUpdateUrl() Self Update URL is %S", pszSelfUpdateUrl);
|
|
DEBUGMSG("GetSelfUpdateUrl() MUI Update URL is %S", pszMuiUpdateUrl);
|
|
hr = S_OK;
|
|
|
|
lFinish:
|
|
if (FAILED(hr))
|
|
{
|
|
if (cchMuiUpdateUrl > 0)
|
|
*pszMuiUpdateUrl = _T('\0');
|
|
if (cchSelfUpdateUrl > 0)
|
|
*pszSelfUpdateUrl = _T('\0');
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CheckForUpdatedComponents
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
HRESULT CheckForUpdatedComponents(BOOL *pfInstalledWUAUENG)
|
|
{
|
|
HRESULT hr;
|
|
LPCTSTR ptszIdentServerUrl = NULL;
|
|
LPTSTR ptszSelfUpdateUrl = NULL;
|
|
LPTSTR ptszMuiUpdateUrl = NULL;
|
|
|
|
if (NULL != (ptszSelfUpdateUrl = (LPTSTR) malloc(sizeof(TCHAR) * INTERNET_MAX_URL_LENGTH)) &&
|
|
NULL != (ptszMuiUpdateUrl = (LPTSTR) malloc(sizeof(TCHAR) * INTERNET_MAX_URL_LENGTH)) &&
|
|
NULL != (ptszIdentServerUrl = gpState->GetIdentServerURL()))
|
|
{
|
|
TCHAR szFileCacheDir[MAX_PATH+1];
|
|
|
|
|
|
if ( FAILED(hr = MakeTempDownloadDir(szFileCacheDir, ARRAYSIZE(szFileCacheDir))) ||
|
|
!CleanFileCache(szFileCacheDir) )
|
|
{
|
|
DEBUGMSG("Couldn't fully clean file cache %S", szFileCacheDir);
|
|
hr = FAILED(hr) ? hr : E_FAIL;
|
|
goto done;
|
|
}
|
|
|
|
BOOL fInCorpWU = gpState->fInCorpWU();
|
|
|
|
if (IsConnected(ptszIdentServerUrl, !fInCorpWU))
|
|
{
|
|
DWORD dwFlags = 0;
|
|
|
|
if (fInCorpWU)
|
|
{
|
|
dwFlags |= WUDF_DONTALLOWPROXY;
|
|
}
|
|
|
|
if (SUCCEEDED(hr = DownloadIUIdent(
|
|
ghServiceFinished,
|
|
ptszIdentServerUrl,
|
|
szFileCacheDir,
|
|
dwFlags)))
|
|
{
|
|
TCHAR tszIdentTxt[MAX_PATH];
|
|
|
|
gPingStatus.ReadLiveServerUrlFromIdent();
|
|
|
|
hr = PathCchCombine(tszIdentTxt, ARRAYSIZE(tszIdentTxt),
|
|
szFileCacheDir, IDENT_TXT);
|
|
if (FAILED(hr))
|
|
goto done;
|
|
|
|
if (SUCCEEDED(hr = GetSelfUpdateUrl(
|
|
_T("AU"),
|
|
gpState->GetSelfUpdateServerURLOverride(),
|
|
tszIdentTxt,
|
|
ptszSelfUpdateUrl,
|
|
INTERNET_MAX_URL_LENGTH,
|
|
ptszMuiUpdateUrl,
|
|
INTERNET_MAX_URL_LENGTH)) &&
|
|
SUCCEEDED(hr = DownloadCab(
|
|
ghServiceFinished,
|
|
WUAUCOMP_CAB,
|
|
ptszSelfUpdateUrl,
|
|
szFileCacheDir,
|
|
dwFlags)))
|
|
{
|
|
TCHAR szWuaucompCif[MAX_PATH+1];
|
|
|
|
if (SUCCEEDED(hr = PathCchCombine(szWuaucompCif, ARRAYSIZE(szWuaucompCif), szFileCacheDir, WUAUCOMP_CIF)))
|
|
{
|
|
// install any updated components
|
|
hr = InstallUpdatedComponents(
|
|
ptszSelfUpdateUrl,
|
|
ptszMuiUpdateUrl,
|
|
tszIdentTxt,
|
|
szFileCacheDir,
|
|
szWuaucompCif,
|
|
pfInstalledWUAUENG);
|
|
#ifdef DBG
|
|
if (FAILED(hr))
|
|
{
|
|
DEBUGMSG("InstallUpdatedComponents failed");
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DEBUGMSG("SelfUpdate: No connection found.");
|
|
hr = E_FAIL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
|
|
done:
|
|
SafeFree(ptszSelfUpdateUrl);
|
|
SafeFree(ptszMuiUpdateUrl);
|
|
return hr;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// SfcMoveFileEx
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
BOOL SfcMoveFileEx( IN LPCTSTR lpExistingFileName,
|
|
IN LPCTSTR lpNewFileName,
|
|
IN LPCTSTR lpSfcProtectedFile,
|
|
IN HANDLE SfcRpcHandle)
|
|
{
|
|
BOOL fRet = TRUE;
|
|
|
|
if ( SfcIsFileProtected(SfcRpcHandle, lpSfcProtectedFile) &&
|
|
(ERROR_SUCCESS != SfcFileException(SfcRpcHandle,
|
|
lpSfcProtectedFile,
|
|
SFC_ACTION_RENAMED_OLD_NAME)) )
|
|
{
|
|
fRet = FALSE;
|
|
goto done;
|
|
}
|
|
|
|
fRet = MoveFileEx(lpExistingFileName, lpNewFileName, MOVEFILE_REPLACE_EXISTING);
|
|
|
|
done:
|
|
if ( !fRet )
|
|
{
|
|
DEBUGMSG("Could not rename %S --> %S", lpExistingFileName, lpNewFileName);
|
|
}
|
|
|
|
return fRet;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function BuildPaths()
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT BuildPaths(AU_FILEINCAB *paufic, LPCTSTR pszFileName, LPCTSTR pszBasePath, LPCTSTR pszExtractBase,
|
|
AU_LANG *paul)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if (paufic == NULL || pszFileName == NULL || pszExtractBase == NULL)
|
|
{
|
|
hr = E_INVALIDARG;
|
|
goto done;
|
|
}
|
|
|
|
if (pszBasePath != NULL)
|
|
{
|
|
// build the full file path
|
|
hr = PathCchCombine(paufic->szFilePath, ARRAYSIZE(paufic->szFilePath),
|
|
pszBasePath, pszFileName);
|
|
if (FAILED(hr))
|
|
goto done;
|
|
|
|
paufic->fFileExists = fFileExists(paufic->szFilePath);
|
|
}
|
|
|
|
// file path we'll temporarily copy the original file to
|
|
if (ReplaceFileExtension(paufic->szFilePath, _T(".bak"),
|
|
paufic->szBackupFilePath,
|
|
ARRAYSIZE(paufic->szBackupFilePath)) == FALSE)
|
|
{
|
|
hr = E_FAIL;
|
|
goto done;
|
|
}
|
|
|
|
// file path we'll temporarily expand the new file to
|
|
if (ReplaceFileExtension(paufic->szFilePath, _T(".new"),
|
|
paufic->szNewFilePath,
|
|
ARRAYSIZE(paufic->szNewFilePath)) == FALSE)
|
|
{
|
|
hr = E_FAIL;
|
|
goto done;
|
|
}
|
|
|
|
if (ReplaceFileInPath(pszExtractBase, pszFileName,
|
|
paufic->szExtractFilePath,
|
|
ARRAYSIZE(paufic->szExtractFilePath)) == FALSE)
|
|
{
|
|
hr = E_FAIL;
|
|
goto done;
|
|
}
|
|
|
|
// if we are processing a language file, append the language name to
|
|
// the end of the extraction path to avoid collisions in this directory.
|
|
if (paul != NULL)
|
|
{
|
|
hr = StringCchCatEx(paufic->szExtractFilePath,
|
|
ARRAYSIZE(paufic->szExtractFilePath),
|
|
paul->szAUName,
|
|
NULL, NULL, MISTSAFE_STRING_FLAGS);
|
|
if (FAILED(hr))
|
|
goto done;
|
|
}
|
|
|
|
|
|
done:
|
|
return hr;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function ProcessFile()
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT ProcessFile(AU_COMPONENT *paucParent, AU_COMPONENT *paucCurr, LPCTSTR pszBasePath,
|
|
AU_LANG *paul, LPCTSTR pszCif)
|
|
{
|
|
USES_IU_CONVERSION;
|
|
|
|
HRESULT hr = NOERROR;
|
|
LPCTSTR pszIniFileVerToUse;
|
|
DWORD dwExistingMS = 0, dwExistingLS = 0;
|
|
TCHAR szValue[64], szIniFileVer[32];
|
|
BOOL fRet;
|
|
int cch, cchLang;
|
|
|
|
// validate params
|
|
if (paucCurr == NULL || pszBasePath == NULL || pszCif == NULL ||
|
|
((paucParent == NULL) != (paul == NULL)))
|
|
{
|
|
hr = E_INVALIDARG;
|
|
goto done;
|
|
}
|
|
|
|
// build the full file path
|
|
hr = PathCchCombine(paucCurr->szFilePath, ARRAYSIZE(paucCurr->szFilePath),
|
|
pszBasePath, paucCurr->szFileName);
|
|
if (FAILED(hr))
|
|
goto done;
|
|
|
|
|
|
// get the version of the file we should have
|
|
if (paul != NULL)
|
|
{
|
|
hr = StringCchPrintfEx(szIniFileVer, ARRAYSIZE(szIniFileVer),
|
|
NULL, NULL, MISTSAFE_STRING_FLAGS,
|
|
_T("%s%s"), AU_KEY_FILE_VERSION, paul->szAUName);
|
|
if (FAILED(hr))
|
|
goto done;
|
|
|
|
pszIniFileVerToUse = szIniFileVer;
|
|
}
|
|
else
|
|
{
|
|
pszIniFileVerToUse = AU_KEY_FILE_VERSION;
|
|
}
|
|
|
|
fRet = MyGetPrivateProfileString(paucCurr->pszSectionName,
|
|
pszIniFileVerToUse,
|
|
szValue, ARRAYSIZE(szValue),
|
|
pszCif);
|
|
if (fRet)
|
|
{
|
|
fRet = fConvertVersionStrToDwords(szValue, &paucCurr->dwUpdateMS,
|
|
&paucCurr->dwUpdateLS);
|
|
}
|
|
// if we couldn't find the version string in the ini file, get it from the
|
|
// parent AU_COMPONENT
|
|
else if (paucParent != NULL)
|
|
{
|
|
paucCurr->dwUpdateMS = paucParent->dwUpdateMS;
|
|
paucCurr->dwUpdateLS = paucParent->dwUpdateLS;
|
|
fRet = TRUE;
|
|
}
|
|
|
|
if (fRet == FALSE)
|
|
{
|
|
hr = E_FAIL;
|
|
goto done;
|
|
}
|
|
|
|
// see if we need to replace the file
|
|
paucCurr->fFileExists = fFileExists(paucCurr->szFilePath);
|
|
if (paucCurr->fFileExists)
|
|
{
|
|
LPSTR pszPathForVer;
|
|
|
|
// if the file exists, then check for the version
|
|
pszPathForVer = T2A(paucCurr->szFilePath);
|
|
if (pszPathForVer == NULL)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto done;
|
|
}
|
|
|
|
// this function will never return a failure code. Intstead, check if
|
|
// both return values are 0
|
|
hr = GetVersionFromFileEx(pszPathForVer, &dwExistingMS, &dwExistingLS,
|
|
TRUE);
|
|
if (FAILED(hr) || (dwExistingMS == 0 && dwExistingLS == 0))
|
|
{
|
|
hr = E_FAIL;
|
|
goto done;
|
|
}
|
|
|
|
paucCurr->fDoUpgrade = fNewerFile(paucCurr->dwUpdateMS,
|
|
paucCurr->dwUpdateLS,
|
|
dwExistingMS,
|
|
dwExistingLS);
|
|
}
|
|
else
|
|
{
|
|
// if the file doesn't exist, obviously gotta replace it
|
|
paucCurr->fDoUpgrade = TRUE;
|
|
}
|
|
|
|
// if we don't need to update the file and it's not a parent file with
|
|
// resources, then can just bail at this point.
|
|
if (paucCurr->fDoUpgrade == FALSE)
|
|
{
|
|
if (paul != NULL ||
|
|
(paul == NULL && paucCurr->fNeedToCheckMui == FALSE))
|
|
{
|
|
hr = S_FALSE;
|
|
goto done;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DEBUGMSG("PASS 1 -- newer file in section %S", paucCurr->pszSectionName);
|
|
}
|
|
|
|
// get the cab and inf name. For non-MUI files, we fetch this out of the ini.
|
|
if (paul == NULL)
|
|
{
|
|
if (MyGetPrivateProfileString(paucCurr->pszSectionName,
|
|
AU_KEY_CAB_NAME,
|
|
paucCurr->szCabName,
|
|
ARRAYSIZE(paucCurr->szCabName),
|
|
pszCif) == FALSE)
|
|
{
|
|
hr = E_FAIL;
|
|
goto done;
|
|
}
|
|
|
|
// if there is no inf, "" is value of field, so we're ok ignoring a
|
|
// failure here
|
|
MyGetPrivateProfileString(paucCurr->pszSectionName,
|
|
AU_KEY_INF_NAME,
|
|
paucCurr->szInfName,
|
|
ARRAYSIZE(paucCurr->szInfName),
|
|
pszCif);
|
|
}
|
|
// for MUI files, we base it on the name of the cab from the parent file.
|
|
else
|
|
{
|
|
LPTSTR pszExt;
|
|
DWORD cchExt, cchName;
|
|
|
|
// make sure the buffer is big enuf
|
|
cch = lstrlen(paucParent->szCabName);
|
|
cchLang = lstrlen(paul->szAUName);
|
|
if (cch + cchLang >= ARRAYSIZE(paucCurr->szCabName))
|
|
{
|
|
hr = HRESULT_FROM_WIN32(ERROR_BUFFER_OVERFLOW);
|
|
goto done;
|
|
}
|
|
|
|
hr = StringCchCopyEx(paucCurr->szCabName, ARRAYSIZE(paucCurr->szCabName),
|
|
paucParent->szCabName,
|
|
NULL, NULL, MISTSAFE_STRING_FLAGS);
|
|
if (FAILED(hr))
|
|
goto done;
|
|
|
|
// paucCurr->szCabName
|
|
for (pszExt = paucCurr->szCabName + cch, cchExt = 0;
|
|
pszExt > paucCurr->szCabName && *pszExt != _T('\\') && *pszExt != _T('.');
|
|
pszExt--, cchExt++);
|
|
|
|
// if we hit a backslash or the beginning of the string, then move the
|
|
// extension pointer to the NULL terminator.
|
|
if (*pszExt == _T('\\') || pszExt <= paucCurr->szCabName)
|
|
{
|
|
pszExt = paucCurr->szCabName + cch;
|
|
cchExt = 0;
|
|
}
|
|
|
|
cchName = (DWORD)(pszExt - paucCurr->szCabName);
|
|
|
|
// append the language to where the extension (if any) currently exists
|
|
hr = StringCchCopyEx(pszExt, ARRAYSIZE(paucCurr->szCabName) - cchName,
|
|
paul->szAUName,
|
|
NULL, NULL, MISTSAFE_STRING_FLAGS);
|
|
if (FAILED(hr))
|
|
goto done;
|
|
|
|
// if there is an extension, copy it over from the original string in
|
|
// the parent AU_COMPONENT
|
|
if (cchExt > 0)
|
|
{
|
|
hr = StringCchCopyEx(&paucCurr->szCabName[cchName + cchLang],
|
|
ARRAYSIZE(paucCurr->szCabName) - cchName - cchLang,
|
|
&paucParent->szCabName[cchName],
|
|
NULL, NULL, MISTSAFE_STRING_FLAGS);
|
|
if (FAILED(hr))
|
|
goto done;
|
|
|
|
}
|
|
}
|
|
|
|
if (ReplaceFileInPath(pszCif, paucCurr->szCabName,
|
|
paucCurr->szCabPath,
|
|
ARRAYSIZE(paucCurr->szCabPath)) == FALSE)
|
|
{
|
|
hr = E_FAIL;
|
|
goto done;
|
|
}
|
|
|
|
hr = BuildPaths(paucCurr, paucCurr->szFileName, NULL, pszCif, paul);
|
|
if (FAILED(hr))
|
|
goto done;
|
|
|
|
done:
|
|
return hr;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Function InstallUpdatedComponents()
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT InstallUpdatedComponents(LPCTSTR pszSelfUpdateUrl,
|
|
LPCTSTR pszMuiUpdateUrl,
|
|
LPCTSTR pszIdentTxt,
|
|
LPCTSTR pszFileCacheDir,
|
|
LPCTSTR pszCif,
|
|
BOOL *pfInstalledWUAUENG)
|
|
{
|
|
USES_IU_CONVERSION;
|
|
|
|
AU_COMPONENT *paucRoot = NULL;
|
|
AU_COMPONENT *paucCurr = NULL;
|
|
AU_COMPONENT *paucParent = NULL;
|
|
AU_COMPONENT *paucMui = NULL;
|
|
AU_FILEINCAB *paufic = NULL;
|
|
|
|
|
|
HRESULT hr = S_OK;
|
|
HANDLE SfcRpcHandle = NULL;
|
|
LPTSTR pszSection = NULL;
|
|
TCHAR szSectionNames[1024];
|
|
TCHAR szSysDir[MAX_PATH + 1];
|
|
TCHAR szSrcPath[MAX_PATH + 1];
|
|
TCHAR szHelpFile[_MAX_FNAME + 1];
|
|
DWORD cchSectionNames, cch;
|
|
BOOL fFailedInstall = FALSE;
|
|
|
|
// MUI stuff
|
|
AU_LANGLIST aull;
|
|
DWORD cchMuiDir = 0, cchMuiDirAvail = 0;
|
|
DWORD cchHelpMuiDir = 0, cchHelpMuiDirAvail = 0;
|
|
TCHAR szMuiDir[MAX_PATH + 1];
|
|
TCHAR szHelpMuiDir[MAX_PATH + 1];
|
|
|
|
ZeroMemory(&aull, sizeof(aull));
|
|
aull.pszIdentFile = pszIdentTxt;
|
|
szMuiDir[0] = _T('\0');
|
|
szHelpMuiDir[0] = _T('\0');
|
|
|
|
*pfInstalledWUAUENG = FALSE;
|
|
SfcRpcHandle = SfcConnectToServer(NULL);
|
|
if (NULL == SfcRpcHandle)
|
|
{
|
|
hr = E_FAIL;
|
|
goto done;
|
|
}
|
|
|
|
// determine how many components there are to update.
|
|
cchSectionNames = GetPrivateProfileSectionNames(szSectionNames,
|
|
ARRAYSIZE(szSectionNames),
|
|
pszCif);
|
|
if ((ARRAYSIZE(szSectionNames) - 2) == cchSectionNames)
|
|
{
|
|
hr = HRESULT_FROM_WIN32(ERROR_BUFFER_OVERFLOW);
|
|
goto done;
|
|
}
|
|
|
|
cchMuiDir = ARRAYSIZE(szMuiDir);
|
|
cchHelpMuiDir = ARRAYSIZE(szHelpMuiDir);
|
|
hr = GetMuiLangList(&aull, szMuiDir, &cchMuiDir, szHelpMuiDir, &cchHelpMuiDir);
|
|
if (FAILED(hr))
|
|
goto done;
|
|
|
|
cchMuiDirAvail = ARRAYSIZE(szMuiDir) - cchMuiDir;
|
|
cchHelpMuiDirAvail = ARRAYSIZE(szHelpMuiDir) - cchHelpMuiDir;
|
|
|
|
cch = GetSystemDirectory(szSysDir, ARRAYSIZE(szSysDir));
|
|
if (cch == 0 || cch >= ARRAYSIZE(szSysDir))
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
goto done;
|
|
}
|
|
|
|
// PASS 1: figure out which files to upgrade
|
|
for (pszSection = szSectionNames;
|
|
*pszSection != _T('\0');
|
|
pszSection += lstrlen(pszSection) + 1)
|
|
{
|
|
szHelpFile[0] = _T('\0');
|
|
|
|
// if we didn't need to upgrade the parent file from the previous pass
|
|
// then we don't need to alloc a new blob- just reuse the one from the
|
|
// previous pass. To signal this, we'll set paucParent to NULL if we
|
|
// add it to the linked list- note this covers us for the first time
|
|
// thru the loop cuz we initialize paucParent to NULL.
|
|
if (paucParent == NULL)
|
|
{
|
|
paucParent = (AU_COMPONENT *)malloc(sizeof(AU_COMPONENT));
|
|
if (paucParent == NULL)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto done;
|
|
}
|
|
}
|
|
ZeroMemory(paucParent, sizeof(AU_COMPONENT));
|
|
paucParent->fMuiFile = FALSE;
|
|
|
|
DEBUGMSG("PASS 1 -- section %S", pszSection);
|
|
paucParent->pszSectionName = pszSection;
|
|
if (MyGetPrivateProfileString(paucParent->pszSectionName,
|
|
AU_KEY_FILE_NAME,
|
|
paucParent->szFileName,
|
|
ARRAYSIZE(paucParent->szFileName),
|
|
pszCif) == FALSE)
|
|
{
|
|
hr = E_FAIL;
|
|
goto done;
|
|
}
|
|
|
|
if (aull.cLangs > 0)
|
|
{
|
|
UINT uiHasResources;
|
|
|
|
// see if we need to test for MUI file updates
|
|
uiHasResources = GetPrivateProfileInt(paucParent->pszSectionName,
|
|
AU_KEY_RESMOD_NAME,
|
|
0,
|
|
pszCif);
|
|
|
|
// if we do have resources, then check if we also have a helpfile
|
|
if (uiHasResources == 1)
|
|
{
|
|
paucParent->fNeedToCheckMui = TRUE;
|
|
|
|
if (MyGetPrivateProfileString(paucParent->pszSectionName,
|
|
AU_KEY_HELPFILE,
|
|
szHelpFile, ARRAYSIZE(szHelpFile),
|
|
pszCif) == FALSE)
|
|
{
|
|
szHelpFile[0] = _T('\0');
|
|
}
|
|
}
|
|
else
|
|
{
|
|
paucParent->fNeedToCheckMui = FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
paucParent->fNeedToCheckMui = FALSE;
|
|
}
|
|
|
|
hr = ProcessFile(NULL, paucParent, szSysDir, NULL, pszCif);
|
|
if (FAILED(hr))
|
|
goto done;
|
|
|
|
if (paucParent->fNeedToCheckMui)
|
|
{
|
|
DWORD iLang;
|
|
DWORD cchParentFile;
|
|
|
|
cchParentFile = lstrlen(paucParent->szFileName);
|
|
if (cchParentFile + ARRAYSIZE(MUI_EXT) > ARRAYSIZE(paucParent->szFileName))
|
|
{
|
|
hr = HRESULT_FROM_WIN32(ERROR_BUFFER_OVERFLOW);
|
|
goto done;
|
|
}
|
|
|
|
|
|
for (iLang = 0; iLang < aull.cLangs; iLang++)
|
|
{
|
|
// if we didn't need to upgrade the file from the previous
|
|
// pass then we don't need to alloc a new blob- just reuse
|
|
// the one from the previous pass.
|
|
if (paucMui == NULL)
|
|
{
|
|
paucMui = (AU_COMPONENT *)malloc(sizeof(AU_COMPONENT));
|
|
if (paucMui == NULL)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto done;
|
|
}
|
|
}
|
|
ZeroMemory(paucMui, sizeof(AU_COMPONENT));
|
|
paucMui->pszSectionName = paucParent->pszSectionName;
|
|
paucMui->fMuiFile = TRUE;
|
|
|
|
// ProcessFile does not expect a trailing backslash, so be sure
|
|
// not to add one. Note that we've checked the size of the
|
|
// buffer against the largest possible string it will contain
|
|
// above, so this should not fail.
|
|
// The directory is build with the MUI langauge name (4 hex chars)
|
|
hr = StringCchCopyEx(&szMuiDir[cchMuiDir], cchMuiDirAvail,
|
|
aull.rgpaulLangs[iLang]->szMuiName,
|
|
NULL, NULL, MISTSAFE_STRING_FLAGS);
|
|
if (FAILED(hr))
|
|
goto done;
|
|
|
|
// the filename for a language is the same as the parent file with
|
|
// a ".mui" added to the end
|
|
hr = StringCchCopyEx(paucMui->szFileName, ARRAYSIZE(paucMui->szFileName),
|
|
paucParent->szFileName,
|
|
NULL, NULL, MISTSAFE_STRING_FLAGS);
|
|
if (FAILED(hr))
|
|
goto done;
|
|
|
|
hr = StringCchCopyEx(&paucMui->szFileName[cchParentFile],
|
|
ARRAYSIZE(paucMui->szFileName) - cchParentFile,
|
|
MUI_EXT,
|
|
NULL, NULL, MISTSAFE_STRING_FLAGS);
|
|
if (FAILED(hr))
|
|
goto done;
|
|
|
|
hr = ProcessFile(paucParent, paucMui,
|
|
szMuiDir,
|
|
aull.rgpaulLangs[iLang],
|
|
pszCif);
|
|
if (FAILED(hr))
|
|
goto done;
|
|
|
|
// Clean up for the next language
|
|
szMuiDir[cchMuiDir] = _T('\0');
|
|
|
|
// don't need to update the file
|
|
if (paucMui->fDoUpgrade == FALSE)
|
|
continue;
|
|
|
|
if (szHelpFile[0] != _T('\0'))
|
|
{
|
|
paucMui->pNextFileInCab = (AU_FILEINCAB *)malloc(sizeof(AU_FILEINCAB));
|
|
if (paucMui->pNextFileInCab == NULL)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto done;
|
|
}
|
|
ZeroMemory(paucMui->pNextFileInCab, sizeof(AU_FILEINCAB));
|
|
|
|
hr = StringCchCopyEx(&szHelpMuiDir[cchHelpMuiDir], cchHelpMuiDirAvail,
|
|
aull.rgpaulLangs[iLang]->szMuiName,
|
|
NULL, NULL, MISTSAFE_STRING_FLAGS);
|
|
if (FAILED(hr))
|
|
goto done;
|
|
|
|
hr = BuildPaths(paucMui->pNextFileInCab,
|
|
szHelpFile, szHelpMuiDir,
|
|
pszCif,
|
|
aull.rgpaulLangs[iLang]);
|
|
if (FAILED(hr))
|
|
goto done;
|
|
}
|
|
|
|
// we do need to update the file, so add it to our list of files
|
|
// to update
|
|
paucMui->pNext = paucRoot;
|
|
paucRoot = paucMui;
|
|
paucMui = NULL;
|
|
}
|
|
}
|
|
|
|
// if we need to update the parent file, add it to our list of files to
|
|
// update
|
|
if (paucParent->fDoUpgrade)
|
|
{
|
|
paucParent->pNext = paucRoot;
|
|
paucRoot = paucParent;
|
|
paucParent = NULL;
|
|
}
|
|
|
|
}
|
|
|
|
// short cut the rest of the function if we have no work to do
|
|
hr = S_OK;
|
|
if (paucRoot == NULL)
|
|
goto done;
|
|
|
|
// PASS 2: bring down the required cabs
|
|
DWORD dwFlags = 0;
|
|
|
|
if (gpState->fInCorpWU())
|
|
{
|
|
dwFlags |= WUDF_DONTALLOWPROXY;
|
|
}
|
|
|
|
for (paucCurr = paucRoot; paucCurr != NULL; paucCurr = paucCurr->pNext)
|
|
{
|
|
LPCTSTR pszDownloadUrl;
|
|
|
|
pszDownloadUrl = (paucCurr->fMuiFile) ? pszMuiUpdateUrl : pszSelfUpdateUrl;
|
|
|
|
DEBUGMSG("PASS 2 -- downloading %S", paucCurr->szCabName);
|
|
|
|
// We have to install so bring down the full cab
|
|
hr = DownloadCab(ghServiceFinished,
|
|
paucCurr->szCabName,
|
|
pszDownloadUrl,
|
|
pszFileCacheDir,
|
|
dwFlags);
|
|
if (FAILED(hr))
|
|
{
|
|
DEBUGMSG("Failed to download %S (%#lx)", paucCurr->szCabName, hr);
|
|
goto done;
|
|
}
|
|
|
|
//Verify that the extracted file is a binary and it's subsystem matches that of the OS
|
|
if (FAILED(hr = IsBinaryCompatible(paucCurr->szExtractFilePath)))
|
|
{
|
|
DEBUGMSG("%S is not a valid binary file (error %#lx)", paucCurr->szExtractFilePath, hr);
|
|
goto done;
|
|
}
|
|
|
|
// Check version number against cif
|
|
DWORD dwNewMS, dwNewLS;
|
|
|
|
LPSTR pszTmp;
|
|
pszTmp = T2A(paucCurr->szExtractFilePath);
|
|
if (pszTmp == NULL)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto done;
|
|
}
|
|
|
|
// this function will never return a failure code. Intstead, check if
|
|
// both return values are 0
|
|
hr = GetVersionFromFileEx(pszTmp, &dwNewMS, &dwNewLS, TRUE /* get version */);
|
|
if (FAILED(hr) || (dwNewMS == 0 && dwNewLS == 0))
|
|
{
|
|
DEBUGMSG("Failed to get version info from %S (%#lx)", paucCurr->szExtractFilePath, hr);
|
|
goto done;
|
|
}
|
|
|
|
if (paucCurr->dwUpdateMS != dwNewMS ||
|
|
paucCurr->dwUpdateLS != dwNewLS)
|
|
{
|
|
hr = HRESULT_FROM_WIN32(ERROR_INSTALL_PACKAGE_VERSION);
|
|
DEBUGMSG("Version mismatch for %S - %d.%d.%d.%d vs %d.%d.%d.%d",
|
|
paucCurr->szExtractFilePath,
|
|
HIWORD(paucCurr->dwUpdateMS),
|
|
LOWORD(paucCurr->dwUpdateMS),
|
|
HIWORD(paucCurr->dwUpdateLS),
|
|
LOWORD(paucCurr->dwUpdateLS),
|
|
HIWORD(dwNewMS),
|
|
LOWORD(dwNewMS),
|
|
HIWORD(dwNewLS),
|
|
LOWORD(dwNewLS));
|
|
goto done;
|
|
}
|
|
}
|
|
|
|
hr = StringCchCopyEx(szSrcPath, ARRAYSIZE(szSrcPath), pszCif,
|
|
NULL, NULL, MISTSAFE_STRING_FLAGS);
|
|
if (FAILED(hr))
|
|
goto done;
|
|
|
|
PathRemoveFileSpec(szSrcPath);
|
|
|
|
// PASS 3: Copy files to *.new in destination directory.
|
|
for (paucCurr = paucRoot; paucCurr != NULL; paucCurr = paucCurr->pNext)
|
|
{
|
|
if (FAILED(hr = vAU_W2A(paucCurr->szCabPath,
|
|
paucCurr->a_szCabPath,
|
|
sizeof(paucCurr->a_szCabPath))))
|
|
{
|
|
fFailedInstall = TRUE;
|
|
goto done;
|
|
}
|
|
|
|
// copy all the files to their new locations
|
|
for (paufic = paucCurr; paufic != NULL; paufic = paufic->pNextFileInCab)
|
|
{
|
|
DEBUGMSG("PASS 3 -- copying %S --> %S",
|
|
paufic->szExtractFilePath,
|
|
paufic->szNewFilePath);
|
|
|
|
|
|
if ( !CopyFile(paufic->szExtractFilePath, paufic->szNewFilePath, FALSE) )
|
|
{
|
|
fFailedInstall = TRUE;
|
|
hr = E_FAIL;
|
|
goto done;
|
|
}
|
|
}
|
|
|
|
// this comparison is sufficient because we don't care if we replaced a
|
|
// MUI lang pack for wuaueng.dll. The reason is that the service runs
|
|
// as local system, which always uses the native language (and the
|
|
// service doesn't pop up UI anyway)
|
|
// we do, however, need to check for a winhttp update
|
|
if (StrCmpI(WUAUENG_DLL, paucCurr->szFileName) == 0 ||
|
|
StrCmpI(c_szWinHttpDll, paucCurr->szFileName) == 0)
|
|
{
|
|
*pfInstalledWUAUENG = TRUE;
|
|
}
|
|
}
|
|
|
|
// PASS 4: Move the <file>.new into its proper location
|
|
for (paucCurr = paucRoot; paucCurr != NULL; paucCurr = paucCurr->pNext)
|
|
{
|
|
// copy all the files to their new locations
|
|
for (paufic = paucCurr; paufic != NULL; paufic = paufic->pNextFileInCab)
|
|
{
|
|
if ( paufic->fFileExists )
|
|
{
|
|
DEBUGMSG("PASS 4 -- renaming %S --> %S", paufic->szFilePath, paufic->szBackupFilePath);
|
|
if ( !SfcMoveFileEx(paufic->szFilePath, paufic->szBackupFilePath,
|
|
paufic->szFilePath, SfcRpcHandle) )
|
|
{
|
|
fFailedInstall = TRUE;
|
|
hr = E_FAIL;
|
|
goto done;
|
|
}
|
|
paufic->fCreatedBackup = TRUE;
|
|
}
|
|
|
|
DEBUGMSG("PASS 4 -- renaming %S --> %S", paufic->szNewFilePath, paufic->szFilePath);
|
|
if (!MoveFileEx(paufic->szNewFilePath, paufic->szFilePath, MOVEFILE_REPLACE_EXISTING))
|
|
{
|
|
fFailedInstall = TRUE;
|
|
hr = E_FAIL;
|
|
goto done;
|
|
}
|
|
}
|
|
}
|
|
|
|
// PASS 5: Run any .inf file.
|
|
for (paucCurr = paucRoot; paucCurr != NULL; paucCurr = paucCurr->pNext)
|
|
{
|
|
if (paucCurr->szInfName[0] != _T('\0'))
|
|
{
|
|
DEBUGMSG("PASS 5A -- executing inf %S", paucCurr->szInfName);
|
|
CABINFO cabinfo;
|
|
HRESULT hr2;
|
|
|
|
cabinfo.pszCab = paucCurr->a_szCabPath;
|
|
cabinfo.pszInf = paucCurr->a_szInfName;
|
|
if (FAILED( hr2 = vAU_W2A(paucCurr->szInfName, paucCurr->a_szInfName, sizeof(paucCurr->a_szInfName)))
|
|
|| FAILED(hr2 = vAU_W2A(szSrcPath, cabinfo.szSrcPath, sizeof(cabinfo.szSrcPath))))
|
|
{
|
|
DEBUGMSG("vAU_W2A failed: %#lx", hr2);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = hr2;
|
|
fFailedInstall = TRUE;
|
|
}
|
|
// don't delete the backup file. Need to restore it afterwards.
|
|
continue;
|
|
}
|
|
|
|
|
|
cabinfo.pszSection = "DefaultInstall";
|
|
cabinfo.dwFlags = ALINF_QUIET;
|
|
if ( FAILED(hr2 = ExecuteCab(NULL, &cabinfo, NULL)) )
|
|
{
|
|
DEBUGMSG("ExecuteCab failed on %s (%#lx)", paucCurr->a_szInfName, hr2);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = hr2;
|
|
fFailedInstall = TRUE;
|
|
}
|
|
// don't delete the backup file. Need to restore it afterwards.
|
|
continue;
|
|
}
|
|
}
|
|
|
|
for (paufic = paucCurr; paufic != NULL; paufic = paufic->pNextFileInCab)
|
|
{
|
|
|
|
// delete the backup file corresponding to the .inf which was successfully installed
|
|
if (paufic->fCreatedBackup &&
|
|
StrCmpI(WUAUENG_DLL, paucCurr->szFileName) != 0)
|
|
{
|
|
DEBUGMSG("PASS 5B - deleting bak file %S", paufic->szBackupFilePath);
|
|
if ( DeleteFile(paufic->szBackupFilePath) )
|
|
{
|
|
paufic->fCreatedBackup = FALSE;
|
|
}
|
|
#ifdef DBG
|
|
else
|
|
{
|
|
DEBUGMSG("Could not delete %S (error %d)", paufic->szBackupFilePath, GetLastError());
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
done:
|
|
// if we failed an install, revert all the prior installs
|
|
if ( fFailedInstall )
|
|
{
|
|
for (paucCurr = paucRoot; paucCurr != NULL; paucCurr = paucCurr->pNext)
|
|
{
|
|
for(paufic = paucCurr; paufic != NULL; paufic = paufic->pNextFileInCab)
|
|
{
|
|
if (paufic->fCreatedBackup)
|
|
{
|
|
DEBUGMSG("Reverting %S --> %S", paufic->szBackupFilePath, paufic->szFilePath);
|
|
MoveFileEx(paufic->szBackupFilePath, paufic->szFilePath, MOVEFILE_REPLACE_EXISTING);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (paucParent != NULL)
|
|
free(paucParent);
|
|
if (paucMui != NULL)
|
|
{
|
|
while (paucMui->pNextFileInCab != NULL)
|
|
{
|
|
paufic = paucMui->pNextFileInCab;
|
|
paucMui->pNextFileInCab = paucMui->pNextFileInCab->pNextFileInCab;
|
|
free(paufic);
|
|
}
|
|
free(paucMui);
|
|
}
|
|
|
|
// cleanup the linked list of files
|
|
while(paucRoot != NULL)
|
|
{
|
|
paucCurr = paucRoot;
|
|
paucRoot = paucCurr->pNext;
|
|
while (paucCurr->pNextFileInCab != NULL)
|
|
{
|
|
paufic = paucCurr->pNextFileInCab;
|
|
paucCurr->pNextFileInCab = paucCurr->pNextFileInCab->pNextFileInCab;
|
|
free(paufic);
|
|
}
|
|
free(paucCurr);
|
|
}
|
|
|
|
// cleanup the MUI stuff
|
|
CleanupMuiLangList(&aull);
|
|
|
|
if ( NULL != SfcRpcHandle )
|
|
{
|
|
SfcClose(SfcRpcHandle);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// fConvertDotVersionStrToDwords
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////
|
|
BOOL fConvertVersionStrToDwords(LPTSTR pszVer, LPDWORD pdwMS, LPDWORD pdwLS)
|
|
{
|
|
DWORD grVerFields[4] = {0,0,0,0};
|
|
TCHAR *pch = pszVer;
|
|
int i;
|
|
|
|
// _ttol will stop when it hits a non-numeric character, so we're
|
|
// safe calling it this way
|
|
grVerFields[0] = _ttol(pch);
|
|
|
|
for (i = 1; i < 4; i++)
|
|
{
|
|
while (*pch != _T('\0') && _istdigit(*pch))
|
|
pch++;
|
|
|
|
if (*pch == _T('\0'))
|
|
break;
|
|
pch++;
|
|
|
|
// _ttol will stop when it hits a non-numeric character, so we're
|
|
// safe calling it this way
|
|
grVerFields[i] = _ttol(pch);
|
|
}
|
|
|
|
*pdwMS = (grVerFields[0] << 16) + grVerFields[1];
|
|
*pdwLS = (grVerFields[2] << 16) + grVerFields[3];
|
|
|
|
return true;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// MyGetPrivateProfileString
|
|
//
|
|
// Same as normal call but if buffer is too small or default string is returned
|
|
// then function returns FALSE.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
BOOL MyGetPrivateProfileString( IN LPCTSTR lpAppName,
|
|
IN LPCTSTR lpKeyName,
|
|
OUT LPTSTR lpReturnedString,
|
|
IN DWORD nSize,
|
|
IN LPCTSTR lpFileName,
|
|
IN LPCTSTR lpDefault)
|
|
{
|
|
BOOL fRet = TRUE;
|
|
|
|
|
|
if (NULL == lpAppName || NULL == lpKeyName || NULL == lpDefault || NULL == lpReturnedString)
|
|
{
|
|
return FALSE;
|
|
}
|
|
DWORD dwRet = GetPrivateProfileString(lpAppName,
|
|
lpKeyName,
|
|
lpDefault,
|
|
lpReturnedString,
|
|
nSize,
|
|
lpFileName);
|
|
|
|
if ( ((nSize - 1) == dwRet) || (_T('\0') == *lpReturnedString) )
|
|
{
|
|
fRet = FALSE;
|
|
}
|
|
|
|
return fRet;
|
|
}
|