ReactOS 0.4.16-dev-197-g92996da
Classes | Typedefs | Functions | Variables
install.c File Reference
#include "setupapi_private.h"
#include <winsvc.h>
#include <ndk/cmfuncs.h>
Include dependency graph for install.c:

Go to the source code of this file.

Classes

struct  files_callback_info
 
struct  registry_callback_info
 
struct  register_dll_info
 
struct  needs_callback_info
 

Typedefs

typedef BOOL(* iterate_fields_func) (HINF hinf, PCWSTR field, void *arg)
 
typedef HRESULT(WINAPI * COINITIALIZE) (IN LPVOID pvReserved)
 
typedef HRESULT(WINAPI * COCREATEINSTANCE) (IN REFCLSID rclsid, IN LPUNKNOWN pUnkOuter, IN DWORD dwClsContext, IN REFIID riid, OUT LPVOID *ppv)
 
typedef HRESULT(WINAPI * COUNINITIALIZE) (VOID)
 

Functions

static BOOL GetLineText (HINF hinf, PCWSTR section_name, PCWSTR key_name, PWSTR *value)
 
static WCHAR * get_field_string (INFCONTEXT *context, DWORD index, WCHAR *buffer, WCHAR *static_buffer, DWORD *size)
 
static BOOL copy_files_callback (HINF hinf, PCWSTR field, void *arg)
 
static BOOL delete_files_callback (HINF hinf, PCWSTR field, void *arg)
 
static BOOL rename_files_callback (HINF hinf, PCWSTR field, void *arg)
 
static HKEY get_root_key (const WCHAR *name, HKEY def_root)
 
static void append_multi_sz_value (HKEY hkey, const WCHAR *value, const WCHAR *strings, DWORD str_size)
 
static void delete_multi_sz_value (HKEY hkey, const WCHAR *value, const WCHAR *string)
 
static BOOL do_reg_operation (HKEY hkey, const WCHAR *value, INFCONTEXT *context, INT flags)
 
static BOOL registry_callback (HINF hinf, PCWSTR field, void *arg)
 
static BOOL do_register_dll (const struct register_dll_info *info, const WCHAR *path, INT flags, INT timeout, const WCHAR *args)
 
static BOOL register_dlls_callback (HINF hinf, PCWSTR field, void *arg)
 
static BOOL update_ini_callback (HINF hinf, PCWSTR field, void *arg)
 
static BOOL update_ini_fields_callback (HINF hinf, PCWSTR field, void *arg)
 
static BOOL ini2reg_callback (HINF hinf, PCWSTR field, void *arg)
 
static BOOL logconf_callback (HINF hinf, PCWSTR field, void *arg)
 
static BOOL bitreg_callback (HINF hinf, PCWSTR field, void *arg)
 
static BOOL Concatenate (int DirId, LPCWSTR SubDirPart, LPCWSTR NamePart, LPWSTR *pFullName)
 
static BOOL profile_items_callback (IN HINF hInf, IN PCWSTR SectionName, IN PVOID Arg)
 
static BOOL copy_inf_callback (HINF hinf, PCWSTR field, void *arg)
 
static BOOL iterate_section_fields (HINF hinf, PCWSTR section, PCWSTR key, iterate_fields_func callback, void *arg)
 
BOOL WINAPI SetupInstallFilesFromInfSectionA (HINF hinf, HINF hlayout, HSPFILEQ queue, PCSTR section, PCSTR src_root, UINT flags)
 
BOOL WINAPI SetupInstallFilesFromInfSectionW (HINF hinf, HINF hlayout, HSPFILEQ queue, PCWSTR section, PCWSTR src_root, UINT flags)
 
BOOL WINAPI SetupInstallFromInfSectionA (HWND owner, HINF hinf, PCSTR section, UINT flags, HKEY key_root, PCSTR src_root, UINT copy_flags, PSP_FILE_CALLBACK_A callback, PVOID context, HDEVINFO devinfo, PSP_DEVINFO_DATA devinfo_data)
 
static BOOL include_callback (HINF hinf, PCWSTR field, void *arg)
 
static BOOL needs_callback (HINF hinf, PCWSTR field, void *arg)
 
BOOL WINAPI SetupInstallFromInfSectionW (HWND owner, HINF hinf, PCWSTR section, UINT flags, HKEY key_root, PCWSTR src_root, UINT copy_flags, PSP_FILE_CALLBACK_W callback, PVOID context, HDEVINFO devinfo, PSP_DEVINFO_DATA devinfo_data)
 
void WINAPI InstallHinfSectionW (HWND hwnd, HINSTANCE handle, LPCWSTR cmdline, INT show)
 
void WINAPI InstallHinfSectionA (HWND hwnd, HINSTANCE handle, LPCSTR cmdline, INT show)
 
BOOL WINAPI SetupInstallServicesFromInfSectionW (HINF Inf, PCWSTR SectionName, DWORD Flags)
 
BOOL WINAPI SetupInstallServicesFromInfSectionA (HINF Inf, PCSTR SectionName, DWORD Flags)
 
BOOL WINAPI SetupInstallServicesFromInfSectionExA (HINF hinf, PCSTR sectionname, DWORD flags, HDEVINFO devinfo, PSP_DEVINFO_DATA devinfo_data, PVOID reserved1, PVOID reserved2)
 
static BOOL GetIntField (HINF hinf, PCWSTR section_name, PCWSTR key_name, INT *value)
 
BOOL GetStringField (PINFCONTEXT context, DWORD index, PWSTR *value)
 
static VOID FixupServiceBinaryPath (IN DWORD ServiceType, IN OUT LPWSTR *ServiceBinary)
 
static BOOL InstallOneService (struct DeviceInfoSet *list, IN HINF hInf, IN LPCWSTR ServiceSection, IN LPCWSTR ServiceName, IN UINT ServiceFlags)
 
BOOL WINAPI SetupInstallServicesFromInfSectionExW (HINF hinf, PCWSTR sectionname, DWORD flags, HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, PVOID reserved1, PVOID reserved2)
 
BOOL WINAPI SetupCopyOEMInfA (IN PCSTR SourceInfFileName, IN PCSTR OEMSourceMediaLocation, IN DWORD OEMSourceMediaType, IN DWORD CopyStyle, OUT PSTR DestinationInfFileName OPTIONAL, IN DWORD DestinationInfFileNameSize, OUT PDWORD RequiredSize OPTIONAL, OUT PSTR *DestinationInfFileNameComponent OPTIONAL)
 
static int compare_files (HANDLE file1, HANDLE file2)
 
BOOL WINAPI SetupCopyOEMInfW (IN PCWSTR SourceInfFileName, IN PCWSTR OEMSourceMediaLocation, IN DWORD OEMSourceMediaType, IN DWORD CopyStyle, OUT PWSTR DestinationInfFileName OPTIONAL, IN DWORD DestinationInfFileNameSize, OUT PDWORD RequiredSize OPTIONAL, OUT PWSTR *DestinationInfFileNameComponent OPTIONAL)
 

Variables

static const WCHAR BackSlash [] = {'\\',0}
 
static const WCHAR GroupOrderListKey [] = {'S','Y','S','T','E','M','\\','C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\','C','o','n','t','r','o','l','\\','G','r','o','u','p','O','r','d','e','r','L','i','s','t',0}
 
static const WCHAR InfDirectory [] = {'i','n','f','\\',0}
 
static const WCHAR OemFileMask [] = {'o','e','m','*','.','i','n','f',0}
 
static const WCHAR OemFileSpecification [] = {'o','e','m','%','l','u','.','i','n','f',0}
 
static const WCHAR DotLnk [] = {'.','l','n','k',0}
 
static const WCHAR DotServices [] = {'.','S','e','r','v','i','c','e','s',0}
 
static const WCHAR DependenciesKey [] = {'D','e','p','e','n','d','e','n','c','i','e','s',0}
 
static const WCHAR DescriptionKey [] = {'D','e','s','c','r','i','p','t','i','o','n',0}
 
static const WCHAR DisplayNameKey [] = {'D','i','s','p','l','a','y','N','a','m','e',0}
 
static const WCHAR ErrorControlKey [] = {'E','r','r','o','r','C','o','n','t','r','o','l',0}
 
static const WCHAR LoadOrderGroupKey [] = {'L','o','a','d','O','r','d','e','r','G','r','o','u','p',0}
 
static const WCHAR SecurityKey [] = {'S','e','c','u','r','i','t','y',0}
 
static const WCHAR ServiceBinaryKey [] = {'S','e','r','v','i','c','e','B','i','n','a','r','y',0}
 
static const WCHAR ServiceTypeKey [] = {'S','e','r','v','i','c','e','T','y','p','e',0}
 
static const WCHAR StartTypeKey [] = {'S','t','a','r','t','T','y','p','e',0}
 
static const WCHAR StartNameKey [] = {'S','t','a','r','t','N','a','m','e',0}
 
static const WCHAR Name [] = {'N','a','m','e',0}
 
static const WCHAR CmdLine [] = {'C','m','d','L','i','n','e',0}
 
static const WCHAR SubDir [] = {'S','u','b','D','i','r',0}
 
static const WCHAR WorkingDir [] = {'W','o','r','k','i','n','g','D','i','r',0}
 
static const WCHAR IconPath [] = {'I','c','o','n','P','a','t','h',0}
 
static const WCHAR IconIndex [] = {'I','c','o','n','I','n','d','e','x',0}
 
static const WCHAR HotKey [] = {'H','o','t','K','e','y',0}
 
static const WCHAR InfoTip [] = {'I','n','f','o','T','i','p',0}
 
static const WCHAR DisplayResource [] = {'D','i','s','p','l','a','y','R','e','s','o','u','r','c','e',0}
 
static const WCHAR AddService [] = {'A','d','d','S','e','r','v','i','c','e',0}
 
static const WCHAR CopyFiles [] = {'C','o','p','y','F','i','l','e','s',0}
 
static const WCHAR DelFiles [] = {'D','e','l','F','i','l','e','s',0}
 
static const WCHAR RenFiles [] = {'R','e','n','F','i','l','e','s',0}
 
static const WCHAR Ini2Reg [] = {'I','n','i','2','R','e','g',0}
 
static const WCHAR LogConf [] = {'L','o','g','C','o','n','f',0}
 
static const WCHAR AddReg [] = {'A','d','d','R','e','g',0}
 
static const WCHAR DelReg [] = {'D','e','l','R','e','g',0}
 
static const WCHAR BitReg [] = {'B','i','t','R','e','g',0}
 
static const WCHAR UpdateInis [] = {'U','p','d','a','t','e','I','n','i','s',0}
 
static const WCHAR CopyINF [] = {'C','o','p','y','I','N','F',0}
 
static const WCHAR UpdateIniFields [] = {'U','p','d','a','t','e','I','n','i','F','i','e','l','d','s',0}
 
static const WCHAR RegisterDlls [] = {'R','e','g','i','s','t','e','r','D','l','l','s',0}
 
static const WCHAR UnregisterDlls [] = {'U','n','r','e','g','i','s','t','e','r','D','l','l','s',0}
 
static const WCHAR ProfileItems [] = {'P','r','o','f','i','l','e','I','t','e','m','s',0}
 
static const WCHAR Include [] = {'I','n','c','l','u','d','e',0}
 
static const WCHAR Needs [] = {'N','e','e','d','s',0}
 
static const WCHAR DotSecurity [] = {'.','S','e','c','u','r','i','t','y',0}
 

Typedef Documentation

◆ COCREATEINSTANCE

typedef HRESULT(WINAPI * COCREATEINSTANCE) (IN REFCLSID rclsid, IN LPUNKNOWN pUnkOuter, IN DWORD dwClsContext, IN REFIID riid, OUT LPVOID *ppv)

Definition at line 102 of file install.c.

◆ COINITIALIZE

typedef HRESULT(WINAPI * COINITIALIZE) (IN LPVOID pvReserved)

Definition at line 101 of file install.c.

◆ COUNINITIALIZE

typedef HRESULT(WINAPI * COUNINITIALIZE) (VOID)

Definition at line 103 of file install.c.

◆ iterate_fields_func

typedef BOOL(* iterate_fields_func) (HINF hinf, PCWSTR field, void *arg)

Definition at line 99 of file install.c.

Function Documentation

◆ append_multi_sz_value()

static void append_multi_sz_value ( HKEY  hkey,
const WCHAR *  value,
const WCHAR *  strings,
DWORD  str_size 
)
static

Definition at line 223 of file install.c.

225{
226 DWORD size, type, total;
227 WCHAR *buffer, *p;
228
229 if (RegQueryValueExW( hkey, value, NULL, &type, NULL, &size )) return;
230 if (type != REG_MULTI_SZ) return;
231
232 size = size + str_size * sizeof(WCHAR) ;
233 if (!(buffer = HeapAlloc( GetProcessHeap(), 0, size))) return;
234 if (RegQueryValueExW( hkey, value, NULL, NULL, (BYTE *)buffer, &size )) goto done;
235
236 /* compare each string against all the existing ones */
237 total = size;
238 while (*strings)
239 {
240 int len = strlenW(strings) + 1;
241
242 for (p = buffer; *p; p += strlenW(p) + 1)
243 if (!strcmpiW( p, strings )) break;
244
245 if (!*p) /* not found, need to append it */
246 {
247 memcpy( p, strings, len * sizeof(WCHAR) );
248 p[len] = 0;
249 total += len * sizeof(WCHAR);
250 }
251 strings += len;
252 }
253 if (total != size)
254 {
255 TRACE( "setting value %s to %s\n", debugstr_w(value), debugstr_w(buffer) );
256 RegSetValueExW( hkey, value, 0, REG_MULTI_SZ, (BYTE *)buffer, total + sizeof(WCHAR) );
257 }
258 done:
259 HeapFree( GetProcessHeap(), 0, buffer );
260}
NULL
#define NULL
Definition: types.h:112
RegSetValueExW
LONG WINAPI RegSetValueExW(_In_ HKEY hKey, _In_ LPCWSTR lpValueName, _In_ DWORD Reserved, _In_ DWORD dwType, _In_ CONST BYTE *lpData, _In_ DWORD cbData)
Definition: reg.c:4882
RegQueryValueExW
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4103
GetProcessHeap
#define GetProcessHeap()
Definition: compat.h:736
HeapAlloc
#define HeapAlloc
Definition: compat.h:733
HeapFree
#define HeapFree(x, y, z)
Definition: compat.h:735
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
total
size_t total
Definition: fxusbpipeapi.cpp:306
type
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
size
GLsizeiptr size
Definition: glext.h:5919
strings
GLsizei const GLchar *const * strings
Definition: glext.h:7622
buffer
GLuint buffer
Definition: glext.h:5915
p
GLfloat GLfloat p
Definition: glext.h:8902
len
GLenum GLsizei len
Definition: glext.h:6722
debugstr_w
#define debugstr_w
Definition: kernel32.h:32
memcpy
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
REG_MULTI_SZ
#define REG_MULTI_SZ
Definition: nt_native.h:1501
strcmpiW
#define strcmpiW(s1, s2)
Definition: unicode.h:45
strlenW
#define strlenW(s)
Definition: unicode.h:34
TRACE
#define TRACE(s)
Definition: solgame.cpp:4
value
Definition: pdh_main.c:94
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180
BYTE
unsigned char BYTE
Definition: xxhash.c:193

Referenced by do_reg_operation().

◆ bitreg_callback()

static BOOL bitreg_callback ( HINF  hinf,
PCWSTR  field,
void *  arg 
)
static

Definition at line 833 of file install.c.

834{
835 FIXME( "should do bitreg %s\n", debugstr_w(field) );
836 return TRUE;
837}
FIXME
#define FIXME(fmt,...)
Definition: precomp.h:53
TRUE
#define TRUE
Definition: types.h:120
field
Definition: parser.c:44

Referenced by SetupInstallFromInfSectionW().

◆ compare_files()

static int compare_files ( HANDLE  file1,
HANDLE  file2 
)
static

Definition at line 2282 of file install.c.

2283{
2284 char buffer1[2048];
2285 char buffer2[2048];
2286 DWORD size1;
2287 DWORD size2;
2288
2289 while( ReadFile(file1, buffer1, sizeof(buffer1), &size1, NULL) &&
2290 ReadFile(file2, buffer2, sizeof(buffer2), &size2, NULL) )
2291 {
2292 int ret;
2293 if (size1 != size2)
2294 return size1 > size2 ? 1 : -1;
2295 if (!size1)
2296 return 0;
2297 ret = memcmp( buffer1, buffer2, size1 );
2298 if (ret)
2299 return ret;
2300 }
2301
2302 return 0;
2303}
memcmp
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
ReadFile
#define ReadFile(a, b, c, d, e)
Definition: compat.h:742
ret
int ret
Definition: wcstombs-tests.c:31

Referenced by find_hash(), and SetupCopyOEMInfW().

◆ Concatenate()

static BOOL Concatenate ( int  DirId,
LPCWSTR  SubDirPart,
LPCWSTR  NamePart,
LPWSTR *  pFullName 
)
static

Definition at line 839 of file install.c.

840{
841 DWORD dwRequired = 0;
842 LPCWSTR Dir;
843 LPWSTR FullName;
844
845 *pFullName = NULL;
846
847 Dir = DIRID_get_string(DirId);
848 if (Dir && *Dir)
849 dwRequired += wcslen(Dir) + 1;
850 else
851 Dir = NULL; /* DIRID_get_string returns L"" for DIRID_ABSOLUTE */
852 if (SubDirPart)
853 dwRequired += wcslen(SubDirPart) + 1;
854 if (NamePart)
855 dwRequired += wcslen(NamePart);
856 dwRequired = dwRequired * sizeof(WCHAR) + sizeof(UNICODE_NULL);
857
858 FullName = MyMalloc(dwRequired);
859 if (!FullName)
860 {
861 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
862 return FALSE;
863 }
864 FullName[0] = UNICODE_NULL;
865
866 if (Dir)
867 {
868 wcscat(FullName, Dir);
869 if (FullName[wcslen(FullName) - 1] != '\\')
870 wcscat(FullName, BackSlash);
871 }
872 if (SubDirPart)
873 {
874 wcscat(FullName, SubDirPart);
875 if (FullName[wcslen(FullName) - 1] != '\\')
876 wcscat(FullName, BackSlash);
877 }
878 if (NamePart)
879 wcscat(FullName, NamePart);
880
881 *pFullName = FullName;
882 return TRUE;
883}
ERROR_NOT_ENOUGH_MEMORY
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
DIRID_get_string
const WCHAR * DIRID_get_string(int dirid)
Definition: dirid.c:159
FALSE
#define FALSE
Definition: types.h:117
SetLastError
#define SetLastError(x)
Definition: compat.h:752
BackSlash
static const WCHAR BackSlash[]
Definition: install.c:28
MyMalloc
LPVOID WINAPI MyMalloc(DWORD dwSize)
Definition: misc.c:147
wcslen
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
UNICODE_NULL
#define UNICODE_NULL
wcscat
_CRTIMP wchar_t *__cdecl wcscat(_Inout_updates_z_(_String_length_(_Dest)+_String_length_(_Source)+1) wchar_t *_Dest, _In_z_ const wchar_t *_Source)
FullName
_In_ PSTRING FullName
Definition: rtlfuncs.h:1662
LPWSTR
WCHAR * LPWSTR
Definition: xmlstorage.h:184
LPCWSTR
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185

Referenced by profile_items_callback().

◆ copy_files_callback()

static BOOL copy_files_callback ( HINF  hinf,
PCWSTR  field,
void *  arg 
)
static

Definition at line 158 of file install.c.

159{
160 struct files_callback_info *info = arg;
161
162 if (field[0] == '@') /* special case: copy single file */
163 SetupQueueDefaultCopyW( info->queue, info->layout ? info->layout : hinf, info->src_root, NULL, field+1, info->copy_flags );
164 else
165 SetupQueueCopySectionW( info->queue, info->src_root, info->layout ? info->layout : hinf, hinf, field, info->copy_flags );
166 return TRUE;
167}
SetupQueueDefaultCopyW
BOOL WINAPI SetupQueueDefaultCopyW(HSPFILEQ queue, HINF hinf, PCWSTR src_root, PCWSTR src_file, PCWSTR dst_file, DWORD style)
Definition: queue.c:623
SetupQueueCopySectionW
BOOL WINAPI SetupQueueCopySectionW(HSPFILEQ queue, PCWSTR src_root, HINF hinf, HINF hlist, PCWSTR section, DWORD style)
Definition: queue.c:772
files_callback_info
Definition: install.c:59
arg
void * arg
Definition: msvc.h:10

Referenced by SetupInstallFilesFromInfSectionW(), and SetupInstallFromInfSectionW().

◆ copy_inf_callback()

static BOOL copy_inf_callback ( HINF  hinf,
PCWSTR  field,
void *  arg 
)
static

Definition at line 1162 of file install.c.

1163{
1164 FIXME( "should do copy inf %s\n", debugstr_w(field) );
1165 return TRUE;
1166}

Referenced by SetupInstallFromInfSectionW().

◆ delete_files_callback()

static BOOL delete_files_callback ( HINF  hinf,
PCWSTR  field,
void *  arg 
)
static

Definition at line 175 of file install.c.

176{
177 struct files_callback_info *info = arg;
178 SetupQueueDeleteSectionW( info->queue, hinf, 0, field );
179 return TRUE;
180}
SetupQueueDeleteSectionW
BOOL WINAPI SetupQueueDeleteSectionW(HSPFILEQ queue, HINF hinf, HINF hlist, PCWSTR section)
Definition: queue.c:870

Referenced by SetupInstallFromInfSectionW().

◆ delete_multi_sz_value()

static void delete_multi_sz_value ( HKEY  hkey,
const WCHAR *  value,
const WCHAR *  string 
)
static

Definition at line 268 of file install.c.

269{
270 DWORD size, type;
271 WCHAR *buffer, *src, *dst;
272
273 if (RegQueryValueExW( hkey, value, NULL, &type, NULL, &size )) return;
274 if (type != REG_MULTI_SZ) return;
275 /* allocate double the size, one for value before and one for after */
276 if (!(buffer = HeapAlloc( GetProcessHeap(), 0, size * 2))) return;
277 if (RegQueryValueExW( hkey, value, NULL, NULL, (BYTE *)buffer, &size )) goto done;
278 src = buffer;
279 dst = buffer + size;
280 while (*src)
281 {
282 int len = strlenW(src) + 1;
283 if (strcmpiW( src, string ))
284 {
285 memcpy( dst, src, len * sizeof(WCHAR) );
286 dst += len;
287 }
288 src += len;
289 }
290 *dst++ = 0;
291 if (dst != buffer + 2*size) /* did we remove something? */
292 {
293 TRACE( "setting value %s to %s\n", debugstr_w(value), debugstr_w(buffer + size) );
294 RegSetValueExW( hkey, value, 0, REG_MULTI_SZ,
295 (BYTE *)(buffer + size), dst - (buffer + size) );
296 }
297 done:
298 HeapFree( GetProcessHeap(), 0, buffer );
299}
src
GLenum src
Definition: glext.h:6340
dst
GLenum GLenum dst
Definition: glext.h:6340

Referenced by do_reg_operation().

◆ do_reg_operation()

static BOOL do_reg_operation ( HKEY  hkey,
const WCHAR *  value,
INFCONTEXT *  context,
INT  flags 
)
static

Definition at line 307 of file install.c.

308{
309 DWORD type, size;
310
311 if (flags & (FLG_ADDREG_DELREG_BIT | FLG_ADDREG_DELVAL)) /* deletion */
312 {
313 if (*value && !(flags & FLG_DELREG_KEYONLY_COMMON))
314 {
315 if ((flags & FLG_DELREG_MULTI_SZ_DELSTRING) == FLG_DELREG_MULTI_SZ_DELSTRING)
316 {
317 WCHAR *str;
318
319 if (!SetupGetStringFieldW( context, 5, NULL, 0, &size ) || !size) return TRUE;
320 if (!(str = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) ))) return FALSE;
321 SetupGetStringFieldW( context, 5, str, size, NULL );
322 delete_multi_sz_value( hkey, value, str );
323 HeapFree( GetProcessHeap(), 0, str );
324 }
325 else RegDeleteValueW( hkey, value );
326 }
327 else NtDeleteKey( hkey );
328 return TRUE;
329 }
330
331 if (flags & (FLG_ADDREG_KEYONLY|FLG_ADDREG_KEYONLY_COMMON)) return TRUE;
332
333 if (flags & (FLG_ADDREG_NOCLOBBER|FLG_ADDREG_OVERWRITEONLY))
334 {
335 BOOL exists = !RegQueryValueExW( hkey, value, NULL, NULL, NULL, NULL );
336 if (exists && (flags & FLG_ADDREG_NOCLOBBER)) return TRUE;
337 if (!exists && (flags & FLG_ADDREG_OVERWRITEONLY)) return TRUE;
338 }
339
340 switch(flags & FLG_ADDREG_TYPE_MASK)
341 {
342 case FLG_ADDREG_TYPE_SZ: type = REG_SZ; break;
343 case FLG_ADDREG_TYPE_MULTI_SZ: type = REG_MULTI_SZ; break;
344 case FLG_ADDREG_TYPE_EXPAND_SZ: type = REG_EXPAND_SZ; break;
345 case FLG_ADDREG_TYPE_BINARY: type = REG_BINARY; break;
346 case FLG_ADDREG_TYPE_DWORD: type = REG_DWORD; break;
347 case FLG_ADDREG_TYPE_NONE: type = REG_NONE; break;
348 default: type = flags >> 16; break;
349 }
350
351 if (!(flags & FLG_ADDREG_BINVALUETYPE) ||
352 (type == REG_DWORD && SetupGetFieldCount(context) == 5))
353 {
354 static const WCHAR empty;
355 WCHAR *str = NULL;
356
357 if (type == REG_MULTI_SZ)
358 {
359 if (!SetupGetMultiSzFieldW( context, 5, NULL, 0, &size )) size = 0;
360 if (size)
361 {
362 if (!(str = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) ))) return FALSE;
363 SetupGetMultiSzFieldW( context, 5, str, size, NULL );
364 }
365 if (flags & FLG_ADDREG_APPEND)
366 {
367 if (!str) return TRUE;
368 append_multi_sz_value( hkey, value, str, size );
369 HeapFree( GetProcessHeap(), 0, str );
370 return TRUE;
371 }
372 /* else fall through to normal string handling */
373 }
374 else
375 {
376 if (!SetupGetStringFieldW( context, 5, NULL, 0, &size )) size = 0;
377 if (size)
378 {
379 if (!(str = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) ))) return FALSE;
380 SetupGetStringFieldW( context, 5, str, size, NULL );
381 }
382 }
383
384 if (type == REG_DWORD)
385 {
386 DWORD dw = str ? strtoulW( str, NULL, 0 ) : 0;
387 TRACE( "setting dword %s to %x\n", debugstr_w(value), dw );
388 RegSetValueExW( hkey, value, 0, type, (BYTE *)&dw, sizeof(dw) );
389 }
390 else
391 {
392 TRACE( "setting value %s to %s\n", debugstr_w(value), debugstr_w(str) );
393 if (str) RegSetValueExW( hkey, value, 0, type, (BYTE *)str, size * sizeof(WCHAR) );
394 else RegSetValueExW( hkey, value, 0, type, (const BYTE *)&empty, sizeof(WCHAR) );
395 }
396 HeapFree( GetProcessHeap(), 0, str );
397 return TRUE;
398 }
399 else /* get the binary data */
400 {
401 BYTE *data = NULL;
402
403 if (!SetupGetBinaryField( context, 5, NULL, 0, &size )) size = 0;
404 if (size)
405 {
406 if (!(data = HeapAlloc( GetProcessHeap(), 0, size ))) return FALSE;
407 TRACE( "setting binary data %s len %d\n", debugstr_w(value), size );
408 SetupGetBinaryField( context, 5, data, size, NULL );
409 }
410 RegSetValueExW( hkey, value, 0, type, data, size );
411 HeapFree( GetProcessHeap(), 0, data );
412 return TRUE;
413 }
414}
FLG_ADDREG_OVERWRITEONLY
#define FLG_ADDREG_OVERWRITEONLY
Definition: registry.c:48
FLG_ADDREG_TYPE_MASK
#define FLG_ADDREG_TYPE_MASK
Definition: registry.c:55
FLG_ADDREG_TYPE_BINARY
#define FLG_ADDREG_TYPE_BINARY
Definition: registry.c:52
FLG_ADDREG_TYPE_SZ
#define FLG_ADDREG_TYPE_SZ
Definition: registry.c:49
FLG_ADDREG_BINVALUETYPE
#define FLG_ADDREG_BINVALUETYPE
Definition: registry.c:43
FLG_ADDREG_APPEND
#define FLG_ADDREG_APPEND
Definition: registry.c:46
FLG_ADDREG_TYPE_EXPAND_SZ
#define FLG_ADDREG_TYPE_EXPAND_SZ
Definition: registry.c:51
FLG_ADDREG_DELVAL
#define FLG_ADDREG_DELVAL
Definition: registry.c:45
FLG_ADDREG_TYPE_MULTI_SZ
#define FLG_ADDREG_TYPE_MULTI_SZ
Definition: registry.c:50
FLG_ADDREG_TYPE_NONE
#define FLG_ADDREG_TYPE_NONE
Definition: registry.c:54
FLG_ADDREG_KEYONLY
#define FLG_ADDREG_KEYONLY
Definition: registry.c:47
FLG_ADDREG_NOCLOBBER
#define FLG_ADDREG_NOCLOBBER
Definition: registry.c:44
FLG_ADDREG_TYPE_DWORD
#define FLG_ADDREG_TYPE_DWORD
Definition: registry.c:53
RegDeleteValueW
LONG WINAPI RegDeleteValueW(HKEY hKey, LPCWSTR lpValueName)
Definition: reg.c:2330
empty
static const WCHAR empty[]
Definition: main.c:47
append_multi_sz_value
static void append_multi_sz_value(HKEY hkey, const WCHAR *value, const WCHAR *strings, DWORD str_size)
Definition: install.c:223
delete_multi_sz_value
static void delete_multi_sz_value(HKEY hkey, const WCHAR *value, const WCHAR *string)
Definition: install.c:268
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
data
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
flags
GLbitfield flags
Definition: glext.h:7161
dw
REFIID LPVOID DWORD_PTR dw
Definition: atlbase.h:40
REG_SZ
#define REG_SZ
Definition: layer.c:22
REG_BINARY
#define REG_BINARY
Definition: nt_native.h:1496
REG_NONE
#define REG_NONE
Definition: nt_native.h:1492
REG_EXPAND_SZ
#define REG_EXPAND_SZ
Definition: nt_native.h:1494
NtDeleteKey
NTSTATUS NTAPI NtDeleteKey(IN HANDLE KeyHandle)
Definition: ntapi.c:408
strtoulW
#define strtoulW(s1, s2, b)
Definition: unicode.h:47
FLG_ADDREG_DELREG_BIT
#define FLG_ADDREG_DELREG_BIT
Definition: reginf.c:45
FLG_DELREG_KEYONLY_COMMON
#define FLG_DELREG_KEYONLY_COMMON
Definition: reginf.c:44
FLG_ADDREG_KEYONLY_COMMON
#define FLG_ADDREG_KEYONLY_COMMON
Definition: reginf.c:43
str
const WCHAR * str
Definition: rpc_transport.c:2724
REG_DWORD
#define REG_DWORD
Definition: sdbapi.c:596
context
Definition: http.c:7252
SetupGetStringFieldW
BOOL WINAPI SetupGetStringFieldW(IN PINFCONTEXT Context, IN ULONG FieldIndex, OUT PWSTR ReturnBuffer, IN ULONG ReturnBufferSize, OUT PULONG RequiredSize)
Definition: infsupp.c:186
SetupGetMultiSzFieldW
BOOL WINAPI SetupGetMultiSzFieldW(IN PINFCONTEXT Context, IN ULONG FieldIndex, OUT PWSTR ReturnBuffer, IN ULONG ReturnBufferSize, OUT PULONG RequiredSize)
Definition: infsupp.c:164
SetupGetFieldCount
ULONG WINAPI SetupGetFieldCount(IN PINFCONTEXT Context)
Definition: infsupp.c:93
SetupGetBinaryField
BOOL WINAPI SetupGetBinaryField(IN PINFCONTEXT Context, IN ULONG FieldIndex, OUT PUCHAR ReturnBuffer, IN ULONG ReturnBufferSize, OUT PULONG RequiredSize)
Definition: infsupp.c:128

