/* parses the destination directory parameters from pszSection * the parameters are of the form: root,key,value,unknown,fallback * we first read the reg value root\\key\\value and if that fails, * use fallback as the destination directory */ static void get_dest_dir(HINF hInf, PCWSTR pszSection, PWSTR pszBuffer, DWORD dwSize) { INFCONTEXT context; WCHAR key[MAX_PATH], value[MAX_PATH]; WCHAR prefix[PREFIX_LEN]; HKEY root, subkey; DWORD size; static const WCHAR hklm[] = {'H','K','L','M',0}; static const WCHAR hkcu[] = {'H','K','C','U',0}; /* load the destination parameters */ SetupFindFirstLineW(hInf, pszSection, NULL, &context); SetupGetStringFieldW(&context, 1, prefix, PREFIX_LEN, &size); SetupGetStringFieldW(&context, 2, key, MAX_PATH, &size); SetupGetStringFieldW(&context, 3, value, MAX_PATH, &size); if (!lstrcmpW(prefix, hklm)) root = HKEY_LOCAL_MACHINE; else if (!lstrcmpW(prefix, hkcu)) root = HKEY_CURRENT_USER; else root = NULL; size = dwSize * sizeof(WCHAR); /* fallback to the default destination dir if reg fails */ if (RegOpenKeyW(root, key, &subkey) || RegQueryValueExW(subkey, value, NULL, NULL, (LPBYTE)pszBuffer, &size)) { SetupGetStringFieldW(&context, 5, pszBuffer, dwSize, NULL); } RegCloseKey(subkey); }
BOOLEAN INF_GetData( IN PINFCONTEXT Context, OUT PWCHAR *Key, OUT PWCHAR *Data) { #ifdef __REACTOS__ return InfGetData(Context, Key, Data); #else static PWCHAR pLastCallData[4] = { NULL, NULL, NULL, NULL }; static DWORD currentIndex = 0; DWORD dwSize, i; BOOL ret; currentIndex ^= 2; if (Key) *Key = NULL; if (Data) *Data = NULL; if (SetupGetFieldCount(Context) != 1) return FALSE; for (i = 0; i <= 1; i++) { ret = SetupGetStringFieldW( Context, i, NULL, 0, &dwSize); if (!ret) return FALSE; HeapFree(GetProcessHeap(), 0, pLastCallData[i + currentIndex]); pLastCallData[i + currentIndex] = HeapAlloc(GetProcessHeap(), 0, dwSize * sizeof(WCHAR)); ret = SetupGetStringFieldW( Context, i, pLastCallData[i + currentIndex], dwSize, NULL); if (!ret) return FALSE; } if (Key) *Key = pLastCallData[0 + currentIndex]; if (Data) *Data = pLastCallData[1 + currentIndex]; return TRUE; #endif /* !__REACTOS__ */ }
static BOOL InstallSysSetupInfDevices(VOID) { INFCONTEXT InfContext; WCHAR szLineBuffer[256]; DWORD dwLineLength; if (!SetupFindFirstLineW(hSysSetupInf, L"DeviceInfsToInstall", NULL, &InfContext)) { return FALSE; } do { if (!SetupGetStringFieldW(&InfContext, 0, szLineBuffer, sizeof(szLineBuffer)/sizeof(szLineBuffer[0]), &dwLineLength)) { return FALSE; } if (!SetupDiInstallClassW(NULL, szLineBuffer, DI_QUIETINSTALL, NULL)) { return FALSE; } } while (SetupFindNextLine(&InfContext, &InfContext)); return TRUE; }
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); }
/* retrieves the contents of a field, dynamically growing the buffer if necessary */ static WCHAR *get_field_string(INFCONTEXT *context, DWORD index, WCHAR *buffer, const WCHAR *static_buffer, DWORD *size) { DWORD required; if (SetupGetStringFieldW(context, index, buffer, *size, &required)) return buffer; if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) { /* now grow the buffer */ if (buffer != static_buffer) HeapFree(GetProcessHeap(), 0, buffer); if (!(buffer = HeapAlloc(GetProcessHeap(), 0, required*sizeof(WCHAR)))) return NULL; *size = required; if (SetupGetStringFieldW(context, index, buffer, *size, &required)) return buffer; } if (buffer != static_buffer) HeapFree(GetProcessHeap(), 0, buffer); return NULL; }
BOOLEAN INF_GetDataField( IN PINFCONTEXT Context, IN ULONG FieldIndex, OUT PWCHAR *Data) { #ifdef __REACTOS__ return InfGetDataField(Context, FieldIndex, Data); #else static PWCHAR pLastCallsData[] = { NULL, NULL, NULL }; static DWORD NextIndex = 0; DWORD dwSize; BOOL ret; *Data = NULL; ret = SetupGetStringFieldW( Context, FieldIndex, NULL, 0, &dwSize); if (!ret) return FALSE; HeapFree(GetProcessHeap(), 0, pLastCallsData[NextIndex]); pLastCallsData[NextIndex] = HeapAlloc(GetProcessHeap(), 0, dwSize * sizeof(WCHAR)); ret = SetupGetStringFieldW( Context, FieldIndex, pLastCallsData[NextIndex], dwSize, NULL); if (!ret) return FALSE; *Data = pLastCallsData[NextIndex]; NextIndex = (NextIndex + 1) % (sizeof(pLastCallsData) / sizeof(pLastCallsData[0])); return TRUE; #endif /* !__REACTOS__ */ }
static LPWSTR get_source_id( HINF hinf, PINFCONTEXT context, PCWSTR filename ) { WCHAR Section[MAX_PATH]; DWORD size; LPWSTR source_id; if (!SetupDiGetActualSectionToInstallW(hinf, source_disks_files, Section, MAX_PATH, NULL, NULL)) return NULL; if (!SetupFindFirstLineW( hinf, Section, filename, context ) && !SetupFindFirstLineW( hinf, source_disks_files, filename, context )) return NULL; if (!SetupGetStringFieldW( context, 1, NULL, 0, &size )) return NULL; if (!(source_id = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) ))) return NULL; if (!SetupGetStringFieldW( context, 1, source_id, size, NULL )) { HeapFree( GetProcessHeap(), 0, source_id ); return NULL; } if (!SetupDiGetActualSectionToInstallW(hinf, source_disks_names, Section, MAX_PATH, NULL, NULL)) { HeapFree( GetProcessHeap(), 0, source_id ); return NULL; } if (!SetupFindFirstLineW( hinf, Section, source_id, context ) && !SetupFindFirstLineW( hinf, source_disks_names, source_id, context )) { HeapFree( GetProcessHeap(), 0, source_id ); return NULL; } return source_id; }
BOOL RegisterTypeLibraries (HINF hinf, LPCWSTR szSection) { INFCONTEXT InfContext; BOOL res; WCHAR szName[MAX_PATH]; WCHAR szPath[MAX_PATH]; INT csidl; LPWSTR p; HMODULE hmod; HRESULT hret; /* Begin iterating the entries in the inf section */ res = SetupFindFirstLine(hinf, szSection, NULL, &InfContext); if (!res) return FALSE; do { /* Get the name of the current type library */ if (!SetupGetStringFieldW(&InfContext, 1, szName, MAX_PATH, NULL)) { FatalError("SetupGetStringFieldW failed\n"); continue; } if (!SetupGetIntField(&InfContext, 2, &csidl)) csidl = CSIDL_SYSTEM; hret = SHGetFolderPathW(NULL, csidl, NULL, 0, szPath); if (FAILED(hret)) { FatalError("SHGetFolderPathW failed hret=0x%d\n", hret); continue; } p = PathAddBackslash(szPath); _tcscpy(p, szName); hmod = LoadLibraryW(szName); if (hmod == NULL) { FatalError("LoadLibraryW failed\n"); continue; } __wine_register_resources(hmod); }while (SetupFindNextLine(&InfContext, &InfContext)); return TRUE; }
static BOOL CreateShortcuts(HINF hinf, LPCWSTR szSection) { INFCONTEXT Context; WCHAR szPath[MAX_PATH]; WCHAR szFolder[MAX_PATH]; WCHAR szFolderSection[MAX_PATH]; INT csidl; CoInitialize(NULL); if (!SetupFindFirstLine(hinf, szSection, NULL, &Context)) return FALSE; do { if (SetupGetFieldCount(&Context) < 2) continue; if (!SetupGetStringFieldW(&Context, 0, szFolderSection, MAX_PATH, NULL)) continue; if (!SetupGetIntField(&Context, 1, &csidl)) continue; if (!SetupGetStringFieldW(&Context, 2, szFolder, MAX_PATH, NULL)) continue; if (FAILED(SHGetFolderPathAndSubDirW(NULL, csidl|CSIDL_FLAG_CREATE, (HANDLE)-1, SHGFP_TYPE_DEFAULT, szFolder, szPath))) continue; CreateShortcutsFromSection(hinf, szFolderSection, szPath); }while (SetupFindNextLine(&Context, &Context)); CoUninitialize(); return TRUE; }
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; }
static BOOL CreateShortcutsFromSection(HINF hinf, LPWSTR pszSection, LPCWSTR pszFolder) { INFCONTEXT Context; WCHAR szCommand[MAX_PATH]; WCHAR szName[MAX_PATH]; WCHAR szDescription[MAX_PATH]; INT iIconNr; if (!SetupFindFirstLine(hinf, pszSection, NULL, &Context)) return FALSE; do { if (SetupGetFieldCount(&Context) < 4) continue; if (!SetupGetStringFieldW(&Context, 1, szCommand, MAX_PATH, NULL)) continue; if (!SetupGetStringFieldW(&Context, 2, szName, MAX_PATH, NULL)) continue; if (!SetupGetStringFieldW(&Context, 3, szDescription, MAX_PATH, NULL)) continue; if (!SetupGetIntField(&Context, 4, &iIconNr)) continue; _tcscat(szName, L".lnk"); CreateShortcut(pszFolder, szName, szCommand, szDescription, iIconNr); }while (SetupFindNextLine(&Context, &Context)); return TRUE; }
BOOL WINAPI SetupGetSourceInfoW( HINF hinf, UINT source_id, UINT info, PWSTR buffer, DWORD buffer_size, LPDWORD required_size ) { WCHAR Section[MAX_PATH]; INFCONTEXT ctx; WCHAR source_id_str[11]; static const WCHAR fmt[] = {'%','d',0}; DWORD index; TRACE("%p, %d, %d, %p, %d, %p\n", hinf, source_id, info, buffer, buffer_size, required_size); sprintfW( source_id_str, fmt, source_id ); if (!SetupDiGetActualSectionToInstallW(hinf, source_disks_names, Section, MAX_PATH, NULL, NULL)) return FALSE; if (!SetupFindFirstLineW( hinf, Section, source_id_str, &ctx ) && !SetupFindFirstLineW( hinf, source_disks_names, source_id_str, &ctx )) return FALSE; switch (info) { case SRCINFO_PATH: index = 4; break; case SRCINFO_TAGFILE: index = 2; break; case SRCINFO_DESCRIPTION: index = 1; break; default: WARN("unknown info level: %d\n", info); return FALSE; } if (SetupGetStringFieldW( &ctx, index, buffer, buffer_size, required_size )) return TRUE; if (required_size) *required_size = 1; if (buffer) { if (buffer_size >= 1) buffer[0] = 0; else { SetLastError( ERROR_INSUFFICIENT_BUFFER ); return FALSE; } } return TRUE; }
static BOOL GetSupportedCP(VOID) { UINT uiCPage, Number; LONG Count; INFCONTEXT infCont; LPCPAGE lpCPage; HANDLE hCPage; CPINFOEX cpInfEx; //TCHAR Section[MAX_PATH]; Count = SetupGetLineCountW(hIntlInf, L"CodePages"); if (Count <= 0) return FALSE; for (Number = 0; Number < (UINT)Count; Number++) { if (SetupGetLineByIndexW(hIntlInf, L"CodePages", Number, &infCont) && SetupGetIntField(&infCont, 0, (PINT)&uiCPage)) { if (!(hCPage = GlobalAlloc(GHND, sizeof(CPAGE)))) return FALSE; lpCPage = GlobalLock(hCPage); lpCPage->CPage = uiCPage; lpCPage->hCPage = hCPage; lpCPage->Status = 0; (lpCPage->Name)[0] = 0; if (GetCPInfoEx(uiCPage, 0, &cpInfEx)) { wcscpy(lpCPage->Name, cpInfEx.CodePageName); } else if (!SetupGetStringFieldW(&infCont, 1, lpCPage->Name, MAX_PATH, NULL)) { GlobalUnlock(hCPage); GlobalFree(hCPage); continue; } lpCPage->NextItem = PCPage; PCPage = lpCPage; } } return TRUE; }
BOOL WINAPI SetupGetSourceFileLocationW( HINF hinf, PINFCONTEXT context, PCWSTR filename, PUINT source_id, PWSTR buffer, DWORD buffer_size, PDWORD required_size ) { INFCONTEXT ctx; WCHAR *end, *source_id_str; TRACE("%p, %p, %s, %p, %p, 0x%08x, %p\n", hinf, context, debugstr_w(filename), source_id, buffer, buffer_size, required_size); if (!context) context = &ctx; if (!(source_id_str = get_source_id( hinf, context, filename ))) return FALSE; *source_id = strtolW( source_id_str, &end, 10 ); if (end == source_id_str || *end) { HeapFree( GetProcessHeap(), 0, source_id_str ); return FALSE; } HeapFree( GetProcessHeap(), 0, source_id_str ); if (SetupGetStringFieldW( context, 4, buffer, buffer_size, required_size )) return TRUE; if (required_size) *required_size = 1; if (buffer) { if (buffer_size >= 1) buffer[0] = 0; else { SetLastError( ERROR_INSUFFICIENT_BUFFER ); return FALSE; } } return TRUE; }
static HRESULT register_ocxs_callback(HINF hinf, PCWSTR field, const void *arg) { HMODULE hm; INFCONTEXT context; HRESULT hr = S_OK; BOOL ok = SetupFindFirstLineW(hinf, field, NULL, &context); for (; ok; ok = SetupFindNextLine(&context, &context)) { WCHAR buffer[MAX_INF_STRING_LENGTH]; /* get OCX filename */ if (!SetupGetStringFieldW(&context, 1, buffer, sizeof(buffer) / sizeof(WCHAR), NULL)) continue; hm = LoadLibraryExW(buffer, NULL, LOAD_WITH_ALTERED_SEARCH_PATH); if (hm) { if (do_ocx_reg(hm, TRUE, NULL, NULL) != S_OK) hr = E_FAIL; FreeLibrary(hm); } else hr = E_FAIL; if (FAILED(hr)) { /* FIXME: display a message box */ break; } } return hr; }
/*********************************************************************** * do_reg_operation * * Perform an add/delete registry operation depending on the flags. */ static BOOLEAN do_reg_operation(HANDLE KeyHandle, PUNICODE_STRING ValueName, PINFCONTEXT Context, ULONG Flags) { WCHAR EmptyStr = (WCHAR)0; ULONG Type; ULONG Size; if (Flags & FLG_ADDREG_DELVAL) /* deletion */ { #if 0 if (ValueName) { RegDeleteValueW( KeyHandle, ValueName ); } else { RegDeleteKeyW( KeyHandle, NULL ); } #endif return TRUE; } if (Flags & FLG_ADDREG_KEYONLY) return TRUE; #if 0 if (Flags & (FLG_ADDREG_NOCLOBBER | FLG_ADDREG_OVERWRITEONLY)) { BOOL exists = !RegQueryValueExW( hkey, value, NULL, NULL, NULL, NULL ); if (exists && (flags & FLG_ADDREG_NOCLOBBER)) return TRUE; if (!exists & (flags & FLG_ADDREG_OVERWRITEONLY)) return TRUE; } #endif switch (Flags & FLG_ADDREG_TYPE_MASK) { case FLG_ADDREG_TYPE_SZ: Type = REG_SZ; break; case FLG_ADDREG_TYPE_MULTI_SZ: Type = REG_MULTI_SZ; break; case FLG_ADDREG_TYPE_EXPAND_SZ: Type = REG_EXPAND_SZ; break; case FLG_ADDREG_TYPE_BINARY: Type = REG_BINARY; break; case FLG_ADDREG_TYPE_DWORD: Type = REG_DWORD; break; case FLG_ADDREG_TYPE_NONE: Type = REG_NONE; break; default: Type = Flags >> 16; break; } if (!(Flags & FLG_ADDREG_BINVALUETYPE) || (Type == REG_DWORD && SetupGetFieldCount (Context) == 5)) { PWCHAR Str = NULL; if (Type == REG_MULTI_SZ) { if (!SetupGetMultiSzFieldW (Context, 5, NULL, 0, &Size)) Size = 0; if (Size) { Str = (WCHAR*) RtlAllocateHeap (ProcessHeap, 0, Size * sizeof(WCHAR)); if (Str == NULL) return FALSE; SetupGetMultiSzFieldW (Context, 5, Str, Size, NULL); } if (Flags & FLG_ADDREG_APPEND) { if (Str == NULL) return TRUE; // append_multi_sz_value( hkey, value, str, size ); RtlFreeHeap (ProcessHeap, 0, Str); return TRUE; } /* else fall through to normal string handling */ } else { if (!SetupGetStringFieldW (Context, 5, NULL, 0, &Size)) Size = 0; if (Size) { Str = (WCHAR*) RtlAllocateHeap (ProcessHeap, 0, Size * sizeof(WCHAR)); if (Str == NULL) return FALSE; SetupGetStringFieldW (Context, 5, Str, Size, NULL); } } if (Type == REG_DWORD) { ULONG dw = Str ? wcstol (Str, NULL, 0) : 0; DPRINT("setting dword %wZ to %lx\n", ValueName, dw); #ifdef __ODYSSEY__ NtSetValueKey (KeyHandle, ValueName, 0, Type, (PVOID)&dw, sizeof(ULONG)); #else RegSetValueExW(KeyHandle, ValueName, 0, Type, (const UCHAR*)&dw, sizeof(ULONG)); #endif } else { DPRINT("setting value %wZ to %S\n", ValueName, Str); if (Str) { #ifdef __ODYSSEY__ NtSetValueKey (KeyHandle, ValueName, 0, Type, (PVOID)Str, Size * sizeof(WCHAR)); #else RegSetValueExW(KeyHandle, ValueName, 0, Type, (const UCHAR*)Str, Size * sizeof(WCHAR)); #endif } else { #ifdef __ODYSSEY__ NtSetValueKey (KeyHandle, ValueName, 0, Type, (PVOID)&EmptyStr, sizeof(WCHAR)); #else RegSetValueExW(KeyHandle, ValueName, 0, Type, (const UCHAR*)&EmptyStr, sizeof(WCHAR)); #endif } } RtlFreeHeap (ProcessHeap, 0, Str); } else /* get the binary data */ { PUCHAR Data = NULL; if (!SetupGetBinaryField (Context, 5, NULL, 0, &Size)) Size = 0; if (Size) { Data = (unsigned char*) RtlAllocateHeap (ProcessHeap, 0, Size); if (Data == NULL) return FALSE; DPRINT("setting binary data %wZ len %lu\n", ValueName, Size); SetupGetBinaryField (Context, 5, Data, Size, NULL); } #ifdef __ODYSSEY__ NtSetValueKey (KeyHandle, ValueName, 0, Type, (PVOID)Data, Size); #else RegSetValueExW(KeyHandle, ValueName, 0, Type, (const UCHAR*)Data, Size); #endif RtlFreeHeap (ProcessHeap, 0, Data); } return TRUE; }
static PBOOTRECORD ReadFreeldrSection(HINF hInf, WCHAR *szSectionName) { PBOOTRECORD pRecord; INFCONTEXT InfContext; WCHAR szName[MAX_PATH]; WCHAR szValue[MAX_PATH]; DWORD LineLength; if (!SetupFindFirstLineW(hInf, szSectionName, NULL, &InfContext)) { /* Failed to find section */ return NULL; } pRecord = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(BOOTRECORD)); if (pRecord == NULL) { return NULL; } wcscpy(pRecord->szSectionName, szSectionName); do { if (!SetupGetStringFieldW(&InfContext, 0, szName, sizeof(szName) / sizeof(WCHAR), &LineLength)) { break; } if (!SetupGetStringFieldW(&InfContext, 1, szValue, sizeof(szValue) / sizeof(WCHAR), &LineLength)) { break; } if (!_wcsnicmp(szName, L"BootType", 8)) { if (!_wcsnicmp(szValue, L"ReactOS", 7)) { // FIXME: Store as enum pRecord->BootType = 1; } else { pRecord->BootType = 0; } } else if (!_wcsnicmp(szName, L"SystemPath", 10)) { wcscpy(pRecord->szBootPath, szValue); } else if (!_wcsnicmp(szName, L"Options", 7)) { // FIXME: Store flags as values wcscpy(pRecord->szOptions, szValue); } } while (SetupFindNextLine(&InfContext, &InfContext)); return pRecord; }
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); }
static INT LoadFreeldrSettings(HINF hInf, HWND hwndDlg) { INFCONTEXT InfContext; PBOOTRECORD pRecord; WCHAR szDefaultOs[MAX_PATH]; WCHAR szName[MAX_PATH]; WCHAR szValue[MAX_PATH]; DWORD LineLength; DWORD TimeOut; LRESULT lResult; if (!SetupFindFirstLineW(hInf, L"FREELOADER", L"DefaultOS", &InfContext)) { /* Failed to find default os */ return FALSE; } if (!SetupGetStringFieldW(&InfContext, 1, szDefaultOs, sizeof(szDefaultOs) / sizeof(WCHAR), &LineLength)) { /* No key */ return FALSE; } if (!SetupFindFirstLineW(hInf, L"FREELOADER", L"TimeOut", &InfContext)) { /* Expected to find timeout value */ return FALSE; } if (!SetupGetIntField(&InfContext, 1, (PINT)&TimeOut)) { /* Failed to retrieve timeout */ return FALSE; } if (!SetupFindFirstLineW(hInf, L"Operating Systems", NULL, &InfContext)) { /* Expected list of operating systems */ return FALSE; } do { if (!SetupGetStringFieldW(&InfContext, 0, szName, sizeof(szName) / sizeof(WCHAR), &LineLength)) { /* The ini file is messed up */ return FALSE; } if (!SetupGetStringFieldW(&InfContext, 1, szValue, sizeof(szValue) / sizeof(WCHAR), &LineLength)) { /* The ini file is messed up */ return FALSE; } pRecord = ReadFreeldrSection(hInf, szName); if (pRecord) { lResult = SendDlgItemMessageW(hwndDlg, IDC_STRECOSCOMBO, CB_ADDSTRING, (WPARAM)0, (LPARAM)szValue); if (lResult != CB_ERR) { SendDlgItemMessageW(hwndDlg, IDC_STRECOSCOMBO, CB_SETITEMDATA, (WPARAM)lResult, (LPARAM)pRecord); if (!wcscmp(szDefaultOs, szName)) { /* We store the friendly name as key */ wcscpy(szDefaultOs, szValue); } } else { HeapFree(GetProcessHeap(), 0, pRecord); } } } while (SetupFindNextLine(&InfContext, &InfContext)); /* Find default os in list */ lResult = SendDlgItemMessageW(hwndDlg, IDC_STRECOSCOMBO, CB_FINDSTRING, (WPARAM)-1, (LPARAM)szDefaultOs); if (lResult != CB_ERR) { /* Set cur sel */ SendDlgItemMessageW(hwndDlg, IDC_STRECOSCOMBO, CB_SETCURSEL, (WPARAM)lResult, (LPARAM)0); } if(TimeOut) { SendDlgItemMessageW(hwndDlg, IDC_STRECLIST, BM_SETCHECK, (WPARAM)BST_CHECKED, (LPARAM)0); } SetTimeout(hwndDlg, TimeOut); return TRUE; }
static INT LoadBootSettings(HINF hInf, HWND hwndDlg) { INFCONTEXT InfContext; WCHAR szName[MAX_PATH]; WCHAR szValue[MAX_PATH]; DWORD LineLength; DWORD TimeOut = 0; WCHAR szDefaultOS[MAX_PATH]; WCHAR szOptions[MAX_PATH]; PBOOTRECORD pRecord; LRESULT lResult; if(!SetupFindFirstLineW(hInf, L"boot loader", NULL, &InfContext)) { return FALSE; } do { if (!SetupGetStringFieldW(&InfContext, 0, szName, sizeof(szName) / sizeof(WCHAR), &LineLength)) { return FALSE; } if (!SetupGetStringFieldW(&InfContext, 1, szValue, sizeof(szValue) / sizeof(WCHAR), &LineLength)) { return FALSE; } if (!_wcsnicmp(szName, L"timeout", 7)) { TimeOut = _wtoi(szValue); } if (!_wcsnicmp(szName, L"default", 7)) { wcscpy(szDefaultOS, szValue); } } while (SetupFindNextLine(&InfContext, &InfContext)); if (!SetupFindFirstLineW(hInf, L"operating systems", NULL, &InfContext)) { /* Failed to find operating systems section */ return FALSE; } do { if (!SetupGetStringFieldW(&InfContext, 0, szName, sizeof(szName) / sizeof(WCHAR), &LineLength)) { return FALSE; } if (!SetupGetStringFieldW(&InfContext, 1, szValue, sizeof(szValue) / sizeof(WCHAR), &LineLength)) { return FALSE; } SetupGetStringFieldW(&InfContext, 2, szOptions, sizeof(szOptions) / sizeof(WCHAR), &LineLength); pRecord = (PBOOTRECORD) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(BOOTRECORD)); if (pRecord) { pRecord->BootType = 0; wcscpy(pRecord->szBootPath, szName); wcscpy(pRecord->szSectionName, szValue); wcscpy(pRecord->szOptions, szOptions); if (!wcscmp(szName, szDefaultOS)) { /* ms boot ini stores the path not the friendly name */ wcscpy(szDefaultOS, szValue); } lResult = SendDlgItemMessageW(hwndDlg, IDC_STRECOSCOMBO, CB_ADDSTRING, (WPARAM)0, (LPARAM)szValue); if (lResult != CB_ERR) { SendDlgItemMessageW(hwndDlg, IDC_STRECOSCOMBO, CB_SETITEMDATA, (WPARAM)lResult, (LPARAM)pRecord); } else { HeapFree(GetProcessHeap(), 0, pRecord); } } } while (SetupFindNextLine(&InfContext, &InfContext)); /* Find default os in list */ lResult = SendDlgItemMessageW(hwndDlg, IDC_STRECOSCOMBO, CB_FINDSTRING, (WPARAM)0, (LPARAM)szDefaultOS); if (lResult != CB_ERR) { /* Set cur sel */ SendDlgItemMessageW(hwndDlg, IDC_STRECOSCOMBO, CB_SETCURSEL, (WPARAM)lResult, (LPARAM)0); } if(TimeOut) { SendDlgItemMessageW(hwndDlg, IDC_STRECLIST, BM_SETCHECK, (WPARAM)BST_CHECKED, (LPARAM)0); } SetTimeout(hwndDlg, TimeOut); return TRUE; }
static BOOL InstallSysSetupInfComponents(VOID) { INFCONTEXT InfContext; WCHAR szNameBuffer[256]; WCHAR szSectionBuffer[256]; HINF hComponentInf = INVALID_HANDLE_VALUE; if (!SetupFindFirstLineW(hSysSetupInf, L"Infs.Always", NULL, &InfContext)) { DPRINT("No Inf.Always section found\n"); } else { do { if (!SetupGetStringFieldW(&InfContext, 1, // Get the component name szNameBuffer, sizeof(szNameBuffer)/sizeof(szNameBuffer[0]), NULL)) { FatalError("Error while trying to get component name \n"); return FALSE; } if (!SetupGetStringFieldW(&InfContext, 2, // Get the component install section szSectionBuffer, sizeof(szSectionBuffer)/sizeof(szSectionBuffer[0]), NULL)) { FatalError("Error while trying to get component install section \n"); return FALSE; } DPRINT("Trying to execute install section '%S' from '%S' \n", szSectionBuffer, szNameBuffer); hComponentInf = SetupOpenInfFileW(szNameBuffer, NULL, INF_STYLE_WIN4, NULL); if (hComponentInf == INVALID_HANDLE_VALUE) { FatalError("SetupOpenInfFileW() failed to open '%S' (Error: %lu)\n", szNameBuffer, GetLastError()); return FALSE; } if (!SetupInstallFromInfSectionW(NULL, hComponentInf, szSectionBuffer, SPINST_ALL, NULL, NULL, SP_COPY_NEWER, SetupDefaultQueueCallbackW, NULL, NULL, NULL)) { FatalError("Error while trying to install : %S (Error: %lu)\n", szNameBuffer, GetLastError()); SetupCloseInfFile(hComponentInf); return FALSE; } SetupCloseInfFile(hComponentInf); } while (SetupFindNextLine(&InfContext, &InfContext)); } return TRUE; }
/* loads the LDIDs specified in the install section of an INF */ void set_ldids(HINF hInf, LPCWSTR pszInstallSection, LPCWSTR pszWorkingDir) { WCHAR field[MAX_FIELD_LENGTH]; WCHAR line[MAX_FIELD_LENGTH]; WCHAR dest[MAX_PATH]; INFCONTEXT context; DWORD size; int ldid; static const WCHAR source_dir[] = {'S','o','u','r','c','e','D','i','r',0}; static const WCHAR custDestW[] = { 'C','u','s','t','o','m','D','e','s','t','i','n','a','t','i','o','n',0 }; if (!SetupGetLineTextW(NULL, hInf, pszInstallSection, custDestW, field, MAX_FIELD_LENGTH, &size)) return; if (!SetupFindFirstLineW(hInf, field, NULL, &context)) return; do { LPWSTR value, ptr, key, key_copy = NULL; DWORD flags = 0; SetupGetLineTextW(&context, NULL, NULL, NULL, line, MAX_FIELD_LENGTH, &size); /* SetupGetLineTextW returns the value if there is only one key, but * returns the whole line if there is more than one key */ if (!(value = strchrW(line, '='))) { SetupGetStringFieldW(&context, 0, NULL, 0, &size); key = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR)); key_copy = key; SetupGetStringFieldW(&context, 0, key, size, &size); value = line; } else { key = line; *(value++) = '\0'; } /* remove leading whitespace from the value */ while (*value == ' ') value++; /* Extract the flags */ ptr = strchrW(value, ','); if (ptr) { *ptr = '\0'; flags = atolW(ptr+1); } /* set dest to pszWorkingDir if key is SourceDir */ if (pszWorkingDir && !lstrcmpiW(value, source_dir)) lstrcpynW(dest, pszWorkingDir, MAX_PATH); else get_dest_dir(hInf, value, dest, MAX_PATH); /* If prompting required, provide dialog to request path */ if (flags & 0x04) FIXME("Need to support changing paths - default will be used\n"); /* set all ldids to dest */ while ((ptr = get_parameter(&key, ',', FALSE))) { ldid = atolW(ptr); SetupSetDirectoryIdW(hInf, ldid, dest); } HeapFree(GetProcessHeap(), 0, key_copy); } while (SetupFindNextLine(&context, &context)); }
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; }
/*********************************************************************** * registry_callback * * Called once for each AddReg and DelReg entry in a given section. */ static BOOLEAN registry_callback (HINF hInf, PCWSTR Section, BOOLEAN Delete) { OBJECT_ATTRIBUTES ObjectAttributes; WCHAR Buffer[MAX_INF_STRING_LENGTH]; UNICODE_STRING Name; UNICODE_STRING Value; PUNICODE_STRING ValuePtr; NTSTATUS Status; UINT Flags; ULONG Length; INFCONTEXT Context; HANDLE KeyHandle; BOOLEAN Ok; Ok = SetupFindFirstLineW (hInf, Section, NULL, &Context); if (Ok) { for (;Ok; Ok = SetupFindNextLine (&Context, &Context)) { /* get root */ if (!SetupGetStringFieldW (&Context, 1, Buffer, MAX_INF_STRING_LENGTH, NULL)) continue; if (!GetRootKey (Buffer)) continue; /* get key */ Length = wcslen (Buffer); if (!SetupGetStringFieldW (&Context, 2, Buffer + Length, MAX_INF_STRING_LENGTH - Length, NULL)) *Buffer = 0; DPRINT("KeyName: <%S>\n", Buffer); /* get flags */ if (!SetupGetIntField (&Context, 4, (PINT)&Flags)) Flags = 0; DPRINT("Flags: %lx\n", Flags); #ifdef __ODYSSEY__ RtlInitUnicodeString (&Name, Buffer); InitializeObjectAttributes (&ObjectAttributes, &Name, OBJ_CASE_INSENSITIVE, NULL, NULL); if (Delete || (Flags & FLG_ADDREG_OVERWRITEONLY)) { Status = NtOpenKey (&KeyHandle, KEY_ALL_ACCESS, &ObjectAttributes); if (!NT_SUCCESS(Status)) { DPRINT("NtOpenKey(%wZ) failed (Status %lx)\n", &Name, Status); continue; /* ignore if it doesn't exist */ } } else { Status = CreateNestedKey (&KeyHandle, KEY_ALL_ACCESS, &ObjectAttributes); if (!NT_SUCCESS(Status)) { DPRINT("CreateNestedKey(%wZ) failed (Status %lx)\n", &Name, Status); continue; } } #else if (Delete || (Flags & FLG_ADDREG_OVERWRITEONLY)) { LONG rc = RegOpenKeyW(NULL, Buffer, &KeyHandle); if (rc != ERROR_SUCCESS) { DPRINT("RegOpenKeyW(%S) failed (error %lu)\n", Buffer, rc); continue; /* ignore if it doesn't exist */ } } else { LONG rc = RegCreateKeyW(NULL, Buffer, &KeyHandle); if (rc != ERROR_SUCCESS) { DPRINT("RegCreateKeyW(%S) failed (error %lu)\n", Buffer, rc); continue; } } #endif /* get value name */ if (SetupGetStringFieldW (&Context, 3, Buffer, MAX_INF_STRING_LENGTH, NULL)) { RtlInitUnicodeString (&Value, Buffer); ValuePtr = &Value; } else { ValuePtr = NULL; } /* and now do it */ if (!do_reg_operation (KeyHandle, ValuePtr, &Context, Flags)) { NtClose (KeyHandle); return FALSE; } #ifdef __ODYSSEY__ NtClose (KeyHandle); #endif } } return TRUE; }