1408 lines
38 KiB
C++
1408 lines
38 KiB
C++
//+---------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1997.
|
|
//
|
|
// File: O E M U P G . C P P
|
|
//
|
|
// Contents: Down level upgrade code for OEM cards
|
|
//
|
|
// Notes:
|
|
//
|
|
// Author: kumarp 12 April 97
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
|
|
#include "pch.h"
|
|
#pragma hdrstop
|
|
|
|
#include "conflict.h"
|
|
#include "infmap.h"
|
|
#include "kkcwinf.h"
|
|
#include "kkutils.h"
|
|
#include "nceh.h"
|
|
#include "ncsetup.h"
|
|
#include "netupgrd.h"
|
|
#include "nustrs.h"
|
|
#include "nuutils.h"
|
|
#include "oemupg.h"
|
|
#include "oemupgex.h"
|
|
#include "resource.h"
|
|
|
|
|
|
static const WCHAR c_szOemNMapFileName[] = L"netmap.inf";
|
|
|
|
TNetMapArray* g_pnmaNetMap=NULL;
|
|
|
|
#if 0
|
|
extern BOOL g_fForceNovellDirCopy;
|
|
#endif
|
|
|
|
//----------------------------------------------------------------------------
|
|
// prototypes
|
|
//
|
|
void AbortUpgradeOemComponent(IN PCWSTR pszPreNT5InfId,
|
|
IN PCWSTR pszDescription,
|
|
IN DWORD dwError,
|
|
IN DWORD dwErrorMessageId);
|
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
// ----------------------------------------------------------------------
|
|
//
|
|
// Function: CNetMapInfo::CNetMapInfo
|
|
//
|
|
// Purpose: constructor for class CNetMapInfo
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns:
|
|
//
|
|
// Author: kumarp 17-December-97
|
|
//
|
|
// Notes:
|
|
//
|
|
CNetMapInfo::CNetMapInfo()
|
|
{
|
|
m_hinfNetMap = NULL;
|
|
m_hOemDll = NULL;
|
|
m_dwFlags = 0;
|
|
m_nud.mszServicesNotToBeDeleted = NULL;
|
|
m_pfnPreUpgradeInitialize = NULL;
|
|
m_pfnDoPreUpgradeProcessing = NULL;
|
|
m_fDllInitFailed = FALSE;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
//
|
|
// Function: CNetMapInfo::~CNetMapInfo
|
|
//
|
|
// Purpose: destructor for class CNetMapInfo
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: None
|
|
//
|
|
// Author: kumarp 17-December-97
|
|
//
|
|
// Notes:
|
|
//
|
|
CNetMapInfo::~CNetMapInfo()
|
|
{
|
|
if (m_hinfNetMap)
|
|
{
|
|
::SetupCloseInfFile(m_hinfNetMap);
|
|
}
|
|
|
|
if (m_hOemDll)
|
|
{
|
|
::FreeLibrary(m_hOemDll);
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
//
|
|
// Function: CNetMapInfo::HrGetOemInfName
|
|
//
|
|
// Purpose: Get name of installation INF of a component
|
|
//
|
|
// Arguments:
|
|
// pszNT5InfId [in] NT5 InfID of a component
|
|
// pstrOemInf [out] pointer to name of INF for this component
|
|
//
|
|
// Returns: S_OK on success, otherwise an error code
|
|
//
|
|
// Author: kumarp 26-May-98
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT CNetMapInfo::HrGetOemInfName(IN PCWSTR pszNT5InfId,
|
|
OUT tstring* pstrOemInf)
|
|
{
|
|
DefineFunctionName("CNetMapInfo::HrGetOemInfName");
|
|
|
|
AssertValidReadPtr(pszNT5InfId);
|
|
AssertValidWritePtr(pstrOemInf);
|
|
|
|
HRESULT hr=S_OK;
|
|
tstring strOemDll;
|
|
|
|
Assert(m_hinfNetMap);
|
|
|
|
hr = HrGetOemUpgradeInfoInInf(m_hinfNetMap, pszNT5InfId,
|
|
&strOemDll, pstrOemInf);
|
|
|
|
TraceError(__FUNCNAME__, hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
//
|
|
// Function: HrOpenNetUpgInfFile
|
|
//
|
|
// Purpose: Open netupg.inf file.
|
|
// - if env var NETUPGRD_INIT_FILE_DIR is set, open it from that dir
|
|
// - otherwise open it from the dir where netuprd.dll is located
|
|
//
|
|
// Arguments:
|
|
// phinf [out] handle of netupg.inf file
|
|
//
|
|
// Returns: S_OK on success, otherwise an error code
|
|
//
|
|
// Author: kumarp 17-December-97
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT HrOpenNetUpgInfFile(OUT HINF* phinf)
|
|
{
|
|
DefineFunctionName("HrOpenNetUpgInfFile");
|
|
|
|
AssertValidWritePtr(phinf);
|
|
|
|
static const WCHAR c_szNetUpgInfFile[] = L"netupg.inf";
|
|
static const WCHAR c_szNetUpgrdInitDir[] = L"NETUPGRD_INIT_FILE_DIR";
|
|
|
|
|
|
HRESULT hr=S_OK;
|
|
tstring strNetUpgInfFile;
|
|
|
|
// first try opening from N
|
|
WCHAR szNetUpgrdInitDir[MAX_PATH+1];
|
|
DWORD dwNumCharsReturned;
|
|
dwNumCharsReturned =
|
|
GetEnvironmentVariable(c_szNetUpgrdInitDir, szNetUpgrdInitDir, MAX_PATH);
|
|
|
|
if (dwNumCharsReturned)
|
|
{
|
|
strNetUpgInfFile = szNetUpgrdInitDir;
|
|
}
|
|
else
|
|
{
|
|
hr = HrGetNetupgrdDir(&strNetUpgInfFile);
|
|
}
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
AppendToPath(&strNetUpgInfFile, c_szNetUpgInfFile);
|
|
hr = HrSetupOpenInfFile(strNetUpgInfFile.c_str(), NULL,
|
|
INF_STYLE_WIN4, NULL, phinf);
|
|
}
|
|
|
|
TraceError(__FUNCNAME__, hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
//
|
|
// Function: HrGetOemDirs
|
|
//
|
|
// Purpose: Get list of OEM dirs from netupg.inf file
|
|
//
|
|
// Arguments:
|
|
// pslOemDirs [out] pointer to list of OEM dirs
|
|
//
|
|
// Returns: S_OK on success, otherwise an error code
|
|
//
|
|
// Author: kumarp 17-December-97
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT HrGetOemDirs(OUT TStringList* pslOemDirs)
|
|
{
|
|
DefineFunctionName("HrGetOemDirs");
|
|
|
|
TraceFunctionEntry(ttidNetUpgrade);
|
|
|
|
AssertValidReadPtr(pslOemDirs);
|
|
|
|
HRESULT hr=S_OK;
|
|
static const WCHAR c_szOemDirsSection[] = L"OemNetUpgradeDirs";
|
|
|
|
HINF hInf;
|
|
INFCONTEXT ic;
|
|
tstring strNetUpgrdDir;
|
|
tstring strDirFullPath;
|
|
|
|
hr = HrGetNetupgrdDir(&strNetUpgrdDir);
|
|
if (S_OK == hr)
|
|
{
|
|
hr = HrOpenNetUpgInfFile(&hInf);
|
|
}
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
tstring strOemDir;
|
|
|
|
hr = HrSetupFindFirstLine(hInf, c_szOemDirsSection, NULL, &ic);
|
|
if (S_OK == hr)
|
|
{
|
|
do
|
|
{
|
|
hr = HrSetupGetLineText(&ic, hInf, NULL, NULL, &strOemDir);
|
|
if (S_OK == hr)
|
|
{
|
|
TraceTag(ttidNetUpgrade, "%s: locating '%S'...",
|
|
__FUNCNAME__, strOemDir.c_str());
|
|
|
|
hr = HrDirectoryExists(strOemDir.c_str());
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
strDirFullPath = strOemDir;
|
|
}
|
|
else if (S_FALSE == hr)
|
|
{
|
|
// this may be a dir. relative to winntupg dir
|
|
//
|
|
strDirFullPath = strNetUpgrdDir;
|
|
AppendToPath(&strDirFullPath, strOemDir.c_str());
|
|
|
|
hr = HrDirectoryExists(strDirFullPath.c_str());
|
|
}
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
pslOemDirs->push_back(new tstring(strDirFullPath));
|
|
TraceTag(ttidNetUpgrade, "%s: ...found OEM dir: %S",
|
|
__FUNCNAME__, strDirFullPath.c_str());
|
|
}
|
|
else if (S_FALSE == hr)
|
|
{
|
|
TraceTag(ttidNetUpgrade,
|
|
"%s: ...could not locate '%S'",
|
|
__FUNCNAME__, strOemDir.c_str());
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = HrSetupFindNextLine(ic, &ic);
|
|
}
|
|
}
|
|
}
|
|
while (S_OK == hr);
|
|
|
|
if (S_FALSE == hr)
|
|
{
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
if (HRESULT_FROM_SETUPAPI(ERROR_LINE_NOT_FOUND) == hr)
|
|
{
|
|
hr = S_OK;
|
|
}
|
|
::SetupCloseInfFile(hInf);
|
|
}
|
|
|
|
TraceError(__FUNCNAME__, hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
//
|
|
// Function: HrOpenOemNMapFile
|
|
//
|
|
// Purpose: Open netmap.inf file from the specified dir.
|
|
//
|
|
// Arguments:
|
|
// pszOemDir [in] name of dir.
|
|
// phinf [out] pointer to handle of netmap.inf file opened
|
|
//
|
|
// Returns: S_OK on success, otherwise an error code
|
|
//
|
|
// Author: kumarp 17-December-97
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT HrOpenOemNMapFile(IN PCWSTR pszOemDir, OUT HINF* phinf)
|
|
{
|
|
DefineFunctionName("HrOpenOemNMapFile");
|
|
|
|
HRESULT hr=S_OK;
|
|
*phinf = NULL;
|
|
|
|
tstring strOemNMapFile;
|
|
|
|
strOemNMapFile = pszOemDir;
|
|
AppendToPath(&strOemNMapFile, c_szOemNMapFileName);
|
|
|
|
hr = HrSetupOpenInfFile(strOemNMapFile.c_str(), NULL,
|
|
INF_STYLE_WIN4, NULL, phinf);
|
|
|
|
TraceError(__FUNCNAME__, hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
//
|
|
// Function: HrAddToNetMapInfo
|
|
//
|
|
// Purpose: Add the specified netmap.inf file to the set of netmap.inf files
|
|
//
|
|
// Arguments:
|
|
// pnma [in] array of CNetMapInfo objects
|
|
// hinf [in] handle of netmap.inf file to add
|
|
// pszOemDir [in] location of the above file
|
|
//
|
|
// Returns: S_OK on success, otherwise an error code
|
|
//
|
|
// Author: kumarp 17-December-97
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT HrAddToNetMapInfo(IN TNetMapArray* pnma,
|
|
IN HINF hinf,
|
|
IN PCWSTR pszOemDir)
|
|
{
|
|
DefineFunctionName("HrAddToNetMapInfo");
|
|
|
|
AssertValidReadPtr(pnma);
|
|
Assert(hinf);
|
|
AssertValidReadPtr(pszOemDir);
|
|
|
|
HRESULT hr=E_OUTOFMEMORY;
|
|
CNetMapInfo* pnmi;
|
|
|
|
pnmi = new CNetMapInfo;
|
|
if (pnmi)
|
|
{
|
|
hr = S_OK;
|
|
|
|
pnmi->m_hinfNetMap = hinf;
|
|
pnmi->m_strOemDir = pszOemDir;
|
|
|
|
pnma->push_back(pnmi);
|
|
}
|
|
|
|
TraceError(__FUNCNAME__, hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
//
|
|
// Function: HrOpenNetMapAndAddToNetMapInfo
|
|
//
|
|
// Purpose: Open and add netmap.inf file in the specified dir.
|
|
// to the set of netmap.inf files
|
|
//
|
|
// Arguments:
|
|
// pnma [in] array of CNetMapInfo objects
|
|
// pszOemDir [in] location of netmap.inf file
|
|
//
|
|
// Returns: S_OK on success, otherwise an error code
|
|
//
|
|
// Author: kumarp 17-December-97
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT HrOpenNetMapAndAddToNetMapInfo(IN TNetMapArray* pnma,
|
|
IN PCWSTR pszOemDir)
|
|
{
|
|
DefineFunctionName("HrOpenNetMapAndAddToNetMapInfo");
|
|
|
|
AssertValidReadPtr(pnma);
|
|
AssertValidReadPtr(pszOemDir);
|
|
|
|
HRESULT hr = S_OK;
|
|
HINF hinf;
|
|
|
|
hr = HrOpenOemNMapFile(pszOemDir, &hinf);
|
|
if (S_OK == hr)
|
|
{
|
|
hr = HrAddToNetMapInfo(pnma, hinf, pszOemDir);
|
|
}
|
|
|
|
TraceError(__FUNCNAME__, hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
//
|
|
// Function: HrAddToGlobalNetMapInfo
|
|
//
|
|
// Purpose: Add the specified netmap.inf file to the set of netmap.inf files
|
|
//
|
|
// Arguments:
|
|
// hinf [in] handle of netmap.inf file to add
|
|
// pszOemDir [in] location of the above file
|
|
//
|
|
// Returns: S_OK on success, otherwise an error code
|
|
//
|
|
// Author: kumarp 17-December-97
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT HrAddToGlobalNetMapInfo(IN HINF hinf,
|
|
IN PCWSTR pszOemDir)
|
|
{
|
|
DefineFunctionName("HrAddToGlobalNetMapInfo");
|
|
|
|
AssertValidReadPtr(g_pnmaNetMap);
|
|
Assert(hinf);
|
|
AssertValidReadPtr(pszOemDir);
|
|
|
|
HRESULT hr=E_OUTOFMEMORY;
|
|
|
|
hr = HrAddToNetMapInfo(g_pnmaNetMap, hinf, pszOemDir);
|
|
|
|
TraceError(__FUNCNAME__, hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
//
|
|
// Function: HrInitNetMapInfo
|
|
//
|
|
// Purpose: Initialize array of CNetMapInfo objects
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: S_OK on success, otherwise an error code
|
|
//
|
|
// Author: kumarp 17-December-97
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT HrInitNetMapInfo()
|
|
{
|
|
DefineFunctionName("HrInitNetMapInfo");
|
|
|
|
HRESULT hr=E_FAIL;
|
|
tstring strNetupgrdDir;
|
|
|
|
g_pnmaNetMap = new TNetMapArray;
|
|
if (!g_pnmaNetMap)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
{
|
|
hr = HrGetNetupgrdDir(&strNetupgrdDir);
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
TraceTag(ttidNetUpgrade, "%s: initializing netmap info from '%S'",
|
|
__FUNCNAME__, strNetupgrdDir.c_str());
|
|
hr = HrOpenNetMapAndAddToNetMapInfo(g_pnmaNetMap,
|
|
strNetupgrdDir.c_str());
|
|
}
|
|
}
|
|
|
|
TraceError(__FUNCNAME__, hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
//
|
|
// Function: UnInitNetMapInfo
|
|
//
|
|
// Purpose: Uninitialize the array of CNetMapInfo objects
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: None
|
|
//
|
|
// Author: kumarp 17-December-97
|
|
//
|
|
// Notes:
|
|
//
|
|
void UnInitNetMapInfo()
|
|
{
|
|
DefineFunctionName("UnInitNetMapInfo");
|
|
|
|
if (g_pnmaNetMap)
|
|
{
|
|
CNetMapInfo* pnmi;
|
|
size_t cNumNetMapEntries = g_pnmaNetMap->size();
|
|
|
|
for (size_t i = 0; i < cNumNetMapEntries; i++)
|
|
{
|
|
pnmi = (CNetMapInfo*) (*g_pnmaNetMap)[i];
|
|
|
|
delete pnmi;
|
|
}
|
|
g_pnmaNetMap->erase(g_pnmaNetMap->begin(), g_pnmaNetMap->end());
|
|
delete g_pnmaNetMap;
|
|
g_pnmaNetMap = NULL;
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
//
|
|
// Function: HrInitAndProcessOemDirs
|
|
//
|
|
// Purpose: Initialize and process each OEM dir specified in netupg.inf file
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: S_OK on success, otherwise an error code
|
|
//
|
|
// Author: kumarp 17-December-97
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT HrInitAndProcessOemDirs()
|
|
{
|
|
DefineFunctionName("HrInitAndProcessOemDirs");
|
|
|
|
TraceFunctionEntry(ttidNetUpgrade);
|
|
|
|
HRESULT hr=S_OK;
|
|
TStringList slOemDirs;
|
|
|
|
hr = HrGetOemDirs(&slOemDirs);
|
|
if (S_OK == hr)
|
|
{
|
|
PCWSTR pszOemDir;
|
|
HINF hinf;
|
|
TStringListIter pos;
|
|
|
|
for (pos=slOemDirs.begin(); pos != slOemDirs.end(); pos++)
|
|
{
|
|
pszOemDir = (*pos)->c_str();
|
|
TraceTag(ttidNetUpgrade, "%s: initializing NetMapInfo for: %S",
|
|
__FUNCNAME__, pszOemDir);
|
|
|
|
hr = HrProcessAndCopyOemFiles(pszOemDir, FALSE);
|
|
if (FAILED(hr))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (S_FALSE == hr)
|
|
{
|
|
hr = S_OK;
|
|
}
|
|
|
|
TraceError(__FUNCNAME__, hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
//
|
|
// Function: HrGetNetUpgradeTempDir
|
|
//
|
|
// Purpose: Return name of temp. dir to use, creating one if necessary
|
|
//
|
|
// Arguments:
|
|
// pstrTempDir [out] pointer to
|
|
//
|
|
// Returns: S_OK on success, otherwise an error code
|
|
//
|
|
// Author: kumarp 17-December-97
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT HrGetNetUpgradeTempDir(OUT tstring* pstrTempDir)
|
|
{
|
|
DefineFunctionName("HrGetNetUpgradeTempDir");
|
|
|
|
HRESULT hr=E_FAIL;
|
|
tstring strNetUpgradeTempDir;
|
|
|
|
hr = HrGetWindowsDir(&strNetUpgradeTempDir);
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
static const WCHAR c_szNetupgrdSubDir[] = L"\\netsetup\\";
|
|
|
|
strNetUpgradeTempDir += c_szNetupgrdSubDir;
|
|
|
|
if (!CreateDirectory(strNetUpgradeTempDir.c_str(), NULL))
|
|
{
|
|
hr = HrFromLastWin32Error();
|
|
if (HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS) == hr)
|
|
{
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
*pstrTempDir = strNetUpgradeTempDir;
|
|
}
|
|
}
|
|
|
|
TraceError(__FUNCNAME__, hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
//
|
|
// Function: HrCreateOemTempDir
|
|
//
|
|
// Purpose: Create a temp. dir with unique name
|
|
//
|
|
// Arguments:
|
|
// pstrOemTempDir [out] name of dir created
|
|
//
|
|
// Returns: S_OK on success, otherwise an error code
|
|
//
|
|
// Author: kumarp 17-December-97
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT HrCreateOemTempDir(OUT tstring* pstrOemTempDir)
|
|
{
|
|
DefineFunctionName("HrCreateOemTempDir");
|
|
|
|
HRESULT hr=S_OK;
|
|
static DWORD dwOemDirCount=0;
|
|
WCHAR szOemDirPath[MAX_PATH];
|
|
|
|
hr = HrGetNetUpgradeTempDir(pstrOemTempDir);
|
|
if (S_OK == hr)
|
|
{
|
|
DWORD dwRetryCount=0;
|
|
const DWORD c_dwMaxRetryCount=1000;
|
|
DWORD err=NO_ERROR;
|
|
DWORD status;
|
|
|
|
do
|
|
{
|
|
swprintf(szOemDirPath, L"%soem%05ld",
|
|
pstrOemTempDir->c_str(), dwOemDirCount++);
|
|
|
|
TraceTag(ttidNetUpgrade, "%s: trying to create %S",
|
|
__FUNCNAME__, szOemDirPath);
|
|
|
|
status = CreateDirectory(szOemDirPath, NULL);
|
|
|
|
if (status)
|
|
{
|
|
*pstrOemTempDir = szOemDirPath;
|
|
}
|
|
else
|
|
{
|
|
err = GetLastError();
|
|
}
|
|
}
|
|
while (!status && (ERROR_ALREADY_EXISTS == err) &&
|
|
(dwRetryCount++ < c_dwMaxRetryCount));
|
|
if (!status)
|
|
{
|
|
hr = HrFromLastWin32Error();
|
|
}
|
|
}
|
|
|
|
TraceError(__FUNCNAME__, hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
//
|
|
// Function: HrLoadAndVerifyOemDll
|
|
//
|
|
// Purpose: Load and check for correct exported fns in the specified OEM DLL
|
|
//
|
|
// Arguments:
|
|
// CNetMapInfo [in]
|
|
// i [in] pointer to
|
|
//
|
|
// Returns: S_OK on success,
|
|
// S_FALSE if DLL init had failed last time when we tried
|
|
// otherwise an error code
|
|
//
|
|
// Author: kumarp 17-December-97
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT HrLoadAndVerifyOemDll(IN OUT CNetMapInfo* pnmi)
|
|
{
|
|
DefineFunctionName("HrLoadAndVerifyOemDll");
|
|
|
|
HRESULT hr=S_OK;
|
|
|
|
Assert(!pnmi->m_hOemDll);
|
|
Assert(pnmi->m_strOemDllName.size() > 0);
|
|
Assert(pnmi->m_strOemDir.size() > 0);
|
|
|
|
if (pnmi->m_fDllInitFailed)
|
|
{
|
|
hr = S_FALSE;
|
|
}
|
|
else if (!pnmi->m_hOemDll)
|
|
{
|
|
TraceTag(ttidNetUpgrade, "%s: loading OEM DLL: %S%S",
|
|
__FUNCNAME__, pnmi->m_strOemDir.c_str(),
|
|
pnmi->m_strOemDllName.c_str());
|
|
|
|
tstring strOemDllFullPath;
|
|
strOemDllFullPath = pnmi->m_strOemDir;
|
|
AppendToPath(&strOemDllFullPath, pnmi->m_strOemDllName.c_str());
|
|
|
|
hr = HrLoadLibAndGetProcsV(strOemDllFullPath.c_str(),
|
|
&pnmi->m_hOemDll,
|
|
c_szPreUpgradeInitialize,
|
|
(FARPROC*) &pnmi->m_pfnPreUpgradeInitialize,
|
|
c_szDoPreUpgradeProcessing,
|
|
(FARPROC*) &pnmi->m_pfnDoPreUpgradeProcessing,
|
|
NULL);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
pnmi->m_hOemDll = NULL;
|
|
pnmi->m_pfnPreUpgradeInitialize = NULL;
|
|
pnmi->m_pfnDoPreUpgradeProcessing = NULL;
|
|
pnmi->m_fDllInitFailed = TRUE;
|
|
}
|
|
}
|
|
|
|
TraceError(__FUNCNAME__, hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
//
|
|
// Function: HrLoadAndInitOemDll
|
|
//
|
|
// Purpose: Load the specified OEM DLL and call its
|
|
// PreUpgradeInitialize function
|
|
//
|
|
// Arguments:
|
|
// pnmi [in] pointer to CNetMapInfo object
|
|
// pNetUpgradeInfo [in] pointer to NetUpgradeInfo
|
|
//
|
|
// Returns: S_OK on success
|
|
// S_FALSE if DLL init had failed last time when we tried
|
|
// otherwise an error code
|
|
//
|
|
// Author: kumarp 17-December-97
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT HrLoadAndInitOemDll(IN CNetMapInfo* pnmi,
|
|
IN NetUpgradeInfo* pNetUpgradeInfo)
|
|
{
|
|
DefineFunctionName("HrLoadAndInitOemDll");
|
|
|
|
HRESULT hr=S_OK;
|
|
DWORD dwError=ERROR_SUCCESS;
|
|
VENDORINFO vi;
|
|
|
|
hr = HrLoadAndVerifyOemDll(pnmi);
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
if (pnmi->m_pfnPreUpgradeInitialize)
|
|
{
|
|
NC_TRY
|
|
{
|
|
TraceTag(ttidNetUpgrade, "%s: initializing OEM DLL: %S in %S",
|
|
__FUNCNAME__,
|
|
pnmi->m_strOemDllName.c_str(),
|
|
pnmi->m_strOemDir.c_str());
|
|
|
|
dwError = pnmi->m_pfnPreUpgradeInitialize(pnmi->m_strOemDir.c_str(),
|
|
pNetUpgradeInfo,
|
|
&vi,
|
|
&pnmi->m_dwFlags,
|
|
&pnmi->m_nud);
|
|
#ifdef ENABLETRACE
|
|
if (pnmi->m_nud.mszServicesNotToBeDeleted)
|
|
{
|
|
TraceMultiSz(ttidNetUpgrade,
|
|
L"OEM services that will not be deleted",
|
|
pnmi->m_nud.mszServicesNotToBeDeleted);
|
|
}
|
|
#endif
|
|
// ensure that this function gets called only once
|
|
//
|
|
pnmi->m_pfnPreUpgradeInitialize = NULL;
|
|
|
|
hr = HRESULT_FROM_WIN32(dwError);
|
|
|
|
if (pnmi->m_dwFlags & NUA_REQUEST_ABORT_UPGRADE)
|
|
{
|
|
TraceTag(ttidNetUpgrade,
|
|
"%s: OEM DLL '%S' requested that upgrade be aborted",
|
|
__FUNCNAME__, pnmi->m_strOemDllName.c_str());
|
|
RequestAbortUpgradeOboOemDll(pnmi->m_strOemDllName.c_str(),
|
|
&vi);
|
|
hr = S_FALSE;
|
|
}
|
|
else if (pnmi->m_dwFlags & NUA_ABORT_UPGRADE)
|
|
{
|
|
TraceTag(ttidNetUpgrade,
|
|
"%s: OEM DLL '%S' aborted the upgrade",
|
|
__FUNCNAME__, pnmi->m_strOemDllName.c_str());
|
|
AbortUpgradeFn(ERROR_SUCCESS, pnmi->m_strOemDllName.c_str());
|
|
hr = S_FALSE;
|
|
}
|
|
}
|
|
NC_CATCH_ALL
|
|
{
|
|
TraceTag(ttidError, "%s: OEM DLL '%S' caused an exception",
|
|
__FUNCNAME__, pnmi->m_strOemDllName.c_str());
|
|
hr = HRESULT_FROM_WIN32(ERROR_DLL_INIT_FAILED);
|
|
}
|
|
}
|
|
}
|
|
|
|
TraceError(__FUNCNAME__, hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
//
|
|
// Function: HrProcessOemComponent
|
|
//
|
|
// Purpose: Load an OEM DLL and call DoPreUpgradeProcessing
|
|
// function for the specified component
|
|
//
|
|
// Arguments:
|
|
// pnmi [in] pointer to CNetMapInfo object
|
|
// pNetUpgradeInfo [in] pointer to NetUpgradeInfo
|
|
// hwndParent [in] handle of parent window
|
|
// hkeyParams [in] handle of Parameters registry key
|
|
// pszPreNT5InfId [in] pre-NT5 InfID of a component (e.g. IEEPRO)
|
|
// pszPreNT5Instance [in] pre-NT5 instance of a component (e.g. IEEPRO2)
|
|
// pszNT5InfId [in] NT5 InfID of the component
|
|
// pszDescription [in] description of the component
|
|
// pszSectionName [in] name of section that the OEM DLL must use
|
|
// for storing its upgrade parameters
|
|
// pdwFlags [out] pointer to flags returned by OEM DLL
|
|
//
|
|
// Returns: S_OK on success, otherwise an error code
|
|
//
|
|
// Author: kumarp 17-December-97
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT HrProcessOemComponent(CNetMapInfo* pnmi,
|
|
IN NetUpgradeInfo* pNetUpgradeInfo,
|
|
IN HWND hwndParent,
|
|
IN HKEY hkeyParams,
|
|
IN PCWSTR pszPreNT5InfId,
|
|
IN PCWSTR pszPreNT5Instance,
|
|
IN PCWSTR pszNT5InfId,
|
|
IN PCWSTR pszDescription,
|
|
IN PCWSTR pszSectionName,
|
|
OUT DWORD* pdwFlags)
|
|
{
|
|
DefineFunctionName("HrProcessOemComponent");
|
|
|
|
AssertValidReadPtr(pnmi);
|
|
AssertValidReadPtr(pNetUpgradeInfo);
|
|
Assert(hkeyParams);
|
|
AssertValidReadPtr(pszPreNT5InfId);
|
|
AssertValidReadPtr(pszPreNT5Instance);
|
|
AssertValidReadPtr(pszNT5InfId);
|
|
AssertValidReadPtr(pszDescription);
|
|
AssertValidReadPtr(pszSectionName);
|
|
AssertValidWritePtr(pdwFlags);
|
|
|
|
TraceTag(ttidNetUpgrade,
|
|
"%s: Processing OEM component: %S(%S), instance: %S",
|
|
__FUNCNAME__, pszNT5InfId, pszPreNT5InfId, pszPreNT5Instance);
|
|
|
|
HRESULT hr=S_OK;
|
|
VENDORINFO vi;
|
|
DWORD dwErrorMessageId=0;
|
|
|
|
if (pnmi->m_strOemDllName.empty())
|
|
{
|
|
tstring strOemInf;
|
|
|
|
hr = HrGetOemUpgradeInfoInInf(pnmi->m_hinfNetMap,
|
|
pszNT5InfId,
|
|
&pnmi->m_strOemDllName,
|
|
&strOemInf);
|
|
if (S_OK == hr)
|
|
{
|
|
hr = HrLoadAndInitOemDll(pnmi, pNetUpgradeInfo);
|
|
if (FAILED(hr))
|
|
{
|
|
dwErrorMessageId = IDS_E_LoadAndInitOemDll;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dwErrorMessageId = IDS_E_GetOemUpgradeDllInfoInInf;
|
|
}
|
|
|
|
}
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
Assert(pnmi->m_pfnDoPreUpgradeProcessing);
|
|
|
|
NC_TRY
|
|
{
|
|
TraceTag(ttidNetUpgrade,
|
|
"%s: calling DoPreUpgradeProcessing in %S for %S",
|
|
__FUNCNAME__, pnmi->m_strOemDllName.c_str(), pszNT5InfId);
|
|
|
|
Assert(pnmi->m_pfnDoPreUpgradeProcessing);
|
|
|
|
DWORD dwError =
|
|
pnmi->m_pfnDoPreUpgradeProcessing(hwndParent, hkeyParams,
|
|
pszPreNT5InfId, pszPreNT5Instance,
|
|
pszNT5InfId,
|
|
pszSectionName,
|
|
&vi,
|
|
pdwFlags, NULL);
|
|
|
|
TraceTag(ttidNetUpgrade, "%s: DoPreUpgradeProcessing returned: 0x%x",
|
|
__FUNCNAME__, dwError);
|
|
|
|
hr = HRESULT_FROM_WIN32(dwError);
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
if (*pdwFlags & NUA_REQUEST_ABORT_UPGRADE)
|
|
{
|
|
RequestAbortUpgradeOboOemDll(pnmi->m_strOemDllName.c_str(),
|
|
&vi);
|
|
hr = S_FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dwErrorMessageId = IDS_E_DoPreUpgradeProcessing;
|
|
}
|
|
}
|
|
NC_CATCH_ALL
|
|
{
|
|
TraceTag(ttidError, "%s: OEM DLL '%S' caused an exception",
|
|
__FUNCNAME__, pnmi->m_strOemDllName.c_str());
|
|
|
|
hr = HRESULT_FROM_WIN32(ERROR_OPERATION_ABORTED);
|
|
dwErrorMessageId = IDS_E_OemDllCausedAnException;
|
|
}
|
|
}
|
|
else if (S_FALSE == hr)
|
|
{
|
|
TraceTag(ttidNetUpgrade, "%s: DoPreUpgradeProcessing was not called"
|
|
" since DLL init had failed", __FUNCNAME__);
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
AbortUpgradeOemComponent(pszPreNT5InfId, pszDescription,
|
|
DwWin32ErrorFromHr(hr), dwErrorMessageId);
|
|
}
|
|
|
|
TraceError(__FUNCNAME__, hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
//
|
|
// Function: HrShowUiAndGetOemFileLocation
|
|
//
|
|
// Purpose: Display UI asking the user to specify location of OEM files
|
|
//
|
|
// Arguments:
|
|
// hwndParent [in] handle of parent window
|
|
// pszComponentName [in] name of Component
|
|
// pstrOemPath [out] name of netmap.inf file the user selected
|
|
//
|
|
// Returns: S_OK on success, otherwise an error code
|
|
//
|
|
// Author: kumarp 17-December-97
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT
|
|
HrShowUiAndGetOemFileLocation(
|
|
IN HWND hwndParent,
|
|
IN PCWSTR pszComponentName,
|
|
OUT tstring* pstrOemPath)
|
|
{
|
|
DefineFunctionName("HrShowUiAndGetOemFileLocation");
|
|
|
|
AssertValidWritePtr(pstrOemPath);
|
|
|
|
OPENFILENAME ofn;
|
|
WCHAR szOemPath[MAX_PATH+1];
|
|
PWSTR pszTitle;
|
|
PCWSTR pszOemQueryFileLocationFormatString =
|
|
SzLoadString(g_hinst, IDS_OemQueryFileLocation);
|
|
|
|
PCWSTR pszOemFileTypeFilter1 =
|
|
SzLoadString(g_hinst, IDS_OemNetMapFileFilter1);
|
|
PCWSTR pszOemFileTypeFilter2 =
|
|
SzLoadString(g_hinst, IDS_OemNetMapFileFilter2);
|
|
|
|
PWSTR mszFileFilter = NULL;
|
|
HRESULT hr = S_OK;
|
|
BOOL f;
|
|
|
|
hr = HrAddSzToMultiSz(pszOemFileTypeFilter1, NULL,
|
|
STRING_FLAG_ENSURE_AT_END,
|
|
0, &mszFileFilter, &f);
|
|
if (S_OK != hr)
|
|
{
|
|
goto cleanup;
|
|
}
|
|
|
|
hr = HrAddSzToMultiSz(pszOemFileTypeFilter2, mszFileFilter,
|
|
STRING_FLAG_ENSURE_AT_END,
|
|
0, &mszFileFilter, &f);
|
|
if (S_OK != hr)
|
|
{
|
|
goto cleanup;
|
|
}
|
|
|
|
ZeroMemory (&ofn, sizeof(ofn));
|
|
*szOemPath = 0;
|
|
|
|
DwFormatStringWithLocalAlloc (
|
|
pszOemQueryFileLocationFormatString,
|
|
&pszTitle,
|
|
pszComponentName);
|
|
|
|
ofn.lStructSize = sizeof(OPENFILENAME);
|
|
ofn.hwndOwner = hwndParent;
|
|
ofn.lpstrFilter = mszFileFilter;
|
|
ofn.lpstrFile = szOemPath;
|
|
ofn.nMaxFile = MAX_PATH;
|
|
ofn.lpstrTitle = pszTitle;
|
|
ofn.Flags = OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST |
|
|
OFN_HIDEREADONLY | OFN_NOCHANGEDIR |
|
|
OFN_NODEREFERENCELINKS;
|
|
|
|
if (GetOpenFileName(&ofn))
|
|
{
|
|
// get rid of the trailing filename.
|
|
//
|
|
szOemPath[ofn.nFileOffset] = 0;
|
|
*pstrOemPath = szOemPath;
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
DWORD err;
|
|
err = CommDlgExtendedError();
|
|
if (err)
|
|
{
|
|
hr = E_FAIL;
|
|
TraceTag(ttidError, "%s: FileOpen dialog returned error: %ld (0x%lx)",
|
|
__FUNCNAME__, err, err);
|
|
}
|
|
else
|
|
{
|
|
hr = S_FALSE;
|
|
TraceTag(ttidError, "%s: FileOpen dialog was canceled by user",
|
|
__FUNCNAME__);
|
|
}
|
|
}
|
|
|
|
LocalFree (pszTitle);
|
|
cleanup:
|
|
MemFree(mszFileFilter);
|
|
|
|
TraceErrorOptional(__FUNCNAME__, hr, (hr == S_FALSE));
|
|
|
|
return hr;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
//
|
|
// Function: HrProcessAndCopyOemFiles
|
|
//
|
|
// Purpose: Copy OEM files from the specified dir to OEM temp. dir.
|
|
//
|
|
// Arguments:
|
|
// pszOemDir [in] location of OEM files
|
|
// fInteractive [in] TRUE --> called when a user has interactively
|
|
// supplied a disk having OEM files, FALSE otherwise
|
|
//
|
|
// Returns: S_OK on success,
|
|
// S_FALSE if the OEM files are valid but not applicable for
|
|
// currently displayed unsupported components,
|
|
// otherwise an error code
|
|
//
|
|
// Author: kumarp 17-December-97
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT HrProcessAndCopyOemFiles(IN PCWSTR pszOemDir,
|
|
IN BOOL fInteractive)
|
|
{
|
|
DefineFunctionName("HrProcessAndCopyOemFiles");
|
|
|
|
HRESULT hr=S_OK;
|
|
HINF hinf=NULL;
|
|
tstring strTempOemDir;
|
|
DWORD dwErrorMessageId;
|
|
|
|
TraceTag(ttidNetUpgrade, "%s: processing OEM files in: %S",
|
|
__FUNCNAME__, pszOemDir);
|
|
|
|
hr = HrOpenOemNMapFile(pszOemDir, &hinf);
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
DWORD dwNumConflictsResolved=0;
|
|
BOOL fHasUpgradeHelpInfo=FALSE;
|
|
|
|
hr = HrUpdateConflictList(FALSE, hinf, &dwNumConflictsResolved,
|
|
&fHasUpgradeHelpInfo);
|
|
|
|
#if 0
|
|
BOOL fNovell = (g_fForceNovellDirCopy && wcsstr(pszOemDir, L"oem\\novell"));
|
|
|
|
if (SUCCEEDED(hr) && ((dwNumConflictsResolved > 0) ||
|
|
fHasUpgradeHelpInfo ||
|
|
fNovell))
|
|
#endif
|
|
if (SUCCEEDED(hr) && ((dwNumConflictsResolved > 0) ||
|
|
fHasUpgradeHelpInfo))
|
|
{
|
|
#if 0
|
|
if (fNovell)
|
|
{
|
|
// special case for novell (dir name is %windir%\netsetup\novell)
|
|
|
|
hr = HrGetNetUpgradeTempDir(&strTempOemDir);
|
|
if (S_OK == hr)
|
|
{
|
|
strTempOemDir += L"novell";
|
|
if (0 == CreateDirectory(strTempOemDir.c_str(), NULL))
|
|
{
|
|
hr = HrFromLastWin32Error();
|
|
if (HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS) == hr)
|
|
{
|
|
// perhaps a previous failed attempt, maybe. Since
|
|
// we can just copy on top of this, ignore the 'error'.
|
|
//
|
|
hr = S_OK;
|
|
}
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
TraceTag(ttidNetUpgrade, "Created oem\\Novell dir",
|
|
__FUNCNAME__);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
#endif
|
|
|
|
{
|
|
// regular case (dir name is %windir%\netsetup\oemNNNNN)
|
|
hr = HrCreateOemTempDir(&strTempOemDir);
|
|
}
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
hr = HrCopyFiles(pszOemDir, strTempOemDir.c_str());
|
|
}
|
|
if (FAILED(hr))
|
|
{
|
|
dwErrorMessageId = IDS_E_CopyingOemFiles;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (fInteractive)
|
|
{
|
|
MessageBox(NULL,
|
|
SzLoadString(g_hinst, IDS_E_OemFilesNotValidForComponents),
|
|
SzLoadString(g_hinst, IDS_NetupgrdCaption),
|
|
MB_OK|MB_APPLMODAL);
|
|
}
|
|
|
|
hr = S_FALSE;
|
|
}
|
|
::SetupCloseInfFile(hinf);
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
hr = HrOpenOemNMapFile(strTempOemDir.c_str(), &hinf);
|
|
if (S_OK == hr)
|
|
{
|
|
hr = HrUpdateConflictList(TRUE, hinf, &dwNumConflictsResolved,
|
|
&fHasUpgradeHelpInfo);
|
|
if (SUCCEEDED(hr) && ((dwNumConflictsResolved > 0) ||
|
|
fHasUpgradeHelpInfo))
|
|
{
|
|
// hinf is stored in the global array, it will be
|
|
// closed in UninitNetMapInfo function
|
|
//
|
|
hr = HrAddToGlobalNetMapInfo(hinf, strTempOemDir.c_str());
|
|
}
|
|
else
|
|
{
|
|
::SetupCloseInfFile(hinf);
|
|
}
|
|
}
|
|
if (FAILED(hr))
|
|
{
|
|
dwErrorMessageId = IDS_E_PresetNetMapInfError;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TraceTag(ttidNetUpgrade, "%s: could not open netmap.inf in %S",
|
|
__FUNCNAME__, pszOemDir);
|
|
dwErrorMessageId = IDS_E_PresetNetMapInfError;
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
FGetConfirmationAndAbortUpgradeId(dwErrorMessageId);
|
|
}
|
|
|
|
TraceErrorOptional(__FUNCNAME__, hr, (hr == S_FALSE));
|
|
|
|
return hr;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
//
|
|
// Function: RequestAbortUpgradeOboOemDll
|
|
//
|
|
// Purpose: Display UI on behalf of an OEM DLL and ask user
|
|
// if upgrade needs to be aborted
|
|
//
|
|
// Arguments:
|
|
// pszDllName [in] name of OEM DLL
|
|
//
|
|
// Returns: None
|
|
//
|
|
// Author: kumarp 17-December-97
|
|
//
|
|
// Notes:
|
|
//
|
|
void RequestAbortUpgradeOboOemDll(IN PCWSTR pszDllName, VENDORINFO* pvi)
|
|
{
|
|
tstring strMessage;
|
|
|
|
strMessage = SzLoadString(g_hinst, IDS_E_OemDllRequestsAbortingUpgrade);
|
|
strMessage += pszDllName;
|
|
strMessage += L"\n\n";
|
|
|
|
strMessage += SzLoadString(g_hinst, IDS_InfoAboutOemDllSupplier);
|
|
|
|
strMessage += SzLoadString(g_hinst, IDS_ViCompanyName);
|
|
strMessage += pvi->szCompanyName;
|
|
strMessage += L"\n";
|
|
|
|
if (*pvi->szSupportNumber)
|
|
{
|
|
strMessage += SzLoadString(g_hinst, IDS_ViSupportNumber);
|
|
strMessage += pvi->szSupportNumber;
|
|
strMessage += L"\n";
|
|
}
|
|
|
|
if (*pvi->szSupportUrl)
|
|
{
|
|
strMessage += SzLoadString(g_hinst, IDS_ViSupportUrl);
|
|
strMessage += pvi->szSupportUrl;
|
|
strMessage += L"\n";
|
|
}
|
|
|
|
if (*pvi->szInstructionsToUser)
|
|
{
|
|
strMessage += SzLoadString(g_hinst, IDS_ViAdditionalInfo);
|
|
strMessage += pvi->szInstructionsToUser;
|
|
strMessage += L"\n";
|
|
}
|
|
|
|
FGetConfirmationAndAbortUpgrade(strMessage.c_str());
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
//
|
|
// Function: AbortUpgradeOemComponent
|
|
//
|
|
// Purpose: Abort upgrade because of a fatal error when upgrading an
|
|
// OEM component
|
|
//
|
|
// Arguments:
|
|
// pszPreNT5InfId [in] pre-NT5 InfID of OEM component
|
|
// pszDescription [in] description of OEM component
|
|
// dwError [in] error code
|
|
// dwErrorMessageId [in] ID of error message resource string
|
|
//
|
|
// Returns: None
|
|
//
|
|
// Author: kumarp 17-December-97
|
|
//
|
|
// Notes:
|
|
//
|
|
void AbortUpgradeOemComponent(IN PCWSTR pszPreNT5InfId,
|
|
IN PCWSTR pszDescription,
|
|
IN DWORD dwError,
|
|
IN DWORD dwErrorMessageId)
|
|
{
|
|
tstring strMessage;
|
|
|
|
static const WCHAR c_szNewLine[] = L"\n";
|
|
WCHAR szErrorCode[16];
|
|
|
|
swprintf(szErrorCode, L"0x%08x", dwError);
|
|
|
|
strMessage = SzLoadString(g_hinst, IDS_E_OemComponentUpgrade);
|
|
strMessage = strMessage + c_szNewLine + pszDescription + L"(" +
|
|
pszPreNT5InfId + L"\n\n" +
|
|
SzLoadString(g_hinst, dwErrorMessageId) +
|
|
c_szNewLine + SzLoadString(g_hinst, IDS_E_ErrorCode) + szErrorCode;
|
|
|
|
FGetConfirmationAndAbortUpgrade(strMessage.c_str());
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
//
|
|
// Function: FCanDeleteOemService
|
|
//
|
|
// Purpose: Determine if a service can be deleted.
|
|
// OEM upgrade DLLs can prevent a service from being deleted,
|
|
// by specifying a list in the mszServicesNotToBeDeleted
|
|
// member of NetUpgradeData structure.
|
|
//
|
|
// Arguments:
|
|
// pszServiceName [in] name of the service to be spared.
|
|
//
|
|
// Returns: TRUE if can delete, FALSE otherwise
|
|
//
|
|
// Author: kumarp 04-March-98
|
|
//
|
|
// Notes:
|
|
//
|
|
BOOL FCanDeleteOemService(IN PCWSTR pszServiceName)
|
|
{
|
|
BOOL fCanDeleteService = TRUE;
|
|
|
|
if (g_pnmaNetMap)
|
|
{
|
|
CNetMapInfo* pnmi;
|
|
size_t cNumNetMapEntries = g_pnmaNetMap->size();
|
|
|
|
for (size_t i = 0; i < cNumNetMapEntries; i++)
|
|
{
|
|
pnmi = (CNetMapInfo*) (*g_pnmaNetMap)[i];
|
|
|
|
if (FIsSzInMultiSzSafe(pszServiceName,
|
|
pnmi->m_nud.mszServicesNotToBeDeleted))
|
|
{
|
|
fCanDeleteService = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return fCanDeleteService;
|
|
}
|