Referenced by registry_callback().

◆ do_register_dll()

static BOOL do_register_dll ( const struct register_dll_info *  info,
const WCHAR *  path,
INT  flags,
INT  timeout,
const WCHAR *  args 
)
static

Definition at line 530 of file install.c.

532{
533 HMODULE module;
534 HRESULT res;
535 SP_REGISTER_CONTROL_STATUSW status;
536 IMAGE_NT_HEADERS *nt;
537
538 status.cbSize = sizeof(status);
539 status.FileName = path;
540 status.FailureCode = SPREG_SUCCESS;
541 status.Win32Error = ERROR_SUCCESS;
542
543 if (info->callback)
544 {
545 switch(info->callback( info->callback_context, SPFILENOTIFY_STARTREGISTRATION,
546 (UINT_PTR)&status, !info->unregister ))
547 {
548 case FILEOP_ABORT:
549 SetLastError( ERROR_OPERATION_ABORTED );
550 return FALSE;
551 case FILEOP_SKIP:
552 return TRUE;
553 case FILEOP_DOIT:
554 break;
555 }
556 }
557
558 if (!(module = LoadLibraryExW( path, 0, LOAD_WITH_ALTERED_SEARCH_PATH )))
559 {
560 WARN( "could not load %s\n", debugstr_w(path) );
561 status.FailureCode = SPREG_LOADLIBRARY;
562 status.Win32Error = GetLastError();
563 goto done;
564 }
565
566 if ((nt = RtlImageNtHeader( module )) && !(nt->FileHeader.Characteristics & IMAGE_FILE_DLL))
567 {
568 /* file is an executable, not a dll */
569 STARTUPINFOW startup;
570 PROCESS_INFORMATION info;
571 WCHAR *cmd_line;
572 BOOL res;
573 static const WCHAR format[] = {'"','%','s','"',' ','%','s',0};
574 static const WCHAR default_args[] = {'/','R','e','g','S','e','r','v','e','r',0};
575
576 FreeLibrary( module );
577 module = NULL;
578 if (!args) args = default_args;
579 cmd_line = HeapAlloc( GetProcessHeap(), 0, (strlenW(path) + strlenW(args) + 4) * sizeof(WCHAR) );
580 sprintfW( cmd_line, format, path, args );
581 memset( &startup, 0, sizeof(startup) );
582 startup.cb = sizeof(startup);
583 TRACE( "executing %s\n", debugstr_w(cmd_line) );
584 res = CreateProcessW( NULL, cmd_line, NULL, NULL, FALSE, 0, NULL, NULL, &startup, &info );
585 HeapFree( GetProcessHeap(), 0, cmd_line );
586 if (!res)
587 {
588 status.FailureCode = SPREG_LOADLIBRARY;
589 status.Win32Error = GetLastError();
590 goto done;
591 }
592 CloseHandle( info.hThread );
593
594 if (WaitForSingleObject( info.hProcess, timeout*1000 ) == WAIT_TIMEOUT)
595 {
596 /* timed out, kill the process */
597 TerminateProcess( info.hProcess, 1 );
598 status.FailureCode = SPREG_TIMEOUT;
599 status.Win32Error = ERROR_TIMEOUT;
600 }
601 CloseHandle( info.hProcess );
602 goto done;
603 }
604
605 if (flags & FLG_REGSVR_DLLREGISTER)
606 {
607 const char *entry_point = info->unregister ? "DllUnregisterServer" : "DllRegisterServer";
608 HRESULT (WINAPI *func)(void) = (void *)GetProcAddress( module, entry_point );
609
610 if (!func)
611 {
612 status.FailureCode = SPREG_GETPROCADDR;
613 status.Win32Error = GetLastError();
614 goto done;
615 }
616
617 TRACE( "calling %s in %s\n", entry_point, debugstr_w(path) );
618 res = func();
619
620 if (FAILED(res))
621 {
622 WARN( "calling %s in %s returned error %x\n", entry_point, debugstr_w(path), res );
623 status.FailureCode = SPREG_REGSVR;
624 status.Win32Error = res;
625 goto done;
626 }
627 }
628
629 if (flags & FLG_REGSVR_DLLINSTALL)
630 {
631 HRESULT (WINAPI *func)(BOOL,LPCWSTR) = (void *)GetProcAddress( module, "DllInstall" );
632
633 if (!func)
634 {
635 status.FailureCode = SPREG_GETPROCADDR;
636 status.Win32Error = GetLastError();
637 goto done;
638 }
639
640 TRACE( "calling DllInstall(%d,%s) in %s\n",
641 !info->unregister, debugstr_w(args), debugstr_w(path) );
642 res = func( !info->unregister, args );
643
644 if (FAILED(res))
645 {
646 WARN( "calling DllInstall in %s returned error %x\n", debugstr_w(path), res );
647 status.FailureCode = SPREG_REGSVR;
648 status.Win32Error = res;
649 goto done;
650 }
651 }
652
653done:
654 if (module) FreeLibrary( module );
655 if (info->callback) info->callback( info->callback_context, SPFILENOTIFY_ENDREGISTRATION,
656 (UINT_PTR)&status, !info->unregister );
657 return TRUE;
658}
startup
static void startup(void)
Definition: adnsresfilter.c:392
WARN
#define WARN(fmt,...)
Definition: precomp.h:61
WAIT_TIMEOUT
#define WAIT_TIMEOUT
Definition: dderror.h:14
ERROR_SUCCESS
#define ERROR_SUCCESS
Definition: deptool.c:10
CloseHandle
#define CloseHandle
Definition: compat.h:739
GetProcAddress
#define GetProcAddress(x, y)
Definition: compat.h:753
FreeLibrary
#define FreeLibrary(x)
Definition: compat.h:748
RtlImageNtHeader
#define RtlImageNtHeader
Definition: compat.h:806
LoadLibraryExW
HINSTANCE WINAPI DECLSPEC_HOTPATCH LoadLibraryExW(LPCWSTR lpLibFileName, HANDLE hFile, DWORD dwFlags)
Definition: loader.c:288
CreateProcessW
BOOL WINAPI DECLSPEC_HOTPATCH CreateProcessW(LPCWSTR lpApplicationName, LPWSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation)
Definition: proc.c:4598
TerminateProcess
BOOL WINAPI TerminateProcess(IN HANDLE hProcess, IN UINT uExitCode)
Definition: proc.c:1532
FILEOP_SKIP
#define FILEOP_SKIP
Definition: fileqsup.h:49
FILEOP_DOIT
#define FILEOP_DOIT
Definition: fileqsup.h:48
FILEOP_ABORT
#define FILEOP_ABORT
Definition: fileqsup.h:47
func
GLenum func
Definition: glext.h:6028
res
GLuint res
Definition: glext.h:9613
FAILED
#define FAILED(hr)
Definition: intsafe.h:51
nt
IMAGE_NT_HEADERS nt
Definition: module.c:50
UINT_PTR
unsigned __int3264 UINT_PTR
Definition: mstsclib_h.h:274
BOOL
#define BOOL
Definition: nt_native.h:43
IMAGE_FILE_DLL
#define IMAGE_FILE_DLL
Definition: pedump.c:169
sprintfW
#define sprintfW
Definition: unicode.h:64
memset
#define memset(x, y, z)
Definition: compat.h:39
SPREG_GETPROCADDR
#define SPREG_GETPROCADDR
Definition: setupapi.h:654
FLG_REGSVR_DLLREGISTER
#define FLG_REGSVR_DLLREGISTER
Definition: setupapi.h:407
SPREG_REGSVR
#define SPREG_REGSVR
Definition: setupapi.h:655
SPFILENOTIFY_STARTREGISTRATION
#define SPFILENOTIFY_STARTREGISTRATION
Definition: setupapi.h:570
SPREG_SUCCESS
#define SPREG_SUCCESS
Definition: setupapi.h:652
SPREG_TIMEOUT
#define SPREG_TIMEOUT
Definition: setupapi.h:657
SPFILENOTIFY_ENDREGISTRATION
#define SPFILENOTIFY_ENDREGISTRATION
Definition: setupapi.h:571
SPREG_LOADLIBRARY
#define SPREG_LOADLIBRARY
Definition: setupapi.h:653
FLG_REGSVR_DLLINSTALL
#define FLG_REGSVR_DLLINSTALL
Definition: setupapi.h:408
_IMAGE_FILE_HEADER::Characteristics
WORD Characteristics
Definition: ntddk_ex.h:128
_IMAGE_NT_HEADERS
Definition: ntddk_ex.h:181
_IMAGE_NT_HEADERS::FileHeader
IMAGE_FILE_HEADER FileHeader
Definition: ntddk_ex.h:183
_PROCESS_INFORMATION
Definition: winbase.h:896
_SP_REGISTER_CONTROL_STATUSW
Definition: setupapi.h:952
_STARTUPINFOW
Definition: winbase.h:875
args
Definition: match.c:390
format
Definition: format.c:58
status
Definition: ps.c:97
timeout
Definition: dhcpd.h:245
WaitForSingleObject
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
GetLastError
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
LOAD_WITH_ALTERED_SEARCH_PATH
#define LOAD_WITH_ALTERED_SEARCH_PATH
Definition: winbase.h:369
HRESULT
#define HRESULT
Definition: msvc.h:7
WINAPI
#define WINAPI
Definition: msvc.h:6
ERROR_TIMEOUT
#define ERROR_TIMEOUT
Definition: winerror.h:941
ERROR_OPERATION_ABORTED
#define ERROR_OPERATION_ABORTED
Definition: winerror.h:575

Referenced by register_dlls_callback().

◆ FixupServiceBinaryPath()

static VOID FixupServiceBinaryPath ( IN DWORD  ServiceType,
IN OUT LPWSTR *  ServiceBinary 
)
static

Definition at line 1738 of file install.c.

1741{
1742 LPWSTR Buffer;
1743 WCHAR ReactOSDir[MAX_PATH];
1744 DWORD RosDirLength, ServiceLength, Win32Length;
1745
1746 GetWindowsDirectoryW(ReactOSDir, MAX_PATH);
1747 RosDirLength = strlenW(ReactOSDir);
1748 ServiceLength = strlenW(*ServiceBinary);
1749
1750 /* Check and fix two things:
1751 1. Get rid of C:\ReactOS and use relative
1752 path instead.
1753 2. Add %SystemRoot% for Win32 services */
1754
1755 if (ServiceLength < RosDirLength)
1756 return;
1757
1758 if (!wcsnicmp(*ServiceBinary, ReactOSDir, RosDirLength))
1759 {
1760 /* Yes, the first part is the C:\ReactOS\, just skip it */
1761 MoveMemory(*ServiceBinary, *ServiceBinary + RosDirLength + 1,
1762 (ServiceLength - RosDirLength) * sizeof(WCHAR));
1763
1764 /* Handle Win32-services differently */
1765 if (ServiceType & SERVICE_WIN32)
1766 {
1767 Win32Length = (ServiceLength - RosDirLength) * sizeof(WCHAR)
1768 - sizeof(L'\\') + sizeof(L"%SystemRoot%\\");
1769 Buffer = MyMalloc(Win32Length);
1770
1771 wcscpy(Buffer, L"%SystemRoot%\\");
1772 wcscat(Buffer, *ServiceBinary);
1773 MyFree(*ServiceBinary);
1774
1775 *ServiceBinary = Buffer;
1776 }
1777 }
1778}
Buffer
Definition: bufpool.h:45
wcsnicmp
#define wcsnicmp
Definition: compat.h:14
MAX_PATH
#define MAX_PATH
Definition: compat.h:34
GetWindowsDirectoryW
UINT WINAPI GetWindowsDirectoryW(OUT LPWSTR lpBuffer, IN UINT uSize)
Definition: path.c:2352
MyFree
VOID WINAPI MyFree(LPVOID lpMem)
Definition: misc.c:128
L
#define L(x)
Definition: ntvdm.h:50
wcscpy
_CRTIMP wchar_t *__cdecl wcscpy(_Out_writes_z_(_String_length_(_Source)+1) wchar_t *_Dest, _In_z_ const wchar_t *_Source)
MoveMemory
#define MoveMemory
Definition: winbase.h:1733
SERVICE_WIN32
#define SERVICE_WIN32
Definition: cmtypes.h:964

