able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/config/shell/netsetup/oemupgrd.cpp

1006 lines
28 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+---------------------------------------------------------------------------
//
// Microsoft Windows NT5.0
// Copyright (C) Microsoft Corporation, 1997.
//
// File: O E M U P G R D . H
//
// Contents: Functions for OEM upgrade
//
// Notes:
//
// Author: kumarp 13-November-97
//
//----------------------------------------------------------------------------
#include "pch.h"
#pragma hdrstop
#include <setupapi.h>
#include "nsbase.h"
#include "afileint.h"
#include "afilestr.h"
#include "kkutils.h"
#include "ncatl.h"
#include "nceh.h"
#include "ncsetup.h"
#include "netcfgn.h"
#include "oemupgrd.h"
#include "nslog.h"
#include "resource.h"
static const PCWSTR c_aszComponentSections[] =
{
c_szAfSectionNetAdapters,
c_szAfSectionNetProtocols,
c_szAfSectionNetClients,
c_szAfSectionNetServices
};
// ----------------------------------------------------------------------
//
// Function: COemInfo::COemInfo
//
// Purpose: constructor for class COemInfo
//
// Arguments: None
//
// Returns: None
//
// Author: kumarp 24-December-97
//
// Notes:
//
COemInfo::COemInfo()
{
TraceFileFunc(ttidGuiModeSetup);
m_hOemDll = 0;
m_dwError = ERROR_SUCCESS;
m_pfnPostUpgradeInitialize = 0;
m_pfnDoPostUpgradeProcessing = 0;
}
// ----------------------------------------------------------------------
//
// Function: COemInfo::~COemInfo
//
// Purpose: destructor for class COemInfo
//
// Arguments: None
//
// Returns: None
//
// Author: kumarp 24-December-97
//
// Notes:
//
COemInfo::~COemInfo()
{
TraceFileFunc(ttidGuiModeSetup);
DefineFunctionName("COemInfo::~COemInfo");
if (m_hOemDll)
{
TraceTag(ttidNetSetup, "%s: unloading OEM DLL: %S\\%S",
__FUNCNAME__, m_strOemDir.c_str(), m_strOemDll.c_str());
::FreeLibrary(m_hOemDll);
}
}
// ----------------------------------------------------------------------
//
// Function: HrLoadAndVerifyOemDll
//
// Purpose: Load OEM upgrade DLL and verify that it has
// correct exported functions
//
// Arguments:
// poi [in/out] pointer to COemInfo object
//
// Returns: S_OK on success, otherwise an error code
//
// Author: kumarp 19-February-98
//
// Notes:
//
HRESULT HrLoadAndVerifyOemDll(IN OUT COemInfo* poi)
{
TraceFileFunc(ttidGuiModeSetup);
AssertValidWritePtr(poi);
DefineFunctionName("HrLoadAndVerifyOemDll");
HRESULT hr=S_OK;
if (!poi->m_hOemDll)
{
tstring strOemDllFullPath;
strOemDllFullPath = poi->m_strOemDir;
AppendToPath(&strOemDllFullPath, poi->m_strOemDll.c_str());
TraceTag(ttidNetSetup, "%s: loading OEM DLL: %S",
__FUNCNAME__, strOemDllFullPath.c_str());
hr = HrLoadLibAndGetProcsV(strOemDllFullPath.c_str(),
&poi->m_hOemDll,
c_szPostUpgradeInitialize,
(FARPROC*) &poi->m_pfnPostUpgradeInitialize,
c_szDoPostUpgradeProcessing,
(FARPROC*) &poi->m_pfnDoPostUpgradeProcessing,
NULL);
if (S_OK != hr)
{
FreeLibrary(poi->m_hOemDll);
poi->m_hOemDll = NULL;
poi->m_pfnPostUpgradeInitialize = NULL;
poi->m_pfnDoPostUpgradeProcessing = NULL;
poi->m_dwError = ERROR_DLL_INIT_FAILED;
}
NetSetupLogComponentStatus(poi->m_strOemDll.c_str(),
SzLoadIds (IDS_LOADING), hr);
}
TraceError(__FUNCNAME__, hr);
return hr;
}
// ----------------------------------------------------------------------
//
// Function: HrLoadAndInitOemDll
//
// Purpose: Load OEM DLL, verify that it exports correct functions
// and call DoPostUpgradeInitialize
//
// Arguments:
// poi [in] pointer to COemInfo object
// pNetUpgradeInfo [in] pointer to NetUpgradeInfo
//
// Returns: S_OK on success, otherwise an error code
//
// Author: kumarp 04-March-98
//
// Notes:
//
HRESULT HrLoadAndInitOemDll(IN COemInfo* poi,
IN NetUpgradeInfo* pNetUpgradeInfo)
{
TraceFileFunc(ttidGuiModeSetup);
DefineFunctionName("HrLoadAndInitOemDll");
HRESULT hr=S_OK;
DWORD dwError=ERROR_SUCCESS;
hr = HrLoadAndVerifyOemDll(poi);
VENDORINFO vi;
if (S_OK == hr)
{
if ((ERROR_SUCCESS == poi->m_dwError) &&
poi->m_pfnPostUpgradeInitialize)
{
NC_TRY
{
TraceTag(ttidNetSetup, "%s: initializing OEM DLL: %S\\%S",
__FUNCNAME__, poi->m_strOemDir.c_str(),
poi->m_strOemDll.c_str());
dwError = poi->m_pfnPostUpgradeInitialize(poi->m_strOemDir.c_str(),
pNetUpgradeInfo,
&vi, NULL);
// ensure that this function gets called only once
//
poi->m_pfnPostUpgradeInitialize = NULL;
if (ERROR_SUCCESS == dwError)
{
hr = S_OK;
}
}
NC_CATCH_ALL
{
dwError = ERROR_DLL_INIT_FAILED;
NetSetupLogHrStatusV(S_FALSE,
SzLoadIds (IDS_POSTUPGRADEINIT_EXCEPTION),
poi->m_strOemDll.c_str());
}
poi->m_dwError = dwError;
NetSetupLogComponentStatus(poi->m_strOemDll.c_str(),
SzLoadIds (IDS_POSTUPGRADE_INIT), dwError);
}
else
{
hr = S_FALSE;
}
}
TraceError(__FUNCNAME__, hr);
return hr;
}
typedef list<COemInfo*> TOemInfoList;
typedef TOemInfoList::iterator TOemInfoListIter;
static TOemInfoList* g_plOemInfo;
// ----------------------------------------------------------------------
//
// Function: HrGetOemInfo
//
// Purpose: Locate (create if not found) and return COemInfo
// for the given dir & dll
//
// Arguments:
// pszOemDir [in] full path to OEM temp dir
// pszOemDll [in] full path to OEM DLL
// ppoi [out] pointer to pointer to COemInfo object
//
// Returns: S_OK on success, otherwise an error code
//
// Author: kumarp 04-March-98
//
// Notes:
//
HRESULT HrGetOemInfo(IN PCWSTR pszOemDir,
IN PCWSTR pszOemDll,
OUT COemInfo** ppoi)
{
TraceFileFunc(ttidGuiModeSetup);
DefineFunctionName("HrGetOemInfo");
HRESULT hr=E_OUTOFMEMORY;
*ppoi = NULL;
if (!g_plOemInfo)
{
g_plOemInfo = new TOemInfoList;
}
if (g_plOemInfo)
{
TOemInfoListIter pos;
COemInfo* poi;
for (pos=g_plOemInfo->begin(); pos != g_plOemInfo->end(); pos++)
{
poi = (COemInfo*) *pos;
if (!lstrcmpiW(pszOemDir, poi->m_strOemDir.c_str()) &&
!lstrcmpiW(pszOemDll, poi->m_strOemDll.c_str()))
{
*ppoi = poi;
hr = S_OK;
break;
}
}
if (!*ppoi)
{
hr = E_OUTOFMEMORY;
*ppoi = new COemInfo;
if (*ppoi)
{
(*ppoi)->m_strOemDir = pszOemDir;
(*ppoi)->m_strOemDll = pszOemDll;
g_plOemInfo->push_back(*ppoi);
hr = S_OK;
}
}
}
TraceError(__FUNCNAME__, hr);
return hr;
}
// ----------------------------------------------------------------------
//
// Function: CleanupOemInfo
//
// Purpose: Cleanup OEM data
//
// Arguments: None
//
// Returns: None
//
// Author: kumarp 04-March-98
//
// Notes:
//
void CleanupOemInfo()
{
TraceFileFunc(ttidGuiModeSetup);
if (g_plOemInfo)
{
FreeCollectionAndItem(*g_plOemInfo);
g_plOemInfo = 0;
}
}
// ----------------------------------------------------------------------
//
// Function: HrProcessOemComponent
//
// Purpose: Process upgrade an OEM component in the following steps
// - if OEM upgrade DLL is not loaded, load it and
// verify that it exports the required functions
// - call DoPostUpgradeInitialize only once
// - call DoPostUpgradeProcessing
//
// Arguments:
// hwndParent [in] handle of parent window
// pszOemDir [in] OEM working temp dir
// pszOemDll [in] full path to OEM DLL
// pNetUpgradeInfo [in] pointer to NetUpgradeInfo
// hkeyParams [in] handle of Parameters regkey
// pszPreNT5Instance [in] pre-NT5 instance e.g. IEEPRO3
// pszNT5InfId [in] NT5 InfID/PnpID
// hinfAnswerFile [in] handle of AnswerFile
// pszSectionName [in] name of OEM Section
//
// Returns: S_OK on success, otherwise an error code
//
// Author: kumarp 04-March-98
//
// Notes:
//
HRESULT HrProcessOemComponent(IN HWND hwndParent,
IN PCWSTR pszOemDir,
IN PCWSTR pszOemDll,
IN NetUpgradeInfo* pNetUpgradeInfo,
IN HKEY hkeyParams,
IN PCWSTR pszPreNT5Instance,
IN PCWSTR pszNT5InfId,
IN HINF hinfAnswerFile,
IN PCWSTR pszSectionName)
{
TraceFileFunc(ttidGuiModeSetup);
DefineFunctionName("HrProcessOemComponent");
VENDORINFO vi;
TraceTag(ttidNetSetup,
"%s: Processing OEM component: %S, instance: %S",
__FUNCNAME__, pszNT5InfId, pszPreNT5Instance);
HRESULT hr=S_OK;
COemInfo* poi;
hr = HrGetOemInfo(pszOemDir, pszOemDll, &poi);
DWORD dwError;
DWORD dwErrorMessageId=0;
if (S_OK == hr)
{
hr = HrLoadAndInitOemDll(poi, pNetUpgradeInfo);
}
if ((S_OK == hr) && (ERROR_SUCCESS == poi->m_dwError))
{
Assert(poi->m_pfnDoPostUpgradeProcessing);
NC_TRY
{
TraceTag(ttidNetSetup,
"%s: calling DoPostUpgradeProcessing in %S\\%S for %S",
__FUNCNAME__, poi->m_strOemDll.c_str(),
poi->m_strOemDir.c_str(), pszNT5InfId);
dwError =
poi->m_pfnDoPostUpgradeProcessing(hwndParent, hkeyParams,
pszPreNT5Instance,
pszNT5InfId, hinfAnswerFile,
pszSectionName, &vi, NULL);
NetSetupLogComponentStatus(pszNT5InfId,
SzLoadIds (IDS_POSTUPGRADE_PROCESSING), dwError);
}
NC_CATCH_ALL
{
dwError = ERROR_OPERATION_ABORTED;
NetSetupLogHrStatusV(S_FALSE,
SzLoadIds (IDS_POSTUPGRADEPROC_EXCEPTION), pszOemDll,
pszNT5InfId);
}
if (dwError == ERROR_SUCCESS)
{
hr = S_OK;
}
else
{
hr = HRESULT_FROM_WIN32(dwError);
}
poi->m_dwError = dwError;
NetSetupLogComponentStatus(pszOemDll,
SzLoadIds (IDS_POSTUPGRADE_PROCESSING),
hr);
}
else
{
hr = HRESULT_FROM_WIN32(poi->m_dwError);
}
TraceError(__FUNCNAME__, hr);
return hr;
}
// ----------------------------------------------------------------------
//
// Function: MapProductFlagToProductType
//
// Purpose: Map Product flag (NSF_*) to PRODUCTTYPE
//
// Arguments:
// dwUpgradeFromProductFlag [in] product flag
//
// Returns: PRODUCTTYPE
//
// Author: kumarp 04-March-98
//
// Notes:
//
PRODUCTTYPE MapProductFlagToProductType(IN DWORD dwUpgradeFromProductFlag)
{
TraceFileFunc(ttidGuiModeSetup);
PRODUCTTYPE pt;
switch (dwUpgradeFromProductFlag)
{
case NSF_WINNT_SVR_UPGRADE:
case NSF_WINNT_SBS_UPGRADE:
pt = NT_SERVER;
break;
case NSF_WINNT_WKS_UPGRADE:
pt = NT_WORKSTATION;
break;
default:
pt = UNKNOWN;
break;
}
return pt;
}
// ----------------------------------------------------------------------
//
// Function: GetCurrentProductBuildNumber
//
// Purpose: Get build number of NT on which we are running
//
// Arguments: None
//
// Returns: build number
//
// Author: kumarp 04-March-98
//
// Notes:
//
DWORD GetCurrentProductBuildNumber()
{
TraceFileFunc(ttidGuiModeSetup);
OSVERSIONINFO osv;
osv.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
GetVersionEx(&osv);
return osv.dwBuildNumber;
}
// ----------------------------------------------------------------------
//
// Function: MapProductFlavorToProductType
//
// Purpose: Map from PRODUCT_FLAVOR to PRODUCTTYPE
//
// Arguments:
// pf [in] product flavor
//
// Returns: product type
//
// Author: kumarp 04-March-98
//
// Notes:
//
PRODUCTTYPE MapProductFlavorToProductType(IN PRODUCT_FLAVOR pf)
{
TraceFileFunc(ttidGuiModeSetup);
PRODUCTTYPE pt;
switch (pf)
{
case PF_WORKSTATION:
pt = NT_WORKSTATION;
break;
case PF_SERVER:
pt = NT_SERVER;
break;
}
return pt;
}
// ----------------------------------------------------------------------
//
// Function: GetCurrentProductInfo
//
// Purpose: Get info. on the product on which we are running
//
// Arguments: None
//
// Returns: pointer to
//
// Author: kumarp 04-March-98
//
// Notes:
//
ProductInfo GetCurrentProductInfo()
{
TraceFileFunc(ttidGuiModeSetup);
ProductInfo pi;
pi.dwBuildNumber = GetCurrentProductBuildNumber();
PRODUCT_FLAVOR pf;
GetProductFlavor(NULL, &pf);
pi.ProductType = MapProductFlavorToProductType(pf);
return pi;
}
// ----------------------------------------------------------------------
//
// Function: HrSetupGetFieldCount
//
// Purpose: Wrapper for SetupGetFieldCount
//
// Arguments:
// pic [in] pointer to INFCONTEXT
// pcNumFields [out] pointer to number of fields
//
// Returns: S_OK on success, otherwise an error code
//
// Author: kumarp 04-March-98
//
// Notes:
//
HRESULT HrSetupGetFieldCount(IN INFCONTEXT* pic,
OUT UINT* pcNumFields)
{
TraceFileFunc(ttidGuiModeSetup);
HRESULT hr=S_OK;
if (!(*pcNumFields = SetupGetFieldCount(pic)))
{
hr = HrFromLastWin32Error();
}
return hr;
}
// ----------------------------------------------------------------------
//
// Function: HrAfGetInfToRunValue
//
// Purpose: Helper fn. to parse and locate the INF/section to run
// Before/After installing an OEM component
//
// Arguments:
// hinfAnswerFile [in] handle of AnswerFile
// szAnswerFileName [in] name of AnswerFile
// szParamsSection [in] name of Params section
// itrType [in] type of InfToRun key (Before/After)
// pstrInfToRun [out] pointer to the name of INF to run
// pstrSectionToRun [out] pointer to the name of section to run
//
// Returns: S_OK on success, otherwise an error code
//
// Author: kumarp 04-March-98
//
// Notes:
//
HRESULT HrAfGetInfToRunValue(IN HINF hinfAnswerFile,
IN PCWSTR szAnswerFileName,
IN PCWSTR szParamsSection,
IN EInfToRunValueType itrType,
OUT tstring* pstrInfToRun,
OUT tstring* pstrSectionToRun,
OUT tstring* pstrInfToRunType)
{
TraceFileFunc(ttidGuiModeSetup);
DefineFunctionName("HrAfGetInfToRunValue");
HRESULT hr=S_OK;
INFCONTEXT ic, ic2;
PCWSTR szInfToRunKey;
if (itrType == I2R_BeforeInstall)
{
szInfToRunKey = c_szInfToRunBeforeInstall;
}
else
{
szInfToRunKey = c_szInfToRunAfterInstall;
}
*pstrInfToRunType = szInfToRunKey;
hr = HrSetupFindFirstLine(hinfAnswerFile, szParamsSection,
c_szAfOemSection, &ic);
if (S_OK == hr)
{
tstring strOemSection;
hr = HrSetupGetStringField(ic, 1, &strOemSection);
if (S_OK == hr)
{
hr = HrSetupFindFirstLine(hinfAnswerFile, strOemSection.c_str(),
szInfToRunKey, &ic2);
if (S_OK == hr)
{
UINT cNumFields=0;
hr = HrSetupGetFieldCount(&ic2, &cNumFields);
if (S_OK == hr)
{
if (2 == cNumFields)
{
hr = HrSetupGetStringField(ic2, 1, pstrInfToRun);
if (S_OK == hr)
{
if (pstrInfToRun->empty())
{
if (itrType == I2R_AfterInstall)
{
*pstrInfToRun = szAnswerFileName;
}
else
{
hr = SPAPI_E_LINE_NOT_FOUND;
}
}
if (S_OK == hr)
{
hr = HrSetupGetStringField(ic2, 2,
pstrSectionToRun);
}
}
}
else
{
hr = SPAPI_E_LINE_NOT_FOUND;
}
}
}
else
{
hr = S_FALSE;
}
}
}
TraceErrorOptional(__FUNCNAME__, hr,
((SPAPI_E_LINE_NOT_FOUND == hr) || (S_FALSE == hr)));
return hr;
}
// ----------------------------------------------------------------------
//
// Function: HrProcessInfToRunForComponent
//
// Purpose: Run INF/section indicated by InfToRunBefore/AfterInstall
// key of a given OEM component
//
// Arguments:
// hinfAnswerFile [in] handle of AnswerFile
// szAnswerFileName [in] name of AnswerFile
// szParamsSection [in] parameters section of a component
// itrType [in] type of InfToRun key (Before/After)
// hwndParent [in] handle of parent window
// hkeyParams [in] handle of Parameters regkey
// fQuietInstall [in] TRUE if we do not want any UI to popup
//
// Returns: S_OK on success, otherwise an error code
//
// Author: kumarp 04-March-98
//
// Notes:
//
HRESULT HrProcessInfToRunForComponent(IN HINF hinfAnswerFile,
IN PCWSTR szAnswerFileName,
IN PCWSTR szParamsSection,
IN EInfToRunValueType itrType,
IN HWND hwndParent,
IN HKEY hkeyParams,
IN BOOL fQuietInstall)
{
TraceFileFunc(ttidGuiModeSetup);
DefineFunctionName("HrProcessInfToRunForComponent");
HRESULT hr=S_OK;
tstring strInfToRun;
tstring strSectionToRun;
tstring strInfToRunType;
hr = HrAfGetInfToRunValue(hinfAnswerFile, szAnswerFileName,
szParamsSection, itrType,
&strInfToRun, &strSectionToRun, &strInfToRunType);
if (S_OK == hr)
{
hr = HrInstallFromInfSectionInFile(hwndParent,
strInfToRun.c_str(),
strSectionToRun.c_str(),
hkeyParams,
fQuietInstall);
NetSetupLogHrStatusV(hr, SzLoadIds (IDS_STATUS_OF_APPLYING),
szParamsSection,
strInfToRunType.c_str(),
strSectionToRun.c_str(),
strInfToRun.c_str());
}
else if (SPAPI_E_LINE_NOT_FOUND == hr)
{
hr = S_FALSE;
}
TraceErrorOptional(__FUNCNAME__, hr, (S_FALSE == hr));
return hr;
}
// ----------------------------------------------------------------------
//
// Function: HrProcessInfToRunBeforeInstall
//
// Purpose: Process the answerfile and run any INFs/sections
// indicated by InfToRunBeforeInstall keys
//
// Arguments:
// hwndParent [in] handle of parent window
// szAnswerFileName [in] name of AnswerFile
//
// Returns: S_OK on success, otherwise an error code
//
// Author: kumarp 04-March-98
//
// Notes:
//
HRESULT HrProcessInfToRunBeforeInstall(IN HWND hwndParent,
IN PCWSTR szAnswerFileName)
{
TraceFileFunc(ttidGuiModeSetup);
AssertValidReadPtr(szAnswerFileName);
DefineFunctionName("HrRunInfToRunBeforeInstall");
HRESULT hr;
HINF hinf;
hr = HrSetupOpenInfFile(szAnswerFileName, NULL,
INF_STYLE_OLDNT | INF_STYLE_WIN4,
NULL, &hinf);
if (S_OK == hr)
{
PCWSTR szSection;
INFCONTEXT ic;
tstring strParamsSection;
for (int iSection=0; iSection < celems(c_aszComponentSections); iSection++)
{
szSection = c_aszComponentSections[iSection];
TraceTag(ttidNetSetup, "%s: Processing section [%S]",
__FUNCNAME__, szSection);
hr = HrSetupFindFirstLine(hinf, szSection, NULL, &ic);
if (S_OK == hr)
{
do
{
hr = HrSetupGetStringField(ic, 1, &strParamsSection);
if (S_OK == hr)
{
hr = HrProcessInfToRunForComponent(hinf, szAnswerFileName,
strParamsSection.c_str(),
I2R_BeforeInstall,
hwndParent,
NULL, // HKR
TRUE); // fQuietInstall
if (SUCCEEDED(hr))
{
hr = HrSetupFindNextLine(ic, &ic);
}
}
} while (S_OK == hr);
}
else if ((SPAPI_E_SECTION_NOT_FOUND == hr) ||
(SPAPI_E_LINE_NOT_FOUND == hr))
{
hr = S_OK;
}
}
SetupCloseInfFile(hinf);
}
if (S_FALSE == hr)
{
hr = S_OK;
}
TraceError(__FUNCNAME__, hr);
return hr;
}
// ----------------------------------------------------------------------
//
// Function: HrNetSetupCopyOemInfs
//
// Purpose: Copies all OEM INF files using SetupCopyOemInf
//
// Arguments:
// szAnswerFileName [in] name of AnswerFile
//
// Returns: S_OK on success, otherwise an error code
//
// Author: kumarp 12-May-98
//
// Notes:
//
HRESULT HrNetSetupCopyOemInfs(IN PCWSTR szAnswerFileName)
{
TraceFileFunc(ttidGuiModeSetup);
DefineFunctionName("HrNetSetupCopyOemInfs");
TraceTag(ttidNetSetup, "----> entering %s", __FUNCNAME__);
AssertValidReadPtr(szAnswerFileName);
HRESULT hr=S_OK;
HINF hinf=NULL;
INFCONTEXT ic;
tstring strParamsSection;
tstring strOemDir;
tstring strOemInf;
WCHAR szInfNameAfterCopy[MAX_PATH+1];
hr = HrSetupOpenInfFile(szAnswerFileName, NULL,
INF_STYLE_OLDNT | INF_STYLE_WIN4,
NULL, &hinf);
if (S_OK == hr)
{
PCWSTR szSection;
for (int iSection=0; iSection < celems(c_aszComponentSections); iSection++)
{
szSection = c_aszComponentSections[iSection];
TraceTag(ttidNetSetup, "%s: Processing section [%S]",
__FUNCNAME__, szSection);
hr = HrSetupFindFirstLine(hinf, szSection, NULL, &ic);
if (S_OK == hr)
{
do
{
hr = HrSetupGetStringField(ic, 1, &strParamsSection);
if (S_OK == hr)
{
hr = HrSetupGetFirstString(hinf, strParamsSection.c_str(),
c_szAfOemInf, &strOemInf);
if (S_OK == hr)
{
hr = HrSetupGetFirstString(hinf,
strParamsSection.c_str(),
c_szAfOemDir,
&strOemDir);
if (S_OK == hr)
{
AppendToPath(&strOemDir, strOemInf.c_str());
TraceTag(ttidNetSetup,
"%s: calling SetupCopyOemInf for %S",
__FUNCNAME__, strOemDir.c_str());
if (SetupCopyOEMInf(strOemDir.c_str(),
NULL, SPOST_PATH,
0, szInfNameAfterCopy,
MAX_PATH, NULL, NULL))
{
ShowProgressMessage(
L"...%s was copied as %s",
strOemDir.c_str(),
szInfNameAfterCopy);
NetSetupLogHrStatusV(S_OK,
SzLoadIds (IDS_OEMINF_COPY),
strOemDir.c_str(),
szInfNameAfterCopy);
}
else
{
hr = HrFromLastWin32Error();
ShowProgressMessage(
L"...SetupCopyOemInf failed for %s: error code: 0x%08x",
strOemDir.c_str(), hr);
NetSetupLogComponentStatus(strOemDir.c_str(),
SzLoadIds (IDS_CALLING_COPY_OEM_INF), hr);
}
}
else if (SPAPI_E_LINE_NOT_FOUND == hr)
{
TraceTag(ttidNetSetup,
"%s: Found %S but not %S!!",
__FUNCNAME__, c_szAfOemInf, c_szAfOemDir);
hr = S_OK;
}
}
else
{
if (SPAPI_E_LINE_NOT_FOUND == hr)
{
hr = S_OK;
}
}
}
// ignore all earlier errors, see if we can do the
// next item right
//
hr = HrSetupFindNextLine(ic, &ic);
} while (S_OK == hr);
}
else if ((SPAPI_E_SECTION_NOT_FOUND == hr) ||
(SPAPI_E_LINE_NOT_FOUND == hr))
{
hr = S_OK;
}
}
SetupCloseInfFile(hinf);
}
if (S_FALSE == hr)
{
hr = S_OK;
}
TraceError(__FUNCNAME__, hr);
return hr;
}
Reference in a new issue Copy permalink