static BOOL RenameHostOnlyConnectionsCallback(HDEVINFO hDevInfo, PSP_DEVINFO_DATA pDev, PVOID pContext)
{
WCHAR DevName[256];
DWORD winEr;
if (SetupDiGetDeviceRegistryPropertyW(hDevInfo, pDev,
SPDRP_FRIENDLYNAME , /* IN DWORD Property,*/
NULL, /*OUT PDWORD PropertyRegDataType, OPTIONAL*/
(PBYTE)DevName, /*OUT PBYTE PropertyBuffer,*/
sizeof(DevName), /* IN DWORD PropertyBufferSize,*/
NULL /*OUT PDWORD RequiredSize OPTIONAL*/
))
{
HKEY hKey = SetupDiOpenDevRegKey(hDevInfo, pDev,
DICS_FLAG_GLOBAL, /* IN DWORD Scope,*/
0, /*IN DWORD HwProfile, */
DIREG_DRV, /* IN DWORD KeyType, */
KEY_READ /*IN REGSAM samDesired*/
);
NonStandardAssert(hKey != INVALID_HANDLE_VALUE);
if (hKey != INVALID_HANDLE_VALUE)
{
WCHAR guid[50];
DWORD cbGuid=sizeof(guid);
winEr = RegQueryValueExW(hKey,
L"NetCfgInstanceId", /*__in_opt LPCTSTR lpValueName,*/
NULL, /*__reserved LPDWORD lpReserved,*/
NULL, /*__out_opt LPDWORD lpType,*/
(LPBYTE)guid, /*__out_opt LPBYTE lpData,*/
&cbGuid /*guid__inout_opt LPDWORD lpcbData*/
);
NonStandardAssert(winEr == ERROR_SUCCESS);
if (winEr == ERROR_SUCCESS)
{
WCHAR ConnectoinName[128];
ULONG cbName = sizeof(ConnectoinName);
HRESULT hr = VBoxNetCfgWinGenHostonlyConnectionName (DevName, ConnectoinName, &cbName);
NonStandardAssert(hr == S_OK);
if (SUCCEEDED(hr))
{
hr = VBoxNetCfgWinRenameConnection(guid, ConnectoinName);
NonStandardAssert(hr == S_OK);
}
}
}
RegCloseKey(hKey);
}
else
{
NonStandardAssert(0);
}
return TRUE;
}
static HRESULT vboxDrvCfgEnumFiles(LPCWSTR pPattern, PFNVBOXNETCFG_ENUMERATION_CALLBACK pfnCallback, PVOID pContext)
{
WIN32_FIND_DATA Data;
memset(&Data, 0, sizeof(Data));
HRESULT hr = S_OK;
HANDLE hEnum = FindFirstFile(pPattern,&Data);
if (hEnum != INVALID_HANDLE_VALUE)
{
do
{
if (!pfnCallback(Data.cFileName, pContext))
{
break;
}
/* next iteration */
memset(&Data, 0, sizeof(Data));
BOOL bNext = FindNextFile(hEnum,&Data);
if (!bNext)
{
DWORD dwErr = GetLastError();
if (dwErr != ERROR_NO_MORE_FILES)
{
NonStandardLogRelCrap((__FUNCTION__": FindNextFile fail dwErr=%ld\n", dwErr));
NonStandardAssert(0);
hr = HRESULT_FROM_WIN32(dwErr);
}
break;
}
}while (true);
FindClose(hEnum);
}
else
{
DWORD dwErr = GetLastError();
if (dwErr != ERROR_NO_MORE_FILES)
{
NonStandardLogRelCrap((__FUNCTION__": FindFirstFile fail dwErr=%ld\n", dwErr));
NonStandardAssert(0);
hr = HRESULT_FROM_WIN32(dwErr);
}
}
return hr;
}
static VOID netCfgLoggerEnable(MSIHANDLE hModule)
{
NonStandardAssert(hModule);
if (g_hCurrentModule)
netCfgLoggerDisable();
g_hCurrentModule = hModule;
VBoxNetCfgWinSetLogging((LOG_ROUTINE)netCfgLoggerCallback);
}
void VBoxNetFltNobj::init(IN INetCfgComponent *pNetCfgComponent, IN INetCfg *pNetCfg, IN BOOL bInstalling)
{
cleanup();
NonStandardAssert(pNetCfg);
NonStandardAssert(pNetCfgComponent);
if (pNetCfg)
{
pNetCfg->AddRef();
mpNetCfg = pNetCfg;
}
if (pNetCfgComponent)
{
pNetCfgComponent->AddRef();
mpNetCfgComponent = pNetCfgComponent;
}
mbInstalling = bInstalling;
}
HRESULT VBoxDrvCfgStringList::resize(int newSize)
{
NonStandardAssert(newSize >= mSize);
if (newSize < mSize)
return E_FAIL;
LPWSTR* pOld = maList;
maList = (LPWSTR*)malloc( sizeof(maList[0]) * newSize);
mBufSize = newSize;
memcpy(maList, pOld, mSize*sizeof(maList[0]));
free(pOld);
return S_OK;
}
static bool vboxDrvCfgInfEnumerationCallback(LPCWSTR lpszFileName, PVOID pCtxt)
{
PINFENUM_CONTEXT pContext = (PINFENUM_CONTEXT)pCtxt;
DWORD dwErr;
NonStandardLogRelCrap((__FUNCTION__": lpszFileName (%S)\n", lpszFileName));
NonStandardLogRelCrap((__FUNCTION__ ": pContext->InfInfo.lpszClassName = (%S)\n", pContext->InfInfo.lpszClassName));
HINF hInf = SetupOpenInfFileW(lpszFileName, pContext->InfInfo.lpszClassName, INF_STYLE_WIN4, NULL /*__in PUINT ErrorLine */);
if (hInf == INVALID_HANDLE_VALUE)
{
dwErr = GetLastError();
// NonStandardAssert(dwErr == ERROR_CLASS_MISMATCH);
if (dwErr != ERROR_CLASS_MISMATCH)
{
NonStandardLogCrap((__FUNCTION__ ": SetupOpenInfFileW err dwErr=%ld\n", dwErr));
}
else
{
NonStandardLogCrap((__FUNCTION__ ": dwErr == ERROR_CLASS_MISMATCH\n"));
}
return true;
}
LPWSTR lpszPnPId;
HRESULT hr = vboxDrvCfgInfQueryFirstPnPId(hInf, &lpszPnPId);
NonStandardLogRelCrap((__FUNCTION__ ": vboxDrvCfgInfQueryFirstPnPId returned lpszPnPId = (%S)\n", lpszPnPId));
NonStandardLogRelCrap((__FUNCTION__ ": pContext->InfInfo.lpszPnPId = (%S)\n", pContext->InfInfo.lpszPnPId));
if (hr == S_OK)
{
if (!wcsicmp(pContext->InfInfo.lpszPnPId, lpszPnPId))
{
if (!SetupUninstallOEMInfW(lpszFileName,
pContext->Flags, /*DWORD Flags could be SUOI_FORCEDELETE */
NULL /*__in PVOID Reserved == NULL */
))
{
dwErr = GetLastError();
NonStandardLogRelCrap((__FUNCTION__ ": SetupUninstallOEMInf failed for file (%S), dwErr=%ld\n", lpszFileName, dwErr));
NonStandardAssert(0);
hr = HRESULT_FROM_WIN32( dwErr );
}
}
free(lpszPnPId);
}
else
{
NonStandardLogCrap((__FUNCTION__ ": vboxDrvCfgInfQueryFirstPnPId failed, hr=0x%x\n", hr));
}
SetupCloseInfFile(hInf);
return true;
}
static VOID netCfgLoggerEnable(MSIHANDLE hModule)
{
NonStandardAssert(hModule);
if (g_hCurrentModule)
netCfgLoggerDisable();
g_hCurrentModule = hModule;
VBoxNetCfgWinSetLogging((LOG_ROUTINE)netCfgLoggerCallback);
/* uncomment next line if you want to add logging information from VBoxDrvCfg.cpp */
VBoxDrvCfgLoggerSet(vboxDrvLoggerCallback, NULL);
}
static HRESULT vboxDrvCfgInfQueryKeyValue(PINFCONTEXT pCtx, DWORD iValue, LPWSTR *lppszValue, PDWORD pcValue)
{
DWORD dwErr;
DWORD cValue;
if (!SetupGetStringFieldW(pCtx, iValue, NULL, 0, &cValue))
{
dwErr = GetLastError();
// NonStandardAssert(dwErr == ERROR_INSUFFICIENT_BUFFER);
if (dwErr != ERROR_INSUFFICIENT_BUFFER)
{
NonStandardLogFlowCrap((__FUNCTION__ ": SetupGetStringField failed WinEr (%d) for iValue(%d)\n", dwErr, iValue));
return HRESULT_FROM_WIN32(dwErr);
}
}
LPWSTR lpszValue = (LPWSTR)malloc(cValue * sizeof (lpszValue[0]));
NonStandardAssert(lpszValue);
if (!lpszValue)
{
NonStandardLogRelCrap((__FUNCTION__ ": SetCoTaskMemAlloc failed to alloc mem of size (%d), for iValue(%d)\n", cValue * sizeof (lpszValue[0]), dwErr, iValue));
return E_FAIL;
}
if (!SetupGetStringFieldW(pCtx, iValue, lpszValue, cValue, &cValue))
{
dwErr = GetLastError();
NonStandardLogRelCrap((__FUNCTION__ ": SetupGetStringField failed WinEr (%d) for iValue(%d)\n", dwErr, iValue));
NonStandardAssert(0);
free(lpszValue);
return HRESULT_FROM_WIN32(dwErr);
}
*lppszValue = lpszValue;
if (pcValue)
*pcValue = cValue;
return S_OK;
}
VBOXDRVCFG_DECL(HRESULT) VBoxDrvCfgInfUninstallAllF(LPCWSTR lpszClassName, LPCWSTR lpszPnPId, DWORD Flags)
{
WCHAR InfDirPath[MAX_PATH];
HRESULT hr = SHGetFolderPathW(NULL, /* HWND hwndOwner*/
CSIDL_WINDOWS, /* int nFolder*/
NULL, /*HANDLE hToken*/
SHGFP_TYPE_CURRENT, /*DWORD dwFlags*/
InfDirPath);
NonStandardAssert(hr == S_OK);
if (hr == S_OK)
{
wcscat(InfDirPath, L"\\inf\\oem*.inf");
INFENUM_CONTEXT Context;
Context.InfInfo.lpszClassName = lpszClassName;
Context.InfInfo.lpszPnPId = lpszPnPId;
Context.Flags = Flags;
Context.hr = S_OK;
hr = vboxDrvCfgEnumFiles(InfDirPath, vboxDrvCfgInfEnumerationCallback, &Context);
NonStandardAssert(hr == S_OK);
if (hr == S_OK)
{
hr = Context.hr;
}
else
{
NonStandardLogRelCrap((__FUNCTION__": vboxDrvCfgEnumFiles failed, hr=0x%x\n", hr));
}
}
else
{
NonStandardLogRelCrap((__FUNCTION__": SHGetFolderPathW failed, hr=0x%x\n", hr));
}
return hr;
}
VBOXDRVCFG_DECL(HRESULT) VBoxDrvCfgInfUninstall(IN LPCWSTR lpszInfPath, DWORD fFlags)
{
WCHAR DstInfName[MAX_PATH];
DWORD cbDword = sizeof (DstInfName);
HRESULT hr = vboxDrvCfgInfCopyEx(lpszInfPath, SP_COPY_REPLACEONLY, DstInfName, cbDword, &cbDword, NULL);
if (hr == VBOXDRVCFG_S_INFEXISTS)
{
if (!SetupUninstallOEMInfW(DstInfName, fFlags, NULL /*__in PVOID Reserved == NULL */))
{
DWORD dwErr = GetLastError();
NonStandardLogRelCrap((__FUNCTION__ ": SetupUninstallOEMInf failed for file (%S), oem(%S), dwErr=%ld\n", lpszInfPath, DstInfName, dwErr));
NonStandardAssert(0);
return HRESULT_FROM_WIN32(dwErr);
}
}
return S_OK;
}
VBOXDRVCFG_DECL(HRESULT) VBoxDrvCfgInfUninstallAllF(LPCWSTR lpszClassName, LPCWSTR lpszPnPId, DWORD Flags)
{
static WCHAR const s_wszFilter[] = L"\\inf\\oem*.inf";
HRESULT hr;
WCHAR wszInfDirPath[MAX_PATH];
UINT cwcInput = RT_ELEMENTS(wszInfDirPath) - RT_ELEMENTS(s_wszFilter);
UINT cwcWindows = GetSystemWindowsDirectory(wszInfDirPath, cwcInput);
if (cwcWindows > 0 && cwcWindows < cwcInput)
{
wcscpy(&wszInfDirPath[cwcWindows], s_wszFilter);
INFENUM_CONTEXT Context;
Context.InfInfo.lpszClassName = lpszClassName;
Context.InfInfo.lpszPnPId = lpszPnPId;
Context.Flags = Flags;
Context.hr = S_OK;
NonStandardLogRelCrap((__FUNCTION__": Calling vboxDrvCfgEnumFiles(wszInfDirPath, vboxDrvCfgInfEnumerationCallback, &Context)"));
hr = vboxDrvCfgEnumFiles(wszInfDirPath, vboxDrvCfgInfEnumerationCallback, &Context);
NonStandardAssert(hr == S_OK);
if (hr == S_OK)
{
hr = Context.hr;
}
else
{
NonStandardLogRelCrap((__FUNCTION__": vboxDrvCfgEnumFiles failed, hr=0x%x\n", hr));
}
}
else
{
NonStandardLogRelCrap((__FUNCTION__": GetSystemWindowsDirectory failed, cwcWindows=%u lasterr=%u\n", cwcWindows, GetLastError()));
NonStandardAssertFailed();
hr = E_FAIL;
}
return hr;
}
static UINT doNetCfgInit(MSIHANDLE hModule, INetCfg **ppnc, BOOL bWrite)
{
MSIHANDLE hMsg = NULL;
UINT uErr = ERROR_GEN_FAILURE;
int MsgResult;
int cRetries = 0;
do
{
LPWSTR lpszLockedBy;
HRESULT hr = VBoxNetCfgWinQueryINetCfg(ppnc, bWrite, VBOX_NETCFG_APP_NAME, 10000, &lpszLockedBy);
if (hr != NETCFG_E_NO_WRITE_LOCK)
{
if (FAILED(hr))
logStringW(hModule, L"doNetCfgInit: VBoxNetCfgWinQueryINetCfg failed, error = 0x%x", hr);
uErr = errorConvertFromHResult(hModule, hr);
break;
}
/* hr == NETCFG_E_NO_WRITE_LOCK */
if (!lpszLockedBy)
{
logStringW(hModule, L"doNetCfgInit: lpszLockedBy == NULL, breaking");
break;
}
/* on vista the 6to4svc.dll periodically maintains the lock for some reason,
* if this is the case, increase the wait period by retrying multiple times
* NOTE: we could alternatively increase the wait timeout,
* however it seems unneeded for most cases, e.g. in case some network connection property
* dialog is opened, it would be better to post a notification to the user as soon as possible
* rather than waiting for a longer period of time before displaying it */
if ( cRetries < VBOX_NETCFG_MAX_RETRIES
&& !wcscmp(lpszLockedBy, L"6to4svc.dll"))
{
cRetries++;
logStringW(hModule, L"doNetCfgInit: lpszLockedBy is 6to4svc.dll, retrying %d out of %d", cRetries, VBOX_NETCFG_MAX_RETRIES);
MsgResult = IDRETRY;
}
else
{
if (!hMsg)
{
hMsg = createNetCfgLockedMsgRecord(hModule);
if (!hMsg)
{
logStringW(hModule, L"doNetCfgInit: Failed to create a message record, breaking");
CoTaskMemFree(lpszLockedBy);
break;
}
}
UINT rTmp = MsiRecordSetStringW(hMsg, 2, lpszLockedBy);
NonStandardAssert(rTmp == ERROR_SUCCESS);
if (rTmp != ERROR_SUCCESS)
{
logStringW(hModule, L"doNetCfgInit: MsiRecordSetStringW failed, error = 0x%x", rTmp);
CoTaskMemFree(lpszLockedBy);
break;
}
MsgResult = MsiProcessMessage(hModule, (INSTALLMESSAGE)(INSTALLMESSAGE_USER | MB_RETRYCANCEL), hMsg);
NonStandardAssert(MsgResult == IDRETRY || MsgResult == IDCANCEL);
logStringW(hModule, L"doNetCfgInit: MsiProcessMessage returned (0x%x)", MsgResult);
}
CoTaskMemFree(lpszLockedBy);
} while(MsgResult == IDRETRY);
if (hMsg)
MsiCloseHandle(hMsg);
return uErr;
}
static HRESULT vboxDrvCfgCollectInfsSetupDi(const GUID * pGuid, LPCWSTR pPnPId, VBoxDrvCfgStringList & list)
{
DWORD dwErr = ERROR_SUCCESS;
int counter = 0;
HDEVINFO hDevInfo = SetupDiCreateDeviceInfoList(
pGuid, /* IN LPGUID ClassGuid, OPTIONAL */
NULL /*IN HWND hwndParent OPTIONAL */
);
if (hDevInfo != INVALID_HANDLE_VALUE)
{
if (SetupDiBuildDriverInfoList(hDevInfo,
NULL, /*IN OUT PSP_DEVINFO_DATA DeviceInfoData, OPTIONAL*/
SPDIT_CLASSDRIVER /*IN DWORD DriverType*/
))
{
SP_DRVINFO_DATA DrvInfo;
DrvInfo.cbSize = sizeof(SP_DRVINFO_DATA);
char DetailBuf[16384];
PSP_DRVINFO_DETAIL_DATA pDrvDetail = (PSP_DRVINFO_DETAIL_DATA)DetailBuf;
for (DWORD i = 0; ; i++)
{
if (SetupDiEnumDriverInfo(hDevInfo,
NULL, /* IN PSP_DEVINFO_DATA DeviceInfoData, OPTIONAL*/
SPDIT_CLASSDRIVER , /*IN DWORD DriverType,*/
i, /*IN DWORD MemberIndex,*/
&DrvInfo /*OUT PSP_DRVINFO_DATA DriverInfoData*/
))
{
DWORD dwReq;
pDrvDetail->cbSize = sizeof(SP_DRVINFO_DETAIL_DATA);
if (SetupDiGetDriverInfoDetail(
hDevInfo, /*IN HDEVINFO DeviceInfoSet,*/
NULL, /*IN PSP_DEVINFO_DATA DeviceInfoData, OPTIONAL*/
&DrvInfo, /*IN PSP_DRVINFO_DATA DriverInfoData,*/
pDrvDetail, /*OUT PSP_DRVINFO_DETAIL_DATA DriverInfoDetailData, OPTIONAL*/
sizeof(DetailBuf), /*IN DWORD DriverInfoDetailDataSize,*/
&dwReq /*OUT PDWORD RequiredSize OPTIONAL*/
))
{
for (WCHAR * pHwId = pDrvDetail->HardwareID; pHwId && *pHwId && pHwId < (TCHAR*)(DetailBuf + sizeof(DetailBuf)/sizeof(DetailBuf[0])) ;pHwId += wcslen(pHwId) + 1)
{
if (!wcsicmp(pHwId, pPnPId))
{
NonStandardAssert(pDrvDetail->InfFileName[0]);
if (pDrvDetail->InfFileName)
{
list.add(pDrvDetail->InfFileName);
}
}
}
}
else
{
DWORD dwErr = GetLastError();
NonStandardLogRelCrap((__FUNCTION__": SetupDiGetDriverInfoDetail fail dwErr=%ld, size(%d)", dwErr, dwReq));
// NonStandardAssert(0);
}
}
else
{
DWORD dwErr = GetLastError();
if (dwErr == ERROR_NO_MORE_ITEMS)
{
break;
}
NonStandardAssert(0);
}
}
SetupDiDestroyDriverInfoList(hDevInfo,
NULL, /*IN PSP_DEVINFO_DATA DeviceInfoData, OPTIONAL*/
SPDIT_CLASSDRIVER/*IN DWORD DriverType*/
);
}
else
{
dwErr = GetLastError();
NonStandardAssert(0);
}
SetupDiDestroyDeviceInfoList(hDevInfo);
}
else
{
dwErr = GetLastError();
NonStandardAssert(0);
}
return HRESULT_FROM_WIN32(dwErr);
}