Referenced by InstallOneService().

◆ get_field_string()

static WCHAR * get_field_string ( INFCONTEXT *  context,
DWORD  index,
WCHAR *  buffer,
WCHAR *  static_buffer,
DWORD *  size 
)
static

Definition at line 134 of file install.c.

136{
137 DWORD required;
138
139 if (SetupGetStringFieldW( context, index, buffer, *size, &required )) return buffer;
140 if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
141 {
142 /* now grow the buffer */
143 if (buffer != static_buffer) HeapFree( GetProcessHeap(), 0, buffer );
144 if (!(buffer = HeapAlloc( GetProcessHeap(), 0, required*sizeof(WCHAR) ))) return NULL;
145 *size = required;
146 if (SetupGetStringFieldW( context, index, buffer, *size, &required )) return buffer;
147 }
148 if (buffer != static_buffer) HeapFree( GetProcessHeap(), 0, buffer );
149 return NULL;
150}
ERROR_INSUFFICIENT_BUFFER
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10
index
GLuint index
Definition: glext.h:6031

◆ get_root_key()

static HKEY get_root_key ( const WCHAR *  name,
HKEY  def_root 
)
static

Definition at line 201 of file install.c.

202{
203 static const WCHAR HKCR[] = {'H','K','C','R',0};
204 static const WCHAR HKCU[] = {'H','K','C','U',0};
205 static const WCHAR HKLM[] = {'H','K','L','M',0};
206 static const WCHAR HKU[] = {'H','K','U',0};
207 static const WCHAR HKR[] = {'H','K','R',0};
208
209 if (!strcmpiW( name, HKCR )) return HKEY_CLASSES_ROOT;
210 if (!strcmpiW( name, HKCU )) return HKEY_CURRENT_USER;
211 if (!strcmpiW( name, HKLM )) return HKEY_LOCAL_MACHINE;
212 if (!strcmpiW( name, HKU )) return HKEY_USERS;
213 if (!strcmpiW( name, HKR )) return def_root;
214 return 0;
215}
HKLM
static const WCHAR HKLM[]
Definition: reginf.c:58
HKCR
static const WCHAR HKCR[]
Definition: reginf.c:56
HKU
static const WCHAR HKU[]
Definition: reginf.c:59
HKR
static const WCHAR HKR[]
Definition: reginf.c:60
HKCU
static const WCHAR HKCU[]
Definition: reginf.c:57
name
Definition: name.c:39
HKEY_LOCAL_MACHINE
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12
HKEY_CURRENT_USER
#define HKEY_CURRENT_USER
Definition: winreg.h:11
HKEY_CLASSES_ROOT
#define HKEY_CLASSES_ROOT
Definition: winreg.h:10
HKEY_USERS
#define HKEY_USERS
Definition: winreg.h:13

Referenced by registry_callback().

◆ GetIntField()

static BOOL GetIntField ( HINF  hinf,
PCWSTR  section_name,
PCWSTR  key_name,
INT *  value 
)
static

Definition at line 1679 of file install.c.

1680{
1681 LPWSTR buffer, end;
1682 INT res;
1683
1684 if (! GetLineText( hinf, section_name, key_name, &buffer ) )
1685 return FALSE;
1686
1687 res = wcstol( buffer, &end, 0 );
1688 if (end != buffer && !*end)
1689 {
1690 HeapFree(GetProcessHeap(), 0, buffer);
1691 *value = res;
1692 return TRUE;
1693 }
1694 else
1695 {
1696 HeapFree(GetProcessHeap(), 0, buffer);
1697 SetLastError( ERROR_INVALID_DATA );
1698 return FALSE;
1699 }
1700}
GetLineText
static BOOL GetLineText(HINF hinf, PCWSTR section_name, PCWSTR key_name, PWSTR *value)
Definition: install.c:1650
end
GLuint GLuint end
Definition: gl.h:1545
wcstol
_Check_return_ long __cdecl wcstol(_In_z_ const wchar_t *_Str, _Out_opt_ _Deref_post_z_ wchar_t **_EndPtr, _In_ int _Radix)
key_name
Definition: registry.c:449
INT
int32_t INT
Definition: typedefs.h:58
ERROR_INVALID_DATA
#define ERROR_INVALID_DATA
Definition: winerror.h:116

Referenced by InstallOneService().

◆ GetLineText()

static BOOL GetLineText ( HINF  hinf,
PCWSTR  section_name,
PCWSTR  key_name,
PWSTR *  value 
)
static

Definition at line 1650 of file install.c.

1651{
1652 DWORD required;
1653 PWSTR buf = NULL;
1654
1655 *value = NULL;
1656
1657 if (! SetupGetLineTextW( NULL, hinf, section_name, key_name, NULL, 0, &required )
1658 && GetLastError() != ERROR_INSUFFICIENT_BUFFER )
1659 return FALSE;
1660
1661 buf = HeapAlloc( GetProcessHeap(), 0, required * sizeof(WCHAR) );
1662 if ( ! buf )
1663 {
1664 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1665 return FALSE;
1666 }
1667
1668 if (! SetupGetLineTextW( NULL, hinf, section_name, key_name, buf, required, &required ) )
1669 {
1670 HeapFree( GetProcessHeap(), 0, buf );
1671 return FALSE;
1672 }
1673
1674 *value = buf;
1675 return TRUE;
1676}
SetupGetLineTextW
BOOL WINAPI SetupGetLineTextW(PINFCONTEXT context, HINF hinf, PCWSTR section_name, PCWSTR key_name, PWSTR buffer, DWORD size, PDWORD required)
Definition: parser.c:1756
buf
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
PWSTR
uint16_t * PWSTR
Definition: typedefs.h:56

Referenced by GetIntField(), InstallOneService(), and profile_items_callback().

◆ GetStringField()

BOOL GetStringField ( PINFCONTEXT  context,
DWORD  index,
PWSTR *  value 
)

Definition at line 1703 of file install.c.

1704{
1705 DWORD RequiredSize;
1706 BOOL ret;
1707
1708 ret = SetupGetStringFieldW(
1709 context,
1710 index,
1711 NULL, 0,
1712 &RequiredSize);
1713 if (!ret)
1714 return FALSE;
1715 else if (RequiredSize == 0)
1716 {
1717 *value = NULL;
1718 return TRUE;
1719 }
1720
1721 /* We got the needed size for the buffer */
1722 *value = MyMalloc(RequiredSize * sizeof(WCHAR));
1723 if (!*value)
1724 {
1725 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1726 return FALSE;
1727 }
1728 ret = SetupGetStringFieldW(
1729 context,
1730 index,
1731 *value, RequiredSize, NULL);
1732 if (!ret)
1733 MyFree(*value);
1734
1735 return ret;
1736}
RequiredSize
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ ULONG _Out_ PVOID _Out_ PULONG RequiredSize
Definition: wdfdevice.h:4439

Referenced by profile_items_callback(), SetupDiInstallDeviceInterfaces(), and SetupInstallServicesFromInfSectionExW().

◆ include_callback()

static BOOL include_callback ( HINF  hinf,
PCWSTR  field,
void *  arg 
)
static

Definition at line 1296 of file install.c.

1297{
1298 return SetupOpenAppendInfFileW( field, hinf, NULL );
1299}
SetupOpenAppendInfFileW
BOOL WINAPI SetupOpenAppendInfFileW(PCWSTR name, HINF parent_hinf, UINT *error)
Definition: parser.c:1346

Referenced by SetupInstallFromInfSectionW(), and SetupInstallServicesFromInfSectionExW().

◆ ini2reg_callback()

static BOOL ini2reg_callback ( HINF  hinf,
PCWSTR  field,
void *  arg 
)
static

Definition at line 821 of file install.c.

822{
823 FIXME( "should do ini2reg %s\n", debugstr_w(field) );
824 return TRUE;
825}

Referenced by SetupInstallFromInfSectionW().

◆ InstallHinfSectionA()

void WINAPI InstallHinfSectionA ( HWND  hwnd,
HINSTANCE  handle,
LPCSTR  cmdline,
INT  show 
)

Definition at line 1601 of file install.c.

1602{
1603 UNICODE_STRING cmdlineW;
1604
1605 if (RtlCreateUnicodeStringFromAsciiz( &cmdlineW, cmdline ))
1606 {
1607 InstallHinfSectionW( hwnd, handle, cmdlineW.Buffer, show );
1608 RtlFreeUnicodeString( &cmdlineW );
1609 }
1610}
InstallHinfSectionW
void WINAPI InstallHinfSectionW(HWND hwnd, HINSTANCE handle, LPCWSTR cmdline, INT show)
Definition: install.c:1468
RtlCreateUnicodeStringFromAsciiz
NTSYSAPI BOOLEAN NTAPI RtlCreateUnicodeStringFromAsciiz(_Out_ PUNICODE_STRING Destination, _In_ PCSZ Source)
RtlFreeUnicodeString
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
cmdline
TCHAR * cmdline
Definition: stretchblt.cpp:32
_UNICODE_STRING
Definition: env_spec_w32.h:368
_UNICODE_STRING::Buffer
PWSTR Buffer
Definition: env_spec_w32.h:371
hwnd
_In_ LONG _In_ HWND hwnd
Definition: winddi.h:4023

◆ InstallHinfSectionW()

void WINAPI InstallHinfSectionW ( HWND  hwnd,
HINSTANCE  handle,
LPCWSTR  cmdline,
INT  show 
)

Definition at line 1468 of file install.c.

1469{
1470 BOOL ret = FALSE;
1471 WCHAR *s, *path, section[MAX_PATH];
1472 void *callback_context = NULL;
1473 DWORD SectionNameLength;
1474 UINT mode;
1475 HINF hinf = INVALID_HANDLE_VALUE;
1476 BOOL bRebootRequired = FALSE;
1477
1478 TRACE("hwnd %p, handle %p, cmdline %s\n", hwnd, handle, debugstr_w(cmdline));
1479
1480 lstrcpynW( section, cmdline, MAX_PATH );
1481
1482 if (!(s = strchrW( section, ' ' ))) goto cleanup;
1483 *s++ = 0;
1484 while (*s == ' ') s++;
1485 mode = atoiW( s );
1486
1487 /* quoted paths are not allowed on native, the rest of the command line is taken as the path */
1488 if (!(s = strchrW( s, ' ' ))) goto cleanup;
1489 while (*s == ' ') s++;
1490 path = s;
1491
1492 if (mode & 0x80)
1493 {
1494 FIXME("default path of the installation not changed\n");
1495 mode &= ~0x80;
1496 }
1497
1498 hinf = SetupOpenInfFileW( path, NULL, INF_STYLE_WIN4, NULL );
1499 if (hinf == INVALID_HANDLE_VALUE)
1500 {
1501 WARN("SetupOpenInfFileW(%s) failed (Error %u)\n", path, GetLastError());
1502 goto cleanup;
1503 }
1504
1505 ret = SetupDiGetActualSectionToInstallW(
1506 hinf, section, section, sizeof(section)/sizeof(section[0]), &SectionNameLength, NULL );
1507 if (!ret)
1508 {
1509 WARN("SetupDiGetActualSectionToInstallW() failed (Error %u)\n", GetLastError());
1510 goto cleanup;
1511 }
1512 if (SectionNameLength > MAX_PATH - strlenW(DotServices))
1513 {
1514 WARN("Section name '%s' too long\n", section);
1515 goto cleanup;
1516 }
1517
1518 /* Copy files and add registry entries */
1519 callback_context = SetupInitDefaultQueueCallback( hwnd );
1520 ret = SetupInstallFromInfSectionW( hwnd, hinf, section, SPINST_ALL, NULL, NULL,
1521 SP_COPY_NEWER | SP_COPY_IN_USE_NEEDS_REBOOT,
1522 SetupDefaultQueueCallbackW, callback_context,
1523 NULL, NULL );
1524 if (!ret)
1525 {
1526 WARN("SetupInstallFromInfSectionW() failed (Error %u)\n", GetLastError());
1527 goto cleanup;
1528 }
1529 /* FIXME: need to check if some files were in use and need reboot
1530 * bReboot = ...;
1531 */
1532
1533 /* Install services */
1534 wcscat(section, DotServices);
1535 ret = SetupInstallServicesFromInfSectionW( hinf, section, 0 );
1536 if (!ret && GetLastError() == ERROR_SECTION_NOT_FOUND)
1537 ret = TRUE;
1538 if (!ret)
1539 {
1540 WARN("SetupInstallServicesFromInfSectionW() failed (Error %u)\n", GetLastError());
1541 goto cleanup;
1542 }
1543 else if (GetLastError() == ERROR_SUCCESS_REBOOT_REQUIRED)
1544 {
1545 bRebootRequired = TRUE;
1546 }
1547
1548 /* Check if we need to reboot */
1549 switch (mode)
1550 {
1551 case 0:
1552 /* Never reboot */
1553 break;
1554 case 1:
1555 /* Always reboot */
1556 ExitWindowsEx(EWX_REBOOT, SHTDN_REASON_MAJOR_APPLICATION |
1557 SHTDN_REASON_MINOR_INSTALLATION | SHTDN_REASON_FLAG_PLANNED);
1558 break;
1559 case 2:
1560 /* Query user before rebooting */
1561 SetupPromptReboot(NULL, hwnd, FALSE);
1562 break;
1563 case 3:
1564 /* Reboot if necessary */
1565 if (bRebootRequired)
1566 {
1567 ExitWindowsEx(EWX_REBOOT, SHTDN_REASON_MAJOR_APPLICATION |
1568 SHTDN_REASON_MINOR_INSTALLATION | SHTDN_REASON_FLAG_PLANNED);
1569 }
1570 break;
1571 case 4:
1572 /* If necessary, query user before rebooting */
1573 if (bRebootRequired)
1574 {
1575 SetupPromptReboot(NULL, hwnd, FALSE);
1576 }
1577 break;
1578 default:
1579 break;
1580 }
1581
1582cleanup:
1583 if ( callback_context )
1584 SetupTermDefaultQueueCallback( callback_context );
1585 if ( hinf != INVALID_HANDLE_VALUE )
1586 SetupCloseInfFile( hinf );
1587
1588#ifdef CORE_11689_IS_FIXED
1589 // TODO: Localize the error string.
1590 if (!ret && !(GlobalSetupFlags & PSPGF_NONINTERACTIVE))
1591 {
1592 MessageBoxW(hwnd, section, L"setupapi.dll: An error happened...", MB_ICONERROR | MB_OK);
1593 }
1594#endif
1595}
INVALID_HANDLE_VALUE
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
lstrcpynW
#define lstrcpynW
Definition: compat.h:738
cleanup
static void cleanup(void)
Definition: main.c:1335
SetupDiGetActualSectionToInstallW
BOOL WINAPI SetupDiGetActualSectionToInstallW(HINF InfHandle, PCWSTR InfSectionName, PWSTR InfSectionWithExt, DWORD InfSectionWithExtSize, PDWORD RequiredSize, PWSTR *Extension)
Definition: devinst.c:1980
DotServices
static const WCHAR DotServices[]
Definition: install.c:34
SetupInstallServicesFromInfSectionW
BOOL WINAPI SetupInstallServicesFromInfSectionW(HINF Inf, PCWSTR SectionName, DWORD Flags)
Definition: install.c:1615
SetupInstallFromInfSectionW
BOOL WINAPI SetupInstallFromInfSectionW(HWND owner, HINF hinf, PCWSTR section, UINT flags, HKEY key_root, PCWSTR src_root, UINT copy_flags, PSP_FILE_CALLBACK_W callback, PVOID context, HDEVINFO devinfo, PSP_DEVINFO_DATA devinfo_data)
Definition: install.c:1330
GlobalSetupFlags
DWORD GlobalSetupFlags
Definition: misc.c:845
SetupOpenInfFileW
HINF WINAPI SetupOpenInfFileW(PCWSTR name, PCWSTR class, DWORD style, UINT *error)
Definition: parser.c:1229
SetupDefaultQueueCallbackW
UINT WINAPI SetupDefaultQueueCallbackW(PVOID context, UINT notification, UINT_PTR param1, UINT_PTR param2)
Definition: queue.c:1729
SetupTermDefaultQueueCallback
void WINAPI SetupTermDefaultQueueCallback(PVOID context)
Definition: queue.c:1656
SetupInitDefaultQueueCallback
PVOID WINAPI SetupInitDefaultQueueCallback(HWND owner)
Definition: queue.c:1629
SetupPromptReboot
INT WINAPI SetupPromptReboot(HSPFILEQ file_queue, HWND owner, BOOL scan_only)
Definition: stubs.c:35
s
GLdouble s
Definition: gl.h:2039
mode
GLenum mode
Definition: glext.h:6217
INF_STYLE_WIN4
#define INF_STYLE_WIN4
Definition: infsupp.h:41
UINT
unsigned int UINT
Definition: ndis.h:50
atoiW
#define atoiW(s)
Definition: unicode.h:60
strchrW
#define strchrW(s, c)
Definition: unicode.h:40
ERROR_SECTION_NOT_FOUND
#define ERROR_SECTION_NOT_FOUND
Definition: setupapi.h:293
SP_COPY_IN_USE_NEEDS_REBOOT
#define SP_COPY_IN_USE_NEEDS_REBOOT
Definition: setupapi.h:485
SPINST_ALL
#define SPINST_ALL
Definition: setupapi.h:601
SP_COPY_NEWER
#define SP_COPY_NEWER
Definition: setupapi.h:478
PSPGF_NONINTERACTIVE
#define PSPGF_NONINTERACTIVE
Definition: setupapi_private.h:257
callback_context
Definition: misc.c:1613
section
Definition: parser.c:56
SetupCloseInfFile
VOID WINAPI SetupCloseInfFile(IN HINF InfHandle)
Definition: infsupp.c:45
ERROR_SUCCESS_REBOOT_REQUIRED
#define ERROR_SUCCESS_REBOOT_REQUIRED
Definition: winerror.h:1215
MessageBoxW
int WINAPI MessageBoxW(_In_opt_ HWND hWnd, _In_opt_ LPCWSTR lpText, _In_opt_ LPCWSTR lpCaption, _In_ UINT uType)
MB_ICONERROR
#define MB_ICONERROR
Definition: winuser.h:790
EWX_REBOOT
#define EWX_REBOOT
Definition: winuser.h:638
MB_OK
#define MB_OK
Definition: winuser.h:793
ExitWindowsEx
BOOL WINAPI ExitWindowsEx(_In_ UINT, _In_ DWORD)

Referenced by InstallHinfSectionA(), and run_cmdline().

◆ InstallOneService()

static BOOL InstallOneService ( struct DeviceInfoSet *  list,
IN HINF  hInf,
IN LPCWSTR  ServiceSection,
IN LPCWSTR  ServiceName,
IN UINT  ServiceFlags 
)
static

Definition at line 1780 of file install.c.

