VOID
ParseSetupInf(VOID)
{
INFCONTEXT InfContext;
WCHAR szBuffer[30];
if (!SetupFindFirstLineW(hSetupInf,
L"Unattend",
L"LocaleID",
&InfContext))
{
SetupCloseInfFile(hSetupInf);
DPRINT1("SetupFindFirstLine failed\n");
return;
}
if (!SetupGetStringFieldW(&InfContext, 1, szBuffer,
sizeof(szBuffer) / sizeof(WCHAR), NULL))
{
SetupCloseInfFile(hSetupInf);
DPRINT1("SetupGetStringField failed\n");
return;
}
UnattendLCID = wcstoul(szBuffer, NULL, 16);
IsUnattendedSetupEnabled = 1;
SetupCloseInfFile(hSetupInf);
}
/***********************************************************************
* TranslateInfStringW (ADVPACK.@)
*
* Translates the value of a specified key in an inf file into the
* current locale by expanding string macros.
*
* PARAMS
* pszInfFilename [I] Filename of the inf file.
* pszInstallSection [I]
* pszTranslateSection [I] Inf section where the key exists.
* pszTranslateKey [I] Key to translate.
* pszBuffer [O] Contains the translated string on exit.
* dwBufferSize [I] Size on input of pszBuffer.
* pdwRequiredSize [O] Length of the translated key.
* pvReserved [I] Reserved, must be NULL.
*
* RETURNS
* Success: S_OK.
* Failure: An hresult error code.
*/
HRESULT WINAPI TranslateInfStringW(LPCWSTR pszInfFilename, LPCWSTR pszInstallSection,
LPCWSTR pszTranslateSection, LPCWSTR pszTranslateKey, LPWSTR pszBuffer,
DWORD dwBufferSize, PDWORD pdwRequiredSize, PVOID pvReserved)
{
HINF hInf;
HRESULT hret = S_OK;
TRACE("(%s, %s, %s, %s, %p, %d, %p, %p)\n",
debugstr_w(pszInfFilename), debugstr_w(pszInstallSection),
debugstr_w(pszTranslateSection), debugstr_w(pszTranslateKey),
pszBuffer, dwBufferSize,pdwRequiredSize, pvReserved);
if (!pszInfFilename || !pszTranslateSection ||
!pszTranslateKey || !pdwRequiredSize)
return E_INVALIDARG;
hInf = SetupOpenInfFileW(pszInfFilename, NULL, INF_STYLE_WIN4, NULL);
if (hInf == INVALID_HANDLE_VALUE)
return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
set_ldids(hInf, pszInstallSection, NULL);
if (!SetupGetLineTextW(NULL, hInf, pszTranslateSection, pszTranslateKey,
pszBuffer, dwBufferSize, pdwRequiredSize))
{
if (dwBufferSize < *pdwRequiredSize)
hret = E_NOT_SUFFICIENT_BUFFER;
else
hret = SPAPI_E_LINE_NOT_FOUND;
}
SetupCloseInfFile(hInf);
return hret;
}
/* Install a section of a .inf file
* Returns TRUE if success, FALSE if failure. Error code can
* be retrieved with GetLastError()
*/
static
BOOL
InstallInfSection(
IN HWND hWnd,
IN LPCWSTR InfFile,
IN LPCWSTR InfSection OPTIONAL,
IN LPCWSTR InfService OPTIONAL)
{
WCHAR Buffer[MAX_PATH];
HINF hInf = INVALID_HANDLE_VALUE;
UINT BufferSize;
PVOID Context = NULL;
BOOL ret = FALSE;
/* Get Windows directory */
BufferSize = MAX_PATH - 5 - wcslen(InfFile);
if (GetWindowsDirectoryW(Buffer, BufferSize) > BufferSize)
{
/* Function failed */
SetLastError(ERROR_GEN_FAILURE);
goto cleanup;
}
/* We have enough space to add some information in the buffer */
if (Buffer[wcslen(Buffer) - 1] != '\\')
wcscat(Buffer, L"\\");
wcscat(Buffer, L"Inf\\");
wcscat(Buffer, InfFile);
/* Install specified section */
hInf = SetupOpenInfFileW(Buffer, NULL, INF_STYLE_WIN4, NULL);
if (hInf == INVALID_HANDLE_VALUE)
goto cleanup;
Context = SetupInitDefaultQueueCallback(hWnd);
if (Context == NULL)
goto cleanup;
ret = TRUE;
if (ret && InfSection)
{
ret = SetupInstallFromInfSectionW(
hWnd, hInf,
InfSection, SPINST_ALL,
NULL, NULL, SP_COPY_NEWER,
SetupDefaultQueueCallbackW, Context,
NULL, NULL);
}
if (ret && InfService)
{
ret = SetupInstallServicesFromInfSectionW(
hInf, InfService, 0);
}
cleanup:
if (Context)
SetupTermDefaultQueueCallback(Context);
if (hInf != INVALID_HANDLE_VALUE)
SetupCloseInfFile(hInf);
return ret;
}
static void test_SetupGetSourceFileLocation(void)
{
char buffer[MAX_PATH] = "not empty", inf_filename[MAX_PATH];
UINT source_id;
DWORD required, error;
HINF hinf;
BOOL ret;
lstrcpyA(inf_filename, CURR_DIR);
lstrcatA(inf_filename, "\\");
lstrcatA(inf_filename, "test.inf");
create_inf_file(inf_filename, inf_data1, sizeof(inf_data1) - 1);
hinf = SetupOpenInfFileA(inf_filename, NULL, INF_STYLE_WIN4, NULL);
ok(hinf != INVALID_HANDLE_VALUE, "could not open inf file\n");
required = 0;
source_id = 0;
ret = SetupGetSourceFileLocationA(hinf, NULL, "lanconf.exe", &source_id, buffer, sizeof(buffer), &required);
ok(ret, "SetupGetSourceFileLocation failed\n");
ok(required == 1, "unexpected required size: %d\n", required);
ok(source_id == 2, "unexpected source id: %d\n", source_id);
ok(!lstrcmpA("", buffer), "unexpected result string: %s\n", buffer);
SetupCloseInfFile(hinf);
DeleteFileA(inf_filename);
create_inf_file(inf_filename, inf_data2, sizeof(inf_data2) - 1);
SetLastError(0xdeadbeef);
hinf = SetupOpenInfFileA(inf_filename, NULL, INF_STYLE_WIN4, NULL);
error = GetLastError();
ok(hinf == INVALID_HANDLE_VALUE, "could open inf file\n");
ok(error == ERROR_WRONG_INF_STYLE, "got wrong error: %d\n", error);
hinf = SetupOpenInfFileA(inf_filename, NULL, INF_STYLE_OLDNT, NULL);
ok(hinf != INVALID_HANDLE_VALUE, "could not open inf file\n");
ret = SetupGetSourceFileLocationA(hinf, NULL, "", &source_id, buffer, sizeof(buffer), &required);
ok(!ret, "SetupGetSourceFileLocation succeeded\n");
SetupCloseInfFile(hinf);
DeleteFileA(inf_filename);
}
static VOID
InitFontSizeList(HWND hWnd)
{
HINF hInf;
HKEY hKey;
HWND hFontSize;
INFCONTEXT Context;
int i, ci = 0;
DWORD dwSize, dwValue, dwType;
hFontSize = GetDlgItem(hWnd, IDC_FONTSIZE_COMBO);
hInf = SetupOpenInfFile(_T("font.inf"), NULL,
INF_STYLE_WIN4, NULL);
if (hInf != INVALID_HANDLE_VALUE)
{
if (SetupFindFirstLine(hInf, _T("Font Sizes"), NULL, &Context))
{
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, _T("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\FontDPI"),
0, KEY_READ, &hKey) == ERROR_SUCCESS)
for (;;)
{
TCHAR Buffer[LINE_LEN];
TCHAR Desc[LINE_LEN];
if (SetupGetStringField(&Context, 0, Buffer, sizeof(Buffer) / sizeof(TCHAR), NULL) &&
SetupGetIntField(&Context, 1, &ci))
{
_stprintf(Desc, _T("%s (%d DPI)"), Buffer, ci);
i = SendMessage(hFontSize, CB_ADDSTRING, 0, (LPARAM)Desc);
if (i != CB_ERR)
SendMessage(hFontSize, CB_SETITEMDATA, (WPARAM)i, (LPARAM)ci);
dwSize = MAX_PATH;
dwType = REG_DWORD;
if (RegQueryValueEx(hKey, _T("LogPixels"), NULL,
&dwType, (LPBYTE)&dwValue, &dwSize) == ERROR_SUCCESS)
{
if ((int)dwValue == ci)
{
SendMessage(hFontSize, CB_SETCURSEL, (WPARAM)i, 0);
SetWindowText(GetDlgItem(hWnd, IDC_FONTSIZE_CUSTOM), Desc);
}
}
}
if (!SetupFindNextLine(&Context, &Context))
{
RegCloseKey(hKey);
break;
}
}
}
}
SetupCloseInfFile(hInf);
}
/* release the install instance information */
static void install_release(const ADVInfo *info)
{
SetupCloseInfFile(info->hinf);
HeapFree(GetProcessHeap(), 0, info->inf_path);
HeapFree(GetProcessHeap(), 0, info->inf_filename);
HeapFree(GetProcessHeap(), 0, info->install_sec);
HeapFree(GetProcessHeap(), 0, info->working_dir);
}
/***********************************************************************
* CloseINFEngine (ADVPACK.@)
*
* Closes a handle to an INF file opened with OpenINFEngine.
*
* PARAMS
* hInf [I] Handle to the INF file to close.
*
* RETURNS
* Success: S_OK.
* Failure: E_FAIL.
*/
HRESULT WINAPI CloseINFEngine(HINF hInf)
{
TRACE("(%p)\n", hInf);
if (!hInf)
return E_INVALIDARG;
SetupCloseInfFile(hInf);
return S_OK;
}
BOOL InfFile::UninstallFiles(const char *pFilesSection) const
{
if (!pPath)
return FALSE;
int res;
HINF hInf;
do {
res = IDCONTINUE;
UINT errLine;
hInf = SetupOpenInfFile(pPath, NULL, INF_STYLE_WIN4, &errLine);
if (hInf == INVALID_HANDLE_VALUE)
res = ShowLastError(MB_CANCELTRYCONTINUE, "SetupOpenInfFile(%s) on line %u", pPath, errLine);
} while (res == IDTRYAGAIN);
if (res != IDCONTINUE)
return FALSE;
do {
res = IDCONTINUE;
HSPFILEQ hFileQueue = SetupOpenFileQueue();
if (hFileQueue != INVALID_HANDLE_VALUE) {
if (SetupQueueDeleteSection(hFileQueue, hInf, NULL, pFilesSection)) {
PVOID pContext = SetupInitDefaultQueueCallback(NULL);
if (pContext) {
if(!SetupCommitFileQueue(NULL, hFileQueue, FileCallback, pContext))
res = ShowLastError(MB_CANCELTRYCONTINUE, "SetupCommitFileQueue()");
SetupTermDefaultQueueCallback(pContext);
} else {
res = ShowLastError(MB_CANCELTRYCONTINUE, "SetupInitDefaultQueueCallback()");
}
} else {
res = ShowLastError(MB_CANCELTRYCONTINUE, "SetupQueueDeleteSection(%s)", pFilesSection);
}
SetupCloseFileQueue(hFileQueue);
} else {
res = ShowLastError(MB_CANCELTRYCONTINUE, "SetupOpenFileQueue()");
}
} while (res == IDTRYAGAIN);
SetupCloseInfFile(hInf);
if (res != IDCONTINUE)
return FALSE;
return TRUE;
}
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;
}
/***********************************************************************
* SetupQueryInfOriginalFileInformationW (SETUPAPI.@)
*/
BOOL WINAPI SetupQueryInfOriginalFileInformationW(
PSP_INF_INFORMATION InfInformation, UINT InfIndex,
PSP_ALTPLATFORM_INFO AlternativePlatformInfo,
PSP_ORIGINAL_FILE_INFO_W OriginalFileInfo)
{
LPCWSTR inf_name;
LPCWSTR inf_path;
HINF hinf;
static const WCHAR wszVersion[] = { 'V','e','r','s','i','o','n',0 };
static const WCHAR wszCatalogFile[] = { 'C','a','t','a','l','o','g','F','i','l','e',0 };
FIXME("(%p, %d, %p, %p): semi-stub\n", InfInformation, InfIndex,
AlternativePlatformInfo, OriginalFileInfo);
if (OriginalFileInfo->cbSize != sizeof(*OriginalFileInfo))
{
WARN("incorrect OriginalFileInfo->cbSize of %d\n", OriginalFileInfo->cbSize);
SetLastError(ERROR_INVALID_USER_BUFFER);
return FALSE;
}
inf_path = (LPWSTR)InfInformation->VersionData;
/* FIXME: we should get OriginalCatalogName from CatalogFile line in
* the original inf file and cache it, but that would require building a
* .pnf file. */
hinf = SetupOpenInfFileW(inf_path, NULL, INF_STYLE_WIN4, NULL);
if (hinf == INVALID_HANDLE_VALUE) return FALSE;
if (!SetupGetLineTextW(NULL, hinf, wszVersion, wszCatalogFile,
OriginalFileInfo->OriginalCatalogName,
sizeof(OriginalFileInfo->OriginalCatalogName)/sizeof(OriginalFileInfo->OriginalCatalogName[0]),
NULL))
{
OriginalFileInfo->OriginalCatalogName[0] = '\0';
}
SetupCloseInfFile(hinf);
/* FIXME: not quite correct as we just return the same file name as
* destination (copied) inf file, not the source (original) inf file.
* to fix it properly would require building a .pnf file */
/* file name is stored in VersionData field of InfInformation */
inf_name = strrchrW(inf_path, '\\');
if (inf_name) inf_name++;
else inf_name = inf_path;
strcpyW(OriginalFileInfo->OriginalInfName, inf_name);
return TRUE;
}
static
VOID
SaveFontSubstitutionSettings(
HWND hwnd,
PGLOBALDATA pGlobalData)
{
WCHAR szDefCP[5 + 1], szSection[MAX_PATH], szDPI[3 + 1];
HINF hFontInf;
UINT Count;
GetLocaleInfoW(MAKELCID(pGlobalData->SystemLCID, SORT_DEFAULT), LOCALE_IDEFAULTCODEPAGE, szDefCP, sizeof(szDefCP) / sizeof(WCHAR));
GetCurrentDPI(szDPI);
wsprintf(szSection, L"Font.CP%s.%s", szDefCP, szDPI);
hFontInf = SetupOpenInfFileW(L"font.inf", NULL, INF_STYLE_WIN4, NULL);
if (hFontInf == INVALID_HANDLE_VALUE)
return;
if (!SetupOpenAppendInfFile(NULL, hFontInf, NULL))
{
SetupCloseInfFile(hFontInf);
return;
}
Count = (UINT) SetupGetLineCount(hFontInf, szSection);
if (Count <= 0) return;
if (!SetupInstallFromInfSectionW(hwnd, hFontInf, szSection, SPINST_REGISTRY & ~SPINST_FILES,
NULL, NULL, 0, NULL, NULL, NULL, NULL))
MessageBoxW(hwnd, L"Unable to install a new language for programs don't support unicode!",
NULL, MB_ICONERROR | MB_OK);
SetupCloseInfFile(hFontInf);
}
static void test_SetupGetSourceInfo(void)
{
char buffer[MAX_PATH], inf_filename[MAX_PATH];
DWORD required;
HINF hinf;
BOOL ret;
lstrcpyA(inf_filename, CURR_DIR);
lstrcatA(inf_filename, "\\");
lstrcatA(inf_filename, "test.inf");
create_inf_file(inf_filename, inf_data1, sizeof(inf_data1) - 1);
hinf = SetupOpenInfFileA(inf_filename, NULL, INF_STYLE_WIN4, NULL);
ok(hinf != INVALID_HANDLE_VALUE, "could not open inf file\n");
required = 0;
ret = SetupGetSourceInfoA(hinf, 2, SRCINFO_PATH, buffer, sizeof(buffer), &required);
ok(ret, "SetupGetSourceInfoA failed\n");
ok(required == 1, "unexpected required size: %d\n", required);
ok(!lstrcmpA("", buffer), "unexpected result string: %s\n", buffer);
required = 0;
buffer[0] = 0;
ret = SetupGetSourceInfoA(hinf, 2, SRCINFO_TAGFILE, buffer, sizeof(buffer), &required);
ok(ret, "SetupGetSourceInfoA failed\n");
ok(required == 28, "unexpected required size: %d\n", required);
ok(!lstrcmpA("LANCOM\\LANtools\\lanconf.cab", buffer), "unexpected result string: %s\n", buffer);
required = 0;
buffer[0] = 0;
ret = SetupGetSourceInfoA(hinf, 2, SRCINFO_DESCRIPTION, buffer, sizeof(buffer), &required);
ok(ret, "SetupGetSourceInfoA failed\n");
ok(required == 19, "unexpected required size: %d\n", required);
ok(!lstrcmpA("LANCOM Software CD", buffer), "unexpected result string: %s\n", buffer);
SetupCloseInfFile(hinf);
DeleteFileA(inf_filename);
}
DWORD
InstallSoftwareDeviceInterfaceInf(IN LPWSTR InfName,
IN LPWSTR SectionName)
{
HDEVINFO hDevInfo;
HINF hInf;
HKEY hKey;
SP_DEVICE_INTERFACE_DATA DeviceInterfaceData;
GUID SWBusGuid = {STATIC_BUSID_SoftwareDeviceEnumerator};
hDevInfo = SetupDiGetClassDevsW(&SWBusGuid, NULL, NULL, 0);
if (!hDevInfo)
{
// failed
return GetLastError();
}
DeviceInterfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
if (!SetupDiEnumDeviceInterfaces(hDevInfo, NULL, &SWBusGuid, 0, &DeviceInterfaceData))
{
// failed
return GetLastError();
}
hInf = SetupOpenInfFileW(InfName, NULL, INF_STYLE_WIN4, NULL);
if (hInf == INVALID_HANDLE_VALUE)
{
SetupDiDestroyDeviceInfoList(hDevInfo);
return GetLastError();
}
//
// FIXME check if interface is already installed
//
hKey = SetupDiCreateDeviceInterfaceRegKeyW(hDevInfo, &DeviceInterfaceData, 0, KEY_ALL_ACCESS, hInf, SectionName);
SetupCloseInfFile(hInf);
SetupDiDestroyDeviceInfoList(hDevInfo);
if (hKey != INVALID_HANDLE_VALUE)
{
RegCloseKey(hKey);
}
return ERROR_SUCCESS;
}
static void test_original_file_name(LPCSTR original, LPCSTR dest)
{
HINF hinf;
PSP_INF_INFORMATION pspii;
SP_ORIGINAL_FILE_INFO spofi;
BOOL res;
DWORD size;
if (!pSetupQueryInfOriginalFileInformationA)
{
win_skip("SetupQueryInfOriginalFileInformationA is not available\n");
return;
}
hinf = SetupOpenInfFileA(dest, NULL, INF_STYLE_WIN4, NULL);
ok(hinf != NULL, "SetupOpenInfFileA failed with error %d\n", GetLastError());
res = SetupGetInfInformation(hinf, INFINFO_INF_SPEC_IS_HINF, NULL, 0, &size);
ok(res, "SetupGetInfInformation failed with error %d\n", GetLastError());
pspii = HeapAlloc(GetProcessHeap(), 0, size);
res = SetupGetInfInformation(hinf, INFINFO_INF_SPEC_IS_HINF, pspii, size, NULL);
ok(res, "SetupGetInfInformation failed with error %d\n", GetLastError());
spofi.cbSize = 0;
res = pSetupQueryInfOriginalFileInformationA(pspii, 0, NULL, &spofi);
ok(!res && GetLastError() == ERROR_INVALID_USER_BUFFER,
"SetupQueryInfOriginalFileInformationA should have failed with ERROR_INVALID_USER_BUFFER instead of %d\n", GetLastError());
spofi.cbSize = sizeof(spofi);
res = pSetupQueryInfOriginalFileInformationA(pspii, 0, NULL, &spofi);
ok(res, "SetupQueryInfOriginalFileInformationA failed with error %d\n", GetLastError());
ok(!spofi.OriginalCatalogName[0], "spofi.OriginalCatalogName should have been \"\" instead of \"%s\"\n", spofi.OriginalCatalogName);
todo_wine
ok(!strcmp(original, spofi.OriginalInfName), "spofi.OriginalInfName of %s didn't match real original name %s\n", spofi.OriginalInfName, original);
HeapFree(GetProcessHeap(), 0, pspii);
SetupCloseInfFile(hinf);
}
/***********************************************************************
* DoInfInstall (ADVPACK.@)
*/
BOOL WINAPI DoInfInstall(const SETUPCOMMAND_PARAMS *setup)
{
BOOL ret;
HINF hinf;
void *callback_context;
TRACE("%p %s %s %s %s\n", setup->hwnd, debugstr_a(setup->title),
debugstr_a(setup->inf_name), debugstr_a(setup->dir),
debugstr_a(setup->section_name));
hinf = SetupOpenInfFileA(setup->inf_name, NULL, INF_STYLE_WIN4, NULL);
if (hinf == (HINF)INVALID_HANDLE_VALUE) return FALSE;
callback_context = SetupInitDefaultQueueCallback(setup->hwnd);
ret = SetupInstallFromInfSectionA(0, hinf, setup->section_name, SPINST_ALL,
0, NULL, 0, SetupDefaultQueueCallbackA,
callback_context, NULL, NULL);
SetupTermDefaultQueueCallback(callback_context);
SetupCloseInfFile(hinf);
return ret;
}
DWORD WINAPI
InstallLiveCD(IN HINSTANCE hInstance)
{
STARTUPINFOW StartupInfo;
PROCESS_INFORMATION ProcessInformation;
BOOL bRes;
if (!CommonInstall())
goto error;
/* Register components */
_SEH2_TRY
{
if (!SetupInstallFromInfSectionW(NULL,
hSysSetupInf, L"RegistrationPhase2",
SPINST_ALL,
0, NULL, 0, NULL, NULL, NULL, NULL))
{
DPRINT1("SetupInstallFromInfSectionW failed!\n");
}
RegisterTypeLibraries(hSysSetupInf, L"TypeLibraries");
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
DPRINT1("Catching exception\n");
}
_SEH2_END;
SetupCloseInfFile(hSysSetupInf);
/* Run the shell */
ZeroMemory(&StartupInfo, sizeof(StartupInfo));
StartupInfo.cb = sizeof(StartupInfo);
bRes = CreateProcessW(
L"userinit.exe",
NULL,
NULL,
NULL,
FALSE,
0,
NULL,
NULL,
&StartupInfo,
&ProcessInformation);
if (!bRes)
goto error;
CloseHandle(ProcessInformation.hThread);
CloseHandle(ProcessInformation.hProcess);
return 0;
error:
MessageBoxW(
NULL,
L"Failed to load LiveCD! You can shutdown your computer, or press ENTER to reboot.",
L"ReactOS LiveCD",
MB_OK);
return 0;
}
int
PreInstallFromInf(
IN HWND hWnd,
IN LPTSTR Inf,
IN LPTSTR InstallSection,
IN LPTSTR ServiceSection
)
{
DWORD Err = NO_ERROR;
HINF hInf = INVALID_HANDLE_VALUE;
UINT ErrorLine;
PVOID Context = NULL;
hInf = SetupOpenInfFile(Inf,
NULL,
INF_STYLE_WIN4,
&ErrorLine);
if (hInf == INVALID_HANDLE_VALUE) {
Err = GetLastError();
goto clean;
}
//
// Install the service section
//
if (!SetupInstallServicesFromInfSection(hInf,
ServiceSection,
0)) {
Err = GetLastError();
goto clean;
}
Context = SetupInitDefaultQueueCallback(hWnd);
if (!SetupInstallFromInfSection(hWnd,
hInf,
InstallSection,
SPINST_REGISTRY | SPINST_FILES,
NULL,
NULL,
0,
SetupDefaultQueueCallback,
Context,
NULL,
NULL)) {
Err = GetLastError();
goto clean;
}
clean:
if (Context != NULL) {
SetupTermDefaultQueueCallback(Context);
}
if (hInf != INVALID_HANDLE_VALUE) {
SetupCloseInfFile(hInf);
}
if (Err == NO_ERROR) {
return 0;
} else {
return 1;
}
}
OSStatus
CThirdPage::LoadPrintDriverDefsFromFile(Manufacturers & manufacturers, const CString & filename, bool checkForDuplicateModels )
{
HINF handle = INVALID_HANDLE_VALUE;
const TCHAR * section = TEXT( "Manufacturer" );
LONG sectionCount;
TCHAR line[ 1000 ];
CString klass;
INFCONTEXT manufacturerContext;
BOOL ok;
OSStatus err = 0;
// Make sure we can open the file
handle = SetupOpenInfFile( filename, NULL, INF_STYLE_WIN4, NULL );
translate_errno( handle != INVALID_HANDLE_VALUE, GetLastError(), kUnknownErr );
require_noerr( err, exit );
// Make sure it's a printer file
ok = SetupGetLineText( NULL, handle, TEXT( "Version" ), TEXT( "Class" ), line, sizeof( line ), NULL );
translate_errno( ok, GetLastError(), kUnknownErr );
require_noerr( err, exit );
klass = line;
require_action( klass == TEXT( "Printer" ), exit, err = kUnknownErr );
sectionCount = SetupGetLineCount( handle, section );
translate_errno( sectionCount != -1, GetLastError(), kUnknownErr );
require_noerr( err, exit );
memset( &manufacturerContext, 0, sizeof( manufacturerContext ) );
for ( LONG i = 0; i < sectionCount; i++ )
{
Manufacturers::iterator iter;
Manufacturer * manufacturer;
CString manufacturerName;
CString temp;
CStringList modelSectionNameDecl;
CString modelSectionName;
CString baseModelName;
CString model;
INFCONTEXT modelContext;
LONG modelCount;
POSITION p;
if ( i == 0 )
{
ok = SetupFindFirstLine( handle, section, NULL, &manufacturerContext );
err = translate_errno( ok, GetLastError(), kUnknownErr );
require_noerr( err, exit );
}
else
{
ok = SetupFindNextLine( &manufacturerContext, &manufacturerContext );
err = translate_errno( ok, GetLastError(), kUnknownErr );
require_noerr( err, exit );
}
ok = SetupGetStringField( &manufacturerContext, 0, line, sizeof( line ), NULL );
err = translate_errno( ok, GetLastError(), kUnknownErr );
require_noerr( err, exit );
manufacturerName = line;
ok = SetupGetLineText( &manufacturerContext, handle, NULL, NULL, line, sizeof( line ), NULL );
err = translate_errno( ok, GetLastError(), kUnknownErr );
require_noerr( err, exit );
// Try to find some model section name that has entries. Explanation of int file structure
// can be found at:
//
// <http://msdn.microsoft.com/en-us/library/ms794359.aspx>
Split( line, ',', modelSectionNameDecl );
p = modelSectionNameDecl.GetHeadPosition();
modelSectionName = modelSectionNameDecl.GetNext( p );
modelCount = SetupGetLineCount( handle, modelSectionName );
baseModelName = modelSectionName;
while ( modelCount <= 0 && p )
{
CString targetOSVersion;
targetOSVersion = modelSectionNameDecl.GetNext( p );
modelSectionName = baseModelName + TEXT( "." ) + targetOSVersion;
modelCount = SetupGetLineCount( handle, modelSectionName );
}
if ( modelCount > 0 )
{
manufacturerName = NormalizeManufacturerName( manufacturerName );
iter = manufacturers.find( manufacturerName );
if ( iter != manufacturers.end() )
{
manufacturer = iter->second;
require_action( manufacturer, exit, err = kUnknownErr );
}
else
{
try
{
manufacturer = new Manufacturer;
}
catch (...)
{
manufacturer = NULL;
}
require_action( manufacturer, exit, err = kNoMemoryErr );
manufacturer->name = manufacturerName;
manufacturers[ manufacturerName ] = manufacturer;
}
memset( &modelContext, 0, sizeof( modelContext ) );
for ( LONG j = 0; j < modelCount; j++ )
{
CString modelName;
Model * model;
if ( j == 0 )
{
ok = SetupFindFirstLine( handle, modelSectionName, NULL, &modelContext );
err = translate_errno( ok, GetLastError(), kUnknownErr );
require_noerr( err, exit );
}
else
{
SetupFindNextLine( &modelContext, &modelContext );
err = translate_errno( ok, GetLastError(), kUnknownErr );
require_noerr( err, exit );
}
ok = SetupGetStringField( &modelContext, 0, line, sizeof( line ), NULL );
err = translate_errno( ok, GetLastError(), kUnknownErr );
require_noerr( err, exit );
modelName = line;
if (checkForDuplicateModels == true)
{
if ( MatchModel( manufacturer, ConvertToModelName( modelName ) ) != NULL )
{
continue;
}
}
//
// Stock Vista printer inf files embed guids in the model
// declarations for Epson printers. Let's ignore those.
//
if ( modelName.Find( TEXT( "{" ), 0 ) != -1 )
{
continue;
}
try
{
model = new Model;
}
catch (...)
{
model = NULL;
}
require_action( model, exit, err = kNoMemoryErr );
model->infFileName = filename;
model->displayName = modelName;
model->name = modelName;
model->driverInstalled = false;
manufacturer->models.push_back(model);
}
}
}
exit:
if ( handle != INVALID_HANDLE_VALUE )
{
SetupCloseInfFile( handle );
handle = NULL;
}
return err;
}
/***********************************************************************
* SetupGetInfInformationW (SETUPAPI.@)
*
* BUGS
* Only handles the case when InfSpec is an INF handle.
*/
BOOL WINAPI SetupGetInfInformationW(LPCVOID InfSpec, DWORD SearchControl,
PSP_INF_INFORMATION ReturnBuffer,
DWORD ReturnBufferSize, PDWORD RequiredSize)
{
HINF inf;
BOOL ret;
DWORD infSize;
TRACE("(%p, %d, %p, %d, %p)\n", InfSpec, SearchControl, ReturnBuffer,
ReturnBufferSize, RequiredSize);
if (!InfSpec)
{
if (SearchControl == INFINFO_INF_SPEC_IS_HINF)
SetLastError(ERROR_INVALID_HANDLE);
else
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
switch (SearchControl)
{
case INFINFO_INF_SPEC_IS_HINF:
inf = (HINF)InfSpec;
break;
case INFINFO_INF_NAME_IS_ABSOLUTE:
case INFINFO_DEFAULT_SEARCH:
inf = SetupOpenInfFileW(InfSpec, NULL,
INF_STYLE_OLDNT | INF_STYLE_WIN4, NULL);
break;
case INFINFO_REVERSE_DEFAULT_SEARCH:
inf = search_for_inf(InfSpec, SearchControl);
break;
case INFINFO_INF_PATH_LIST_SEARCH:
FIXME("Unhandled search control: %d\n", SearchControl);
if (RequiredSize)
*RequiredSize = 0;
return FALSE;
default:
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
if (inf == INVALID_HANDLE_VALUE)
{
SetLastError(ERROR_FILE_NOT_FOUND);
return FALSE;
}
ret = fill_inf_info(inf, ReturnBuffer, ReturnBufferSize, &infSize);
if (!ReturnBuffer && (ReturnBufferSize >= infSize))
{
SetLastError(ERROR_INVALID_PARAMETER);
ret = FALSE;
}
if (RequiredSize) *RequiredSize = infSize;
if (SearchControl >= INFINFO_INF_NAME_IS_ABSOLUTE)
SetupCloseInfFile(inf);
return ret;
}
DWORD WINAPI
InstallReactOS(HINSTANCE hInstance)
{
TCHAR szBuffer[MAX_PATH];
HANDLE token;
TOKEN_PRIVILEGES privs;
HKEY hKey;
HINF hShortcutsInf;
InitializeSetupActionLog(FALSE);
LogItem(SYSSETUP_SEVERITY_INFORMATION, L"Installing ReactOS");
if (!InitializeProfiles())
{
FatalError("InitializeProfiles() failed");
return 0;
}
CreateTempDir(L"TEMP");
CreateTempDir(L"TMP");
if (GetWindowsDirectory(szBuffer, sizeof(szBuffer) / sizeof(TCHAR)))
{
if (RegOpenKeyExW(HKEY_LOCAL_MACHINE,
L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion",
0,
KEY_WRITE,
&hKey) == ERROR_SUCCESS)
{
RegSetValueExW(hKey,
L"PathName",
0,
REG_SZ,
(LPBYTE)szBuffer,
(wcslen(szBuffer) + 1) * sizeof(WCHAR));
RegSetValueExW(hKey,
L"SystemRoot",
0,
REG_SZ,
(LPBYTE)szBuffer,
(wcslen(szBuffer) + 1) * sizeof(WCHAR));
RegCloseKey(hKey);
}
PathAddBackslash(szBuffer);
_tcscat(szBuffer, _T("system"));
CreateDirectory(szBuffer, NULL);
}
if (!CommonInstall())
return 0;
InstallWizard();
InstallSecurity();
SetAutoAdminLogon();
hShortcutsInf = SetupOpenInfFileW(L"shortcuts.inf",
NULL,
INF_STYLE_WIN4,
NULL);
if (hShortcutsInf == INVALID_HANDLE_VALUE)
{
FatalError("Failed to open shortcuts.inf");
return 0;
}
if (!CreateShortcuts(hShortcutsInf, L"ShortcutFolders"))
{
FatalError("CreateShortcuts() failed");
return 0;
}
SetupCloseInfFile(hShortcutsInf);
/* ROS HACK, as long as NtUnloadKey is not implemented */
{
NTSTATUS Status = NtUnloadKey(NULL);
if (Status == STATUS_NOT_IMPLEMENTED)
{
/* Create the Administrator profile */
PROFILEINFOW ProfileInfo;
HANDLE hToken;
BOOL ret;
ret = LogonUserW(AdminInfo.Name,
AdminInfo.Domain,
AdminInfo.Password,
LOGON32_LOGON_INTERACTIVE,
LOGON32_PROVIDER_DEFAULT,
&hToken);
if (!ret)
{
FatalError("LogonUserW() failed!");
return 0;
}
ZeroMemory(&ProfileInfo, sizeof(PROFILEINFOW));
ProfileInfo.dwSize = sizeof(PROFILEINFOW);
ProfileInfo.lpUserName = L"Administrator";
ProfileInfo.dwFlags = PI_NOUI;
LoadUserProfileW(hToken, &ProfileInfo);
CloseHandle(hToken);
}
else
{
DPRINT1("ROS HACK not needed anymore. Please remove it\n");
}
}
/* END OF ROS HACK */
SetupCloseInfFile(hSysSetupInf);
SetSetupType(0);
LogItem(SYSSETUP_SEVERITY_INFORMATION, L"Installing ReactOS done");
TerminateSetupActionLog();
if (AdminInfo.Name != NULL)
RtlFreeHeap(RtlGetProcessHeap(), 0, AdminInfo.Name);
if (AdminInfo.Domain != NULL)
RtlFreeHeap(RtlGetProcessHeap(), 0, AdminInfo.Domain);
if (AdminInfo.Password != NULL)
RtlFreeHeap(RtlGetProcessHeap(), 0, AdminInfo.Password);
/* Get shutdown privilege */
if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &token))
{
FatalError("OpenProcessToken() failed!");
return 0;
}
if (!LookupPrivilegeValue(
NULL,
SE_SHUTDOWN_NAME,
&privs.Privileges[0].Luid))
{
FatalError("LookupPrivilegeValue() failed!");
return 0;
}
privs.PrivilegeCount = 1;
privs.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
if (AdjustTokenPrivileges(
token,
FALSE,
&privs,
0,
(PTOKEN_PRIVILEGES)NULL,
NULL) == 0)
{
FatalError("AdjustTokenPrivileges() failed!");
return 0;
}
ExitWindowsEx(EWX_REBOOT, 0);
return 0;
}
/***********************************************************************
* SetupCopyOEMInfW (SETUPAPI.@)
*/
BOOL WINAPI SetupCopyOEMInfW( PCWSTR source, PCWSTR location,
DWORD media_type, DWORD style, PWSTR dest,
DWORD buffer_size, PDWORD required_size, PWSTR *component )
{
BOOL ret = FALSE;
WCHAR target[MAX_PATH], catalog_file[MAX_PATH], *p;
static const WCHAR inf[] = { '\\','i','n','f','\\',0 };
static const WCHAR wszVersion[] = { 'V','e','r','s','i','o','n',0 };
static const WCHAR wszCatalogFile[] = { 'C','a','t','a','l','o','g','F','i','l','e',0 };
DWORD size;
HINF hinf;
TRACE("%s, %s, %d, %d, %p, %d, %p, %p\n", debugstr_w(source), debugstr_w(location),
media_type, style, dest, buffer_size, required_size, component);
if (!source)
{
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
/* check for a relative path */
if (!(*source == '\\' || (*source && source[1] == ':')))
{
SetLastError(ERROR_FILE_NOT_FOUND);
return FALSE;
}
if (!GetWindowsDirectoryW( target, sizeof(target)/sizeof(WCHAR) )) return FALSE;
strcatW( target, inf );
if ((p = strrchrW( source, '\\' )))
strcatW( target, p + 1 );
/* does the file exist already? */
if ((GetFileAttributesW( target ) != INVALID_FILE_ATTRIBUTES) &&
!(style & SP_COPY_NOOVERWRITE))
{
static const WCHAR oem[] = { 'o','e','m',0 };
unsigned int i;
LARGE_INTEGER source_file_size;
HANDLE source_file;
source_file = CreateFileW( source, FILE_READ_DATA | FILE_READ_ATTRIBUTES,
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
NULL, OPEN_EXISTING, 0, NULL );
if (source_file == INVALID_HANDLE_VALUE)
return FALSE;
if (!GetFileSizeEx( source_file, &source_file_size ))
{
CloseHandle( source_file );
return FALSE;
}
p = strrchrW( target, '\\' ) + 1;
memcpy( p, oem, sizeof(oem) );
p += sizeof(oem)/sizeof(oem[0]) - 1;
/* generate OEMnnn.inf ending */
for (i = 0; i < OEM_INDEX_LIMIT; i++)
{
static const WCHAR format[] = { '%','u','.','i','n','f',0 };
HANDLE dest_file;
LARGE_INTEGER dest_file_size;
wsprintfW( p, format, i );
dest_file = CreateFileW( target, FILE_READ_DATA | FILE_READ_ATTRIBUTES,
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
NULL, OPEN_EXISTING, 0, NULL );
/* if we found a file name that doesn't exist then we're done */
if (dest_file == INVALID_HANDLE_VALUE)
break;
/* now check if the same inf file has already been copied to the inf
* directory. if so, use that file and don't create a new one */
if (!GetFileSizeEx( dest_file, &dest_file_size ) ||
(dest_file_size.QuadPart != source_file_size.QuadPart) ||
compare_files( source_file, dest_file ))
{
CloseHandle( dest_file );
continue;
}
CloseHandle( dest_file );
break;
}
CloseHandle( source_file );
if (i == OEM_INDEX_LIMIT)
{
SetLastError( ERROR_FILENAME_EXCED_RANGE );
return FALSE;
}
}
hinf = SetupOpenInfFileW( source, NULL, INF_STYLE_WIN4, NULL );
if (hinf == INVALID_HANDLE_VALUE) return FALSE;
if (SetupGetLineTextW( NULL, hinf, wszVersion, wszCatalogFile, catalog_file,
sizeof(catalog_file)/sizeof(catalog_file[0]), NULL ))
{
WCHAR source_cat[MAX_PATH];
strcpyW( source_cat, source );
p = strrchrW( source_cat, '\\' );
if (p) p++;
else p = source_cat;
strcpyW( p, catalog_file );
FIXME("install catalog file %s\n", debugstr_w( source_cat ));
}
SetupCloseInfFile( hinf );
if (!(ret = CopyFileW( source, target, (style & SP_COPY_NOOVERWRITE) != 0 )))
return ret;
if (style & SP_COPY_DELETESOURCE)
DeleteFileW( source );
size = strlenW( target ) + 1;
if (dest)
{
if (buffer_size >= size)
{
strcpyW( dest, target );
}
else
{
SetLastError( ERROR_INSUFFICIENT_BUFFER );
ret = FALSE;
}
}
if (component) *component = p + 1;
if (required_size) *required_size = size;
if (ret) SetLastError(ERROR_SUCCESS);
return ret;
}
static
VOID
InstallPrivileges(VOID)
{
HINF hSecurityInf = INVALID_HANDLE_VALUE;
LSA_OBJECT_ATTRIBUTES ObjectAttributes;
WCHAR szPrivilegeString[256];
WCHAR szSidString[256];
INFCONTEXT InfContext;
DWORD i;
PRIVILEGE_SET PrivilegeSet;
PSID AccountSid;
NTSTATUS Status;
LSA_HANDLE PolicyHandle = NULL;
LSA_HANDLE AccountHandle;
DPRINT("InstallPrivileges()\n");
hSecurityInf = SetupOpenInfFileW(L"defltws.inf", //szNameBuffer,
NULL,
INF_STYLE_WIN4,
NULL);
if (hSecurityInf == INVALID_HANDLE_VALUE)
{
DPRINT1("SetupOpenInfFileW failed\n");
return;
}
memset(&ObjectAttributes, 0, sizeof(LSA_OBJECT_ATTRIBUTES));
Status = LsaOpenPolicy(NULL,
&ObjectAttributes,
POLICY_CREATE_ACCOUNT,
&PolicyHandle);
if (!NT_SUCCESS(Status))
{
DPRINT1("LsaOpenPolicy failed (Status %08lx)\n", Status);
goto done;
}
if (!SetupFindFirstLineW(hSecurityInf,
L"Privilege Rights",
NULL,
&InfContext))
{
DPRINT1("SetupFindfirstLineW failed\n");
goto done;
}
PrivilegeSet.PrivilegeCount = 1;
PrivilegeSet.Control = 0;
do
{
/* Retrieve the privilege name */
if (!SetupGetStringFieldW(&InfContext,
0,
szPrivilegeString,
256,
NULL))
{
DPRINT1("SetupGetStringFieldW() failed\n");
goto done;
}
DPRINT("Privilege: %S\n", szPrivilegeString);
if (!LookupPrivilegeValueW(NULL,
szPrivilegeString,
&(PrivilegeSet.Privilege[0].Luid)))
{
DPRINT1("LookupPrivilegeNameW() failed\n");
goto done;
}
PrivilegeSet.Privilege[0].Attributes = 0;
for (i = 0; i < SetupGetFieldCount(&InfContext); i++)
{
if (!SetupGetStringFieldW(&InfContext,
i + 1,
szSidString,
256,
NULL))
{
DPRINT1("SetupGetStringFieldW() failed\n");
goto done;
}
DPRINT("SID: %S\n", szSidString);
ConvertStringSidToSid(szSidString, &AccountSid);
Status = LsaOpenAccount(PolicyHandle,
AccountSid,
ACCOUNT_VIEW | ACCOUNT_ADJUST_PRIVILEGES,
&AccountHandle);
if (NT_SUCCESS(Status))
{
Status = LsaAddPrivilegesToAccount(AccountHandle,
&PrivilegeSet);
if (!NT_SUCCESS(Status))
{
DPRINT1("LsaAddPrivilegesToAccount() failed (Status %08lx)\n", Status);
}
LsaClose(AccountHandle);
}
LocalFree(AccountSid);
}
}
while (SetupFindNextLine(&InfContext, &InfContext));
done:
if (PolicyHandle != NULL)
LsaClose(PolicyHandle);
if (hSecurityInf != INVALID_HANDLE_VALUE)
SetupCloseInfFile(hSecurityInf);
}
/**
* Do some cleanup of data we used. Called by installVideoDriver()
*/
void closeAndDestroy(HDEVINFO hDevInfo, HINF hInf)
{
SetupDiDestroyDriverInfoList(hDevInfo, NULL, SPDIT_CLASSDRIVER);
SetupDiDestroyDeviceInfoList(hDevInfo);
SetupCloseInfFile(hInf);
}
DWORD WINAPI
NetClassInstaller(
IN DI_FUNCTION InstallFunction,
IN HDEVINFO DeviceInfoSet,
IN PSP_DEVINFO_DATA DeviceInfoData OPTIONAL)
{
SP_DRVINFO_DATA_W DriverInfoData;
SP_DRVINFO_DETAIL_DATA_W DriverInfoDetail;
WCHAR SectionName[LINE_LEN];
HINF hInf = INVALID_HANDLE_VALUE;
INFCONTEXT InfContext;
UINT ErrorLine;
INT CharacteristicsInt;
DWORD Characteristics;
LPWSTR BusType = NULL;
RPC_STATUS RpcStatus;
UUID Uuid;
LPWSTR UuidRpcString = NULL;
LPWSTR UuidString = NULL;
LONG rc;
DWORD dwLength;
if (InstallFunction != DIF_INSTALLDEVICE)
return ERROR_DI_DO_DEFAULT;
DPRINT("%lu %p %p\n", InstallFunction, DeviceInfoSet, DeviceInfoData);
/* Get driver info details */
DriverInfoData.cbSize = sizeof(SP_DRVINFO_DATA_W);
if (!SetupDiGetSelectedDriverW(DeviceInfoSet, DeviceInfoData, &DriverInfoData))
{
rc = GetLastError();
DPRINT("SetupDiGetSelectedDriverW() failed with error 0x%lx\n", rc);
goto cleanup;
}
DriverInfoDetail.cbSize = sizeof(SP_DRVINFO_DETAIL_DATA_W);
if (!SetupDiGetDriverInfoDetailW(DeviceInfoSet, DeviceInfoData, &DriverInfoData, &DriverInfoDetail, sizeof(DriverInfoDetail), NULL)
&& GetLastError() != ERROR_INSUFFICIENT_BUFFER)
{
rc = GetLastError();
DPRINT("SetupDiGetDriverInfoDetailW() failed with error 0x%lx\n", rc);
goto cleanup;
}
hInf = SetupOpenInfFileW(DriverInfoDetail.InfFileName, NULL, INF_STYLE_WIN4, &ErrorLine);
if (hInf == INVALID_HANDLE_VALUE)
{
rc = GetLastError();
DPRINT("SetupOpenInfFileW() failed with error 0x%lx\n", rc);
goto cleanup;
}
if (!SetupDiGetActualSectionToInstallW(hInf, DriverInfoDetail.SectionName, SectionName, LINE_LEN, NULL, NULL))
{
rc = GetLastError();
DPRINT("SetupDiGetActualSectionToInstallW() failed with error 0x%lx\n", rc);
goto cleanup;
}
/* Get Characteristics and BusType (optional) from .inf file */
if (!SetupFindFirstLineW(hInf, SectionName, L"Characteristics", &InfContext))
{
rc = GetLastError();
DPRINT("Unable to find key %S in section %S of file %S (error 0x%lx)\n",
L"Characteristics", SectionName, DriverInfoDetail.InfFileName, rc);
goto cleanup;
}
if (!SetupGetIntField(&InfContext, 1, &CharacteristicsInt))
{
rc = GetLastError();
DPRINT("SetupGetIntField() failed with error 0x%lx\n", rc);
goto cleanup;
}
Characteristics = (DWORD)CharacteristicsInt;
if (IsEqualIID(&DeviceInfoData->ClassGuid, &GUID_DEVCLASS_NET))
{
if (SetupFindFirstLineW(hInf, SectionName, L"BusType", &InfContext))
{
if (!SetupGetStringFieldW(&InfContext, 1, NULL, 0, &dwLength))
{
rc = GetLastError();
DPRINT("SetupGetStringFieldW() failed with error 0x%lx\n", rc);
goto cleanup;
}
BusType = HeapAlloc(GetProcessHeap(), 0, dwLength * sizeof(WCHAR));
if (!BusType)
{
DPRINT("HeapAlloc() failed\n");
rc = ERROR_NOT_ENOUGH_MEMORY;
goto cleanup;
}
if (!SetupGetStringFieldW(&InfContext, 1, BusType, dwLength, NULL))
{
rc = GetLastError();
DPRINT("SetupGetStringFieldW() failed with error 0x%lx\n", rc);
goto cleanup;
}
}
}
/* Create a new UUID */
RpcStatus = UuidCreate(&Uuid);
if (RpcStatus != RPC_S_OK && RpcStatus != RPC_S_UUID_LOCAL_ONLY)
{
DPRINT("UuidCreate() failed with RPC status 0x%lx\n", RpcStatus);
rc = ERROR_GEN_FAILURE;
goto cleanup;
}
RpcStatus = UuidToStringW(&Uuid, &UuidRpcString);
if (RpcStatus != RPC_S_OK)
{
DPRINT("UuidToStringW() failed with RPC status 0x%lx\n", RpcStatus);
rc = ERROR_GEN_FAILURE;
goto cleanup;
}
/* Add curly braces around Uuid */
UuidString = HeapAlloc(GetProcessHeap(), 0, (2 + wcslen(UuidRpcString)) * sizeof(WCHAR) + sizeof(UNICODE_NULL));
if (!UuidString)
{
DPRINT("HeapAlloc() failed\n");
rc = ERROR_NOT_ENOUGH_MEMORY;
goto cleanup;
}
wcscpy(UuidString, L"{");
wcscat(UuidString, UuidRpcString);
wcscat(UuidString, L"}");
if (IsEqualIID(&DeviceInfoData->ClassGuid, &GUID_DEVCLASS_NET))
rc = InstallNetDevice(DeviceInfoSet, DeviceInfoData, UuidString, Characteristics, BusType);
else if (IsEqualIID(&DeviceInfoData->ClassGuid, &GUID_DEVCLASS_NETCLIENT))
rc = InstallNetClient();
else if (IsEqualIID(&DeviceInfoData->ClassGuid, &GUID_DEVCLASS_NETSERVICE))
rc = InstallNetService();
else if (IsEqualIID(&DeviceInfoData->ClassGuid, &GUID_DEVCLASS_NETTRANS))
rc = InstallNetTransport();
else
{
DPRINT("Invalid class guid\n");
rc = ERROR_GEN_FAILURE;
}
cleanup:
if (hInf != INVALID_HANDLE_VALUE)
SetupCloseInfFile(hInf);
if (UuidRpcString != NULL)
RpcStringFreeW(&UuidRpcString);
HeapFree(GetProcessHeap(), 0, BusType);
HeapFree(GetProcessHeap(), 0, UuidString);
if (rc == ERROR_SUCCESS)
rc = ERROR_DI_DO_DEFAULT;
DPRINT("Returning 0x%lx\n", rc);
return rc;
}
static void test_SetupGetTargetPath(void)
{
char buffer[MAX_PATH], inf_filename[MAX_PATH];
char destfile[MAX_PATH];
DWORD required;
HINF hinf;
INFCONTEXT ctx;
BOOL ret;
lstrcpyA(inf_filename, CURR_DIR);
lstrcatA(inf_filename, "\\");
lstrcatA(inf_filename, "test.inf");
create_inf_file(inf_filename, inf_data1, sizeof(inf_data1) - 1);
hinf = SetupOpenInfFileA(inf_filename, NULL, INF_STYLE_WIN4, NULL);
ok(hinf != INVALID_HANDLE_VALUE, "could not open inf file\n");
ctx.Inf = hinf;
ctx.CurrentInf = hinf;
ctx.Section = 7;
ctx.Line = 0;
required = 0;
ret = SetupGetTargetPathA(hinf, &ctx, NULL, buffer, sizeof(buffer), &required);
ok(ret, "SetupGetTargetPathA failed\n");
ok(required == 10, "unexpected required size: %d\n", required);
/* Retrieve the system drive from the windows directory.
* (%SystemDrive% is not available on Win9x)
*/
lstrcpyA(destfile, WIN_DIR);
destfile[3] = '\0';
lstrcatA(destfile, "LANCOM");
ok(!lstrcmpiA(destfile, buffer), "unexpected result string: %s\n", buffer);
SetupCloseInfFile(hinf);
DeleteFileA(inf_filename);
create_inf_file(inf_filename, inf_data3, sizeof(inf_data3) - 1);
hinf = SetupOpenInfFileA(inf_filename, NULL, INF_STYLE_WIN4, NULL);
ok(hinf != INVALID_HANDLE_VALUE, "could not open inf file\n");
required = 0;
ret = SetupGetTargetPathA(hinf, NULL, "CopyAlways.Windir.Files", buffer, sizeof(buffer), &required);
ok(ret, "SetupGetTargetPathA failed\n");
lstrcpyA(destfile, WIN_DIR);
ok(required == lstrlenA(destfile) + 1, "unexpected required size: %d\n", required);
ok(!lstrcmpiA(buffer, destfile), "unexpected path: %s\n", buffer);
SetupCloseInfFile(hinf);
DeleteFileA(inf_filename);
create_inf_file(inf_filename, inf_data4, sizeof(inf_data4) - 1);
hinf = SetupOpenInfFileA(inf_filename, NULL, INF_STYLE_WIN4, NULL);
ok(hinf != INVALID_HANDLE_VALUE, "could not open inf file\n");
required = 0;
ret = SetupGetTargetPathA(hinf, NULL, "CopyAlways.System32.Files", buffer, sizeof(buffer), &required);
ok(ret, "SetupGetTargetPathA failed\n");
GetSystemDirectoryA(destfile, MAX_PATH);
ok(required == lstrlenA(destfile) + 1, "unexpected required size: %d\n", required);
ok(!lstrcmpiA(buffer, destfile), "unexpected path: %s\n", buffer);
SetupCloseInfFile(hinf);
DeleteFileA(inf_filename);
create_inf_file(inf_filename, inf_data5, sizeof(inf_data5) - 1);
hinf = SetupOpenInfFileA(inf_filename, NULL, INF_STYLE_WIN4, NULL);
ok(hinf != INVALID_HANDLE_VALUE, "could not open inf file\n");
required = 0;
ret = SetupGetTargetPathA(hinf, NULL, "CopyAlways.Windir.Files", buffer, sizeof(buffer), &required);
ok(ret, "SetupGetTargetPathA failed\n");
lstrcpyA(destfile, WIN_DIR);
ok(required == lstrlenA(destfile) + 1, "unexpected required size: %d\n", required);
ok(!lstrcmpiA(buffer, destfile), "unexpected path: %s\n", buffer);
SetupCloseInfFile(hinf);
DeleteFileA(inf_filename);
create_inf_file(inf_filename, inf_data6, sizeof(inf_data6) - 1);
hinf = SetupOpenInfFileA(inf_filename, NULL, INF_STYLE_WIN4, NULL);
ok(hinf != INVALID_HANDLE_VALUE, "could not open inf file\n");
required = 0;
ret = SetupGetTargetPathA(hinf, NULL, "CopyAlways.Windir.Files", buffer, sizeof(buffer), &required);
ok(ret, "SetupGetTargetPathA failed\n");
lstrcpyA(destfile, WIN_DIR);
ok(required == lstrlenA(destfile) + 1, "unexpected required size: %d\n", required);
ok(!lstrcmpiA(buffer, destfile), "unexpected path: %s\n", buffer);
SetupCloseInfFile(hinf);
DeleteFileA(inf_filename);
}
static VOID
InitCodePagesList(HWND hwndDlg)
{
LPCPAGE lpCPage;
INT ItemIndex;
HWND hList;
LV_COLUMN column;
LV_ITEM item;
RECT ListRect;
hList = GetDlgItem(hwndDlg, IDC_CONV_TABLES);
hIntlInf = SetupOpenInfFileW(L"intl.inf", NULL, INF_STYLE_WIN4, NULL);
if (hIntlInf == INVALID_HANDLE_VALUE)
return;
if (!SetupOpenAppendInfFile(NULL, hIntlInf, NULL))
{
SetupCloseInfFile(hIntlInf);
hIntlInf = NULL;
return;
}
if (!GetSupportedCP())
return;
SetupCloseInfFile(hIntlInf);
if (!EnumSystemCodePages(InstalledCPProc, CP_INSTALLED))
return;
ZeroMemory(&column, sizeof(LV_COLUMN));
column.mask = LVCF_FMT|LVCF_TEXT|LVCF_WIDTH;
column.fmt = LVCFMT_LEFT;
GetClientRect(hList, &ListRect);
column.cx = ListRect.right - GetSystemMetrics(SM_CYHSCROLL);
(VOID) ListView_InsertColumn(hList, 0, &column);
(VOID) ListView_SetExtendedListViewStyle(hList, LVS_EX_CHECKBOXES|LVS_EX_FULLROWSELECT);
lpCPage = PCPage;
for (;;)
{
if (!lpCPage) break;
ZeroMemory(&item, sizeof(LV_ITEM));
item.mask = LVIF_TEXT|LVIF_PARAM|LVIF_STATE;
item.state = 0;
item.stateMask = LVIS_STATEIMAGEMASK;
item.pszText = lpCPage->Name;
item.lParam = (LPARAM)lpCPage;
ItemIndex = ListView_InsertItem(hList, &item);
if (ItemIndex >= 0)
{
if (lpCPage->Status & 0x0001)
{
ListView_SetItemState(hList, ItemIndex,
INDEXTOSTATEIMAGEMASK(LVIS_SELECTED),
LVIS_STATEIMAGEMASK);
}
else
{
ListView_SetItemState(hList, ItemIndex,
INDEXTOSTATEIMAGEMASK(LVIS_FOCUSED),
LVIS_STATEIMAGEMASK);
}
}
lpCPage = lpCPage->NextItem;
}
}
static void test_SetupGetInfInformation(void)
{
PSP_INF_INFORMATION info;
CHAR inf_filename[MAX_PATH];
CHAR inf_one[MAX_PATH], inf_two[MAX_PATH];
LPSTR revfile;
DWORD size;
HINF hinf;
BOOL ret;
lstrcpyA(inf_filename, CURR_DIR);
lstrcatA(inf_filename, "\\");
lstrcatA(inf_filename, "test.inf");
/* try an invalid inf handle */
size = 0xdeadbeef;
SetLastError(0xbeefcafe);
ret = SetupGetInfInformationA(NULL, INFINFO_INF_SPEC_IS_HINF, NULL, 0, &size);
ok(ret == FALSE, "Expected SetupGetInfInformation to fail\n");
ok(GetLastError() == ERROR_INVALID_HANDLE ||
broken(GetLastError() == ERROR_BAD_PATHNAME) || /* win95 */
broken(GetLastError() == ERROR_FILE_NOT_FOUND) || /* win98 */
broken(GetLastError() == ERROR_PATH_NOT_FOUND) || /* NT4 */
broken(GetLastError() == ERROR_INVALID_NAME) || /* win2k */
broken(GetLastError() == ERROR_GENERAL_SYNTAX), /* another win2k / winMe */
"Expected ERROR_INVALID_HANDLE, got %d\n", GetLastError());
ok(size == 0xdeadbeef, "Expected size to remain unchanged\n");
/* try an invalid inf filename */
/* do not use NULL as absolute inf filename on win9x/winMe (crash) */
if ((GetLastError() != ERROR_BAD_PATHNAME) && /* win95 */
(GetLastError() != ERROR_FILE_NOT_FOUND) && /* win98 */
(GetLastError() != ERROR_GENERAL_SYNTAX)) /* winMe */
{
size = 0xdeadbeef;
SetLastError(0xbeefcafe);
ret = SetupGetInfInformationA(NULL, INFINFO_INF_NAME_IS_ABSOLUTE, NULL, 0, &size);
ok(ret == FALSE, "Expected SetupGetInfInformation to fail\n");
ok(GetLastError() == ERROR_INVALID_PARAMETER,
"Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
ok(size == 0xdeadbeef, "Expected size to remain unchanged\n");
}
create_inf_file(inf_filename, inf_data1, sizeof(inf_data1) - 1);
/* try an invalid search flag */
size = 0xdeadbeef;
SetLastError(0xbeefcafe);
ret = SetupGetInfInformationA(inf_filename, -1, NULL, 0, &size);
ok(ret == FALSE, "Expected SetupGetInfInformation to fail\n");
ok(GetLastError() == ERROR_INVALID_PARAMETER,
"Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
ok(size == 0xdeadbeef, "Expected size to remain unchanged\n");
/* try a nonexistent inf file */
size = 0xdeadbeef;
SetLastError(0xbeefcafe);
ret = SetupGetInfInformationA("idontexist", INFINFO_INF_NAME_IS_ABSOLUTE, NULL, 0, &size);
ok(ret == FALSE, "Expected SetupGetInfInformation to fail\n");
ok(GetLastError() == ERROR_FILE_NOT_FOUND,
"Expected ERROR_FILE_NOT_FOUND, got %d\n", GetLastError());
ok(size == 0xdeadbeef, "Expected size to remain unchanged\n");
/* successfully open the inf file */
size = 0xdeadbeef;
ret = SetupGetInfInformationA(inf_filename, INFINFO_INF_NAME_IS_ABSOLUTE, NULL, 0, &size);
ok(ret == TRUE, "Expected SetupGetInfInformation to succeed\n");
ok(size != 0xdeadbeef, "Expected a valid size on return\n");
/* set ReturnBuffer to NULL and ReturnBufferSize to non-zero value 'size' */
SetLastError(0xbeefcafe);
ret = SetupGetInfInformationA(inf_filename, INFINFO_INF_NAME_IS_ABSOLUTE, NULL, size, &size);
ok(ret == FALSE, "Expected SetupGetInfInformation to fail\n");
ok(GetLastError() == ERROR_INVALID_PARAMETER,
"Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
/* set ReturnBuffer to NULL and ReturnBufferSize to non-zero value 'size-1' */
ret = SetupGetInfInformationA(inf_filename, INFINFO_INF_NAME_IS_ABSOLUTE, NULL, size-1, &size);
ok(ret == TRUE, "Expected SetupGetInfInformation to succeed\n");
/* some tests for behaviour with a NULL RequiredSize pointer */
ret = SetupGetInfInformationA(inf_filename, INFINFO_INF_NAME_IS_ABSOLUTE, NULL, 0, NULL);
ok(ret == TRUE, "Expected SetupGetInfInformation to succeed\n");
ret = SetupGetInfInformationA(inf_filename, INFINFO_INF_NAME_IS_ABSOLUTE, NULL, size - 1, NULL);
ok(ret == TRUE, "Expected SetupGetInfInformation to succeed\n");
ret = SetupGetInfInformationA(inf_filename, INFINFO_INF_NAME_IS_ABSOLUTE, NULL, size, NULL);
ok(ret == FALSE, "Expected SetupGetInfInformation to fail\n");
info = HeapAlloc(GetProcessHeap(), 0, size);
/* try valid ReturnBuffer but too small size */
SetLastError(0xbeefcafe);
ret = SetupGetInfInformationA(inf_filename, INFINFO_INF_NAME_IS_ABSOLUTE, info, size - 1, &size);
ok(ret == FALSE, "Expected SetupGetInfInformation to fail\n");
ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
"Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
/* successfully get the inf information */
ret = SetupGetInfInformationA(inf_filename, INFINFO_INF_NAME_IS_ABSOLUTE, info, size, &size);
ok(ret == TRUE, "Expected SetupGetInfInformation to succeed\n");
ok(check_info_filename(info, inf_filename), "Expected returned filename to be equal\n");
HeapFree(GetProcessHeap(), 0, info);
/* try the INFINFO_INF_SPEC_IS_HINF search flag */
hinf = SetupOpenInfFileA(inf_filename, NULL, INF_STYLE_WIN4, NULL);
info = alloc_inf_info(hinf, INFINFO_INF_SPEC_IS_HINF, &size);
ret = SetupGetInfInformationA(hinf, INFINFO_INF_SPEC_IS_HINF, info, size, &size);
ok(ret == TRUE, "Expected SetupGetInfInformation to succeed\n");
ok(check_info_filename(info, inf_filename), "Expected returned filename to be equal\n");
SetupCloseInfFile(hinf);
lstrcpyA(inf_two, WIN_DIR);
lstrcatA(inf_two, "\\system32\\");
lstrcatA(inf_two, "test.inf");
create_inf_file(inf_two, inf_data1, sizeof(inf_data1) - 1);
HeapFree(GetProcessHeap(), 0, info);
info = alloc_inf_info("test.inf", INFINFO_DEFAULT_SEARCH, &size);
/* check if system32 is searched for inf */
ret = SetupGetInfInformationA("test.inf", INFINFO_DEFAULT_SEARCH, info, size, &size);
if (!ret && GetLastError() == ERROR_FILE_NOT_FOUND)
revfile = inf_one; /* Vista */
else
revfile = inf_two;
lstrcpyA(inf_one, WIN_DIR);
lstrcatA(inf_one, "\\inf\\");
lstrcatA(inf_one, "test.inf");
create_inf_file(inf_one, inf_data1, sizeof(inf_data1) - 1);
HeapFree(GetProcessHeap(), 0, info);
info = alloc_inf_info("test.inf", INFINFO_DEFAULT_SEARCH, &size);
/* test the INFINFO_DEFAULT_SEARCH search flag */
ret = SetupGetInfInformationA("test.inf", INFINFO_DEFAULT_SEARCH, info, size, &size);
ok(ret == TRUE, "Expected SetupGetInfInformation to succeed: %d\n", GetLastError());
ok(check_info_filename(info, inf_one), "Expected returned filename to be equal\n");
HeapFree(GetProcessHeap(), 0, info);
info = alloc_inf_info("test.inf", INFINFO_REVERSE_DEFAULT_SEARCH, &size);
/* test the INFINFO_REVERSE_DEFAULT_SEARCH search flag */
ret = SetupGetInfInformationA("test.inf", INFINFO_REVERSE_DEFAULT_SEARCH, info, size, &size);
ok(ret == TRUE, "Expected SetupGetInfInformation to succeed\n");
ok(check_info_filename(info, revfile), "Expected returned filename to be equal\n");
HeapFree(GetProcessHeap(), 0, info);
DeleteFileA(inf_filename);
DeleteFileA(inf_one);
DeleteFileA(inf_two);
}
/**
* Executes a sepcified .INF section to install/uninstall drivers and/or services.
*
* @return Exit code (EXIT_OK, EXIT_FAIL)
* @param pszSection Section to execute; usually it's "DefaultInstall".
* @param iMode Execution mode to use (see MSDN).
* @param pszInf Full qualified path of the .INF file to use.
*/
int ExecuteInfFile(const _TCHAR *pszSection, int iMode, const _TCHAR *pszInf)
{
_tprintf(_T("Installing from INF-File: %ws (Section: %ws) ...\n"),
pszInf, pszSection);
UINT uErrorLine = 0;
HINF hINF = SetupOpenInfFile(pszInf, NULL, INF_STYLE_WIN4, &uErrorLine);
if (hINF != INVALID_HANDLE_VALUE)
{
PVOID pvQueue = SetupInitDefaultQueueCallback(NULL);
BOOL fSuccess = SetupInstallFromInfSection(NULL,
hINF,
pszSection,
SPINST_ALL,
HKEY_LOCAL_MACHINE,
NULL,
SP_COPY_NEWER_OR_SAME | SP_COPY_NOSKIP,
vboxDrvInstExecuteInfFileCallback,
pvQueue,
NULL,
NULL
);
if (fSuccess)
{
_tprintf (_T( "File installation stage successful\n"));
fSuccess = SetupInstallServicesFromInfSection(hINF,
L"DefaultInstall.Services",
0 /* Flags */);
if (fSuccess)
{
_tprintf (_T( "Service installation stage successful. Installation completed\n"));
}
else
{
DWORD dwErr = GetLastError();
switch (dwErr)
{
case ERROR_SUCCESS_REBOOT_REQUIRED:
_tprintf (_T( "A reboot is required to complete the installation\n"));
break;
case ERROR_SECTION_NOT_FOUND:
break;
default:
_tprintf (_T( "Error %ld while installing service\n"), dwErr);
break;
}
}
}
else
_tprintf (_T( "Error %ld while installing files\n"), GetLastError());
if (pvQueue)
SetupTermDefaultQueueCallback(pvQueue);
SetupCloseInfFile(hINF);
}
else
_tprintf (_T( "Unable to open %ws: %ld (error line %u)\n"),
pszInf, GetLastError(), uErrorLine);
return EXIT_OK;
}
DWORD
MMSYS_InstallDevice(HDEVINFO hDevInfo, PSP_DEVINFO_DATA pspDevInfoData)
{
UINT Length;
LPWSTR pBuffer;
WCHAR szBuffer[MAX_PATH];
HINF hInf;
PVOID Context;
BOOL Result;
SC_HANDLE hSCManager, hService;
WCHAR WaveName[20];
HKEY hKey;
DWORD BufferSize;
ULONG Index;
if (!IsEqualIID(&pspDevInfoData->ClassGuid, &GUID_DEVCLASS_SOUND) &&
!IsEqualIID(&pspDevInfoData->ClassGuid, &GUID_DEVCLASS_MEDIA))
return ERROR_DI_DO_DEFAULT;
Length = GetWindowsDirectoryW(szBuffer, MAX_PATH);
if (!Length || Length >= MAX_PATH - 14)
{
return ERROR_GEN_FAILURE;
}
pBuffer = PathAddBackslashW(szBuffer);
if (!pBuffer)
{
return ERROR_GEN_FAILURE;
}
wcscpy(pBuffer, L"inf\\audio.inf");
hInf = SetupOpenInfFileW(szBuffer,
NULL,
INF_STYLE_WIN4,
NULL);
if (hInf == INVALID_HANDLE_VALUE)
{
return ERROR_GEN_FAILURE;
}
Context = SetupInitDefaultQueueCallback(NULL);
if (Context == NULL)
{
SetupCloseInfFile(hInf);
return ERROR_GEN_FAILURE;
}
Result = SetupInstallFromInfSectionW(NULL,
hInf,
L"AUDIO_Inst.NT",
SPINST_ALL,
NULL,
NULL,
SP_COPY_NEWER,
SetupDefaultQueueCallbackW,
Context,
NULL,
NULL);
if (Result)
{
Result = SetupInstallServicesFromInfSectionW(hInf,
L"Audio_Inst.NT.Services",
0);
}
SetupTermDefaultQueueCallback(Context);
SetupCloseInfFile(hInf);
hSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT);
if (!hSCManager)
{
return ERROR_DI_DO_DEFAULT;
}
hService = OpenService(hSCManager, L"RosAudioSrv", SERVICE_ALL_ACCESS);
if (hService)
{
/* Make RosAudioSrv start automatically */
ChangeServiceConfig(hService, SERVICE_NO_CHANGE, SERVICE_AUTO_START, SERVICE_NO_CHANGE, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
StartService(hService, 0, NULL);
CloseServiceHandle(hService);
}
CloseServiceHandle(hSCManager);
if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Drivers32", 0, GENERIC_READ | GENERIC_WRITE, &hKey) == ERROR_SUCCESS)
{
szBuffer[Length] = '\0';
pBuffer = PathAddBackslashW(szBuffer);
wcscpy(pBuffer, L"system32\\wdmaud.drv");
for(Index = 1; Index <= 4; Index++)
{
swprintf(WaveName, L"wave%u", Index);
if (RegQueryValueExW(hKey, WaveName, 0, NULL, NULL, &BufferSize) != ERROR_MORE_DATA)
{
/* Store new audio driver entry */
RegSetValueExW(hKey, WaveName, 0, REG_SZ, (LPBYTE)szBuffer, (wcslen(szBuffer)+1) * sizeof(WCHAR));
break;
}
else
{
WCHAR Buffer[MAX_PATH];
BufferSize = sizeof(Buffer);
if (RegQueryValueExW(hKey, WaveName, 0, NULL, (LPBYTE)Buffer, &BufferSize) == ERROR_SUCCESS)
{
/* Make sure the buffer is zero terminated */
Buffer[MAX_PATH-1] = L'\0';
if (!wcsicmp(Buffer, szBuffer))
{
/* An entry already exists */
break;
}
}
}
}
RegCloseKey(hKey);
}
InstallSystemSoundScheme();
return ERROR_DI_DO_DEFAULT;
}
static void test_install_svc_from(void)
{
char inf[2048];
char path[MAX_PATH];
HINF infhandle;
BOOL ret;
SC_HANDLE scm_handle, svc_handle;
/* Bail out if we are on win98 */
SetLastError(0xdeadbeef);
scm_handle = OpenSCManagerA(NULL, NULL, GENERIC_ALL);
if (!scm_handle && (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED))
{
win_skip("OpenSCManagerA is not implemented, we are most likely on win9x\n");
return;
}
CloseServiceHandle(scm_handle);
/* Basic inf file to satisfy SetupOpenInfFileA */
strcpy(inf, "[Version]\nSignature=\"$Chicago$\"\n");
create_inf_file(inffile, inf);
sprintf(path, "%s\\%s", CURR_DIR, inffile);
infhandle = SetupOpenInfFileA(path, NULL, INF_STYLE_WIN4, NULL);
/* Nothing but the Version section */
SetLastError(0xdeadbeef);
ret = SetupInstallServicesFromInfSectionA(infhandle, "Winetest.Services", 0);
ok(!ret, "Expected failure\n");
ok(GetLastError() == ERROR_SECTION_NOT_FOUND,
"Expected ERROR_SECTION_NOT_FOUND, got %08x\n", GetLastError());
SetupCloseInfFile(infhandle);
DeleteFileA(inffile);
/* Add the section */
strcat(inf, "[Winetest.Services]\n");
create_inf_file(inffile, inf);
infhandle = SetupOpenInfFileA(path, NULL, INF_STYLE_WIN4, NULL);
SetLastError(0xdeadbeef);
ret = SetupInstallServicesFromInfSectionA(infhandle, "Winetest.Services", 0);
ok(!ret, "Expected failure\n");
ok(GetLastError() == ERROR_SECTION_NOT_FOUND,
"Expected ERROR_SECTION_NOT_FOUND, got %08x\n", GetLastError());
SetupCloseInfFile(infhandle);
DeleteFileA(inffile);
/* Add a reference */
strcat(inf, "AddService=Winetest,,Winetest.Service\n");
create_inf_file(inffile, inf);
infhandle = SetupOpenInfFileA(path, NULL, INF_STYLE_WIN4, NULL);
SetLastError(0xdeadbeef);
ret = SetupInstallServicesFromInfSectionA(infhandle, "Winetest.Services", 0);
ok(!ret, "Expected failure\n");
ok(GetLastError() == ERROR_BAD_SERVICE_INSTALLSECT,
"Expected ERROR_BAD_SERVICE_INSTALLSECT, got %08x\n", GetLastError());
SetupCloseInfFile(infhandle);
DeleteFileA(inffile);
/* Add the section */
strcat(inf, "[Winetest.Service]\n");
create_inf_file(inffile, inf);
infhandle = SetupOpenInfFileA(path, NULL, INF_STYLE_WIN4, NULL);
SetLastError(0xdeadbeef);
ret = SetupInstallServicesFromInfSectionA(infhandle, "Winetest.Services", 0);
ok(!ret, "Expected failure\n");
ok(GetLastError() == ERROR_BAD_SERVICE_INSTALLSECT,
"Expected ERROR_BAD_SERVICE_INSTALLSECT, got %08x\n", GetLastError());
SetupCloseInfFile(infhandle);
DeleteFileA(inffile);
/* Just the ServiceBinary */
strcat(inf, "ServiceBinary=%12%\\winetest.sys\n");
create_inf_file(inffile, inf);
infhandle = SetupOpenInfFileA(path, NULL, INF_STYLE_WIN4, NULL);
SetLastError(0xdeadbeef);
ret = SetupInstallServicesFromInfSectionA(infhandle, "Winetest.Services", 0);
ok(!ret, "Expected failure\n");
ok(GetLastError() == ERROR_BAD_SERVICE_INSTALLSECT,
"Expected ERROR_BAD_SERVICE_INSTALLSECT, got %08x\n", GetLastError());
SetupCloseInfFile(infhandle);
DeleteFileA(inffile);
/* Add the ServiceType */
strcat(inf, "ServiceType=1\n");
create_inf_file(inffile, inf);
infhandle = SetupOpenInfFileA(path, NULL, INF_STYLE_WIN4, NULL);
SetLastError(0xdeadbeef);
ret = SetupInstallServicesFromInfSectionA(infhandle, "Winetest.Services", 0);
ok(!ret, "Expected failure\n");
ok(GetLastError() == ERROR_BAD_SERVICE_INSTALLSECT,
"Expected ERROR_BAD_SERVICE_INSTALLSECT, got %08x\n", GetLastError());
SetupCloseInfFile(infhandle);
DeleteFileA(inffile);
/* Add the StartType */
strcat(inf, "StartType=4\n");
create_inf_file(inffile, inf);
infhandle = SetupOpenInfFileA(path, NULL, INF_STYLE_WIN4, NULL);
SetLastError(0xdeadbeef);
ret = SetupInstallServicesFromInfSectionA(infhandle, "Winetest.Services", 0);
ok(!ret, "Expected failure\n");
ok(GetLastError() == ERROR_BAD_SERVICE_INSTALLSECT,
"Expected ERROR_BAD_SERVICE_INSTALLSECT, got %08x\n", GetLastError());
SetupCloseInfFile(infhandle);
DeleteFileA(inffile);
/* This should be it, the minimal entries to install a service */
strcat(inf, "ErrorControl=1");
create_inf_file(inffile, inf);
infhandle = SetupOpenInfFileA(path, NULL, INF_STYLE_WIN4, NULL);
SetLastError(0xdeadbeef);
ret = SetupInstallServicesFromInfSectionA(infhandle, "Winetest.Services", 0);
if (!ret && GetLastError() == ERROR_ACCESS_DENIED)
{
skip("Not enough rights to install the service\n");
SetupCloseInfFile(infhandle);
DeleteFileA(inffile);
return;
}
ok(ret, "Expected success\n");
ok(GetLastError() == ERROR_SUCCESS,
"Expected ERROR_SUCCESS, got %08x\n", GetLastError());
SetupCloseInfFile(infhandle);
DeleteFileA(inffile);
scm_handle = OpenSCManagerA(NULL, NULL, GENERIC_ALL);
/* Open the service to see if it's really there */
svc_handle = OpenServiceA(scm_handle, "Winetest", DELETE);
ok(svc_handle != NULL, "Service was not created\n");
SetLastError(0xdeadbeef);
ret = DeleteService(svc_handle);
ok(ret, "Service could not be deleted : %d\n", GetLastError());
CloseServiceHandle(svc_handle);
CloseServiceHandle(scm_handle);
strcpy(inf, "[Version]\nSignature=\"$Chicago$\"\n");
strcat(inf, "[XSP.InstallPerVer]\n");
strcat(inf, "AddReg=AspEventlogMsg.Reg,Perf.Reg,AspVersions.Reg,FreeADO.Reg,IndexServer.Reg\n");
create_inf_file(inffile, inf);
sprintf(path, "%s\\%s", CURR_DIR, inffile);
infhandle = SetupOpenInfFileA(path, NULL, INF_STYLE_WIN4, NULL);
SetLastError(0xdeadbeef);
ret = SetupInstallServicesFromInfSectionA(infhandle, "XSP.InstallPerVer", 0);
ok(ret, "Expected success\n");
ok(GetLastError() == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %08x\n", GetLastError());
SetupCloseInfFile(infhandle);
DeleteFileA(inffile);
/* TODO: Test the Flags */
}