1786{
1787 SC_HANDLE hSCManager = NULL;
1788 SC_HANDLE hService = NULL;
1789 LPDWORD GroupOrder = NULL;
1790 LPQUERY_SERVICE_CONFIGW ServiceConfig = NULL;
1791 HKEY hServicesKey, hServiceKey;
1792 LONG rc;
1793 BOOL ret = FALSE;
1794
1795 HKEY hGroupOrderListKey = NULL;
1796 LPWSTR ServiceBinary = NULL;
1797 LPWSTR LoadOrderGroup = NULL;
1798 LPWSTR DisplayName = NULL;
1799 LPWSTR Description = NULL;
1800 LPWSTR Dependencies = NULL;
1801 LPWSTR StartName = NULL;
1802 LPWSTR SecurityDescriptor = NULL;
1803 PSECURITY_DESCRIPTOR sd = NULL;
1804 INT ServiceType, StartType, ErrorControl;
1805 DWORD dwRegType;
1806 DWORD tagId = (DWORD)-1;
1807 BOOL useTag;
1808
1809 if (!GetIntField(hInf, ServiceSection, ServiceTypeKey, &ServiceType))
1810 {
1811 SetLastError( ERROR_BAD_SERVICE_INSTALLSECT );
1812 goto cleanup;
1813 }
1814 if (!GetIntField(hInf, ServiceSection, StartTypeKey, &StartType))
1815 {
1816 SetLastError( ERROR_BAD_SERVICE_INSTALLSECT );
1817 goto cleanup;
1818 }
1819 if (!GetIntField(hInf, ServiceSection, ErrorControlKey, &ErrorControl))
1820 {
1821 SetLastError( ERROR_BAD_SERVICE_INSTALLSECT );
1822 goto cleanup;
1823 }
1824 useTag = (ServiceType == SERVICE_BOOT_START || ServiceType == SERVICE_SYSTEM_START);
1825
1826 hSCManager = OpenSCManagerW(NULL, SERVICES_ACTIVE_DATABASE, SC_MANAGER_CREATE_SERVICE);
1827 if (hSCManager == NULL)
1828 goto cleanup;
1829
1830 if (!GetLineText(hInf, ServiceSection, ServiceBinaryKey, &ServiceBinary))
1831 {
1832 SetLastError( ERROR_BAD_SERVICE_INSTALLSECT );
1833 goto cleanup;
1834 }
1835
1836 /* Adjust binary path according to the service type */
1837 FixupServiceBinaryPath(ServiceType, &ServiceBinary);
1838
1839 /* Don't check return value, as these fields are optional and
1840 * GetLineText initialize output parameter even on failure */
1841 GetLineText(hInf, ServiceSection, LoadOrderGroupKey, &LoadOrderGroup);
1842 GetLineText(hInf, ServiceSection, DisplayNameKey, &DisplayName);
1843 GetLineText(hInf, ServiceSection, DescriptionKey, &Description);
1844 GetLineText(hInf, ServiceSection, DependenciesKey, &Dependencies);
1845 GetLineText(hInf, ServiceSection, StartNameKey, &StartName);
1846
1847 /* If there is no group, we must not request a tag */
1848 if (!LoadOrderGroup || !*LoadOrderGroup)
1849 useTag = FALSE;
1850
1851 hService = OpenServiceW(
1852 hSCManager,
1853 ServiceName,
1854 DELETE | SERVICE_QUERY_CONFIG | SERVICE_CHANGE_CONFIG | WRITE_DAC);
1855 if (hService == NULL && GetLastError() != ERROR_SERVICE_DOES_NOT_EXIST)
1856 goto cleanup;
1857
1858 if (hService && (ServiceFlags & SPSVCINST_DELETEEVENTLOGENTRY))
1859 {
1860 ret = DeleteService(hService);
1861 if (!ret && GetLastError() != ERROR_SERVICE_MARKED_FOR_DELETE)
1862 goto cleanup;
1863 }
1864
1865 if (hService == NULL)
1866 {
1867 /* Create new service */
1868 hService = CreateServiceW(
1869 hSCManager,
1870 ServiceName,
1871 DisplayName,
1872 WRITE_DAC,
1873 ServiceType,
1874 StartType,
1875 ErrorControl,
1876 ServiceBinary,
1877 LoadOrderGroup,
1878 useTag ? &tagId : NULL,
1879 Dependencies,
1880 StartName,
1881 NULL);
1882 if (hService == NULL)
1883 goto cleanup;
1884 }
1885 else
1886 {
1887 DWORD bufferSize;
1888 /* Read current configuration */
1889 if (!QueryServiceConfigW(hService, NULL, 0, &bufferSize))
1890 {
1891 if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
1892 goto cleanup;
1893 ServiceConfig = MyMalloc(bufferSize);
1894 if (!ServiceConfig)
1895 {
1896 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1897 goto cleanup;
1898 }
1899 if (!QueryServiceConfigW(hService, ServiceConfig, bufferSize, &bufferSize))
1900 goto cleanup;
1901 }
1902 tagId = ServiceConfig->dwTagId;
1903
1904 /* Update configuration */
1905 ret = ChangeServiceConfigW(
1906 hService,
1907 ServiceType,
1908 (ServiceFlags & SPSVCINST_NOCLOBBER_STARTTYPE) ? SERVICE_NO_CHANGE : StartType,
1909 (ServiceFlags & SPSVCINST_NOCLOBBER_ERRORCONTROL) ? SERVICE_NO_CHANGE : ErrorControl,
1910 ServiceBinary,
1911 (ServiceFlags & SPSVCINST_NOCLOBBER_LOADORDERGROUP && ServiceConfig->lpLoadOrderGroup) ? NULL : LoadOrderGroup,
1912 useTag ? &tagId : NULL,
1913 (ServiceFlags & SPSVCINST_NOCLOBBER_DEPENDENCIES && ServiceConfig->lpDependencies) ? NULL : Dependencies,
1914 StartName,
1915 NULL,
1916 (ServiceFlags & SPSVCINST_NOCLOBBER_DISPLAYNAME && ServiceConfig->lpDisplayName) ? NULL : DisplayName);
1917 if (!ret)
1918 goto cleanup;
1919 }
1920
1921 /* Set security */
1922 if (GetLineText(hInf, ServiceSection, SecurityKey, &SecurityDescriptor))
1923 {
1924 ret = ConvertStringSecurityDescriptorToSecurityDescriptorW(SecurityDescriptor, SDDL_REVISION_1, &sd, NULL);
1925 if (!ret)
1926 goto cleanup;
1927 ret = SetServiceObjectSecurity(hService, DACL_SECURITY_INFORMATION, sd);
1928 if (!ret)
1929 goto cleanup;
1930 }
1931
1932 /* FIXME: use Description and SPSVCINST_NOCLOBBER_DESCRIPTION */
1933
1934 if (useTag)
1935 {
1936 /* Add the tag to SYSTEM\CurrentControlSet\Control\GroupOrderList key */
1937 LPCWSTR lpLoadOrderGroup;
1938 DWORD bufferSize;
1939
1940 lpLoadOrderGroup = LoadOrderGroup;
1941 if ((ServiceFlags & SPSVCINST_NOCLOBBER_LOADORDERGROUP) && ServiceConfig && ServiceConfig->lpLoadOrderGroup)
1942 lpLoadOrderGroup = ServiceConfig->lpLoadOrderGroup;
1943
1944 rc = RegOpenKeyW(
1945 list ? list->HKLM : HKEY_LOCAL_MACHINE,
1946 GroupOrderListKey,
1947 &hGroupOrderListKey);
1948 if (rc != ERROR_SUCCESS)
1949 {
1950 SetLastError(rc);
1951 goto cleanup;
1952 }
1953 rc = RegQueryValueExW(hGroupOrderListKey, lpLoadOrderGroup, NULL, &dwRegType, NULL, &bufferSize);
1954 if (rc == ERROR_FILE_NOT_FOUND)
1955 bufferSize = sizeof(DWORD);
1956 else if (rc != ERROR_SUCCESS)
1957 {
1958 SetLastError(rc);
1959 goto cleanup;
1960 }
1961 else if (dwRegType != REG_BINARY || bufferSize == 0 || bufferSize % sizeof(DWORD) != 0)
1962 {
1963 SetLastError(ERROR_GEN_FAILURE);
1964 goto cleanup;
1965 }
1966 /* Allocate buffer to store existing data + the new tag */
1967 GroupOrder = MyMalloc(bufferSize + sizeof(DWORD));
1968 if (!GroupOrder)
1969 {
1970 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1971 goto cleanup;
1972 }
1973 if (rc == ERROR_SUCCESS)
1974 {
1975 /* Read existing data */
1976 rc = RegQueryValueExW(
1977 hGroupOrderListKey,
1978 lpLoadOrderGroup,
1979 NULL,
1980 NULL,
1981 (BYTE*)GroupOrder,
1982 &bufferSize);
1983 if (rc != ERROR_SUCCESS)
1984 {
1985 SetLastError(rc);
1986 goto cleanup;
1987 }
1988 if (ServiceFlags & SPSVCINST_TAGTOFRONT)
1989 memmove(&GroupOrder[2], &GroupOrder[1], bufferSize - sizeof(DWORD));
1990 }
1991 else
1992 {
1993 GroupOrder[0] = 0;
1994 }
1995 GroupOrder[0]++;
1996 if (ServiceFlags & SPSVCINST_TAGTOFRONT)
1997 GroupOrder[1] = tagId;
1998 else
1999 GroupOrder[bufferSize / sizeof(DWORD)] = tagId;
2000
2001 rc = RegSetValueExW(
2002 hGroupOrderListKey,
2003 lpLoadOrderGroup,
2004 0,
2005 REG_BINARY,
2006 (BYTE*)GroupOrder,
2007 bufferSize + sizeof(DWORD));
2008 if (rc != ERROR_SUCCESS)
2009 {
2010 SetLastError(rc);
2011 goto cleanup;
2012 }
2013 }
2014
2015 /* Handle AddReg and DelReg */
2016 rc = RegOpenKeyExW(
2017 list ? list->HKLM : HKEY_LOCAL_MACHINE,
2018 REGSTR_PATH_SERVICES,
2019 0,
2020 READ_CONTROL,
2021 &hServicesKey);
2022 if (rc != ERROR_SUCCESS)
2023 {
2024 SetLastError(rc);
2025 goto cleanup;
2026 }
2027 rc = RegOpenKeyExW(
2028 hServicesKey,
2029 ServiceName,
2030 0,
2031 KEY_READ | KEY_WRITE,
2032 &hServiceKey);
2033 RegCloseKey(hServicesKey);
2034 if (rc != ERROR_SUCCESS)
2035 {
2036 SetLastError(rc);
2037 goto cleanup;
2038 }
2039
2040 ret = SetupInstallFromInfSectionW(
2041 NULL,
2042 hInf,
2043 ServiceSection,
2044 SPINST_REGISTRY,
2045 hServiceKey,
2046 NULL,
2047 0,
2048 NULL,
2049 NULL,
2050 NULL,
2051 NULL);
2052 RegCloseKey(hServiceKey);
2053
2054cleanup:
2055 if (hSCManager != NULL)
2056 CloseServiceHandle(hSCManager);
2057 if (hService != NULL)
2058 CloseServiceHandle(hService);
2059 if (hGroupOrderListKey != NULL)
2060 RegCloseKey(hGroupOrderListKey);
2061 if (sd != NULL)
2062 LocalFree(sd);
2063 MyFree(ServiceConfig);
2064 MyFree(ServiceBinary);
2065 MyFree(LoadOrderGroup);
2066 MyFree(DisplayName);
2067 MyFree(Description);
2068 MyFree(Dependencies);
2069 MyFree(SecurityDescriptor);
2070 MyFree(GroupOrder);
2071 MyFree(StartName);
2072
2073 TRACE("Returning %d\n", ret);
2074 return ret;
2075}
ServiceName
static WCHAR ServiceName[]
Definition: browser.c:19
hServicesKey
static HANDLE hServicesKey
Definition: devinst.c:21
RegCloseKey
#define RegCloseKey(hKey)
Definition: registry.h:49
list
Definition: list.h:37
RegOpenKeyExW
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3333
RegOpenKeyW
LONG WINAPI RegOpenKeyW(HKEY hKey, LPCWSTR lpSubKey, PHKEY phkResult)
Definition: reg.c:3268
ConvertStringSecurityDescriptorToSecurityDescriptorW
BOOL WINAPI ConvertStringSecurityDescriptorToSecurityDescriptorW(LPCWSTR StringSecurityDescriptor, DWORD StringSDRevision, PSECURITY_DESCRIPTOR *SecurityDescriptor, PULONG SecurityDescriptorSize)
Definition: security.c:3062
Description
static const WCHAR Description[]
Definition: oid.c:1266
DependenciesKey
static const WCHAR DependenciesKey[]
Definition: install.c:36
StartNameKey
static const WCHAR StartNameKey[]
Definition: install.c:45
ServiceTypeKey
static const WCHAR ServiceTypeKey[]
Definition: install.c:43
ErrorControlKey
static const WCHAR ErrorControlKey[]
Definition: install.c:39
GetIntField
static BOOL GetIntField(HINF hinf, PCWSTR section_name, PCWSTR key_name, INT *value)
Definition: install.c:1679
GroupOrderListKey
static const WCHAR GroupOrderListKey[]
Definition: install.c:29
LoadOrderGroupKey
static const WCHAR LoadOrderGroupKey[]
Definition: install.c:40
DescriptionKey
static const WCHAR DescriptionKey[]
Definition: install.c:37
ServiceBinaryKey
static const WCHAR ServiceBinaryKey[]
Definition: install.c:42
FixupServiceBinaryPath
static VOID FixupServiceBinaryPath(IN DWORD ServiceType, IN OUT LPWSTR *ServiceBinary)
Definition: install.c:1738
SecurityKey
static const WCHAR SecurityKey[]
Definition: install.c:41
StartTypeKey
static const WCHAR StartTypeKey[]
Definition: install.c:44
DisplayNameKey
static const WCHAR DisplayNameKey[]
Definition: install.c:38
bufferSize
size_t bufferSize
Definition: fxusbdeviceapi.cpp:564
LocalFree
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1594
memmove
#define memmove(s1, s2, n)
Definition: mkisofs.h:881
ERROR_FILE_NOT_FOUND
#define ERROR_FILE_NOT_FOUND
Definition: disk.h:79
sd
static const WCHAR sd[]
Definition: suminfo.c:286
WRITE_DAC
#define WRITE_DAC
Definition: nt_native.h:59
KEY_READ
#define KEY_READ
Definition: nt_native.h:1023
DELETE
#define DELETE
Definition: nt_native.h:57
KEY_WRITE
#define KEY_WRITE
Definition: nt_native.h:1031
READ_CONTROL
#define READ_CONTROL
Definition: nt_native.h:58
DWORD
#define DWORD
Definition: nt_native.h:44
LONG
long LONG
Definition: pedump.c:60
REGSTR_PATH_SERVICES
#define REGSTR_PATH_SERVICES
Definition: regstr.h:47
hSCManager
SC_HANDLE hSCManager
Definition: sc.c:12
DeleteService
BOOL WINAPI DeleteService(SC_HANDLE hService)
Definition: scm.c:921
OpenSCManagerW
SC_HANDLE WINAPI OpenSCManagerW(LPCWSTR lpMachineName, LPCWSTR lpDatabaseName, DWORD dwDesiredAccess)
Definition: scm.c:2068
OpenServiceW
SC_HANDLE WINAPI OpenServiceW(SC_HANDLE hSCManager, LPCWSTR lpServiceName, DWORD dwDesiredAccess)
Definition: scm.c:2160
QueryServiceConfigW
BOOL WINAPI QueryServiceConfigW(SC_HANDLE hService, LPQUERY_SERVICE_CONFIGW lpServiceConfig, DWORD cbBufSize, LPDWORD pcbBytesNeeded)
Definition: scm.c:2291
ChangeServiceConfigW
BOOL WINAPI ChangeServiceConfigW(SC_HANDLE hService, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPCWSTR lpBinaryPathName, LPCWSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPCWSTR lpDependencies, LPCWSTR lpServiceStartName, LPCWSTR lpPassword, LPCWSTR lpDisplayName)
Definition: scm.c:482
CreateServiceW
SC_HANDLE WINAPI CreateServiceW(SC_HANDLE hSCManager, LPCWSTR lpServiceName, LPCWSTR lpDisplayName, DWORD dwDesiredAccess, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPCWSTR lpBinaryPathName, LPCWSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPCWSTR lpDependencies, LPCWSTR lpServiceStartName, LPCWSTR lpPassword)
Definition: scm.c:812
SetServiceObjectSecurity
BOOL WINAPI SetServiceObjectSecurity(SC_HANDLE hService, SECURITY_INFORMATION dwSecurityInformation, PSECURITY_DESCRIPTOR lpSecurityDescriptor)
Definition: scm.c:2774
CloseServiceHandle
BOOL WINAPI CloseServiceHandle(SC_HANDLE hSCObject)
Definition: scm.c:580
SDDL_REVISION_1
#define SDDL_REVISION_1
Definition: sddl.h:30
SPSVCINST_NOCLOBBER_ERRORCONTROL
#define SPSVCINST_NOCLOBBER_ERRORCONTROL
Definition: setupapi.h:630
SPSVCINST_DELETEEVENTLOGENTRY
#define SPSVCINST_DELETEEVENTLOGENTRY
Definition: setupapi.h:627
SPSVCINST_NOCLOBBER_DISPLAYNAME
#define SPSVCINST_NOCLOBBER_DISPLAYNAME
Definition: setupapi.h:628
SPSVCINST_NOCLOBBER_LOADORDERGROUP
#define SPSVCINST_NOCLOBBER_LOADORDERGROUP
Definition: setupapi.h:631
ERROR_BAD_SERVICE_INSTALLSECT
#define ERROR_BAD_SERVICE_INSTALLSECT
Definition: setupapi.h:319
SPSVCINST_NOCLOBBER_STARTTYPE
#define SPSVCINST_NOCLOBBER_STARTTYPE
Definition: setupapi.h:629
SPINST_REGISTRY
#define SPINST_REGISTRY
Definition: setupapi.h:590
SPSVCINST_TAGTOFRONT
#define SPSVCINST_TAGTOFRONT
Definition: setupapi.h:625
SPSVCINST_NOCLOBBER_DEPENDENCIES
#define SPSVCINST_NOCLOBBER_DEPENDENCIES
Definition: setupapi.h:632
_QUERY_SERVICE_CONFIGW
Definition: winsvc.h:155
_QUERY_SERVICE_CONFIGW::dwTagId
DWORD dwTagId
Definition: winsvc.h:161
_QUERY_SERVICE_CONFIGW::lpDependencies
LPWSTR lpDependencies
Definition: winsvc.h:162
_QUERY_SERVICE_CONFIGW::lpLoadOrderGroup
LPWSTR lpLoadOrderGroup
Definition: winsvc.h:160
_QUERY_SERVICE_CONFIGW::lpDisplayName
LPWSTR lpDisplayName
Definition: winsvc.h:164
_SECURITY_DESCRIPTOR
Definition: ms-dtyp.idl:301
LPDWORD
uint32_t * LPDWORD
Definition: typedefs.h:59
ERROR_SERVICE_MARKED_FOR_DELETE
#define ERROR_SERVICE_MARKED_FOR_DELETE
Definition: winerror.h:623
ERROR_GEN_FAILURE
#define ERROR_GEN_FAILURE
Definition: winerror.h:134
ERROR_SERVICE_DOES_NOT_EXIST
#define ERROR_SERVICE_DOES_NOT_EXIST
Definition: winerror.h:611
SC_MANAGER_CREATE_SERVICE
#define SC_MANAGER_CREATE_SERVICE
Definition: winsvc.h:15
SERVICE_NO_CHANGE
#define SERVICE_NO_CHANGE
Definition: winsvc.h:20
SERVICE_CHANGE_CONFIG
#define SERVICE_CHANGE_CONFIG
Definition: winsvc.h:54
SERVICES_ACTIVE_DATABASE
#define SERVICES_ACTIVE_DATABASE
Definition: winsvc.h:564
SERVICE_QUERY_CONFIG
#define SERVICE_QUERY_CONFIG
Definition: winsvc.h:53
SecurityDescriptor
_In_ USHORT _In_ ULONG _In_ PSOCKADDR _In_ PSOCKADDR _Reserved_ ULONG _In_opt_ PVOID _In_opt_ const WSK_CLIENT_CONNECTION_DISPATCH _In_opt_ PEPROCESS _In_opt_ PETHREAD _In_opt_ PSECURITY_DESCRIPTOR SecurityDescriptor
Definition: wsk.h:191
SERVICE_BOOT_START
#define SERVICE_BOOT_START
Definition: cmtypes.h:975
SERVICE_SYSTEM_START
#define SERVICE_SYSTEM_START
Definition: cmtypes.h:976
DACL_SECURITY_INFORMATION
#define DACL_SECURITY_INFORMATION
Definition: setypes.h:125

Referenced by SetupInstallServicesFromInfSectionExW().

◆ iterate_section_fields()

static BOOL iterate_section_fields ( HINF  hinf,
PCWSTR  section,
PCWSTR  key,
iterate_fields_func  callback,
void *  arg 
)
static

Definition at line 1174 of file install.c.

1176{
1177 WCHAR static_buffer[200];
1178 WCHAR *buffer = static_buffer;
1179 DWORD size = sizeof(static_buffer)/sizeof(WCHAR);
1180 INFCONTEXT context;
1181 BOOL ret = FALSE;
1182
1183 BOOL ok = SetupFindFirstLineW( hinf, section, key, &context );
1184 while (ok)
1185 {
1186 UINT i, count = SetupGetFieldCount( &context );
1187 for (i = 1; i <= count; i++)
1188 {
1189 if (!(buffer = get_field_string( &context, i, buffer, static_buffer, &size )))
1190 goto done;
1191 if (!callback( hinf, buffer, arg ))
1192 {
1193 WARN("callback failed for %s %s err %d\n",
1194 debugstr_w(section), debugstr_w(buffer), GetLastError() );
1195 goto done;
1196 }
1197 }
1198 ok = SetupFindNextMatchLineW( &context, key, &context );
1199 }
1200 ret = TRUE;
1201 done:
1202 if (buffer != static_buffer) HeapFree( GetProcessHeap(), 0, buffer );
1203 return ret;
1204}
ok
#define ok(value,...)
Definition: atltest.h:57
get_field_string
static WCHAR * get_field_string(INFCONTEXT *context, DWORD index, WCHAR *buffer, const WCHAR *static_buffer, DWORD *size)
Definition: install.c:242
SetupFindNextMatchLineW
BOOL WINAPI SetupFindNextMatchLineW(PINFCONTEXT context_in, PCWSTR key, PINFCONTEXT context_out)
Definition: parser.c:1694
count
GLuint GLuint GLsizei count
Definition: gl.h:1545
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
callback
static IPrintDialogCallback callback
Definition: printdlg.c:326
_INFCONTEXT
Definition: infsupp.h:23
key
Definition: copy.c:22
SetupFindFirstLineW
BOOL WINAPI SetupFindFirstLineW(IN HINF InfHandle, IN PCWSTR Section, IN PCWSTR Key, IN OUT PINFCONTEXT Context)
Definition: infsupp.c:56

◆ logconf_callback()

static BOOL logconf_callback ( HINF  hinf,
PCWSTR  field,
void *  arg 
)
static

Definition at line 827 of file install.c.

828{
829 FIXME( "should do logconf %s\n", debugstr_w(field) );
830 return TRUE;
831}

Referenced by SetupInstallFromInfSectionW().

◆ needs_callback()

static BOOL needs_callback ( HINF  hinf,
PCWSTR  field,
void *  arg 
)
static

Definition at line 1307 of file install.c.

1308{
1309 struct needs_callback_info *info = arg;
1310
1311 switch (info->type)
1312 {
1313 case 0:
1314 return SetupInstallFromInfSectionW(info->owner, *(HINF*)hinf, field, info->flags,
1315 info->key_root, info->src_root, info->copy_flags, info->callback,
1316 info->context, info->devinfo, info->devinfo_data);
1317 case 1:
1318 return SetupInstallServicesFromInfSectionExW(*(HINF*)hinf, field, info->flags,
1319 info->devinfo, info->devinfo_data, info->reserved1, info->reserved2);
1320 default:
1321 ERR("Unknown info type %u\n", info->type);
1322 return FALSE;
1323 }
1324}
ERR
#define ERR(fmt,...)
Definition: precomp.h:57
SetupInstallServicesFromInfSectionExW
BOOL WINAPI SetupInstallServicesFromInfSectionExW(HINF hinf, PCWSTR sectionname, DWORD flags, HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, PVOID reserved1, PVOID reserved2)
Definition: install.c:2081
needs_callback_info
Definition: install.c:83

Referenced by SetupInstallFromInfSectionW(), and SetupInstallServicesFromInfSectionExW().

◆ profile_items_callback()

static BOOL profile_items_callback ( IN HINF  hInf,
IN PCWSTR  SectionName,
IN PVOID  Arg 
)
static

Definition at line 891 of file install.c.

895{
896 INFCONTEXT Context;
897 LPWSTR LinkSubDir = NULL, LinkName = NULL;
898 INT LinkAttributes = 0;
899 INT LinkFolder = 0;
900 INT FileDirId = 0;
901 INT CSIDL = CSIDL_COMMON_PROGRAMS;
902 LPWSTR FileSubDir = NULL;
903 INT DirId = 0;
904 LPWSTR SubDirPart = NULL, NamePart = NULL;
905 LPWSTR FullLinkName = NULL, FullFileName = NULL, FullWorkingDir = NULL, FullIconName = NULL;
906 INT IconIdx = 0;
907 LPWSTR lpHotKey = NULL, lpInfoTip = NULL;
908 LPWSTR DisplayName = NULL;
909 INT DisplayResId = 0;
910 BOOL ret = FALSE;
911 DWORD Index, Required;
912
913 IShellLinkW *psl;
914 IPersistFile *ppf;
915 HMODULE hOle32 = NULL;
916 COINITIALIZE pCoInitialize;
917 COCREATEINSTANCE pCoCreateInstance;
918 COUNINITIALIZE pCoUninitialize;
919 HRESULT hr;
920
921 TRACE("hInf %p, SectionName %s, Arg %p\n",
922 hInf, debugstr_w(SectionName), Arg);
923
924 /* Read 'Name' entry */
925 if (!SetupFindFirstLineW(hInf, SectionName, Name, &Context))
926 goto cleanup;
927 if (!GetStringField(&Context, 1, &LinkName))
928 goto cleanup;
929 if (SetupGetFieldCount(&Context) >= 2)
930 {
931 if (!SetupGetIntField(&Context, 2, &LinkAttributes))
932 goto cleanup;
933 }
934 if (SetupGetFieldCount(&Context) >= 3)
935 {
936 if (!SetupGetIntField(&Context, 3, &LinkFolder))
937 goto cleanup;
938 }
939
940 /* Read 'CmdLine' entry */
941 if (!SetupFindFirstLineW(hInf, SectionName, CmdLine, &Context))
942 goto cleanup;
943 Index = 1;
944 if (!SetupGetIntField(&Context, Index++, &FileDirId))
945 goto cleanup;
946 if (SetupGetFieldCount(&Context) >= 3)
947 {
948 if (!GetStringField(&Context, Index++, &FileSubDir))
949 goto cleanup;
950 }
951 if (!GetStringField(&Context, Index++, &NamePart))
952 goto cleanup;
953 if (!Concatenate(FileDirId, FileSubDir, NamePart, &FullFileName))
954 goto cleanup;
955 MyFree(NamePart);
956 NamePart = NULL;
957
958 /* Read 'SubDir' entry */
959 if ((LinkAttributes & FLG_PROFITEM_GROUP) == 0 && SetupFindFirstLineW(hInf, SectionName, SubDir, &Context))
960 {
961 if (!GetStringField(&Context, 1, &LinkSubDir))
962 goto cleanup;
963 }
964
965 /* Read 'WorkingDir' entry */
966 if (SetupFindFirstLineW(hInf, SectionName, WorkingDir, &Context))
967 {
968 if (!SetupGetIntField(&Context, 1, &DirId))
969 goto cleanup;
970 if (SetupGetFieldCount(&Context) >= 2)
971 {
972 if (!GetStringField(&Context, 2, &SubDirPart))
973 goto cleanup;
974 }
975 if (!Concatenate(DirId, SubDirPart, NULL, &FullWorkingDir))
976 goto cleanup;
977 MyFree(SubDirPart);
978 SubDirPart = NULL;
979 }
980 else
981 {
982 if (!Concatenate(FileDirId, FileSubDir, NULL, &FullWorkingDir))
983 goto cleanup;
984 }
985
986 /* Read 'IconPath' entry */
987 if (SetupFindFirstLineW(hInf, SectionName, IconPath, &Context))
988 {
989 Index = 1;
990 if (!SetupGetIntField(&Context, Index++, &DirId))
991 goto cleanup;
992 if (SetupGetFieldCount(&Context) >= 3)
993 {
994 if (!GetStringField(&Context, Index++, &SubDirPart))
995 goto cleanup;
996 }
997 if (!GetStringField(&Context, Index, &NamePart))
998 goto cleanup;
999 if (!Concatenate(DirId, SubDirPart, NamePart, &FullIconName))
1000 goto cleanup;
1001 MyFree(SubDirPart);
1002 MyFree(NamePart);
1003 SubDirPart = NamePart = NULL;
1004 }
1005 else
1006 {
1007 FullIconName = pSetupDuplicateString(FullFileName);
1008 if (!FullIconName)
1009 goto cleanup;
1010 }
1011
1012 /* Read 'IconIndex' entry */
1013 if (SetupFindFirstLineW(hInf, SectionName, IconIndex, &Context))
1014 {
1015 if (!SetupGetIntField(&Context, 1, &IconIdx))
1016 goto cleanup;
1017 }
1018
1019 /* Read 'HotKey' and 'InfoTip' entries */
1020 GetLineText(hInf, SectionName, HotKey, &lpHotKey);
1021 GetLineText(hInf, SectionName, InfoTip, &lpInfoTip);
1022
1023 /* Read 'DisplayResource' entry */
1024 if (SetupFindFirstLineW(hInf, SectionName, DisplayResource, &Context))
1025 {
1026 if (!GetStringField(&Context, 1, &DisplayName))
1027 goto cleanup;
1028 if (!SetupGetIntField(&Context, 2, &DisplayResId))
1029 goto cleanup;
1030 }
1031
1032 /* Some debug */
1033 TRACE("Link is %s\\%s, attributes 0x%x\n", debugstr_w(LinkSubDir), debugstr_w(LinkName), LinkAttributes);
1034 TRACE("File is %s\n", debugstr_w(FullFileName));
1035 TRACE("Working dir %s\n", debugstr_w(FullWorkingDir));
1036 TRACE("Icon is %s, %d\n", debugstr_w(FullIconName), IconIdx);
1037 TRACE("Hotkey %s\n", debugstr_w(lpHotKey));
1038 TRACE("InfoTip %s\n", debugstr_w(lpInfoTip));
1039 TRACE("Display %s, %d\n", DisplayName, DisplayResId);
1040
1041 /* Load ole32.dll */
1042 hOle32 = LoadLibraryA("ole32.dll");
1043 if (!hOle32)
1044 goto cleanup;
1045 pCoInitialize = (COINITIALIZE)GetProcAddress(hOle32, "CoInitialize");
1046 if (!pCoInitialize)
1047 goto cleanup;
1048 pCoCreateInstance = (COCREATEINSTANCE)GetProcAddress(hOle32, "CoCreateInstance");
1049 if (!pCoCreateInstance)
1050 goto cleanup;
1051 pCoUninitialize = (COUNINITIALIZE)GetProcAddress(hOle32, "CoUninitialize");
1052 if (!pCoUninitialize)
1053 goto cleanup;
1054
1055 /* Create shortcut */
1056 hr = pCoInitialize(NULL);
1057 if (!SUCCEEDED(hr))
1058 {
1059 if (HRESULT_FACILITY(hr) == FACILITY_WIN32)
1060 SetLastError(HRESULT_CODE(hr));
1061 else
1062 SetLastError(E_FAIL);
1063 goto cleanup;
1064 }
1065 hr = pCoCreateInstance(&CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, &IID_IShellLinkW, (LPVOID*)&psl);
1066 if (SUCCEEDED(hr))
1067 {
1068 /* Fill link properties */
1069 hr = IShellLinkW_SetPath(psl, FullFileName);
1070 if (SUCCEEDED(hr))
1071 hr = IShellLinkW_SetArguments(psl, L"");
1072 if (SUCCEEDED(hr))
1073 hr = IShellLinkW_SetWorkingDirectory(psl, FullWorkingDir);
1074 if (SUCCEEDED(hr))
1075 hr = IShellLinkW_SetIconLocation(psl, FullIconName, IconIdx);
1076 if (SUCCEEDED(hr) && lpHotKey)
1077 FIXME("Need to store hotkey %s in shell link\n", debugstr_w(lpHotKey));
1078 if (SUCCEEDED(hr) && lpInfoTip)
1079 hr = IShellLinkW_SetDescription(psl, lpInfoTip);
1080 if (SUCCEEDED(hr) && DisplayName)
1081 FIXME("Need to store display name %s, %d in shell link\n", debugstr_w(DisplayName), DisplayResId);
1082 if (SUCCEEDED(hr))
1083 {
1084 hr = IShellLinkW_QueryInterface(psl, &IID_IPersistFile, (LPVOID*)&ppf);
1085 if (SUCCEEDED(hr))
1086 {
1087 Required = (MAX_PATH + 1 +
1088 ((LinkSubDir != NULL) ? wcslen(LinkSubDir) : 0) +
1089 ((LinkName != NULL) ? wcslen(LinkName) : 0)) * sizeof(WCHAR);
1090 FullLinkName = MyMalloc(Required);
1091 if (!FullLinkName)
1092 hr = E_OUTOFMEMORY;
1093 else
1094 {
1095 if (LinkAttributes & (FLG_PROFITEM_DELETE | FLG_PROFITEM_GROUP))
1096 FIXME("Need to handle FLG_PROFITEM_DELETE and FLG_PROFITEM_GROUP\n");
1097 if (LinkAttributes & FLG_PROFITEM_CSIDL)
1098 CSIDL = LinkFolder;
1099 else if (LinkAttributes & FLG_PROFITEM_CURRENTUSER)
1100 CSIDL = CSIDL_PROGRAMS;
1101
1102 if (SHGetSpecialFolderPathW(
1103 NULL,
1104 FullLinkName,
1105 CSIDL,
1106 TRUE))
1107 {
1108 if (FullLinkName[wcslen(FullLinkName) - 1] != '\\')
1109 wcscat(FullLinkName, BackSlash);
1110 if (LinkSubDir)
1111 {
1112 wcscat(FullLinkName, LinkSubDir);
1113 if (FullLinkName[wcslen(FullLinkName) - 1] != '\\')
1114 wcscat(FullLinkName, BackSlash);
1115 }
1116 if (LinkName)
1117 {
1118 wcscat(FullLinkName, LinkName);
1119 wcscat(FullLinkName, DotLnk);
1120 }
1121 hr = IPersistFile_Save(ppf, FullLinkName, TRUE);
1122 }
1123 else
1124 hr = HRESULT_FROM_WIN32(GetLastError());
1125 }
1126 IPersistFile_Release(ppf);
1127 }
1128 }
1129 IShellLinkW_Release(psl);
1130 }
1131 pCoUninitialize();
1132 if (SUCCEEDED(hr))
1133 ret = TRUE;
1134 else
1135 {
1136 if (HRESULT_FACILITY(hr) == FACILITY_WIN32)
1137 SetLastError(HRESULT_CODE(hr));
1138 else
1139 SetLastError(E_FAIL);
1140 }
1141
1142cleanup:
1143 MyFree(LinkSubDir);
1144 MyFree(LinkName);
1145 MyFree(FileSubDir);
1146 MyFree(SubDirPart);
1147 MyFree(NamePart);
1148 MyFree(FullFileName);
1149 MyFree(FullWorkingDir);
1150 MyFree(FullIconName);
1151 MyFree(FullLinkName);
1152 MyFree(lpHotKey);
1153 MyFree(lpInfoTip);
1154 MyFree(DisplayName);
1155 if (hOle32)
1156 FreeLibrary(hOle32);
1157
1158 TRACE("Returning %d\n", ret);
1159 return ret;
1160}
E_OUTOFMEMORY
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
E_FAIL
#define E_FAIL
Definition: ddrawi.h:102
LoadLibraryA
HINSTANCE WINAPI DECLSPEC_HOTPATCH LoadLibraryA(LPCSTR lpLibFileName)
Definition: loader.c:111
WorkingDir
static const WCHAR WorkingDir[]
Definition: install.c:50
COINITIALIZE
HRESULT(WINAPI * COINITIALIZE)(IN LPVOID pvReserved)
Definition: install.c:101
Concatenate
static BOOL Concatenate(int DirId, LPCWSTR SubDirPart, LPCWSTR NamePart, LPWSTR *pFullName)
Definition: install.c:839
InfoTip
static const WCHAR InfoTip[]
Definition: install.c:54
CmdLine
static const WCHAR CmdLine[]
Definition: install.c:48
HotKey
static const WCHAR HotKey[]
Definition: install.c:53
IconIndex
static const WCHAR IconIndex[]
Definition: install.c:52
COCREATEINSTANCE
HRESULT(WINAPI * COCREATEINSTANCE)(IN REFCLSID rclsid, IN LPUNKNOWN pUnkOuter, IN DWORD dwClsContext, IN REFIID riid, OUT LPVOID *ppv)
Definition: install.c:102
GetStringField
BOOL GetStringField(PINFCONTEXT context, DWORD index, PWSTR *value)
Definition: install.c:1703
IconPath
static const WCHAR IconPath[]
Definition: install.c:51
COUNINITIALIZE
HRESULT(WINAPI * COUNINITIALIZE)(VOID)
Definition: install.c:103
SubDir
static const WCHAR SubDir[]
Definition: install.c:49
DotLnk
static const WCHAR DotLnk[]
Definition: install.c:33
DisplayResource
static const WCHAR DisplayResource[]
Definition: install.c:55
pSetupDuplicateString
LPWSTR WINAPI pSetupDuplicateString(LPCWSTR lpSrc)
Definition: misc.c:198
SHGetSpecialFolderPathW
BOOL WINAPI SHGetSpecialFolderPathW(HWND hwndOwner, LPWSTR szPath, int nFolder, BOOL bCreate)
Definition: shellpath.c:3092
SUCCEEDED
#define SUCCEEDED(hr)
Definition: intsafe.h:50
Required
_In_ PMEMORY_AREA _In_ PVOID _In_ BOOLEAN _Inout_ PMM_REQUIRED_RESOURCES Required
Definition: newmm.h:210
IID_IPersistFile
const GUID IID_IPersistFile
FLG_PROFITEM_CSIDL
#define FLG_PROFITEM_CSIDL
Definition: setupapi.h:406
FLG_PROFITEM_GROUP
#define FLG_PROFITEM_GROUP
Definition: setupapi.h:405
FLG_PROFITEM_DELETE
#define FLG_PROFITEM_DELETE
Definition: setupapi.h:404
FLG_PROFITEM_CURRENTUSER
#define FLG_PROFITEM_CURRENTUSER
Definition: setupapi.h:403
hr
HRESULT hr
Definition: shlfolder.c:183
CSIDL_COMMON_PROGRAMS
#define CSIDL_COMMON_PROGRAMS
Definition: shlobj.h:2195
CSIDL_PROGRAMS
#define CSIDL_PROGRAMS
Definition: shlobj.h:2175
NameRec_
Definition: apinames.c:49
SetupGetIntField
BOOL WINAPI SetupGetIntField(IN PINFCONTEXT Context, IN ULONG FieldIndex, OUT INT *IntegerValue)
Definition: infsupp.c:148
Index
_In_ WDFCOLLECTION _In_ ULONG Index
Definition: wdfcollection.h:182
HRESULT_FACILITY
#define HRESULT_FACILITY(hr)
Definition: winerror.h:79
HRESULT_FROM_WIN32
#define HRESULT_FROM_WIN32(x)
Definition: winerror.h:92
FACILITY_WIN32
#define FACILITY_WIN32
Definition: winerror.h:27
HRESULT_CODE
#define HRESULT_CODE(hr)
Definition: winerror.h:76
sizeof
ActualNumberDriverObjects * sizeof(PDRIVER_OBJECT)) PDRIVER_OBJECT *DriverObjectList

Referenced by SetupInstallFromInfSectionW().

◆ register_dlls_callback()

static BOOL register_dlls_callback ( HINF  hinf,
PCWSTR  field,
void *  arg 
)
static

Definition at line 666 of file install.c.

667{
668 struct register_dll_info *info = arg;
669 INFCONTEXT context;
670 BOOL ret = TRUE;
671 BOOL ok = SetupFindFirstLineW( hinf, field, NULL, &context );
672
673 for (; ok; ok = SetupFindNextLine( &context, &context ))
674 {
675 WCHAR *path, *args, *p;
676 WCHAR buffer[MAX_INF_STRING_LENGTH];
677 INT flags, timeout;
678
679 /* get directory */
680 if (!(path = PARSER_get_dest_dir( &context ))) continue;
681
682 /* get dll name */
683 if (!SetupGetStringFieldW( &context, 3, buffer, sizeof(buffer)/sizeof(WCHAR), NULL ))
684 goto done;
685 if (!(p = HeapReAlloc( GetProcessHeap(), 0, path,
686 (strlenW(path) + strlenW(buffer) + 2) * sizeof(WCHAR) ))) goto done;
687 path = p;
688 p += strlenW(p);
689 if (p == path || p[-1] != '\\') *p++ = '\\';
690 strcpyW( p, buffer );
691
692 /* get flags */
693 if (!SetupGetIntField( &context, 4, &flags )) flags = 0;
694
695 /* get timeout */
696#ifdef __REACTOS__
697 /* "11,,cmd.exe,,,/K dir" means default timeout, not a timeout of zero */
698 if (!SetupGetIntField( &context, 5, &timeout ) || timeout == 0) timeout = 60;
699#else
700 if (!SetupGetIntField( &context, 5, &timeout )) timeout = 60;
701#endif
702
703 /* get command line */
704 args = NULL;
705 if (SetupGetStringFieldW( &context, 6, buffer, sizeof(buffer)/sizeof(WCHAR), NULL ))
706 args = buffer;
707
708 ret = do_register_dll( info, path, flags, timeout, args );
709
710 done:
711 HeapFree( GetProcessHeap(), 0, path );
712 if (!ret) break;
713 }
714 return ret;
715}
HeapReAlloc
#define HeapReAlloc
Definition: compat.h:734
do_register_dll
static BOOL do_register_dll(const struct register_dll_info *info, const WCHAR *path, INT flags, INT timeout, const WCHAR *args)
Definition: install.c:530
PARSER_get_dest_dir
WCHAR * PARSER_get_dest_dir(INFCONTEXT *context)
Definition: parser.c:1116
MAX_INF_STRING_LENGTH
#define MAX_INF_STRING_LENGTH
Definition: infsupp.h:34
strcpyW
#define strcpyW(d, s)
Definition: unicode.h:35
args
#define args
Definition: format.c:66
register_dll_info
Definition: install.c:75
SetupFindNextLine
BOOL WINAPI SetupFindNextLine(IN PINFCONTEXT ContextIn, OUT PINFCONTEXT ContextOut)
Definition: infsupp.c:82

Referenced by SetupInstallFromInfSectionW().

◆ registry_callback()

static BOOL registry_callback ( HINF  hinf,
PCWSTR  field,
void *  arg 
)
static

Definition at line 422 of file install.c.

423{
424 struct registry_callback_info *info = arg;
425 LPWSTR security_key, security_descriptor;
426 INFCONTEXT context, security_context;
427 PSECURITY_DESCRIPTOR sd = NULL;
428 SECURITY_ATTRIBUTES security_attributes = { 0, };
429 HKEY root_key, hkey;
430 DWORD required;
431
432 BOOL ok = SetupFindFirstLineW( hinf, field, NULL, &context );
433 if (!ok)
434 return TRUE;
435
436 /* Check for .Security section */
437 security_key = MyMalloc( (strlenW( field ) + strlenW( DotSecurity )) * sizeof(WCHAR) + sizeof(UNICODE_NULL) );
438 if (!security_key)
439 {
440 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
441 return FALSE;
442 }
443 strcpyW( security_key, field );
444 strcatW( security_key, DotSecurity );
445 ok = SetupFindFirstLineW( hinf, security_key, NULL, &security_context );
446 MyFree(security_key);
447 if (ok)
448 {
449 if (!SetupGetLineTextW( &security_context, NULL, NULL, NULL, NULL, 0, &required ))
450 return FALSE;
451 security_descriptor = MyMalloc( required * sizeof(WCHAR) );
452 if (!security_descriptor)
453 {
454 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
455 return FALSE;
456 }
457 if (!SetupGetLineTextW( &security_context, NULL, NULL, NULL, security_descriptor, required, NULL ))
458 return FALSE;
459 ok = ConvertStringSecurityDescriptorToSecurityDescriptorW( security_descriptor, SDDL_REVISION_1, &sd, NULL );
460 MyFree( security_descriptor );
461 if (!ok)
462 return FALSE;
463 security_attributes.nLength = sizeof(SECURITY_ATTRIBUTES);
464 security_attributes.lpSecurityDescriptor = sd;
465 }
466
467 for (ok = TRUE; ok; ok = SetupFindNextLine( &context, &context ))
468 {
469 WCHAR buffer[MAX_INF_STRING_LENGTH];
470 INT flags;
471
472 /* get root */
473 if (!SetupGetStringFieldW( &context, 1, buffer, sizeof(buffer)/sizeof(WCHAR), NULL ))
474 continue;
475 if (!(root_key = get_root_key( buffer, info->default_root )))
476 continue;
477
478 /* get key */
479 if (!SetupGetStringFieldW( &context, 2, buffer, sizeof(buffer)/sizeof(WCHAR), NULL ))
480 *buffer = 0;
481
482 /* get flags */
483 if (!SetupGetIntField( &context, 4, &flags )) flags = 0;
484
485 if (!info->delete)
486 {
487 if (flags & FLG_ADDREG_DELREG_BIT) continue; /* ignore this entry */
488 }
489 else
490 {
491 if (!flags) flags = FLG_ADDREG_DELREG_BIT;
492 else if (!(flags & FLG_ADDREG_DELREG_BIT)) continue; /* ignore this entry */
493 }
494
495 if (info->delete || (flags & FLG_ADDREG_OVERWRITEONLY))
496 {
497 if (RegOpenKeyW( root_key, buffer, &hkey )) continue; /* ignore if it doesn't exist */
498 }
499 else if (RegCreateKeyExW( root_key, buffer, 0, NULL, 0, MAXIMUM_ALLOWED,
500 sd ? &security_attributes : NULL, &hkey, NULL ))
501 {
502 ERR( "could not create key %p %s\n", root_key, debugstr_w(buffer) );
503 continue;
504 }
505 TRACE( "key %p %s\n", root_key, debugstr_w(buffer) );
506
507 /* get value name */
508 if (!SetupGetStringFieldW( &context, 3, buffer, sizeof(buffer)/sizeof(WCHAR), NULL ))
509 *buffer = 0;
510
511 /* and now do it */
512 if (!do_reg_operation( hkey, buffer, &context, flags ))
513 {
514 if (hkey != root_key) RegCloseKey( hkey );
515 if (sd) LocalFree( sd );
516 return FALSE;
517 }
518 if (hkey != root_key) RegCloseKey( hkey );
519 }
520 if (sd) LocalFree( sd );
521 return TRUE;
522}
RegCreateKeyExW
LONG WINAPI RegCreateKeyExW(_In_ HKEY hKey, _In_ LPCWSTR lpSubKey, _In_ DWORD Reserved, _In_opt_ LPWSTR lpClass, _In_ DWORD dwOptions, _In_ REGSAM samDesired, _In_opt_ LPSECURITY_ATTRIBUTES lpSecurityAttributes, _Out_ PHKEY phkResult, _Out_opt_ LPDWORD lpdwDisposition)
Definition: reg.c:1096
SECURITY_ATTRIBUTES
struct _SECURITY_ATTRIBUTES SECURITY_ATTRIBUTES
DotSecurity
static const WCHAR DotSecurity[]
Definition: install.c:123
get_root_key
static HKEY get_root_key(const WCHAR *name, HKEY def_root)
Definition: install.c:201
do_reg_operation
static BOOL do_reg_operation(HKEY hkey, const WCHAR *value, INFCONTEXT *context, INT flags)
Definition: install.c:307
MAXIMUM_ALLOWED
#define MAXIMUM_ALLOWED
Definition: nt_native.h:83
strcatW
#define strcatW(d, s)
Definition: unicode.h:36
_SECURITY_ATTRIBUTES
Definition: compat.h:191
_SECURITY_ATTRIBUTES::nLength
DWORD nLength
Definition: compat.h:192
_SECURITY_ATTRIBUTES::lpSecurityDescriptor
LPVOID lpSecurityDescriptor
Definition: compat.h:193
registry_callback_info
Definition: install.c:68

Referenced by SetupInstallFromInfSectionW().

◆ rename_files_callback()

static BOOL rename_files_callback ( HINF  hinf,
PCWSTR  field,
void *  arg 
)
static

Definition at line 188 of file install.c.

189{
190 struct files_callback_info *info = arg;
191 SetupQueueRenameSectionW( info->queue, hinf, 0, field );
192 return TRUE;
193}
SetupQueueRenameSectionW
BOOL WINAPI SetupQueueRenameSectionW(HSPFILEQ queue, HINF hinf, HINF hlist, PCWSTR section)
Definition: queue.c:919

Referenced by SetupInstallFromInfSectionW().

◆ SetupCopyOEMInfA()

BOOL WINAPI SetupCopyOEMInfA ( IN PCSTR  SourceInfFileName,
IN PCSTR  OEMSourceMediaLocation,
IN DWORD  OEMSourceMediaType,
IN DWORD  CopyStyle,
OUT PSTR DestinationInfFileName  OPTIONAL,
IN DWORD  DestinationInfFileNameSize,
OUT PDWORD RequiredSize  OPTIONAL,
OUT PSTR *DestinationInfFileNameComponent  OPTIONAL 
)

Definition at line 2199 of file install.c.

2208{
2209 PWSTR SourceInfFileNameW = NULL;
2210 PWSTR OEMSourceMediaLocationW = NULL;
2211 PWSTR DestinationInfFileNameW = NULL;
2212 PWSTR DestinationInfFileNameComponentW = NULL;
2213 BOOL ret = FALSE;
2214 DWORD size;
2215
2216 TRACE("%s %s 0x%lx 0x%lx %p 0%lu %p %p\n",
2217 SourceInfFileName, OEMSourceMediaLocation, OEMSourceMediaType,
2218 CopyStyle, DestinationInfFileName, DestinationInfFileNameSize,
2219 RequiredSize, DestinationInfFileNameComponent);
2220
2221 if (!DestinationInfFileName && DestinationInfFileNameSize > 0)
2222 SetLastError(ERROR_INVALID_PARAMETER);
2223 else if (!(SourceInfFileNameW = pSetupMultiByteToUnicode(SourceInfFileName, CP_ACP)))
2224 SetLastError(ERROR_INVALID_PARAMETER);
2225 else if (OEMSourceMediaType != SPOST_NONE && !(OEMSourceMediaLocationW = pSetupMultiByteToUnicode(OEMSourceMediaLocation, CP_ACP)))
2226 SetLastError(ERROR_INVALID_PARAMETER);
2227 else
2228 {
2229 if (DestinationInfFileNameSize != 0)
2230 {
2231 DestinationInfFileNameW = MyMalloc(DestinationInfFileNameSize * sizeof(WCHAR));
2232 if (!DestinationInfFileNameW)
2233 {
2234 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2235 goto cleanup;
2236 }
2237 }
2238
2239 ret = SetupCopyOEMInfW(
2240 SourceInfFileNameW,
2241 OEMSourceMediaLocationW,
2242 OEMSourceMediaType,
2243 CopyStyle,
2244 DestinationInfFileNameW,
2245 DestinationInfFileNameSize,
2246 &size,
2247 DestinationInfFileNameComponent ? &DestinationInfFileNameComponentW : NULL);
2248 if (!ret)
2249 {
2250 if (RequiredSize) *RequiredSize = size;
2251 goto cleanup;
2252 }
2253
2254 if (DestinationInfFileNameSize != 0)
2255 {
2256 if (WideCharToMultiByte(CP_ACP, 0, DestinationInfFileNameW, -1,
2257 DestinationInfFileName, DestinationInfFileNameSize, NULL, NULL) == 0)
2258 {
2259 DestinationInfFileName[0] = '\0';
2260 goto cleanup;
2261 }
2262 }
2263 if (DestinationInfFileNameComponent)
2264 {
2265 if (DestinationInfFileNameComponentW)
2266 *DestinationInfFileNameComponent = &DestinationInfFileName[DestinationInfFileNameComponentW - DestinationInfFileNameW];
2267 else
2268 *DestinationInfFileNameComponent = NULL;
2269 }
2270 ret = TRUE;
2271 }
2272
2273cleanup:
2274 MyFree(SourceInfFileNameW);
2275 MyFree(OEMSourceMediaLocationW);
2276 MyFree(DestinationInfFileNameW);
2277 TRACE("Returning %d\n", ret);
2278 if (ret) SetLastError(ERROR_SUCCESS);
2279 return ret;
2280}
ERROR_INVALID_PARAMETER
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
CP_ACP
#define CP_ACP
Definition: compat.h:109
WideCharToMultiByte
#define WideCharToMultiByte
Definition: compat.h:111
SetupCopyOEMInfW
BOOL WINAPI SetupCopyOEMInfW(IN PCWSTR SourceInfFileName, IN PCWSTR OEMSourceMediaLocation, IN DWORD OEMSourceMediaType, IN DWORD CopyStyle, OUT PWSTR DestinationInfFileName OPTIONAL, IN DWORD DestinationInfFileNameSize, OUT PDWORD RequiredSize OPTIONAL, OUT PWSTR *DestinationInfFileNameComponent OPTIONAL)
Definition: install.c:2308
pSetupMultiByteToUnicode
LPWSTR WINAPI pSetupMultiByteToUnicode(LPCSTR lpMultiByteStr, UINT uCodePage)
Definition: misc.c:281
SPOST_NONE
#define SPOST_NONE
Definition: setupapi.h:609

◆ SetupCopyOEMInfW()

BOOL WINAPI SetupCopyOEMInfW ( IN PCWSTR  SourceInfFileName,
IN PCWSTR  OEMSourceMediaLocation,
IN DWORD  OEMSourceMediaType,
IN DWORD  CopyStyle,
OUT PWSTR DestinationInfFileName  OPTIONAL,
IN DWORD  DestinationInfFileNameSize,
OUT PDWORD RequiredSize  OPTIONAL,
OUT PWSTR *DestinationInfFileNameComponent  OPTIONAL 
)

Definition at line 2308 of file install.c.

2317{
2318 BOOL ret = FALSE;
2319
2320 TRACE("%s %s 0x%lx 0x%lx %p 0%lu %p %p\n",
2321 debugstr_w(SourceInfFileName), debugstr_w(OEMSourceMediaLocation), OEMSourceMediaType,
2322 CopyStyle, DestinationInfFileName, DestinationInfFileNameSize,
2323 RequiredSize, DestinationInfFileNameComponent);
2324
2325 if (!SourceInfFileName)
2326 SetLastError(ERROR_INVALID_PARAMETER);
2327 else if (OEMSourceMediaType != SPOST_NONE && OEMSourceMediaType != SPOST_PATH && OEMSourceMediaType != SPOST_URL)
2328 SetLastError(ERROR_INVALID_PARAMETER);
2329 else if (CopyStyle & ~(SP_COPY_DELETESOURCE | SP_COPY_REPLACEONLY | SP_COPY_NOOVERWRITE | SP_COPY_OEMINF_CATALOG_ONLY))
2330 {
2331 TRACE("Unknown flags: 0x%08lx\n", CopyStyle & ~(SP_COPY_DELETESOURCE | SP_COPY_REPLACEONLY | SP_COPY_NOOVERWRITE | SP_COPY_OEMINF_CATALOG_ONLY));
2332 SetLastError(ERROR_INVALID_FLAGS);
2333 }
2334 else if (!DestinationInfFileName && DestinationInfFileNameSize > 0)
2335 SetLastError(ERROR_INVALID_PARAMETER);
2336 else if (CopyStyle & SP_COPY_OEMINF_CATALOG_ONLY)
2337 {
2338 FIXME("CopyStyle 0x%x not supported\n", SP_COPY_OEMINF_CATALOG_ONLY);
2339 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2340 }
2341 else
2342 {
2343 HANDLE hSearch = INVALID_HANDLE_VALUE;
2344 WIN32_FIND_DATAW FindFileData;
2345 BOOL AlreadyExists;
2346 DWORD NextFreeNumber = 0;
2347 SIZE_T len;
2348 LPWSTR pFullFileName = NULL;
2349 LPWSTR pFileName; /* Pointer into pFullFileName buffer */
2350 HANDLE hSourceFile = INVALID_HANDLE_VALUE;
2351
2352 if (OEMSourceMediaType == SPOST_PATH || OEMSourceMediaType == SPOST_URL)
2353 FIXME("OEMSourceMediaType 0x%lx ignored\n", OEMSourceMediaType);
2354
2355 /* Check if source file exists, and open it */
2356 if (strchrW(SourceInfFileName, '\\' ) || strchrW(SourceInfFileName, '/' ))
2357 {
2358 WCHAR *path;
2359
2360 if (!(len = GetFullPathNameW(SourceInfFileName, 0, NULL, NULL)))
2361 return FALSE;
2362 if (!(path = MyMalloc(len * sizeof(WCHAR))))
2363 {
2364 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2365 return FALSE;
2366 }
2367 GetFullPathNameW(SourceInfFileName, len, path, NULL);
2368 hSourceFile = CreateFileW(
2369 path, FILE_READ_DATA | FILE_READ_ATTRIBUTES,
2370 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
2371 NULL, OPEN_EXISTING, 0, NULL);
2372 MyFree(path);
2373 }
2374 else /* try Windows directory */
2375 {
2376 WCHAR *path, *p;
2377 static const WCHAR Inf[] = {'\\','i','n','f','\\',0};
2378 static const WCHAR System32[] = {'\\','s','y','s','t','e','m','3','2','\\',0};
2379
2380 len = GetWindowsDirectoryW(NULL, 0) + strlenW(SourceInfFileName) + 12;
2381 if (!(path = MyMalloc(len * sizeof(WCHAR))))
2382 {
2383 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2384 return FALSE;
2385 }
2386 GetWindowsDirectoryW(path, len);
2387 p = path + strlenW(path);
2388 strcpyW(p, Inf);
2389 strcatW(p, SourceInfFileName);
2390 hSourceFile = CreateFileW(
2391 path, FILE_READ_DATA | FILE_READ_ATTRIBUTES,
2392 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
2393 NULL, OPEN_EXISTING, 0, NULL);
2394 if (hSourceFile == INVALID_HANDLE_VALUE)
2395 {
2396 strcpyW(p, System32);
2397 strcatW(p, SourceInfFileName);
2398 hSourceFile = CreateFileW(
2399 path, FILE_READ_DATA | FILE_READ_ATTRIBUTES,
2400 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
2401 NULL, OPEN_EXISTING, 0, NULL);
2402 }
2403 MyFree(path);
2404 }
2405 if (hSourceFile == INVALID_HANDLE_VALUE)
2406 {
2407 SetLastError(ERROR_FILE_NOT_FOUND);
2408 goto cleanup;
2409 }
2410
2411 /* Prepare .inf file specification */
2412 len = MAX_PATH + 1 + strlenW(InfDirectory) + 13;
2413 pFullFileName = MyMalloc(len * sizeof(WCHAR));
2414 if (!pFullFileName)
2415 {
2416 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2417 goto cleanup;
2418 }
2419 len = GetSystemWindowsDirectoryW(pFullFileName, MAX_PATH);
2420 if (len == 0 || len > MAX_PATH)
2421 goto cleanup;
2422 if (pFullFileName[strlenW(pFullFileName) - 1] != '\\')
2423 strcatW(pFullFileName, BackSlash);
2424 strcatW(pFullFileName, InfDirectory);
2425 pFileName = &pFullFileName[strlenW(pFullFileName)];
2426
2427 /* Search if the specified .inf file already exists in %WINDIR%\Inf */
2428 AlreadyExists = FALSE;
2429 strcpyW(pFileName, OemFileMask);
2430 hSearch = FindFirstFileW(pFullFileName, &FindFileData);
2431 if (hSearch != INVALID_HANDLE_VALUE)
2432 {
2433 LARGE_INTEGER SourceFileSize;
2434
2435 if (GetFileSizeEx(hSourceFile, &SourceFileSize))
2436 {
2437 do
2438 {
2439 LARGE_INTEGER DestFileSize;
2440 HANDLE hDestFile;
2441
2442 strcpyW(pFileName, FindFileData.cFileName);
2443 hDestFile = CreateFileW(
2444 pFullFileName, FILE_READ_DATA | FILE_READ_ATTRIBUTES,
2445 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
2446 NULL, OPEN_EXISTING, 0, NULL);
2447 if (hDestFile != INVALID_HANDLE_VALUE)
2448 {
2449 if (GetFileSizeEx(hDestFile, &DestFileSize)
2450 && DestFileSize.QuadPart == SourceFileSize.QuadPart
2451 && !compare_files(hSourceFile, hDestFile))
2452 {
2453 TRACE("%s already exists as %s\n",
2454 debugstr_w(SourceInfFileName), debugstr_w(pFileName));
2455 AlreadyExists = TRUE;
2456 }
2457 }
2458 } while (!AlreadyExists && FindNextFileW(hSearch, &FindFileData));
2459 }
2460 FindClose(hSearch);
2461 hSearch = INVALID_HANDLE_VALUE;
2462 }
2463
2464 if (!AlreadyExists && CopyStyle & SP_COPY_REPLACEONLY)
2465 {
2466 /* FIXME: set DestinationInfFileName, RequiredSize, DestinationInfFileNameComponent */
2467 SetLastError(ERROR_FILE_NOT_FOUND);
2468 goto cleanup;
2469 }
2470 else if (AlreadyExists && (CopyStyle & SP_COPY_NOOVERWRITE))
2471 {
2472 DWORD Size = strlenW(pFileName) + 1;
2473
2474 if (RequiredSize)
2475 *RequiredSize = Size;
2476 if (DestinationInfFileNameSize == 0)
2477 SetLastError(ERROR_FILE_EXISTS);
2478 else if (DestinationInfFileNameSize < Size)
2479 SetLastError(ERROR_INSUFFICIENT_BUFFER);
2480 else
2481 {
2482 SetLastError(ERROR_FILE_EXISTS);
2483 strcpyW(DestinationInfFileName, pFileName);
2484 }
2485 goto cleanup;
2486 }
2487
2488 /* Search the number to give to OEM??.INF */
2489 strcpyW(pFileName, OemFileMask);
2490 hSearch = FindFirstFileW(pFullFileName, &FindFileData);
2491 if (hSearch == INVALID_HANDLE_VALUE)
2492 {
2493 if (GetLastError() != ERROR_FILE_NOT_FOUND)
2494 goto cleanup;
2495 }
2496 else
2497 {
2498 do
2499 {
2500 DWORD CurrentNumber;
2501 if (swscanf(FindFileData.cFileName, OemFileSpecification, &CurrentNumber) == 1
2502 && CurrentNumber <= 99999)
2503 {
2504 if (CurrentNumber >= NextFreeNumber)
2505 NextFreeNumber = CurrentNumber + 1;
2506 }
2507 } while (FindNextFileW(hSearch, &FindFileData));
2508 }
2509
2510 if (NextFreeNumber > 99999)
2511 {
2512 ERR("Too much custom .inf files\n");
2513 SetLastError(ERROR_GEN_FAILURE);
2514 goto cleanup;
2515 }
2516
2517 /* Create the full path: %WINDIR%\Inf\OEM{XXXXX}.inf */
2518 sprintfW(pFileName, OemFileSpecification, NextFreeNumber);
2519 TRACE("Next available file is %s\n", debugstr_w(pFileName));
2520
2521 if (!CopyFileW(SourceInfFileName, pFullFileName, TRUE))
2522 {
2523 TRACE("CopyFileW() failed with error 0x%lx\n", GetLastError());
2524 goto cleanup;
2525 }
2526
2527 len = strlenW(pFullFileName) + 1;
2528 if (RequiredSize)
2529 *RequiredSize = len;
2530 if (DestinationInfFileName)
2531 {
2532 if (DestinationInfFileNameSize >= len)
2533 {
2534 strcpyW(DestinationInfFileName, pFullFileName);
2535 if (DestinationInfFileNameComponent)
2536 *DestinationInfFileNameComponent = &DestinationInfFileName[pFileName - pFullFileName];
2537 }
2538 else
2539 {
2540 SetLastError(ERROR_INSUFFICIENT_BUFFER);
2541 goto cleanup;
2542 }
2543 }
2544
2545 if (CopyStyle & SP_COPY_DELETESOURCE)
2546 {
2547 if (!DeleteFileW(SourceInfFileName))
2548 {
2549 TRACE("DeleteFileW() failed with error 0x%lx\n", GetLastError());
2550 goto cleanup;
2551 }
2552 }
2553
2554 ret = TRUE;
2555
2556cleanup:
2557 if (hSourceFile != INVALID_HANDLE_VALUE)
2558 CloseHandle(hSourceFile);
2559 if (hSearch != INVALID_HANDLE_VALUE)
2560 FindClose(hSearch);
2561 MyFree(pFullFileName);
2562 }
2563
2564 TRACE("Returning %d\n", ret);
2565 if (ret) SetLastError(ERROR_SUCCESS);
2566 return ret;
2567}
ERROR_CALL_NOT_IMPLEMENTED
#define ERROR_CALL_NOT_IMPLEMENTED
Definition: compat.h:102
OPEN_EXISTING
#define OPEN_EXISTING
Definition: compat.h:775
CreateFileW
#define CreateFileW
Definition: compat.h:741
GetFileSizeEx
#define GetFileSizeEx
Definition: compat.h:757
FILE_SHARE_READ
#define FILE_SHARE_READ
Definition: compat.h:136
CopyFileW
BOOL WINAPI CopyFileW(IN LPCWSTR lpExistingFileName, IN LPCWSTR lpNewFileName, IN BOOL bFailIfExists)
Definition: copy.c:439
DeleteFileW
BOOL WINAPI DeleteFileW(IN LPCWSTR lpFileName)
Definition: delete.c:39
FindFirstFileW
HANDLE WINAPI FindFirstFileW(IN LPCWSTR lpFileName, OUT LPWIN32_FIND_DATAW lpFindFileData)
Definition: find.c:320
FindClose
BOOL WINAPI FindClose(HANDLE hFindFile)
Definition: find.c:502
FindNextFileW
BOOL WINAPI FindNextFileW(IN HANDLE hFindFile, OUT LPWIN32_FIND_DATAW lpFindFileData)
Definition: find.c:382
GetSystemWindowsDirectoryW
UINT WINAPI GetSystemWindowsDirectoryW(OUT LPWSTR lpBuffer, IN UINT uSize)
Definition: path.c:2397
GetFullPathNameW
DWORD WINAPI GetFullPathNameW(IN LPCWSTR lpFileName, IN DWORD nBufferLength, OUT LPWSTR lpBuffer, OUT LPWSTR *lpFilePart)
Definition: path.c:1106
OemFileMask
static const WCHAR OemFileMask[]
Definition: install.c:31
compare_files
static int compare_files(HANDLE file1, HANDLE file2)
Definition: install.c:2282
OemFileSpecification
static const WCHAR OemFileSpecification[]
Definition: install.c:32
InfDirectory
static const WCHAR InfDirectory[]
Definition: install.c:30
swscanf
_Check_return_ _CRTIMP int __cdecl swscanf(_In_z_ const wchar_t *_Src, _In_z_ _Scanf_format_string_ const wchar_t *_Format,...)
FILE_SHARE_WRITE
#define FILE_SHARE_WRITE
Definition: nt_native.h:681
FILE_READ_DATA
#define FILE_READ_DATA
Definition: nt_native.h:628
FILE_READ_ATTRIBUTES
#define FILE_READ_ATTRIBUTES
Definition: nt_native.h:647
FILE_SHARE_DELETE
#define FILE_SHARE_DELETE
Definition: nt_native.h:682
SP_COPY_OEMINF_CATALOG_ONLY
#define SP_COPY_OEMINF_CATALOG_ONLY
Definition: setupapi.h:494
SP_COPY_NOOVERWRITE
#define SP_COPY_NOOVERWRITE
Definition: setupapi.h:480
SP_COPY_DELETESOURCE
#define SP_COPY_DELETESOURCE
Definition: setupapi.h:476
SP_COPY_REPLACEONLY
#define SP_COPY_REPLACEONLY
Definition: setupapi.h:477
SPOST_URL
#define SPOST_URL
Definition: setupapi.h:611
SPOST_PATH
#define SPOST_PATH
Definition: setupapi.h:610
WIN32_FIND_DATAA
Definition: shtypes.idl:80
SIZE_T
ULONG_PTR SIZE_T
Definition: typedefs.h:80
_LARGE_INTEGER
Definition: typedefs.h:103
_LARGE_INTEGER::QuadPart
LONGLONG QuadPart
Definition: typedefs.h:114
Size
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG Size
Definition: wdfdevice.h:4533
ERROR_FILE_EXISTS
#define ERROR_FILE_EXISTS
Definition: winerror.h:165
ERROR_INVALID_FLAGS
#define ERROR_INVALID_FLAGS
Definition: winerror.h:583

Referenced by SetupCopyOEMInfA(), and SetupDiInstallDevice().

◆ SetupInstallFilesFromInfSectionA()

BOOL WINAPI SetupInstallFilesFromInfSectionA ( HINF  hinf,
HINF  hlayout,
HSPFILEQ  queue,
PCSTR  section,
PCSTR  src_root,
UINT  flags 
)

Definition at line 1210 of file install.c.

1212{
1213 UNICODE_STRING sectionW;
1214 BOOL ret = FALSE;
1215
1216 if (!RtlCreateUnicodeStringFromAsciiz( &sectionW, section ))
1217 {
1218 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1219 return FALSE;
1220 }
1221 if (!src_root)
1222 ret = SetupInstallFilesFromInfSectionW( hinf, hlayout, queue, sectionW.Buffer,
1223 NULL, flags );
1224 else
1225 {
1226 UNICODE_STRING srcW;
1227 if (RtlCreateUnicodeStringFromAsciiz( &srcW, src_root ))
1228 {
1229 ret = SetupInstallFilesFromInfSectionW( hinf, hlayout, queue, sectionW.Buffer,
1230 srcW.Buffer, flags );
1231 RtlFreeUnicodeString( &srcW );
1232 }
1233 else SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1234 }
1235 RtlFreeUnicodeString( &sectionW );
1236 return ret;
1237}
queue
Definition: _queue.h:67
SetupInstallFilesFromInfSectionW
BOOL WINAPI SetupInstallFilesFromInfSectionW(HINF hinf, HINF hlayout, HSPFILEQ queue, PCWSTR section, PCWSTR src_root, UINT flags)
Definition: install.c:1243

◆ SetupInstallFilesFromInfSectionW()

BOOL WINAPI SetupInstallFilesFromInfSectionW ( HINF  hinf,
HINF  hlayout,
HSPFILEQ  queue,
PCWSTR  section,
PCWSTR  src_root,
UINT  flags 
)

Definition at line 1243 of file install.c.

1245{
1246 struct files_callback_info info;
1247
1248 info.queue = queue;
1249 info.src_root = src_root;
1250 info.copy_flags = flags;
1251 info.layout = hlayout;
1252 return iterate_section_fields( hinf, section, CopyFiles, copy_files_callback, &info );
1253}
iterate_section_fields
static HRESULT iterate_section_fields(HINF hinf, PCWSTR section, PCWSTR key, iterate_fields_func callback, void *arg)
Definition: install.c:263
CopyFiles
static const WCHAR CopyFiles[]
Definition: install.c:107
copy_files_callback
static BOOL copy_files_callback(HINF hinf, PCWSTR field, void *arg)
Definition: install.c:158
files_callback_info::src_root
PCWSTR src_root
Definition: install.c:61
files_callback_info::queue
HSPFILEQ queue
Definition: install.c:60

Referenced by SetupInstallFilesFromInfSectionA().

◆ SetupInstallFromInfSectionA()

BOOL WINAPI SetupInstallFromInfSectionA ( HWND  owner,
HINF  hinf,
PCSTR  section,
UINT  flags,
HKEY  key_root,
PCSTR  src_root,
UINT  copy_flags,
PSP_FILE_CALLBACK_A  callback,
PVOID  context,
HDEVINFO  devinfo,
PSP_DEVINFO_DATA  devinfo_data 
)

Definition at line 1259 of file install.c.

1263{
1264 UNICODE_STRING sectionW, src_rootW;
1265 struct callback_WtoA_context ctx;
1266 BOOL ret = FALSE;
1267
1268 src_rootW.Buffer = NULL;
1269 if (src_root && !RtlCreateUnicodeStringFromAsciiz( &src_rootW, src_root ))
1270 {
1271 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1272 return FALSE;
1273 }
1274
1275 if (RtlCreateUnicodeStringFromAsciiz( &sectionW, section ))
1276 {
1277 ctx.orig_context = context;
1278 ctx.orig_handler = callback;
1279 ret = SetupInstallFromInfSectionW( owner, hinf, sectionW.Buffer, flags, key_root,
1280 src_rootW.Buffer, copy_flags, QUEUE_callback_WtoA,
1281 &ctx, devinfo, devinfo_data );
1282 RtlFreeUnicodeString( &sectionW );
1283 }
1284 else SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1285
1286 RtlFreeUnicodeString( &src_rootW );
1287 return ret;
1288}
QUEUE_callback_WtoA
UINT CALLBACK QUEUE_callback_WtoA(void *context, UINT notification, UINT_PTR param1, UINT_PTR param2)
Definition: queue.c:187
callback_WtoA_context
Definition: setupapi_private.h:288

Referenced by test_install_from().

◆ SetupInstallFromInfSectionW()

BOOL WINAPI SetupInstallFromInfSectionW ( HWND  owner,
HINF  hinf,
PCWSTR  section,
UINT  flags,
HKEY  key_root,
PCWSTR  src_root,
UINT  copy_flags,
PSP_FILE_CALLBACK_W  callback,
PVOID  context,
HDEVINFO  devinfo,
PSP_DEVINFO_DATA  devinfo_data 
)

Definition at line 1330 of file install.c.

1334{
1335 struct needs_callback_info needs_info;
1336
1337 /* Parse 'Include' and 'Needs' directives */
1338 iterate_section_fields( hinf, section, Include, include_callback, NULL);
1339 needs_info.type = 0;
1340 needs_info.owner = owner;
1341 needs_info.flags = flags;
1342 needs_info.key_root = key_root;
1343 needs_info.src_root = src_root;
1344 needs_info.copy_flags = copy_flags;
1345 needs_info.callback = callback;
1346 needs_info.context = context;
1347 needs_info.devinfo = devinfo;
1348 needs_info.devinfo_data = devinfo_data;
1349 iterate_section_fields( hinf, section, Needs, needs_callback, &needs_info);
1350
1351 if (flags & SPINST_FILES)
1352 {
1353 SP_DEVINSTALL_PARAMS_W install_params;
1354 struct files_callback_info info;
1355 HSPFILEQ queue = NULL;
1356 BOOL use_custom_queue;
1357 BOOL ret;
1358
1359 install_params.cbSize = sizeof(SP_DEVINSTALL_PARAMS);
1360 use_custom_queue = SetupDiGetDeviceInstallParamsW(devinfo, devinfo_data, &install_params) && (install_params.Flags & DI_NOVCP);
1361 if (!use_custom_queue && ((queue = SetupOpenFileQueue()) == (HSPFILEQ)INVALID_HANDLE_VALUE ))
1362 return FALSE;
1363 info.queue = use_custom_queue ? install_params.FileQueue : queue;
1364 info.src_root = src_root;
1365 info.copy_flags = copy_flags;
1366 info.layout = hinf;
1367 ret = (iterate_section_fields( hinf, section, CopyFiles, copy_files_callback, &info ) &&
1368 iterate_section_fields( hinf, section, DelFiles, delete_files_callback, &info ) &&
1369 iterate_section_fields( hinf, section, RenFiles, rename_files_callback, &info ));
1370 if (!use_custom_queue)
1371 {
1372 if (ret)
1373 ret = SetupCommitFileQueueW( owner, queue, callback, context );
1374 SetupCloseFileQueue( queue );
1375 }
1376 if (!ret) return FALSE;
1377 }
1378 if (flags & SPINST_INIFILES)
1379 {
1380 if (!iterate_section_fields( hinf, section, UpdateInis, update_ini_callback, NULL ) ||
1381 !iterate_section_fields( hinf, section, UpdateIniFields,
1382 update_ini_fields_callback, NULL ))
1383 return FALSE;
1384 }
1385 if (flags & SPINST_INI2REG)
1386 {
1387 if (!iterate_section_fields( hinf, section, Ini2Reg, ini2reg_callback, NULL ))
1388 return FALSE;
1389 }
1390 if (flags & SPINST_LOGCONFIG)
1391 {
1392 if (!iterate_section_fields( hinf, section, LogConf, logconf_callback, NULL ))
1393 return FALSE;
1394 }
1395 if (flags & SPINST_REGSVR)
1396 {
1397 struct register_dll_info info;
1398
1399 info.unregister = FALSE;
1400 if (flags & SPINST_REGISTERCALLBACKAWARE)
1401 {
1402 info.callback = callback;
1403 info.callback_context = context;
1404 }
1405 else info.callback = NULL;
1406
1407 if (!iterate_section_fields( hinf, section, RegisterDlls, register_dlls_callback, &info ))
1408 return FALSE;
1409
1410#ifdef __WINESRC__
1411 if (!iterate_section_fields( hinf, section, WineFakeDlls, fake_dlls_callback, NULL ))
1412 return FALSE;
1413#endif // __WINESRC__
1414 }
1415 if (flags & SPINST_UNREGSVR)
1416 {
1417 struct register_dll_info info;
1418
1419 info.unregister = TRUE;
1420 if (flags & SPINST_REGISTERCALLBACKAWARE)
1421 {
1422 info.callback = callback;
1423 info.callback_context = context;
1424 }
1425 else info.callback = NULL;
1426
1427 if (!iterate_section_fields( hinf, section, UnregisterDlls, register_dlls_callback, &info ))
1428 return FALSE;
1429 }
1430 if (flags & SPINST_REGISTRY)
1431 {
1432 struct registry_callback_info info;
1433
1434 info.default_root = key_root;
1435 info.delete = TRUE;
1436 if (!iterate_section_fields( hinf, section, DelReg, registry_callback, &info ))
1437 return FALSE;
1438 info.delete = FALSE;
1439 if (!iterate_section_fields( hinf, section, AddReg, registry_callback, &info ))
1440 return FALSE;
1441 }
1442 if (flags & SPINST_BITREG)
1443 {
1444 if (!iterate_section_fields( hinf, section, BitReg, bitreg_callback, NULL ))
1445 return FALSE;
1446 }
1447 if (flags & SPINST_PROFILEITEMS)
1448 {
1449 if (!iterate_section_fields( hinf, section, ProfileItems, profile_items_callback, NULL ))
1450 return FALSE;
1451 }
1452 if (flags & SPINST_COPYINF)
1453 {
1454 if (!iterate_section_fields( hinf, section, CopyINF, copy_inf_callback, NULL ))
1455 return FALSE;
1456 }
1457
1458 return TRUE;
1459}
SetupDiGetDeviceInstallParamsW
BOOL WINAPI SetupDiGetDeviceInstallParamsW(IN HDEVINFO DeviceInfoSet, IN PSP_DEVINFO_DATA DeviceInfoData OPTIONAL, OUT PSP_DEVINSTALL_PARAMS_W DeviceInstallParams)
Definition: devinst.c:4451
profile_items_callback
static BOOL profile_items_callback(IN HINF hInf, IN PCWSTR SectionName, IN PVOID Arg)
Definition: install.c:891
copy_inf_callback
static BOOL copy_inf_callback(HINF hinf, PCWSTR field, void *arg)
Definition: install.c:1162
DelFiles
static const WCHAR DelFiles[]
Definition: install.c:108
UpdateInis
static const WCHAR UpdateInis[]
Definition: install.c:115
needs_callback
static BOOL needs_callback(HINF hinf, PCWSTR field, void *arg)
Definition: install.c:1307
RenFiles
static const WCHAR RenFiles[]
Definition: install.c:109
logconf_callback
static BOOL logconf_callback(HINF hinf, PCWSTR field, void *arg)
Definition: install.c:827
update_ini_callback
static BOOL update_ini_callback(HINF hinf, PCWSTR field, void *arg)
Definition: install.c:766
Ini2Reg
static const WCHAR Ini2Reg[]
Definition: install.c:110
Needs
static const WCHAR Needs[]
Definition: install.c:122
registry_callback
static BOOL registry_callback(HINF hinf, PCWSTR field, void *arg)
Definition: install.c:422
Include
static const WCHAR Include[]
Definition: install.c:121
delete_files_callback
static BOOL delete_files_callback(HINF hinf, PCWSTR field, void *arg)
Definition: install.c:175
ProfileItems
static const WCHAR ProfileItems[]
Definition: install.c:120
include_callback
static BOOL include_callback(HINF hinf, PCWSTR field, void *arg)
Definition: install.c:1296
register_dlls_callback
static BOOL register_dlls_callback(HINF hinf, PCWSTR field, void *arg)
Definition: install.c:666
rename_files_callback
static BOOL rename_files_callback(HINF hinf, PCWSTR field, void *arg)
Definition: install.c:188
LogConf
static const WCHAR LogConf[]
Definition: install.c:111
ini2reg_callback
static BOOL ini2reg_callback(HINF hinf, PCWSTR field, void *arg)
Definition: install.c:821
BitReg
static const WCHAR BitReg[]
Definition: install.c:114
bitreg_callback
static BOOL bitreg_callback(HINF hinf, PCWSTR field, void *arg)
Definition: install.c:833
AddReg
static const WCHAR AddReg[]
Definition: install.c:112
RegisterDlls
static const WCHAR RegisterDlls[]
Definition: install.c:118
update_ini_fields_callback
static BOOL update_ini_fields_callback(HINF hinf, PCWSTR field, void *arg)
Definition: install.c:815
DelReg
static const WCHAR DelReg[]
Definition: install.c:113
UnregisterDlls
static const WCHAR UnregisterDlls[]
Definition: install.c:119
UpdateIniFields
static const WCHAR UpdateIniFields[]
Definition: install.c:117
CopyINF
static const WCHAR CopyINF[]
Definition: install.c:116
SetupOpenFileQueue
#define SetupOpenFileQueue
Definition: fileqsup.c:29
SetupCommitFileQueueW
#define SetupCommitFileQueueW
Definition: fileqsup.c:33
SetupCloseFileQueue
#define SetupCloseFileQueue
Definition: fileqsup.c:30
SPINST_BITREG
#define SPINST_BITREG
Definition: setupapi.h:593
SPINST_UNREGSVR
#define SPINST_UNREGSVR
Definition: setupapi.h:595
DI_NOVCP
#define DI_NOVCP
Definition: setupapi.h:49
SPINST_PROFILEITEMS
#define SPINST_PROFILEITEMS
Definition: setupapi.h:596
SPINST_INI2REG
#define SPINST_INI2REG
Definition: setupapi.h:591
SP_DEVINSTALL_PARAMS
SP_DEVINSTALL_PARAMS_A SP_DEVINSTALL_PARAMS
Definition: setupapi.h:1155
SPINST_REGSVR
#define SPINST_REGSVR
Definition: setupapi.h:594
SPINST_INIFILES
#define SPINST_INIFILES
Definition: setupapi.h:589
SPINST_LOGCONFIG
#define SPINST_LOGCONFIG
Definition: setupapi.h:588
SPINST_FILES
#define SPINST_FILES
Definition: setupapi.h:592
_SP_DEVINSTALL_PARAMS_W
Definition: setupapi.h:890
_SP_DEVINSTALL_PARAMS_W::FileQueue
HSPFILEQ FileQueue
Definition: setupapi.h:897
_SP_DEVINSTALL_PARAMS_W::cbSize
DWORD cbSize
Definition: setupapi.h:891
_SP_DEVINSTALL_PARAMS_W::Flags
DWORD Flags
Definition: setupapi.h:892
files_callback_info::copy_flags
UINT copy_flags
Definition: install.c:62
needs_callback_info::devinfo
HDEVINFO devinfo
Definition: install.c:93
needs_callback_info::src_root
LPCWSTR src_root
Definition: install.c:89
needs_callback_info::owner
HWND owner
Definition: install.c:86
needs_callback_info::key_root
HKEY key_root
Definition: install.c:88
needs_callback_info::context
PVOID context
Definition: install.c:92
needs_callback_info::copy_flags
UINT copy_flags
Definition: install.c:90
needs_callback_info::devinfo_data
PSP_DEVINFO_DATA devinfo_data
Definition: install.c:94

Referenced by InstallDeviceData(), InstallHinfSectionW(), InstallInfSections(), InstallLiveCD(), InstallOneInterface(), InstallOneService(), InstallSysSetupInfComponents(), MMSYS_InstallDevice(), needs_callback(), RegisterDlls(), SaveFontSubstitutionSettings(), SetupDiInstallClassExW(), SetupDiInstallDevice(), SetupDiInstallDriverFiles(), SetupDiRegisterCoDeviceInstallers(), SetupInstallFromInfSectionA(), and spapi_install().

◆ SetupInstallServicesFromInfSectionA()

BOOL WINAPI SetupInstallServicesFromInfSectionA ( HINF  Inf,
PCSTR  SectionName,
DWORD  Flags 
)

Definition at line 1624 of file install.c.

1625{
1626 return SetupInstallServicesFromInfSectionExA( Inf, SectionName, Flags,
1627 NULL, NULL, NULL, NULL );
1628}
SetupInstallServicesFromInfSectionExA
BOOL WINAPI SetupInstallServicesFromInfSectionExA(HINF hinf, PCSTR sectionname, DWORD flags, HDEVINFO devinfo, PSP_DEVINFO_DATA devinfo_data, PVOID reserved1, PVOID reserved2)
Definition: install.c:1633
Flags
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170

Referenced by test_install_svc_from().

◆ SetupInstallServicesFromInfSectionExA()

BOOL WINAPI SetupInstallServicesFromInfSectionExA ( HINF  hinf,
PCSTR  sectionname,
DWORD  flags,
HDEVINFO  devinfo,
PSP_DEVINFO_DATA  devinfo_data,
PVOID  reserved1,
PVOID  reserved2 
)

Definition at line 1633 of file install.c.

1634{
1635 UNICODE_STRING sectionnameW;
1636 BOOL ret = FALSE;
1637
1638 if (RtlCreateUnicodeStringFromAsciiz( &sectionnameW, sectionname ))
1639 {
1640 ret = SetupInstallServicesFromInfSectionExW( hinf, sectionnameW.Buffer, flags, devinfo, devinfo_data, reserved1, reserved2 );
1641 RtlFreeUnicodeString( &sectionnameW );
1642 }
1643 else
1644 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1645
1646 return ret;
1647}
reserved2
uint8_t reserved2[12]
Definition: fsck.fat.h:23

Referenced by SetupInstallServicesFromInfSectionA(), and test_SetupInstallServicesFromInfSectionExA().

◆ SetupInstallServicesFromInfSectionExW()

BOOL WINAPI SetupInstallServicesFromInfSectionExW ( HINF  hinf,
PCWSTR  sectionname,
DWORD  flags,
HDEVINFO  DeviceInfoSet,
PSP_DEVINFO_DATA  DeviceInfoData,
PVOID  reserved1,
PVOID  reserved2 
)

Definition at line 2081 of file install.c.

2082{
2083 struct DeviceInfoSet *list = NULL;
2084 BOOL ret = FALSE;
2085
2086 TRACE("%p, %s, 0x%lx, %p, %p, %p, %p\n", hinf, debugstr_w(sectionname),
2087 flags, DeviceInfoSet, DeviceInfoData, reserved1, reserved2);
2088
2089 if (!sectionname)
2090 SetLastError(ERROR_INVALID_PARAMETER);
2091 else if (flags & ~(SPSVCINST_TAGTOFRONT | SPSVCINST_DELETEEVENTLOGENTRY | SPSVCINST_NOCLOBBER_DISPLAYNAME | SPSVCINST_NOCLOBBER_STARTTYPE | SPSVCINST_NOCLOBBER_ERRORCONTROL | SPSVCINST_NOCLOBBER_LOADORDERGROUP | SPSVCINST_NOCLOBBER_DEPENDENCIES | SPSVCINST_STOPSERVICE))
2092 {
2093 TRACE("Unknown flags: 0x%08lx\n", flags & ~(SPSVCINST_TAGTOFRONT | SPSVCINST_DELETEEVENTLOGENTRY | SPSVCINST_NOCLOBBER_DISPLAYNAME | SPSVCINST_NOCLOBBER_STARTTYPE | SPSVCINST_NOCLOBBER_ERRORCONTROL | SPSVCINST_NOCLOBBER_LOADORDERGROUP | SPSVCINST_NOCLOBBER_DEPENDENCIES | SPSVCINST_STOPSERVICE));
2094 SetLastError(ERROR_INVALID_FLAGS);
2095 }
2096 else if (DeviceInfoSet == (HDEVINFO)INVALID_HANDLE_VALUE)
2097 SetLastError(ERROR_INVALID_HANDLE);
2098 else if (DeviceInfoSet && (list = (struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEVICE_INFO_SET_MAGIC)
2099 SetLastError(ERROR_INVALID_HANDLE);
2100 else if (DeviceInfoData && DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
2101 SetLastError(ERROR_INVALID_USER_BUFFER);
2102 else if (reserved1 != NULL || reserved2 != NULL)
2103 SetLastError(ERROR_INVALID_PARAMETER);
2104 else
2105 {
2106 struct needs_callback_info needs_info;
2107 LPWSTR ServiceName = NULL;
2108 LPWSTR ServiceSection = NULL;
2109 INT ServiceFlags;
2110 INFCONTEXT ContextService;
2111 BOOL bNeedReboot = FALSE;
2112
2113 /* Parse 'Include' and 'Needs' directives */
2114 iterate_section_fields( hinf, sectionname, Include, include_callback, NULL);
2115 needs_info.type = 1;
2116 needs_info.flags = flags;
2117 needs_info.devinfo = DeviceInfoSet;
2118 needs_info.devinfo_data = DeviceInfoData;
2119 needs_info.reserved1 = reserved1;
2120 needs_info.reserved2 = reserved2;
2121 iterate_section_fields( hinf, sectionname, Needs, needs_callback, &needs_info);
2122
2123 if (flags & SPSVCINST_STOPSERVICE)
2124 {
2125 FIXME("Stopping the device not implemented\n");
2126 /* This may lead to require a reboot */
2127 /* bNeedReboot = TRUE; */
2128#if 0
2129 SERVICE_STATUS ServiceStatus;
2130 ret = ControlService(hService, SERVICE_CONTROL_STOP, &ServiceStatus);
2131 if (!ret && GetLastError() != ERROR_SERVICE_NOT_ACTIVE)
2132 goto done;
2133 if (ServiceStatus.dwCurrentState != SERVICE_STOP_PENDING && ServiceStatus.dwCurrentState != SERVICE_STOPPED)
2134 {
2135 SetLastError(ERROR_INSTALL_SERVICE_FAILURE);
2136 goto done;
2137 }
2138#endif
2139 flags &= ~SPSVCINST_STOPSERVICE;
2140 }
2141
2142 if (!(ret = SetupFindFirstLineW( hinf, sectionname, NULL, &ContextService )))
2143 {
2144 SetLastError( ERROR_SECTION_NOT_FOUND );
2145 goto done;
2146 }
2147
2148 ret = SetupFindFirstLineW(hinf, sectionname, AddService, &ContextService);
2149 while (ret)
2150 {
2151 if (!GetStringField(&ContextService, 1, &ServiceName))
2152 goto done;
2153
2154 ret = SetupGetIntField(
2155 &ContextService,
2156 2, /* Field index */
2157 &ServiceFlags);
2158 if (!ret)
2159 {
2160 /* The field may be empty. Ignore the error */
2161 ServiceFlags = 0;
2162 }
2163
2164 if (!GetStringField(&ContextService, 3, &ServiceSection))
2165 goto done;
2166
2167 ret = InstallOneService(list, hinf, ServiceSection, ServiceName, (ServiceFlags & ~SPSVCINST_ASSOCSERVICE) | flags);
2168 if (!ret)
2169 goto done;
2170
2171 if (ServiceFlags & SPSVCINST_ASSOCSERVICE)
2172 {
2173 ret = SetupDiSetDeviceRegistryPropertyW(DeviceInfoSet, DeviceInfoData, SPDRP_SERVICE, (LPBYTE)ServiceName, (strlenW(ServiceName) + 1) * sizeof(WCHAR));
2174 if (!ret)
2175 goto done;
2176 }
2177
2178 HeapFree(GetProcessHeap(), 0, ServiceName);
2179 HeapFree(GetProcessHeap(), 0, ServiceSection);
2180 ServiceName = ServiceSection = NULL;
2181 ret = SetupFindNextMatchLineW(&ContextService, AddService, &ContextService);
2182 }
2183
2184 if (bNeedReboot)
2185 SetLastError(ERROR_SUCCESS_REBOOT_REQUIRED);
2186 else
2187 SetLastError(ERROR_SUCCESS);
2188 ret = TRUE;
2189 }
2190done:
2191 TRACE("Returning %d\n", ret);
2192 return ret;
2193}
ServiceStatus
static SERVICE_STATUS ServiceStatus
Definition: browser.c:22
ERROR_INVALID_HANDLE
#define ERROR_INVALID_HANDLE
Definition: compat.h:98
SetupDiSetDeviceRegistryPropertyW
BOOL WINAPI SetupDiSetDeviceRegistryPropertyW(HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, DWORD Property, const BYTE *PropertyBuffer, DWORD PropertyBufferSize)
Definition: devinst.c:3452
AddService
static const WCHAR AddService[]
Definition: install.c:106
InstallOneService
static BOOL InstallOneService(struct DeviceInfoSet *list, IN HINF hInf, IN LPCWSTR ServiceSection, IN LPCWSTR ServiceName, IN UINT ServiceFlags)
Definition: install.c:1780
magic
u32_t magic(void)
ControlService
BOOL WINAPI ControlService(SC_HANDLE hService, DWORD dwControl, LPSERVICE_STATUS lpServiceStatus)
Definition: scm.c:622
SPSVCINST_ASSOCSERVICE
#define SPSVCINST_ASSOCSERVICE
Definition: setupapi.h:626
DeviceInfoData
_In_opt_ PSP_DEVINFO_DATA DeviceInfoData
Definition: setupapi.h:1528
SPDRP_SERVICE
#define SPDRP_SERVICE
Definition: setupapi.h:511
SPSVCINST_STOPSERVICE
#define SPSVCINST_STOPSERVICE
Definition: setupapi.h:634
SETUP_DEVICE_INFO_SET_MAGIC
#define SETUP_DEVICE_INFO_SET_MAGIC
Definition: setupapi_private.h:63
_SERVICE_STATUS
Definition: winsvc.h:98
_SERVICE_STATUS::dwCurrentState
DWORD dwCurrentState
Definition: winsvc.h:100
_SP_DEVINFO_DATA
Definition: setupapi.h:834
_SP_DEVINFO_DATA::cbSize
DWORD cbSize
Definition: setupapi.h:835
needs_callback_info::reserved1
PVOID reserved1
Definition: install.c:95
LPBYTE
unsigned char * LPBYTE
Definition: typedefs.h:53
ERROR_INVALID_USER_BUFFER
#define ERROR_INVALID_USER_BUFFER
Definition: winerror.h:1091
ERROR_SERVICE_NOT_ACTIVE
#define ERROR_SERVICE_NOT_ACTIVE
Definition: winerror.h:613
ERROR_INSTALL_SERVICE_FAILURE
#define ERROR_INSTALL_SERVICE_FAILURE
Definition: winerror.h:959
SERVICE_STOPPED
#define SERVICE_STOPPED
Definition: winsvc.h:21
SERVICE_STOP_PENDING
#define SERVICE_STOP_PENDING
Definition: winsvc.h:23
SERVICE_CONTROL_STOP
#define SERVICE_CONTROL_STOP
Definition: winsvc.h:36

Referenced by needs_callback(), SetupDiInstallClassExW(), SetupDiInstallDevice(), SetupInstallServicesFromInfSectionExA(), SetupInstallServicesFromInfSectionW(), and test_SetupInstallServicesFromInfSectionExW().

◆ SetupInstallServicesFromInfSectionW()

BOOL WINAPI SetupInstallServicesFromInfSectionW ( HINF  Inf,
PCWSTR  SectionName,
DWORD  Flags 
)

Definition at line 1615 of file install.c.

1616{
1617 return SetupInstallServicesFromInfSectionExW( Inf, SectionName, Flags,
1618 NULL, NULL, NULL, NULL );
1619}

Referenced by InstallHinfSectionW(), InstallInfSections(), and MMSYS_InstallDevice().

◆ update_ini_callback()

static BOOL update_ini_callback ( HINF  hinf,
PCWSTR  field,
void *  arg 
)
static

Definition at line 766 of file install.c.

767{
768 INFCONTEXT context;
769
770 BOOL ok = SetupFindFirstLineW( hinf, field, NULL, &context );
771
772 for (; ok; ok = SetupFindNextLine( &context, &context ))
773 {
774 WCHAR buffer[MAX_INF_STRING_LENGTH];
775 WCHAR filename[MAX_INF_STRING_LENGTH];
776 WCHAR section[MAX_INF_STRING_LENGTH];
777 WCHAR entry[MAX_INF_STRING_LENGTH];
778 WCHAR string[MAX_INF_STRING_LENGTH];
779 LPWSTR divider;
780
781 if (!SetupGetStringFieldW( &context, 1, filename,
782 sizeof(filename)/sizeof(WCHAR), NULL ))
783 continue;
784
785 if (!SetupGetStringFieldW( &context, 2, section,
786 sizeof(section)/sizeof(WCHAR), NULL ))
787 continue;
788
789 if (!SetupGetStringFieldW( &context, 4, buffer,
790 sizeof(buffer)/sizeof(WCHAR), NULL ))
791 continue;
792
793 divider = strchrW(buffer,'=');
794 if (divider)
795 {
796 *divider = 0;
797 strcpyW(entry,buffer);
798 divider++;
799 strcpyW(string,divider);
800 }
801 else
802 {
803 strcpyW(entry,buffer);
804 string[0]=0;
805 }
806
807 TRACE("Writing %s = %s in %s of file %s\n",debugstr_w(entry),
808 debugstr_w(string),debugstr_w(section),debugstr_w(filename));
809 WritePrivateProfileStringW(section,entry,string,filename);
810
811 }
812 return TRUE;
813}
WritePrivateProfileStringW
BOOL WINAPI WritePrivateProfileStringW(LPCWSTR section, LPCWSTR entry, LPCWSTR string, LPCWSTR filename)
Definition: profile.c:1453
filename
const char * filename
Definition: ioapi.h:137
entry
uint32_t entry
Definition: isohybrid.c:63

Referenced by SetupInstallFromInfSectionW().

◆ update_ini_fields_callback()

static BOOL update_ini_fields_callback ( HINF  hinf,
PCWSTR  field,
void *  arg 
)
static

Definition at line 815 of file install.c.

816{
817 FIXME( "should update ini fields %s\n", debugstr_w(field) );
818 return TRUE;
819}

Referenced by SetupInstallFromInfSectionW().

Variable Documentation

◆ AddReg

const WCHAR AddReg[] = {'A','d','d','R','e','g',0}
static

Definition at line 112 of file install.c.

Referenced by SetupInstallFromInfSectionW().

◆ AddService

const WCHAR AddService[] = {'A','d','d','S','e','r','v','i','c','e',0}
static

Definition at line 106 of file install.c.

Referenced by GetServices(), and SetupInstallServicesFromInfSectionExW().

◆ BackSlash

const WCHAR BackSlash[] = {'\\',0}
static

Definition at line 28 of file install.c.

Referenced by Concatenate(), profile_items_callback(), and SetupCopyOEMInfW().

◆ BitReg

const WCHAR BitReg[] = {'B','i','t','R','e','g',0}
static

Definition at line 114 of file install.c.

Referenced by SetupInstallFromInfSectionW().

◆ CmdLine

const WCHAR CmdLine[] = {'C','m','d','L','i','n','e',0}
static

Definition at line 48 of file install.c.

Referenced by _tWinMain(), BootMain(), CmdLineParse(), DosCreateProcess(), EfiEntry(), LoadSettings(), profile_items_callback(), RunControlPanelApplet(), shell(), Test_CommandLine(), TestCrossProcessEncrypt(), wmain(), and wWinMain().

◆ CopyFiles

const WCHAR CopyFiles[] = {'C','o','p','y','F','i','l','e','s',0}
static

Definition at line 107 of file install.c.

Referenced by SetupInstallFilesFromInfSectionW(), SetupInstallFileW(), and SetupInstallFromInfSectionW().

◆ CopyINF

const WCHAR CopyINF[] = {'C','o','p','y','I','N','F',0}
static

Definition at line 116 of file install.c.

Referenced by SetupInstallFromInfSectionW().

◆ DelFiles

const WCHAR DelFiles[] = {'D','e','l','F','i','l','e','s',0}
static

Definition at line 108 of file install.c.

Referenced by SetupInstallFromInfSectionW().

◆ DelReg

const WCHAR DelReg[] = {'D','e','l','R','e','g',0}
static

Definition at line 113 of file install.c.

Referenced by SetupInstallFromInfSectionW().

◆ DependenciesKey

const WCHAR DependenciesKey[] = {'D','e','p','e','n','d','e','n','c','i','e','s',0}
static

Definition at line 36 of file install.c.

Referenced by InstallOneService().

◆ DescriptionKey

const WCHAR DescriptionKey[] = {'D','e','s','c','r','i','p','t','i','o','n',0}
static

Definition at line 37 of file install.c.

Referenced by InstallOneService(), and IoReportHalResourceUsage().

◆ DisplayNameKey

const WCHAR DisplayNameKey[] = {'D','i','s','p','l','a','y','N','a','m','e',0}
static

Definition at line 38 of file install.c.

Referenced by InstallOneService().

◆ DisplayResource

const WCHAR DisplayResource[] = {'D','i','s','p','l','a','y','R','e','s','o','u','r','c','e',0}
static

Definition at line 55 of file install.c.

Referenced by profile_items_callback().

◆ DotLnk

const WCHAR DotLnk[] = {'.','l','n','k',0}
static

Definition at line 33 of file install.c.

Referenced by profile_items_callback().

◆ DotSecurity

const WCHAR DotSecurity[] = {'.','S','e','c','u','r','i','t','y',0}
static

Definition at line 123 of file install.c.

Referenced by registry_callback().

◆ DotServices

const WCHAR DotServices[] = {'.','S','e','r','v','i','c','e','s',0}
static

Definition at line 34 of file install.c.

Referenced by InstallHinfSectionW().

◆ ErrorControlKey

const WCHAR ErrorControlKey[] = {'E','r','r','o','r','C','o','n','t','r','o','l',0}
static

Definition at line 39 of file install.c.

Referenced by InstallOneService().

◆ GroupOrderListKey

const WCHAR GroupOrderListKey[] = {'S','Y','S','T','E','M','\\','C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\','C','o','n','t','r','o','l','\\','G','r','o','u','p','O','r','d','e','r','L','i','s','t',0}
static

Definition at line 29 of file install.c.

Referenced by InstallOneService().

◆ HotKey

const WCHAR HotKey[] = {'H','o','t','K','e','y',0}
static

Definition at line 53 of file install.c.

Referenced by profile_items_callback().

◆ IconIndex

const WCHAR IconIndex[] = {'I','c','o','n','I','n','d','e','x',0}
static

Definition at line 52 of file install.c.

Referenced by CAppsListView::AddApplication(), CSideTreeView::AddCategory(), CAppsListView::AddItem(), CShellLink::CreateShortcutIcon(), EditTypeDlg_OnChangeIcon(), GetIconOverlay(), CShellLink::OnCommand(), and profile_items_callback().

◆ IconPath

const WCHAR IconPath[] = {'I','c','o','n','P','a','t','h',0}
static

Definition at line 51 of file install.c.

Referenced by CAvailableApplicationInfo::CAvailableApplicationInfo(), DoExtractIcon(), LoadShellLinkConsoleInfo(), profile_items_callback(), CAppDB::RemoveCached(), WshShortcut_get_IconLocation(), and WshShortcut_put_IconLocation().

◆ Include

const WCHAR Include[] = {'I','n','c','l','u','d','e',0}
static

Definition at line 121 of file install.c.

Referenced by SetupInstallFromInfSectionW(), and SetupInstallServicesFromInfSectionExW().

◆ InfDirectory

const WCHAR InfDirectory[] = {'i','n','f','\\',0}
static

Definition at line 30 of file install.c.

Referenced by SetupCopyOEMInfW().

◆ InfoTip

const WCHAR InfoTip[] = {'I','n','f','o','T','i','p',0}
static

Definition at line 54 of file install.c.

Referenced by profile_items_callback().

◆ Ini2Reg

const WCHAR Ini2Reg[] = {'I','n','i','2','R','e','g',0}
static

Definition at line 110 of file install.c.

Referenced by SetupInstallFromInfSectionW().

◆ LoadOrderGroupKey

const WCHAR LoadOrderGroupKey[] = {'L','o','a','d','O','r','d','e','r','G','r','o','u','p',0}
static

Definition at line 40 of file install.c.

Referenced by InstallOneService().

◆ LogConf

const WCHAR LogConf[] = {'L','o','g','C','o','n','f',0}
static

Definition at line 111 of file install.c.

Referenced by SetupInstallFromInfSectionW().

◆ Name

const WCHAR Name[] = {'N','a','m','e',0}
static

Definition at line 47 of file install.c.

◆ Needs

const WCHAR Needs[] = {'N','e','e','d','s',0}
static

Definition at line 122 of file install.c.

Referenced by SetupInstallFromInfSectionW(), and SetupInstallServicesFromInfSectionExW().

◆ OemFileMask

const WCHAR OemFileMask[] = {'o','e','m','*','.','i','n','f',0}
static

Definition at line 31 of file install.c.

Referenced by SetupCopyOEMInfW().

◆ OemFileSpecification

const WCHAR OemFileSpecification[] = {'o','e','m','%','l','u','.','i','n','f',0}
static

Definition at line 32 of file install.c.

Referenced by SetupCopyOEMInfW().

◆ ProfileItems

const WCHAR ProfileItems[] = {'P','r','o','f','i','l','e','I','t','e','m','s',0}
static

Definition at line 120 of file install.c.

Referenced by SetupInstallFromInfSectionW().

◆ RegisterDlls

const WCHAR RegisterDlls[] = {'R','e','g','i','s','t','e','r','D','l','l','s',0}
static

Definition at line 118 of file install.c.

Referenced by ItemCompletionThread(), and SetupInstallFromInfSectionW().

◆ RenFiles

const WCHAR RenFiles[] = {'R','e','n','F','i','l','e','s',0}
static

Definition at line 109 of file install.c.

Referenced by SetupInstallFromInfSectionW().

◆ SecurityKey

const WCHAR SecurityKey[] = {'S','e','c','u','r','i','t','y',0}
static

Definition at line 41 of file install.c.

Referenced by InstallOneService().

◆ ServiceBinaryKey

const WCHAR ServiceBinaryKey[] = {'S','e','r','v','i','c','e','B','i','n','a','r','y',0}
static

Definition at line 42 of file install.c.

Referenced by InstallOneService().

◆ ServiceTypeKey

const WCHAR ServiceTypeKey[] = {'S','e','r','v','i','c','e','T','y','p','e',0}
static

Definition at line 43 of file install.c.

Referenced by InstallOneService().

◆ StartNameKey

const WCHAR StartNameKey[] = {'S','t','a','r','t','N','a','m','e',0}
static

Definition at line 45 of file install.c.

Referenced by InstallOneService().

◆ StartTypeKey

const WCHAR StartTypeKey[] = {'S','t','a','r','t','T','y','p','e',0}
static

Definition at line 44 of file install.c.

Referenced by InstallOneService().

◆ SubDir

const WCHAR SubDir[] = {'S','u','b','D','i','r',0}
static

Definition at line 49 of file install.c.

Referenced by MempGetOrCreatePageDir(), and profile_items_callback().

◆ UnregisterDlls

const WCHAR UnregisterDlls[] = {'U','n','r','e','g','i','s','t','e','r','D','l','l','s',0}
static

Definition at line 119 of file install.c.

Referenced by SetupInstallFromInfSectionW().

◆ UpdateIniFields

const WCHAR UpdateIniFields[] = {'U','p','d','a','t','e','I','n','i','F','i','e','l','d','s',0}
static

Definition at line 117 of file install.c.

Referenced by SetupInstallFromInfSectionW().

◆ UpdateInis

const WCHAR UpdateInis[] = {'U','p','d','a','t','e','I','n','i','s',0}
static

Definition at line 115 of file install.c.

Referenced by SetupInstallFromInfSectionW().

◆ WorkingDir

const WCHAR WorkingDir[] = {'W','o','r','k','i','n','g','D','i','r',0}
static

Definition at line 50 of file install.c.

Referenced by profile_items_callback().